Deteksi puncak dalam array 2D

Saya membantu klinik hewan mengukur tekanan di bawah kaki anjing. Saya menggunakan Python untuk analisis data saya dan sekarang saya terjebak mencoba untuk membagi cakram menjadi subregional (anatomi).

Saya membuat array 2D dari setiap kaki, yang terdiri dari nilai maksimal untuk setiap sensor yang telah dimuat oleh kaki dari waktu ke waktu. Berikut adalah contoh satu kaki, di mana saya menggunakan Excel untuk menggambar area yang ingin saya 'deteksi'. Ini adalah kotak 2 per 2 di sekitar sensor dengan maxima lokal, yang bersama-sama memiliki jumlah terbesar.

Jadi saya mencoba beberapa percobaan dan memutuskan untuk hanya mencari maksimum setiap kolom dan baris (tidak dapat melihat satu arah karena bentuk paw). Ini tampaknya 'mendeteksi' lokasi jari-jari yang terpisah dengan cukup baik, tetapi juga menandai sensor tetangga.

Jadi apa cara terbaik untuk memberi tahu Python yang mana dari maksimum ini yang saya inginkan?

Catatan: Kotak 2x2 tidak bisa tumpang tindih, karena harus terpisah!

Juga saya menggunakan 2x2 sebagai solusi, ada solusi yang lebih maju, tetapi saya hanya seorang ilmuwan gerakan manusia, jadi saya bukan programmer sejati atau ahli matematika, jadi tolong jaga agar tetap 'sederhana'.

Berikut ini adalah versi yang dapat dimuatnp.loadtxt

Hasil

Jadi saya mencoba solusi @ jextee (lihat hasil di bawah). Seperti yang Anda lihat, ini bekerja sangat baik di kaki depan, tetapi bekerja kurang baik untuk kaki belakang.

Lebih khusus lagi, itu tidak bisa mengenali puncak kecil itu ujung keempat. Ini jelas melekat pada kenyataan bahwa loop terlihat dari atas ke bawah menuju nilai terendah, tanpa memperhitungkan di mana ini.

Adakah yang tahu cara men-tweak algoritma @ jextee, sehingga mungkin bisa menemukan jari ke-4 juga?

Karena saya belum memproses percobaan lain, saya tidak dapat menyediakan sampel lain. Tapi data yang saya berikan sebelumnya adalah rata-rata dari setiap kaki. File ini adalah larik dengan data maksimal 9 kaki sesuai urutan kontak.

Gambar ini menunjukkan bagaimana mereka tersebar secara spasial di atas piring.

Memperbarui:

Saya telah membuat blog untuk siapa saja yang tertarik dan saya sudah menyiapkan SkyDrive dengan semua pengukuran mentah. Jadi bagi siapa pun yang meminta lebih banyak data: lebih banyak kekuatan untuk Anda!

Pembaruan baru:

Jadi setelah bantuan yang saya dapatkan dengan pertanyaan saya tentang deteksi kaki dan penyortiran kaki , saya akhirnya dapat memeriksa deteksi jari kaki untuk setiap kaki! Ternyata, itu tidak bekerja dengan baik dalam apa pun kecuali ukuran kaki seperti yang ada dalam contoh saya sendiri. Tentu saja di belakang, itu salah saya sendiri untuk memilih 2x2 begitu sewenang-wenang.

Ini adalah contoh yang bagus tentang kesalahannya: kuku dikenali sebagai jari kaki dan 'tumit' sangat lebar, sehingga dikenali dua kali!

Kaki terlalu besar, jadi mengambil ukuran 2x2 tanpa tumpang tindih, menyebabkan beberapa jari kaki terdeteksi dua kali. Sebaliknya, pada anjing kecil seringkali gagal menemukan jari kaki ke-5, yang saya duga disebabkan oleh area 2x2 yang terlalu besar.

Setelah mencoba solusi saat ini pada semua pengukuran saya, saya sampai pada kesimpulan mengejutkan bahwa untuk hampir semua anjing kecil saya tidak menemukan jari kaki ke-5 dan bahwa lebih dari 50% dampak untuk anjing besar itu akan menemukan lebih banyak!

Jadi jelas saya perlu mengubahnya. Dugaan saya sendiri adalah mengubah ukuran neighborhoodmenjadi sesuatu yang lebih kecil untuk anjing kecil dan lebih besar untuk anjing besar. Tapi generate_binary_structuresaya tidak akan membiarkan saya mengubah ukuran array.

Oleh karena itu, saya berharap ada orang lain yang memiliki saran yang lebih baik untuk menemukan jari kaki, mungkin berskala jari kaki dengan ukuran kaki?

Saya mendeteksi puncak menggunakan filter maksimum lokal . Ini adalah hasil dari dataset pertama Anda 4 kaki:

Saya juga menjalankannya pada dataset kedua 9 kaki dan berhasil juga .

Inilah cara Anda melakukannya:

import numpy as np
from scipy.ndimage.filters import maximum_filter
from scipy.ndimage.morphology import generate_binary_structure, binary_erosion
import matplotlib.pyplot as pp

#for some reason I had to reshape. Numpy ignored the shape header.
paws_data = np.loadtxt("paws.txt").reshape(4,11,14)

#getting a list of images
paws = [p.squeeze() for p in np.vsplit(paws_data,4)]


def detect_peaks(image):
    """
    Takes an image and detect the peaks usingthe local maximum filter.
    Returns a boolean mask of the peaks (i.e. 1 when
    the pixel's value is the neighborhood maximum, 0 otherwise)
    """

    # define an 8-connected neighborhood
    neighborhood = generate_binary_structure(2,2)

    #apply the local maximum filter; all pixel of maximal value 
    #in their neighborhood are set to 1
    local_max = maximum_filter(image, footprint=neighborhood)==image
    #local_max is a mask that contains the peaks we are 
    #looking for, but also the background.
    #In order to isolate the peaks we must remove the background from the mask.

    #we create the mask of the background
    background = (image==0)

    #a little technicality: we must erode the background in order to 
    #successfully subtract it form local_max, otherwise a line will 
    #appear along the background border (artifact of the local maximum filter)
    eroded_background = binary_erosion(background, structure=neighborhood, border_value=1)

    #we obtain the final mask, containing only peaks, 
    #by removing the background from the local_max mask (xor operation)
    detected_peaks = local_max ^ eroded_background

    return detected_peaks


#applying the detection and plotting results
for i, paw in enumerate(paws):
    detected_peaks = detect_peaks(paw)
    pp.subplot(4,2,(2*i+1))
    pp.imshow(paw)
    pp.subplot(4,2,(2*i+2) )
    pp.imshow(detected_peaks)

pp.show()

Yang perlu Anda lakukan adalah menggunakan scipy.ndimage.measurements.labeltopeng untuk memberi label pada semua objek yang berbeda. Maka Anda akan dapat bermain dengan mereka secara individual.

Perhatikan bahwa metode ini berfungsi dengan baik karena latar belakangnya tidak berisik. Jika ya, Anda akan mendeteksi sekelompok puncak yang tidak diinginkan lainnya di latar belakang. Faktor penting lainnya adalah ukuran lingkungan . Anda harus menyesuaikannya jika ukuran puncaknya berubah (seharusnya tetap proporsional).

Larutan

File data: paw.txt . Kode sumber:

from scipy import *
from operator import itemgetter

n = 5  # how many fingers are we looking for

d = loadtxt("paw.txt")
width, height = d.shape

# Create an array where every element is a sum of 2x2 squares.

fourSums = d[:-1,:-1] + d[1:,:-1] + d[1:,1:] + d[:-1,1:]

# Find positions of the fingers.

# Pair each sum with its position number (from 0 to width*height-1),

pairs = zip(arange(width*height), fourSums.flatten())

# Sort by descending sum value, filter overlapping squares

def drop_overlapping(pairs):
    no_overlaps = []
    def does_not_overlap(p1, p2):
        i1, i2 = p1[0], p2[0]
        r1, col1 = i1 / (width-1), i1 % (width-1)
        r2, col2 = i2 / (width-1), i2 % (width-1)
        return (max(abs(r1-r2),abs(col1-col2)) >= 2)
    for p in pairs:
        if all(map(lambda prev: does_not_overlap(p,prev), no_overlaps)):
            no_overlaps.append(p)
    return no_overlaps

pairs2 = drop_overlapping(sorted(pairs, key=itemgetter(1), reverse=True))

# Take the first n with the heighest values

positions = pairs2[:n]

# Print results

print d, "\n"

for i, val in positions:
    row = i / (width-1)
    column = i % (width-1)
    print "sum = %f @ %d,%d (%d)" % (val, row, column, i)
    print d[row:row+2,column:column+2], "\n"

Keluaran tanpa kotak tumpang tindih. Tampaknya area yang sama dipilih seperti pada contoh Anda.

Beberapa komentar

Bagian yang sulit adalah untuk menghitung jumlah semua kotak 2x2. Saya berasumsi Anda membutuhkan semuanya, jadi mungkin ada beberapa yang tumpang tindih. Saya menggunakan irisan untuk memotong kolom pertama / terakhir dan baris dari array 2D asli, dan kemudian tumpang tindih semuanya bersama-sama dan menghitung jumlah.

Untuk memahaminya dengan lebih baik, gambar array 3x3:

>>> a = arange(9).reshape(3,3) ; a
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

Kemudian Anda dapat mengambil irisannya:

>>> a[:-1,:-1]
array([[0, 1],
       [3, 4]])
>>> a[1:,:-1]
array([[3, 4],
       [6, 7]])
>>> a[:-1,1:]
array([[1, 2],
       [4, 5]])
>>> a[1:,1:]
array([[4, 5],
       [7, 8]])

Sekarang bayangkan Anda menumpuknya satu di atas yang lain dan menjumlahkan elemen pada posisi yang sama. Jumlah ini akan menjadi jumlah yang sama persis di atas kotak 2x2 dengan sudut kiri atas di posisi yang sama:

>>> sums = a[:-1,:-1] + a[1:,:-1] + a[:-1,1:] + a[1:,1:]; sums
array([[ 8, 12],
       [20, 24]])

Saat Anda memiliki jumlah lebih dari kotak 2x2, Anda dapat menggunakan maxuntuk menemukan maksimum, atau sort, atau sorteduntuk menemukan puncak.

Untuk mengingat posisi puncak, saya memasangkan setiap nilai (jumlah) dengan posisi ordinalnya dalam array yang rata (lihat zip ). Kemudian saya menghitung posisi baris / kolom lagi ketika saya mencetak hasilnya.

Catatan

Saya mengizinkan kotak 2x2 untuk tumpang tindih. Versi yang diedit menyaring beberapa dari mereka sehingga hanya kotak yang tidak tumpang tindih yang muncul dalam hasil.

Memilih jari (ide)

Masalah lain adalah bagaimana memilih apa yang mungkin menjadi jari dari semua puncak. Saya punya ide yang mungkin berhasil atau tidak. Saya tidak punya waktu untuk mengimplementasikannya sekarang, jadi pseudo-code saja.

Saya perhatikan bahwa jika jari-jari depan tetap berada pada lingkaran yang hampir sempurna, jari belakang harus berada di dalam lingkaran itu. Juga, jari-jari depan memiliki jarak yang kurang lebih sama. Kita dapat mencoba menggunakan sifat heuristik ini untuk mendeteksi jari.

Kode palsu:

select the top N finger candidates (not too many, 10 or 12)
consider all possible combinations of 5 out of N (use itertools.combinations)
for each combination of 5 fingers:
    for each finger out of 5:
        fit the best circle to the remaining 4
        => position of the center, radius
        check if the selected finger is inside of the circle
        check if the remaining four are evenly spread
        (for example, consider angles from the center of the circle)
        assign some cost (penalty) to this selection of 4 peaks + a rear finger
        (consider, probably weighted:
             circle fitting error,
             if the rear finger is inside,
             variance in the spreading of the front fingers,
             total intensity of 5 peaks)
choose a combination of 4 peaks + a rear peak with the lowest penalty

Ini adalah pendekatan brute-force. Jika N relatif kecil, maka saya pikir itu bisa dilakukan. Untuk N = 12, ada C_12 ^ 5 = 792 kombinasi, kali 5 cara untuk memilih jari belakang, jadi 3960 kasus untuk dievaluasi untuk setiap kaki.

Ini adalah masalah registrasi gambar . Strategi umum adalah:

• Memiliki contoh yang diketahui, atau semacam sebelumnya pada data.
• Cocokkan data Anda dengan contoh, atau cocokkan contoh dengan data Anda.
• Ini membantu jika data Anda secara rata disejajarkan.

Inilah pendekatan kasar dan siap , "hal terbodoh yang mungkin bisa berhasil":

• Mulailah dengan koordinat lima jari kaki di tempat yang Anda harapkan.
• Dengan masing-masing, iteratif naik ke puncak bukit. yaitu diberi posisi saat ini, pindah ke piksel tetangga maksimum, jika nilainya lebih besar dari piksel saat ini. Berhentilah saat koordinat jari kaki Anda berhenti bergerak.

Untuk mengatasi masalah orientasi, Anda dapat memiliki 8 atau lebih pengaturan awal untuk arah dasar (Utara, Timur Laut, dll). Jalankan masing-masing secara terpisah dan buang semua hasil di mana dua jari atau lebih berakhir pada piksel yang sama. Saya akan memikirkan ini lagi, tetapi hal semacam ini masih diteliti dalam pemrosesan gambar - tidak ada jawaban yang benar!

Gagasan yang sedikit lebih rumit: K-means clustering. Tidak seburuk itu.

• Mulailah dengan koordinat lima jari kaki, tetapi sekarang ini adalah "pusat cluster".

Kemudian beralih hingga konvergensi:

• Tetapkan setiap piksel ke kluster terdekat (cukup buat daftar untuk setiap kluster).
• Hitung pusat massa masing-masing cluster. Untuk setiap cluster, ini adalah: Jumlah (koordinat * nilai intensitas) / Jumlah (koordinat)
• Pindahkan setiap cluster ke pusat massa baru.

Metode ini hampir pasti akan memberikan hasil yang jauh lebih baik, dan Anda mendapatkan massa masing-masing cluster yang dapat membantu dalam mengidentifikasi jari-jari kaki.

(Sekali lagi, Anda telah menentukan jumlah cluster di depan. Dengan pengelompokan Anda harus menentukan kepadatan dengan satu atau lain cara: Baik memilih jumlah cluster, sesuai dalam kasus ini, atau memilih jari-jari cluster dan melihat berapa banyak Anda berakhir dengan. Contoh yang terakhir adalah mean-shift .)

Maaf tentang kurangnya detail implementasi atau spesifikasi lainnya. Saya akan membuat kode ini tetapi saya punya tenggat waktu. Jika tidak ada yang berhasil minggu depan, beri tahu saya dan saya akan mencobanya.

Dengan menggunakan homologi persisten untuk menganalisis set data Anda, saya mendapatkan hasil berikut (klik untuk memperbesar):

Ini adalah versi 2D dari metode deteksi puncak yang dijelaskan dalam jawaban SO ini . Gambar di atas hanya menunjukkan kelas homologi persisten 0-dimensi yang diurutkan berdasarkan kegigihan.

Saya melakukan peningkatan pada dataset asli dengan faktor 2 menggunakan scipy.misc.imresize (). Namun, perhatikan bahwa saya menganggap empat cakar sebagai satu dataset; membaginya menjadi empat akan membuat masalah lebih mudah.

Metodologi. Gagasan di balik ini cukup sederhana: Pertimbangkan grafik fungsi dari fungsi yang menetapkan setiap piksel levelnya. Ini terlihat seperti ini:

Sekarang perhatikan ketinggian air pada ketinggian 255 yang terus-menerus turun ke tingkat yang lebih rendah. Di pulau-pulau maxima lokal muncul (lahir). Pada titik sadel dua pulau bergabung; kami menganggap pulau yang lebih rendah untuk bergabung ke pulau yang lebih tinggi (kematian). Diagram kegigihan yang disebut (dari kelas homologi dimensi ke-0, pulau-pulau kita) menggambarkan nilai-nilai kelahiran-mati dari semua pulau:

The ketekunan dari sebuah pulau kemudian perbedaan antara sejak lahir dan kematian-tingkat; jarak vertikal sebuah titik ke diagonal utama abu-abu. Sosok itu memberi label pulau-pulau dengan mengurangi kegigihan.

Gambar pertama menunjukkan lokasi kelahiran pulau-pulau. Metode ini tidak hanya memberikan maksimum lokal tetapi juga mengukur "signifikansi" mereka dengan kegigihan yang disebutkan di atas. Satu kemudian akan menyaring semua pulau dengan ketekunan yang terlalu rendah. Namun, dalam contoh Anda, setiap pulau (yaitu, setiap maksimum lokal) adalah puncak yang Anda cari.

Kode python dapat ditemukan di sini .

Masalah ini telah dipelajari secara mendalam oleh fisikawan. Ada implementasi yang baik di ROOT . Lihatlah kelas TSpectrum (khususnya TSpectrum2 untuk kasus Anda) dan dokumentasi untuk mereka.

Referensi:

1. M.Morhac et al.: Metode eliminasi latar belakang untuk spektrum gamma-ray kebetulan multidimensi. Instrumen dan Metode Nuklir dalam Penelitian Fisika A 401 (1997) 113-132.
2. M.Morhac et al .: Dekonvolusi emas satu dan dua dimensi yang efisien dan aplikasinya pada dekomposisi spektrum sinar gamma. Instrumen dan Metode Nuklir dalam Penelitian Fisika A 401 (1997) 385-408.
3. M.Morhac et al.: Identifikasi puncak dalam spektrum gamma-ray kebetulan multidimensi. Instrumen dan Metode Nuklir dalam Fisika Penelitian A 443 (2000), 108-125.

... dan bagi mereka yang tidak memiliki akses ke berlangganan NIM:

• Spectrum.doc
• SpectrumDec.ps.gz
• SpectrumSrc.ps.gz
• SpectrumBck.ps.gz

Berikut adalah sebuah ide: Anda menghitung Laplacian (diskrit) dari gambar. Saya berharap itu menjadi (negatif dan) besar di maxima, dengan cara yang lebih dramatis daripada di gambar aslinya. Dengan demikian, maxima bisa lebih mudah ditemukan.

Berikut adalah ide lain: jika Anda tahu ukuran khas dari tempat-tempat bertekanan tinggi, pertama-tama Anda dapat menghaluskan gambar dengan membelitnya dengan Gaussian dengan ukuran yang sama. Ini dapat memberi Anda gambar yang lebih sederhana untuk diproses.

Hanya beberapa ide dari kepala saya:

• ambil gradien (turunan) dari pemindaian, lihat apakah itu menghilangkan panggilan palsu
• ambil maksimum dari maxima lokal

Anda mungkin juga ingin melihat OpenCV , itu punya Python API yang cukup baik dan mungkin memiliki beberapa fungsi yang Anda anggap berguna.

Saya yakin Anda sudah cukup untuk melanjutkan sekarang, tetapi saya tidak bisa tidak menyarankan menggunakan metode k-means clustering. k-means adalah algoritma pengelompokan tanpa pengawasan yang akan membawa Anda data (dalam sejumlah dimensi - saya kebetulan melakukan ini dalam 3D) dan mengaturnya menjadi k cluster dengan batas-batas yang berbeda. Sangat menyenangkan di sini karena Anda tahu persis berapa banyak jari kaki yang seharusnya dimiliki oleh gigi taring ini.

Selain itu, ini diterapkan di Scipy yang sangat bagus ( http://docs.scipy.org/doc/scipy/reference/cluster.vq.html ).

Berikut adalah contoh apa yang dapat dilakukan untuk menyelesaikan klaster 3D secara spasial:

Apa yang ingin Anda lakukan sedikit berbeda (2D dan termasuk nilai tekanan), tapi saya masih berpikir Anda bisa mencobanya.

terima kasih untuk data mentah. Saya di kereta dan ini sejauh yang saya dapat (berhenti saya akan datang). Saya memijat file txt Anda dengan regexps dan memasukkannya ke halaman html dengan beberapa javascript untuk visualisasi. Saya membagikannya di sini karena beberapa, seperti saya, mungkin merasa lebih mudah diretas daripada python.

Saya pikir pendekatan yang baik adalah skala dan rotasi invarian, dan langkah selanjutnya adalah menyelidiki campuran gaussians. (masing-masing paw pad menjadi pusat gaussian).

    <html>
<head>
    <script type="text/javascript" src="http://vis.stanford.edu/protovis/protovis-r3.2.js"></script> 
    <script type="text/javascript">
    var heatmap = [[[0,0,0,0,0,0,0,4,4,0,0,0,0],
[0,0,0,0,0,7,14,22,18,7,0,0,0],
[0,0,0,0,11,40,65,43,18,7,0,0,0],
[0,0,0,0,14,61,72,32,7,4,11,14,4],
[0,7,14,11,7,22,25,11,4,14,65,72,14],
[4,29,79,54,14,7,4,11,18,29,79,83,18],
[0,18,54,32,18,43,36,29,61,76,25,18,4],
[0,4,7,7,25,90,79,36,79,90,22,0,0],
[0,0,0,0,11,47,40,14,29,36,7,0,0],
[0,0,0,0,4,7,7,4,4,4,0,0,0]
],[
[0,0,0,4,4,0,0,0,0,0,0,0,0],
[0,0,11,18,18,7,0,0,0,0,0,0,0],
[0,4,29,47,29,7,0,4,4,0,0,0,0],
[0,0,11,29,29,7,7,22,25,7,0,0,0],
[0,0,0,4,4,4,14,61,83,22,0,0,0],
[4,7,4,4,4,4,14,32,25,7,0,0,0],
[4,11,7,14,25,25,47,79,32,4,0,0,0],
[0,4,4,22,58,40,29,86,36,4,0,0,0],
[0,0,0,7,18,14,7,18,7,0,0,0,0],
[0,0,0,0,4,4,0,0,0,0,0,0,0],
],[
[0,0,0,4,11,11,7,4,0,0,0,0,0],
[0,0,0,4,22,36,32,22,11,4,0,0,0],
[4,11,7,4,11,29,54,50,22,4,0,0,0],
[11,58,43,11,4,11,25,22,11,11,18,7,0],
[11,50,43,18,11,4,4,7,18,61,86,29,4],
[0,11,18,54,58,25,32,50,32,47,54,14,0],
[0,0,14,72,76,40,86,101,32,11,7,4,0],
[0,0,4,22,22,18,47,65,18,0,0,0,0],
[0,0,0,0,4,4,7,11,4,0,0,0,0],
],[
[0,0,0,0,4,4,4,0,0,0,0,0,0],
[0,0,0,4,14,14,18,7,0,0,0,0,0],
[0,0,0,4,14,40,54,22,4,0,0,0,0],
[0,7,11,4,11,32,36,11,0,0,0,0,0],
[4,29,36,11,4,7,7,4,4,0,0,0,0],
[4,25,32,18,7,4,4,4,14,7,0,0,0],
[0,7,36,58,29,14,22,14,18,11,0,0,0],
[0,11,50,68,32,40,61,18,4,4,0,0,0],
[0,4,11,18,18,43,32,7,0,0,0,0,0],
[0,0,0,0,4,7,4,0,0,0,0,0,0],
],[
[0,0,0,0,0,0,4,7,4,0,0,0,0],
[0,0,0,0,4,18,25,32,25,7,0,0,0],
[0,0,0,4,18,65,68,29,11,0,0,0,0],
[0,4,4,4,18,65,54,18,4,7,14,11,0],
[4,22,36,14,4,14,11,7,7,29,79,47,7],
[7,54,76,36,18,14,11,36,40,32,72,36,4],
[4,11,18,18,61,79,36,54,97,40,14,7,0],
[0,0,0,11,58,101,40,47,108,50,7,0,0],
[0,0,0,4,11,25,7,11,22,11,0,0,0],
[0,0,0,0,0,4,0,0,0,0,0,0,0],
],[
[0,0,4,7,4,0,0,0,0,0,0,0,0],
[0,0,11,22,14,4,0,4,0,0,0,0,0],
[0,0,7,18,14,4,4,14,18,4,0,0,0],
[0,4,0,4,4,0,4,32,54,18,0,0,0],
[4,11,7,4,7,7,18,29,22,4,0,0,0],
[7,18,7,22,40,25,50,76,25,4,0,0,0],
[0,4,4,22,61,32,25,54,18,0,0,0,0],
[0,0,0,4,11,7,4,11,4,0,0,0,0],
],[
[0,0,0,0,7,14,11,4,0,0,0,0,0],
[0,0,0,4,18,43,50,32,14,4,0,0,0],
[0,4,11,4,7,29,61,65,43,11,0,0,0],
[4,18,54,25,7,11,32,40,25,7,11,4,0],
[4,36,86,40,11,7,7,7,7,25,58,25,4],
[0,7,18,25,65,40,18,25,22,22,47,18,0],
[0,0,4,32,79,47,43,86,54,11,7,4,0],
[0,0,0,14,32,14,25,61,40,7,0,0,0],
[0,0,0,0,4,4,4,11,7,0,0,0,0],
],[
[0,0,0,0,4,7,11,4,0,0,0,0,0],
[0,4,4,0,4,11,18,11,0,0,0,0,0],
[4,11,11,4,0,4,4,4,0,0,0,0,0],
[4,18,14,7,4,0,0,4,7,7,0,0,0],
[0,7,18,29,14,11,11,7,18,18,4,0,0],
[0,11,43,50,29,43,40,11,4,4,0,0,0],
[0,4,18,25,22,54,40,7,0,0,0,0,0],
[0,0,4,4,4,11,7,0,0,0,0,0,0],
],[
[0,0,0,0,0,7,7,7,7,0,0,0,0],
[0,0,0,0,7,32,32,18,4,0,0,0,0],
[0,0,0,0,11,54,40,14,4,4,22,11,0],
[0,7,14,11,4,14,11,4,4,25,94,50,7],
[4,25,65,43,11,7,4,7,22,25,54,36,7],
[0,7,25,22,29,58,32,25,72,61,14,7,0],
[0,0,4,4,40,115,68,29,83,72,11,0,0],
[0,0,0,0,11,29,18,7,18,14,4,0,0],
[0,0,0,0,0,4,0,0,0,0,0,0,0],
]
];
</script>
</head>
<body>
    <script type="text/javascript+protovis">    
    for (var a=0; a < heatmap.length; a++) {
    var w = heatmap[a][0].length,
    h = heatmap[a].length;
var vis = new pv.Panel()
    .width(w * 6)
    .height(h * 6)
    .strokeStyle("#aaa")
    .lineWidth(4)
    .antialias(true);
vis.add(pv.Image)
    .imageWidth(w)
    .imageHeight(h)
    .image(pv.Scale.linear()
        .domain(0, 99, 100)
        .range("#000", "#fff", '#ff0a0a')
        .by(function(i, j) heatmap[a][j][i]));
vis.render();
}
</script>
  </body>
</html>

Solusi fisikawan:
Tetapkan 5 marka-kaki yang diidentifikasi oleh posisi mereka X_idan init dengan posisi acak. Tentukan beberapa fungsi energi yang menggabungkan beberapa penghargaan untuk lokasi penanda di posisi kaki dengan beberapa hukuman karena tumpang tindih penanda; Katakanlah:

E(X_i;S)=-Sum_i(S(X_i))+alfa*Sum_ij (|X_i-Xj|<=2*sqrt(2)?1:0)

( S(X_i)adalah kekuatan rata-rata dalam 2x2 persegi di sekitar X_i, alfaadalah parameter yang akan memuncak secara eksperimental)

Sekarang saatnya untuk melakukan beberapa sihir Metropolis-Hastings:
1. Pilih penanda acak dan pindahkan dengan satu piksel ke arah acak.
2. Hitung dE, perbedaan energi yang disebabkan gerakan ini.
3. Dapatkan nomor acak seragam dari 0-1 dan sebut saja r.
4. Jika dE<0atau exp(-beta*dE)>r, terima langkah dan lanjutkan ke 1; jika tidak, batalkan pemindahan dan lanjutkan ke 1.
Ini harus diulang sampai marker akan menyatu menjadi cakar. Beta mengontrol pemindaian untuk mengoptimalkan tradeoff, sehingga harus juga dioptimalkan secara eksperimental; itu juga dapat terus meningkat dengan waktu simulasi (simulated annealing).

Inilah pendekatan lain yang saya gunakan ketika melakukan sesuatu yang serupa untuk teleskop besar:

1) Cari piksel tertinggi. Setelah Anda memilikinya, cari yang paling cocok untuk 2x2 (mungkin memaksimalkan jumlah 2x2), atau lakukan kecocokan gaussian 2d di dalam sub wilayah katakanlah 4x4 berpusat pada piksel tertinggi.

Kemudian atur 2x2 piksel yang Anda temukan ke nol (atau mungkin 3x3) di sekitar pusat puncak

kembali ke 1) dan ulangi sampai puncak tertinggi jatuh di bawah ambang batas kebisingan, atau Anda memiliki semua jari kaki yang Anda butuhkan

Mungkin patut untuk dicoba dengan jaringan saraf jika Anda dapat membuat beberapa data pelatihan ... tetapi ini membutuhkan banyak sampel yang dianotasi dengan tangan.

garis besar kasar ...

Anda mungkin ingin menggunakan algoritma komponen yang terhubung untuk mengisolasi setiap wilayah paw. wiki memiliki deskripsi yang layak tentang ini (dengan beberapa kode) di sini: http://en.wikipedia.org/wiki/Connected_Component_Labeling

Anda harus membuat keputusan tentang apakah menggunakan 4 atau 8 keterhubungan. secara pribadi, untuk sebagian besar masalah saya lebih suka koneksi-6. Lagi pula, setelah Anda memisahkan masing-masing "paw print" sebagai wilayah yang terhubung, itu akan cukup mudah untuk beralih ke wilayah tersebut dan menemukan maxima. setelah Anda menemukan maxima, Anda bisa memperbesar wilayah itu secara iteratif hingga Anda mencapai ambang yang telah ditentukan untuk mengidentifikasi itu sebagai "jari" yang diberikan.

satu masalah halus di sini adalah bahwa segera setelah Anda mulai menggunakan teknik visi komputer untuk mengidentifikasi sesuatu sebagai kaki kanan / kiri / depan / belakang dan Anda mulai melihat jari kaki individu, Anda harus mulai mengambil rotasi, skew, dan terjemahan ke dalam akun. ini dicapai melalui analisis yang disebut "momen". ada beberapa momen berbeda untuk dipertimbangkan dalam aplikasi penglihatan:

momen sentral: momen invarian terjemahan dinormalisasi: scaling dan terjemahan momen invarian hu: terjemahan, skala, dan rotasi invarian

informasi lebih lanjut tentang momen dapat ditemukan dengan mencari "momen gambar" di wiki.

Mungkin Anda bisa menggunakan sesuatu seperti Gaussian Mixture Models. Berikut adalah paket Python untuk melakukan GMM (baru saja melakukan pencarian Google) http://www.ar.media.kyoto-u.ac.jp/members/david/softwares/em/

Sepertinya Anda bisa menipu sedikit menggunakan algoritma jetxee. Dia menemukan tiga jari kaki pertama baik-baik saja, dan Anda harus bisa menebak di mana yang keempat didasarkan itu.

Masalah menarik. Solusi yang akan saya coba adalah sebagai berikut.

1. Terapkan filter low pass, seperti konvolusi dengan topeng gaussian 2D. Ini akan memberi Anda banyak nilai (mungkin, tetapi tidak harus floating point).

2. Lakukan penindasan non-maksimal 2D menggunakan radius perkiraan yang diketahui dari setiap paw pad (atau jari kaki).

Ini akan memberi Anda posisi maksimal tanpa memiliki banyak kandidat yang berdekatan. Hanya untuk memperjelas, jari-jari topeng pada langkah 1 juga harus serupa dengan jari-jari yang digunakan pada langkah 2. Jari-jari ini bisa dipilih, atau dokter hewan dapat secara eksplisit mengukurnya sebelumnya (ini akan bervariasi dengan usia / jenis / dll).

Beberapa solusi yang disarankan (pergeseran rata-rata, jaring saraf, dan sebagainya) mungkin akan bekerja pada tingkat tertentu, tetapi terlalu rumit dan mungkin tidak ideal.

Nah, ini beberapa kode sederhana dan tidak terlalu efisien, tetapi untuk ukuran set data ini tidak masalah.

import numpy as np
grid = np.array([[0,0,0,0,0,0,0,0,0,0,0,0,0,0],
              [0,0,0,0,0,0,0,0,0.4,0.4,0.4,0,0,0],
              [0,0,0,0,0.4,1.4,1.4,1.8,0.7,0,0,0,0,0],
              [0,0,0,0,0.4,1.4,4,5.4,2.2,0.4,0,0,0,0],
              [0,0,0.7,1.1,0.4,1.1,3.2,3.6,1.1,0,0,0,0,0],
              [0,0.4,2.9,3.6,1.1,0.4,0.7,0.7,0.4,0.4,0,0,0,0],
              [0,0.4,2.5,3.2,1.8,0.7,0.4,0.4,0.4,1.4,0.7,0,0,0],
              [0,0,0.7,3.6,5.8,2.9,1.4,2.2,1.4,1.8,1.1,0,0,0],
              [0,0,1.1,5,6.8,3.2,4,6.1,1.8,0.4,0.4,0,0,0],
              [0,0,0.4,1.1,1.8,1.8,4.3,3.2,0.7,0,0,0,0,0],
              [0,0,0,0,0,0.4,0.7,0.4,0,0,0,0,0,0]])

arr = []
for i in xrange(grid.shape[0] - 1):
    for j in xrange(grid.shape[1] - 1):
        tot = grid[i][j] + grid[i+1][j] + grid[i][j+1] + grid[i+1][j+1]
        arr.append([(i,j),tot])

best = []

arr.sort(key = lambda x: x[1])

for i in xrange(5):
    best.append(arr.pop())
    badpos = set([(best[-1][0][0]+x,best[-1][0][1]+y)
                  for x in [-1,0,1] for y in [-1,0,1] if x != 0 or y != 0])
    for j in xrange(len(arr)-1,-1,-1):
        if arr[j][0] in badpos:
            arr.pop(j)


for item in best:
    print grid[item[0][0]:item[0][0]+2,item[0][1]:item[0][1]+2]

Saya pada dasarnya hanya membuat array dengan posisi kiri atas dan jumlah masing-masing 2x2 persegi dan mengurutkannya dengan jumlah. Saya kemudian mengambil kotak 2x2 dengan jumlah pertengkaran tertinggi, memasukkannya ke dalambest array, dan menghapus semua kotak 2x2 lainnya yang menggunakan bagian mana saja dari 2x2 persegi yang baru saja dihapus ini.

Tampaknya berfungsi dengan baik kecuali dengan paw terakhir (yang dengan jumlah terkecil di paling kanan dalam gambar pertama Anda), ternyata ada dua kotak 2x2 lain yang memenuhi syarat dengan jumlah yang lebih besar (dan mereka memiliki jumlah yang sama dengan satu sama lain). Salah satunya masih memilih satu kotak dari kotak 2x2 Anda, tetapi yang lainnya ke kiri. Untungnya, kita beruntung memilih lebih dari yang Anda inginkan, tetapi ini mungkin memerlukan beberapa ide lain untuk digunakan untuk mendapatkan apa yang sebenarnya Anda inginkan sepanjang waktu.

Hanya ingin memberi tahu kalian ada pilihan bagus untuk menemukan maximagambar lokal dengan python:

from skimage.feature import peak_local_max

atau untuk skimage 0.8.0:

from skimage.feature.peak import peak_local_max

http://scikit-image.org/docs/0.8.0/api/skimage.feature.peak.html

Mungkin pendekatan naif sudah cukup di sini: Buat daftar semua kotak 2x2 di pesawat Anda, pesan dengan jumlah mereka (dalam urutan menurun).

Pertama, pilih kotak bernilai tertinggi ke dalam "daftar kaki" Anda. Kemudian, pilih 4 dari kotak terbaik berikutnya yang tidak bersinggungan dengan kotak yang sebelumnya ditemukan.

Ada beberapa perangkat lunak luas yang tersedia dari komunitas astronomi dan kosmologi - ini adalah bidang penelitian yang signifikan baik secara historis maupun saat ini.

Jangan khawatir jika Anda bukan astronom - ada yang mudah digunakan di luar lapangan. Misalnya, Anda dapat menggunakan astropi / fotutil:

https://photutils.readthedocs.io/en/stable/detection.html#local-peak-detection

[Tampaknya agak kasar untuk mengulang kode sampel pendek mereka di sini.]

Daftar teknik / paket / tautan yang mungkin tidak lengkap dan sedikit menarik diberikan di bawah ini - tambahkan lebih banyak di komentar dan saya akan memperbarui jawaban ini seperlunya. Tentu saja ada pertukaran akurasi dan sumber daya komputasi. [Jujur, ada terlalu banyak untuk memberikan contoh kode dalam satu jawaban seperti ini jadi saya tidak yakin apakah jawaban ini akan terbang atau tidak.]

Sumber Extractor https://www.astromatic.net/software/sextractor

MultiNest https://github.com/farhanferoz/MultiNest [+ pyMultiNest]

Tantangan pencarian sumber ASKAP / EMU: https://arxiv.org/abs/1509.03931

Anda juga dapat mencari tantangan ekstraksi sumber Planck dan / atau WMAP.

...

Bagaimana jika Anda melanjutkan langkah demi langkah: pertama-tama Anda menemukan maksimum global, proses jika perlu titik-titik di sekitarnya diberi nilainya, kemudian atur wilayah yang ditemukan ke nol, dan ulangi untuk yang berikutnya.

Saya tidak yakin ini menjawab pertanyaan, tetapi sepertinya Anda bisa mencari n puncak tertinggi yang tidak memiliki tetangga.

Inilah intinya. Perhatikan bahwa itu ada di Ruby, tetapi idenya harus jelas.

require 'pp'

NUM_PEAKS = 5
NEIGHBOR_DISTANCE = 1

data = [[1,2,3,4,5],
        [2,6,4,4,6],
        [3,6,7,4,3],
       ]

def tuples(matrix)
  tuples = []
  matrix.each_with_index { |row, ri|
    row.each_with_index { |value, ci|
      tuples << [value, ri, ci]
    }
  }
  tuples
end

def neighbor?(t1, t2, distance = 1)
  [1,2].each { |axis|
    return false if (t1[axis] - t2[axis]).abs > distance
  }
  true
end

# convert the matrix into a sorted list of tuples (value, row, col), highest peaks first
sorted = tuples(data).sort_by { |tuple| tuple.first }.reverse

# the list of peaks that don't have neighbors
non_neighboring_peaks = []

sorted.each { |candidate|
  # always take the highest peak
  if non_neighboring_peaks.empty?
    non_neighboring_peaks << candidate
    puts "took the first peak: #{candidate}"
  else
    # check that this candidate doesn't have any accepted neighbors
    is_ok = true
    non_neighboring_peaks.each { |accepted|
      if neighbor?(candidate, accepted, NEIGHBOR_DISTANCE)
        is_ok = false
        break
      end
    }
    if is_ok
      non_neighboring_peaks << candidate
      puts "took #{candidate}"
    else
      puts "denied #{candidate}"
    end
  end
}

pp non_neighboring_peaks