ද්විමාන අරාවක උපරිම හඳුනාගැනීම

මම පශු වෛද්‍ය සායනයකට උදව් කරන්නේ බල්ලෙකුගේ පාදයක් යටතේ පීඩනය මැනීම සඳහා ය. මගේ දත්ත විශ්ලේෂණය සඳහා මම පයිතන් භාවිතා කරන අතර දැන් මම පාද (ව්‍යුහ විද්‍යාත්මක) උප කලාපවලට බෙදීමට උත්සාහ කරමි.

මම එක් එක් පාදයේ 2D අරා එකක් සෑදුවෙමි, එය කාලයාගේ ඇවෑමෙන් උකස් විසින් පටවා ඇති එක් එක් සංවේදකයේ උපරිම අගයන්ගෙන් සමන්විත වේ. මෙන්න එක් ඉත්තෙකුගේ උදාහරණයක්, මට 'හඳුනා ගැනීමට' අවශ්‍ය ප්‍රදේශ ඇඳීමට මම එක්සෙල් භාවිතා කළෙමි. මේවා දේශීය උපරිම සමඟ සංවේදකය වටා ඇති පෙට්ටි 2 සිට 2 දක්වා වන අතර ඒවායින් විශාලතම එකතුව ඇත.

ඒ නිසා මම යම් අත්හදා බැලීමක් කිරීමට උත්සාහ කළ අතර එක් එක් තීරුවේ සහ පේළියේ උපරිමය සොයා බැලීමට තීරණය කළෙමි (උකස් වල හැඩය නිසා එක් දිශාවකට බැලිය නොහැක). මෙය වෙනම ඇඟිලි වල පිහිටීම තරමක් හොඳින් හඳුනාගෙන ඇති නමුත් එය අසල්වැසි සංවේදක ද සලකුණු කරයි.

ඉතින් පයිතන්ට පැවසීමට ඇති හොඳම ක්‍රමය කුමක්ද?

සටහන: 2x2 චතුරස්රයන් එකිනෙකට පරස්පර විය නොහැක, මන්ද ඒවා වෙනම ඇඟිලි විය යුතුය!

එසේම මම 2x2 පහසුව සඳහා ගෙන ගියෙමි, වඩාත් දියුණු විසඳුමක් සාදරයෙන් පිළිගනිමු, නමුත් මම හුදෙක් මානව චලන විද්‍යා ist යෙක්, එබැවින් මම සැබෑ ක්‍රමලේඛකයෙකු හෝ ගණිත ian යෙක් නොවෙමි, එබැවින් කරුණාකර එය 'සරල' ලෙස තබා ගන්න.

මෙන්න පටවා ගත හැකි අනුවාදයක්np.loadtxt

ප්රතිපල

එබැවින් මම @ ජෙක්ස්ටීගේ විසඳුම උත්සාහ කළෙමි (පහත ප්‍රති results ල බලන්න). ඔබට පෙනෙන පරිදි, එය ඉදිරිපස පාදවල ඉතා හොඳින් ක්රියා කරයි, නමුත් එය පසුපස කකුල් සඳහා හොඳින් ක්රියා කරයි.

වඩාත් නිශ්චිතවම, එයට සිව්වන ඇඟිල්ල වන කුඩා කඳු මුදුන හඳුනාගත නොහැක. මෙය කොතැනද යන්න සැලකිල්ලට නොගෙන, ලූපය පහළම අගය දෙසට ඉහළට පෙනෙන බව මෙය පැහැදිලිවම ආවේනික වේ.

@ ජෙක්ස්ටීගේ ඇල්ගොරිතම නවීකරණය කරන්නේ කෙසේදැයි යමෙක් දන්නවාද, එවිට 4 වන ඇඟිල්ලද සොයාගත හැකිය.

මම තවම වෙනත් අත්හදා බැලීම් කර නොමැති බැවින් මට වෙනත් සාම්පල සැපයිය නොහැක. නමුත් මා මීට පෙර ලබා දුන් දත්ත එක් එක් පාදයේ සාමාන්‍යය විය. මෙම ගොනුව තහඩුව සමඟ සම්බන්ධතා ඇති අනුපිළිවෙලෙහි උකස් 9 ක උපරිම දත්ත සහිත අරාවකි.

මෙම රූපයේ දැක්වෙන්නේ ඒවා තහඩුව පුරා අවකාශීයව පැතිරී ඇති ආකාරයයි.

යාවත්කාලීන කිරීම:

මම කැමති ඕනෑම කෙනෙකුට සඳහා බ්ලොග් පිහිටුවා ඇති අතර මේ සියලු අමු මිනුම් සමග SkyDrive හි පිහිටුවා තිබෙනවා. එබැවින් වැඩි දත්ත ඉල්ලන ඕනෑම කෙනෙකුට: ඔබට වැඩි බලයක්!

නව යාවත්කාලීන කිරීම:

උකස් හඳුනාගැනීම සහ උකස් වර්ග කිරීම පිළිබඳ මගේ ප්‍රශ්න සමඟ මට ලැබුණු උදව්වෙන් පසුව, සෑම ඉත්තෙකුටම ඇඟිලි හඳුනාගැනීම පරීක්ෂා කිරීමට මට හැකි විය! හැරෙනවා, එය කිසිම දෙයකින් එතරම් හොඳින් ක්‍රියා නොකරන නමුත් මගේම උදාහරණයේ ඇති පාද මෙන් ප්‍රමාණයේ පාද. 2x2 එතරම් අත්තනෝමතික ලෙස තෝරා ගැනීම මගේම වරදකි.

නියපොතු ඇඟිල්ලක් ලෙස හඳුනාගෙන ඇති අතර 'විලුඹ' එතරම් පුළුල් ය, එය දෙවරක් හඳුනා ගනී!

උකස් ඉතා විශාල බැවින් අතිච්ඡාදනයකින් තොරව 2x2 ප්‍රමාණයක් ගැනීමෙන් සමහර ඇඟිලි දෙවරක් අනාවරණය වේ. අනෙක් පැත්තෙන්, කුඩා සුනඛයන් තුළ බොහෝ විට 5 වන ඇඟිල්ල සොයා ගැනීමට අපොහොසත් වන අතර, 2x2 ප්‍රදේශය විශාල වීම නිසා මෙය සිදුවනු ඇතැයි මම සැක කරමි.

මගේ සියලු මිනුම් සඳහා වර්තමාන විසඳුම අත්හදා බැලීමෙන් පසු, මගේ කුඩා සුනඛයින් සියල්ලටම පාහේ 5 වන ඇඟිල්ලක් හමු නොවූ බවත්, විශාල සුනඛයින්ට ඇති බලපෑමෙන් 50% කට වඩා වැඩි ප්‍රමාණයක් සොයා ගත හැකි බවත් මම නිගමනය කළෙමි.

එබැවින් පැහැදිලිවම මට එය වෙනස් කළ යුතුය. මගේම අනුමානය වූයේ neighborhoodකුඩා සුනඛයින් සඳහා ප්‍රමාණය කුඩා හා විශාල සුනඛයින් සඳහා විශාල ප්‍රමාණයකට වෙනස් කිරීමයි. නමුත් generate_binary_structureඅරාවෙහි ප්‍රමාණය වෙනස් කිරීමට මට ඉඩ නොදේ.

එමනිසා, ඇඟිලි සොයා ගැනීම සඳහා වෙනත් කෙනෙකුට වඩා හොඳ යෝජනාවක් ඇතැයි මම බලාපොරොත්තු වෙමි.

දේශීය උපරිම පෙරණයක් භාවිතා කරමින් මම කඳු මුදුන් හඳුනා ගතිමි . ඔබේ පළමු දත්ත කට්ටලයේ පාද 4 ක ප්‍රති result ලය මෙන්න:

මම ද හිසකින් යුත් රවුමක දෙපැත්තට තැබූ 9 දෙවන දත්ත සමුදාය මත දිව ගොස් එය හොඳින් ලෙස සේවය .

ඔබ එය කරන ආකාරය මෙන්න:

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()

ඔබ පසුව scipy.ndimage.measurements.labelකළ යුත්තේ වෙස්මුහුණ භාවිතා කර සියලු වෙනස් වස්තු ලේබල් කිරීමයි. එවිට ඔබට ඔවුන් සමඟ තනි තනිව සෙල්ලම් කිරීමට හැකි වනු ඇත.

පසුබිම is ෝෂාකාරී නොවන නිසා ක්‍රමය හොඳින් ක්‍රියාත්මක වන බව සලකන්න . එය එසේ නම්, පසුබිමේ ඇති අනවශ්‍ය කඳු මුදුන් කිහිපයක් ඔබ හඳුනා ගනු ඇත. තවත් වැදගත් සාධකයක් වන්නේ අසල්වැසියාගේ ප්‍රමාණයයි . උපරිම ප්‍රමාණය වෙනස් වුවහොත් ඔබට එය සකස් කිරීමට අවශ්‍ය වනු ඇත (දළ වශයෙන් සමානුපාතිකව පැවතිය යුතුය).

විසඳුමක්

දත්ත ගොනුව: paw.txt . ප්රභව කේතය:

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"

චතුරස්රයන් අතිච්ඡාදනය නොකර නිමැවුම් . ඔබේ උදාහරණයේ දී මෙන් එකම ප්‍රදේශ තෝරාගෙන ඇති බව පෙනේ.

සමහර අදහස්

උපක්‍රමශීලී කොටස නම් වර්ග 2x2 හි එකතුව ගණනය කිරීමයි. මම හිතුවේ ඔබට ඒ සියල්ල අවශ්‍ය බවයි, එබැවින් අතිච්ඡාදනය විය හැකිය. මුල් 2D අරා වලින් පළමු / අවසාන තීරු සහ පේළි කැපීමට මම පෙති භාවිතා කළෙමි, පසුව ඒවා සියල්ලම එකට එකතු කර මුදල් ගණනය කරමි.

එය වඩා හොඳින් තේරුම් ගැනීමට, 3x3 අරා රූපගත කිරීම:

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

එවිට ඔබට එහි පෙති ගත හැකිය:

>>> 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]])

දැන් ඔබ ඒවා එකකට වඩා ඉහළින් එක තැනක තබාගෙන එකම ස්ථානවල මූලද්‍රව්‍ය එකතු කරන්න. මෙම මුදල් වර්ග 2x2 ට වඩා ඉහළ වම් කෙළවරේ එකම ස්ථානයක එකම අගයන් වනු ඇත:

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

ඔබට වර්ග 2x2 ට වඩා වැඩි ප්‍රමාණයක් ඇති විට, ඔබට maxඋපරිමය සොයා ගැනීමට sortහෝ sortedකඳු මුදුන් සොයා ගැනීමට භාවිතා කළ හැකිය .

කඳු මුදුන්වල පිහිටීම් මතක තබා ගැනීම සඳහා මම සෑම අගයක්ම (එකතුවක්) සමතලා කරන ලද අරාවකින් එහි සාමාන්‍ය පිහිටීම සමඟ (බලන්න zip). ප්‍රති .ල මුද්‍රණය කරන විට මම නැවත පේළි / තීරු පිහිටීම ගණනය කරමි.

සටහන්

වර්ග 2x2 අතිච්ඡාදනය වීමට මම ඉඩ දුන්නෙමි. සංස්කරණය කරන ලද අනුවාදය ඒවායින් සමහරක් පෙරහන් කරයි, එමඟින් ප්‍රති .ලවල අතිච්ඡාදනය නොවන චතුරස්ර පමණක් දිස් වේ.

ඇඟිලි තෝරා ගැනීම (අදහසක්)

තවත් ගැටළුවක් නම්, සියලු කඳු මුදුන් වලින් ඇඟිලි විය හැකි දේ තෝරා ගන්නේ කෙසේද යන්නයි. මට අදහසක් ඇත, එය ක්‍රියාත්මක විය හැකි හෝ නොවිය හැකිය. මට දැන් එය ක්‍රියාත්මක කිරීමට වෙලාවක් නැත, එබැවින් ව්‍යාජ කේතයක් පමණි.

ඉදිරිපස ඇඟිලි පරිපූර්ණ රවුමක රැඳී තිබේ නම් පසුපස ඇඟිල්ල එම කවය තුළ තිබිය යුතු බව මම දුටුවෙමි. එසේම, ඉදිරිපස ඇඟිලි අඩු හෝ වැඩි වශයෙන් සමාන පරතරයකින් යුක්ත වේ. ඇඟිලි හඳුනා ගැනීම සඳහා අපි මෙම ගුණාංග භාවිතා කිරීමට උත්සාහ කළ හැකිය.

ව්‍යාජ කේතය:

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

මෙය තිරිසන් බලවේග ප්‍රවේශයකි. N සාපේක්ෂව කුඩා නම්, එය කළ හැකි යැයි මම සිතමි. N = 12 සඳහා, C_12 ^ 5 = 792 සංයෝජන ඇත, පසුපස ඇඟිල්ලක් තෝරා ගැනීමට 5 වතාවක් වාර ගණනක් ඇත, එබැවින් සෑම ඉත්තෙකු සඳහාම ඇගයීමට අවස්ථා 3960 ක් ඇත.

මෙය රූප ලියාපදිංචි කිරීමේ ගැටලුවකි . පොදු උපාය මාර්ගය නම්:

• දන්නා උදාහරණයක් හෝ දත්ත පිළිබඳ යම් ආකාරයක පෙර දැක්මක් තබා ගන්න.
• ඔබගේ දත්ත උදාහරණයට සවි කරන්න, නැතහොත් උදාහරණය ඔබේ දත්ත වලට ගැලපෙන්න.
• ඔබේ දත්ත දළ වශයෙන් මුලින් පෙළගස්වා ඇත්නම් එය උපකාරී වේ .

මෙන්න රළු සහ සූදානම් ප්‍රවේශයක් , “වැඩ කළ හැකි ගොළු දෙය”:

• දළ වශයෙන් ඔබ අපේක්ෂා කරන ස්ථානයේ ඇඟිලි ඛණ්ඩාංක පහකින් ආරම්භ කරන්න.
• සෑම එකක් සමඟම, නැවත කඳු මුදුනට නැඟීම. එනම් වත්මන් පිහිටීම අනුව, එහි වටිනාකම වත්මන් පික්සෙල් වලට වඩා වැඩි නම් උපරිම අසල්වැසි පික්සෙල් වෙත යන්න. ඔබේ ඇඟිලි ඛණ්ඩාංක චලනය වීම නතර වූ විට නවත්වන්න.

දිශානතියේ ගැටලුවට මුහුණ දීම සඳහා, ඔබට මූලික දිශාවන් සඳහා (උතුරු, උතුරු නැගෙනහිර, ආදිය) ආරම්භක සැකසුම් 8 ක් හෝ ඊට වැඩි ප්‍රමාණයක් තිබිය හැකිය. එක් එක් ඒවා තනි තනිව ධාවනය කර එකම පික්සෙල් එකක ඇඟිලි දෙකක් හෝ වැඩි ගණනක් අවසන් වන ප්‍රති results ල ඉවත දමන්න. මම මේ ගැන තව ටිකක් සිතන්නම්, නමුත් රූප සැකසීමේදී මේ ආකාරයේ දෙයක් තවමත් පර්යේෂණ කරමින් පවතී - නිවැරදි පිළිතුරු නොමැත!

තරමක් සංකීර්ණ අදහස: (බර) K- යන්න පොකුරුකරණය. එය එතරම් නරක නැත.

• ඇඟිලි ඛණ්ඩාංක පහකින් ආරම්භ කරන්න, නමුත් දැන් මේවා "පොකුරු මධ්‍යස්ථාන" වේ.

අභිසාරී වන තෙක් නැවත කියන්න:

• සෑම පික්සෙල් එකක්ම ආසන්නතම පොකුරට පවරන්න (එක් එක් පොකුරු සඳහා ලැයිස්තුවක් සාදන්න).
• එක් එක් පොකුරු ස්කන්ධයේ කේන්ද්‍රය ගණනය කරන්න. එක් එක් පොකුරු සඳහා, මෙය: එකතුව (ඛණ්ඩාංක * තීව්‍රතා අගය) / එකතුව (ඛණ්ඩාංක)
• සෑම පොකුරක්ම නව ස්කන්ධ කේන්ද්‍රයට ගෙන යන්න.

මෙම ක්‍රමය නිසැකවම වඩා හොඳ ප්‍රති results ල ලබා දෙන අතර ඇඟිලි හඳුනා ගැනීමට උපකාරී වන එක් එක් පොකුරු වල ස්කන්ධය ඔබට ලැබේ.

. දක්වා ඇත. දෙවැන්න සඳහා උදාහරණයක් වන්නේ මධ්‍යන්‍ය මාරුවයි .)

ක්‍රියාත්මක කිරීමේ තොරතුරු හෝ වෙනත් විශේෂතා නොමැති වීම ගැන කණගාටුයි. මම මෙය කේතනය කළ නමුත් මට නියමිත දිනක් තිබේ. ලබන සතිය වන විට වෙන කිසිවක් ක්‍රියාත්මක වී නොමැති නම් මට දන්වන්න, මම එය ලබා දෙන්නෙමි.

ඔබේ දත්ත කට්ටලය විශ්ලේෂණය කිරීම සඳහා අඛණ්ඩ සමජාතීයතාවයක් භාවිතා කිරීමෙන් මට පහත ප්‍රති result ලය ලැබේ (විශාල කිරීමට ක්ලික් කරන්න):

මෙම SO පිළිතුරෙහි විස්තර කර ඇති උපරිම හඳුනාගැනීමේ ක්‍රමයේ 2D අනුවාදය මෙයයි . ඉහත රූපයේ දැක්වෙන්නේ නොනැසී පැවතීම අනුව වර්ග කරන ලද 0-මාන අඛණ්ඩ සමජාතීය පන්ති ය.

මම මුල් දත්ත කට්ටලය scipy.misc.imresize () භාවිතා කරමින් 2 කින් වැඩි කළෙමි. කෙසේ වෙතත්, මා විසින් පාද හතරම එක දත්ත කට්ටලයක් ලෙස සැලකූ බව සලකන්න. එය හතරකට බෙදීමෙන් ගැටළුව පහසු වේ.

ක්‍රමවේදය. මෙය පිටුපස ඇති අදහස තරමක් සරල ය: එක් එක් පික්සෙල් මට්ටමට පවරන ශ්‍රිතයේ ශ්‍රිත ප්‍රස්තාරය සලකා බලන්න. එය මේ වගේ ය:

255 උසින් යුත් ජල මට්ටමක් අඛණ්ඩව පහළ මට්ටමට බැස යන ආකාරය දැන් සලකා බලන්න. දේශීය උපරිම දූපත් වල උත්පතන (උපත). සෑදලයේදී දූපත් දෙකක් ඒකාබද්ධ වේ; පහළ දූපත ඉහළ දූපතට (මරණය) ඒකාබද්ධ කිරීම ලෙස අපි සලකමු. ඊනියා නොනැසී පවත්නා රූප සටහන (0 වන මාන සමජාතීය පංතිවල, අපගේ දූපත්) සියලු දූපත් වල උපත් අගයන්ට වඩා මරණය නිරූපණය කරයි:

මෙම භෞතික සාධක දිවයින එවකට birth- සහ මරණය මට්ටමේ අතර ඇති වෙනස, තිත් වල සිරස් දුර අළු ප්‍රධාන විකර්ණයට. අඛණ්ඩතාව අඩු කිරීමෙන් රූපය දූපත් ලේබල් කරයි.

මුල්ම පින්තූරයේ දැක්වෙන්නේ දූපත් වල උපත් පිහිටීමයි. මෙම ක්‍රමය මඟින් දේශීය උපරිමය ලබා දෙනවා පමණක් නොව, ඉහත සඳහන් අඛණ්ඩතාවයෙන් ඒවායේ “වැදගත්කම” ප්‍රමාණාත්මක කරයි. එවිට යමෙක් සියළුම දූපත් ඉතා අඩු ස්ථීරභාවයකින් පෙරහන් කරයි. කෙසේ වෙතත්, ඔබේ උදාහරණයේ සෑම දිවයිනක්ම (එනම් සෑම දේශීය උපරිමයක්ම) ඔබ සොයන උච්චතම අවස්ථාවයි.

පයිතන් කේතය මෙහි සොයාගත හැකිය .

මෙම ගැටළුව භෞතික විද්‍යා by යින් විසින් යම් ගැඹුරකින් අධ්‍යයනය කර ඇත. ROOT හි හොඳ ක්‍රියාත්මක කිරීමක් තිබේ . දෙස බලා, TSpectrum පන්ති (විශේෂයෙන් TSpectrum2 ඔබගේ නඩුව සඳහා) සහ ඔවුන් සඳහා ලේඛගතකිරීම.

යොමුව:

1. එම්. මෝර්හාක් සහ වෙනත් අය: බහුමානීය අහඹු සිදුවීම් ගැමා කිරණ වර්ණාවලිය සඳහා පසුබිම් තුරන් කිරීමේ ක්‍රම. භෞතික විද්‍යා පර්යේෂණයේ න්‍යෂ්ටික උපකරණ සහ ක්‍රම A 401 (1997) 113-132.
2. එම්. මෝර්හාක් සහ වෙනත් අය: කාර්යක්ෂම එක් හා ද්විමාන රන් විසංයෝජනය සහ ගැමා කිරණ වර්ණාවලී විසංයෝජනය සඳහා එහි යෙදුම. න්‍යෂ්ටික උපකරණ සහ භෞතික විද්‍යා පර්යේෂණ ක්‍රම 401 (1997) 385-408.
3. එම්. මෝර්හාක් සහ වෙනත් අය: බහුමානීය අහඹු සිදුවීම් ගැමා කිරණ වර්ණාවලීක්ෂයේ උච්චයන් හඳුනා ගැනීම. පර්යේෂණ භෞතික විද්‍යාවේ න්‍යෂ්ටික උපකරණ සහ ක්‍රම A 443 (2000), 108-125.

... සහ NIM වෙත දායක වීමට ප්‍රවේශයක් නැති අය සඳහා:

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

මෙන්න අදහසක්: ඔබ රූපයේ (විවික්ත) ලැප්ලේෂියන් ගණනය කරයි. මුල් රූපවලට වඩා නාටකාකාර ලෙස එය උපරිම වශයෙන් (negative ණ සහ) විශාල වනු ඇතැයි මම අපේක්ෂා කරමි. මේ අනුව, මැක්සිම සොයා ගැනීම පහසු විය හැකිය.

මෙන්න තවත් අදහසක්: අධි පීඩන ලප වල සාමාන්‍ය ප්‍රමාණය ඔබ දන්නේ නම්, ඔබට මුලින්ම ඔබේ රූපය එකම ප්‍රමාණයේ ගෝස්ෂන් සමඟ කැටි ගැසීමෙන් සුමට කළ හැකිය. මෙය ඔබට සැකසීමට සරල රූප ලබා දෙනු ඇත.

මගේ හිසට ඉහළින් අදහස් කිහිපයක්:

• ස්කෑන් කිරීමේ ශ්‍රේණිය (ව්‍යුත්පන්නය) ගන්න, එය ව්‍යාජ ඇමතුම් ඉවත් කරන්නේ දැයි බලන්න
• දේශීය උපරිමයේ උපරිමය ගන්න

ඔබට OpenCV දෙස බැලීමට අවශ්‍ය විය හැකිය , එය තරමක් හොඳ පයිතන් API එකක් ඇති අතර ඔබට ප්‍රයෝජනවත් යැයි පෙනෙන සමහර ක්‍රියාකාරකම් තිබිය හැකිය.

මට විශ්වාසයි ඔබට මේ වන විට ඉදිරියට යාමට ප්‍රමාණවත් බව, නමුත් මට උදව් කළ නොහැකි නමුත් k-means පොකුරු ක්‍රමය භාවිතා කිරීමට යෝජනා කරන්න. k-means යනු අධීක්ෂණය නොකරන ලද පොකුරු ඇල්ගොරිතමයකි, එය ඔබට දත්ත ගෙන යනු ඇත (ඕනෑම මානයන් ගණනාවක - මම මෙය ත්‍රිමාණ ආකාරයෙන් සිදු කරමි) සහ එය විශේෂිත මායිම් සහිත k පොකුරු ලෙස සකස් කරන්න. මෙම සුනඛයින්ට (තිබිය යුතු) ඇඟිලි කීයක් තිබේදැයි ඔබ හරියටම දන්නා නිසා එය මෙහි හොඳයි.

මීට අමතරව, එය Scipy හි ක්‍රියාත්මක කර ඇති අතර එය ඇත්තෙන්ම හොඳයි ( http://docs.scipy.org/doc/scipy/reference/cluster.vq.html ).

ත්‍රිමාණ පොකුරු අවකාශීයව විසඳීමට එයට කළ හැකි දේ පිළිබඳ උදාහරණයක් මෙන්න:

ඔබට කිරීමට අවශ්‍ය වන්නේ ටිකක් වෙනස් (2D සහ පීඩන අගයන් ඇතුළත්), නමුත් මම තවමත් ඔබට සිතන්නේ ඔබට එය ලබා දිය හැකි බවයි.

අමු දත්ත වලට ස්තූතියි. මම දුම්රියේ සිටිමි, මෙය මා ලබා ඇති තාක් දුරට (මගේ නැවතුම පැමිණේ). මම ඔබේ ටෙක්ස්ට් ගොනුව රීජෙක්ස්ප් සමඟ සම්බාහනය කර දෘශ්‍යකරණය සඳහා ජාවාස්ක්‍රිප්ට් සහිත HTML පිටුවකට දැමුවෙමි. මම එය මෙහි බෙදාගන්නේ මා වැනි සමහරුන්ට එය පයිතන්ට වඩා පහසුවෙන් හැක් කළ හැකි බැවිනි.

මම හිතන්නේ හොඳ ප්‍රවේශයක් පරිමාණ සහ භ්‍රමණ වෙනස් නොවන අතර මගේ ඊළඟ පියවර වනුයේ ගවුසියානුවන්ගේ මිශ්‍රණයන් විමර්ශනය කිරීමයි. (සෑම උකස් පෑඩ්ම ගෝස්සියානු කේන්ද්‍රයක් වේ).

    <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>

භෞතික විද්‍යා solution යාගේ විසඳුම:
උකස් සලකුණු 5 ක් ඔවුන්ගේ තනතුරු මගින් හඳුනාගෙන X_iඒවා අහඹු ස්ථාන වලින් ආරම්භ කරන්න. සලකුණුවල අතිච්ඡාදනය සඳහා යම් ද punishment ුවමක් සමඟ උකස් ස්ථානවල සලකුණු ස්ථානගත කිරීම සඳහා යම් සම්මානයක් ඒකාබද්ධ කරමින් යම් ශක්ති ශ්‍රිතයක් අර්ථ දක්වන්න; අපි කියමු:

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

( S(X_i)වර්ග 2x2 ක මධ්‍යන්‍ය බලය X_i, alfaපර්යේෂණාත්මකව ඉහළට යා යුතු පරාමිතියකි)

මෙට්‍රොපොලිස්-හේස්ටිං මැජික් කිහිපයක් කිරීමට දැන් කාලය:
1. අහඹු සලකුණු තෝරන්න සහ අහඹු දිශාවට එක් පික්සෙල් එකකින් එය ගෙනයන්න.
2. dE ගණනය කරන්න, මෙම පියවර නිසා ඇති වූ ශක්ති වෙනස.
3. 0-1 සිට ඒකාකාර අහඹු අංකයක් ලබා ගෙන එය r ලෙස අමතන්න.
4. නම් dE<0හෝ exp(-beta*dE)>r, 1 වන දා දක්වා පියවරකට යන්න පිළිගන්නා එසේ නොවේ නම්, චලනය අහෝසි කර 1 වෙත යන්න
. සලකුණු කරුවන් උකස් බවට පත්වන තෙක් මෙය නැවත නැවතත් කළ යුතුය. වෙළඳාම ප්‍රශස්ත කිරීම සඳහා බීටා ස්කෑන් කිරීම පාලනය කරයි, එබැවින් එය පර්යේෂණාත්මකව ප්‍රශස්තිකරණය කළ යුතුය; සමාකරණයේ කාලයත් සමඟ එය නිරන්තරයෙන් වැඩි කළ හැකිය.

විශාල දුරේක්ෂයක් සඳහා සමාන දෙයක් කිරීමේදී මා භාවිතා කළ තවත් ප්‍රවේශයක් මෙන්න:

1) වැඩිම පික්සෙල් සඳහා සොයන්න. ඔබට එය ලැබුණු පසු, 2x2 සඳහා හොඳම සුදුසුකම සඳහා එය වටා සොයන්න (සමහර විට 2x2 එකතුව උපරිම කළ හැක), හෝ 4x4 යැයි කියනු ලබන උප කලාපය තුළ 2d ගෝස්ෂන් සුදුසුකමක් ඉහළම පික්සෙල් කේන්ද්‍ර කර ගන්න.

ඉන්පසු ඔබ සොයාගත් එම පික්සල් 2x2 උපරිම කේන්ද්‍රය වටා බිංදුවට (හෝ 3x3) සකසන්න

1 වෙත ආපසු යන්න) සහ ඉහළම කඳු මුදුන ශබ්ද සීමාවට වඩා පහළට වැටෙන තුරු නැවත නැවත කරන්න, නැතහොත් ඔබට අවශ්‍ය සියලුම ඇඟිලි තිබේ

ඔබට යම් පුහුණු දත්ත නිර්මාණය කිරීමට හැකි නම් ස්නායුක ජාලයන් සමඟ උත්සාහ කිරීම වටී ... නමුත් මේ සඳහා අතින් විවරණය කළ බොහෝ සාම්පල අවශ්‍ය වේ.

දළ සටහනක් ...

එක් එක් උකස් කලාපය හුදකලා කිරීම සඳහා සම්බන්ධිත සංරචක ඇල්ගොරිතමයක් භාවිතා කිරීමට ඔබට අවශ්‍ය වනු ඇත. විකීට මෙහි හොඳ විස්තරයක් ඇත (යම් කේතයක් සමඟ): http://en.wikipedia.org/wiki/Connected_Component_Labeling

සම්බන්ධතාවය 4 හෝ 8 භාවිතා කළ යුතුද යන්න පිළිබඳව ඔබට තීරණයක් ගැනීමට සිදුවේ. පුද්ගලිකව, බොහෝ ගැටලු සඳහා මම 6 සම්බන්ධතාවයට කැමැත්තෙමි. කෙසේ වෙතත්, ඔබ එක් එක් "උකස් මුද්‍රණය" සම්බන්ධිත කලාපයක් ලෙස වෙන් කළ පසු, කලාපය හරහා නැවත කියවීමට සහ උපරිමය සොයා ගැනීමට එය පහසු විය යුතුය. ඔබ උපරිමය සොයාගත් පසු, ඔබ ලබා දුන් “ඇඟිල්ලක්” ලෙස හඳුනා ගැනීම සඳහා කලින් තීරණය කළ එළිපත්තකට ළඟා වන තෙක් කලාපය නැවත විශාල කර ගත හැකිය.

මෙහි ඇති එක් සියුම් ගැටළුවක් නම්, ඔබ දකුණේ / වමේ / ඉදිරිපස / පසුපස ඉත්තක් ලෙස යමක් හඳුනා ගැනීමට පරිගණක දර්ශන ශිල්පීය ක්‍රම භාවිතා කිරීමට පටන් ගත් වහාම ඔබ තනි ඇඟිලි දෙස බැලීමට පටන් ගත් වහාම, ඔබ භ්‍රමණයන්, ස්කීස් සහ පරිවර්තන සැලකිල්ලට ගැනීම ආරම්භ කළ යුතුය. මෙය සිදු කරනු ලබන්නේ ඊනියා "මොහොත" විශ්ලේෂණය කිරීමෙනි. දර්ශන යෙදුම්වල සලකා බැලිය යුතු වෙනස් අවස්ථා කිහිපයක් තිබේ:

කේන්ද්‍රීය අවස්ථා: පරිවර්තන වෙනස් නොවන සාමාන්‍යකරණය වූ අවස්ථා: පරිමාණය සහ පරිවර්තනය වෙනස් නොවන මොහොත: පරිවර්තනය, පරිමාණය සහ භ්‍රමණ ආක්‍රමණ

විකියේ "රූප මොහොත" සෙවීමෙන් මොහොත පිළිබඳ වැඩි විස්තර සොයාගත හැකිය.

සමහර විට ඔබට ගවුසියානු මිශ්‍රණ ආකෘති වැනි දෙයක් භාවිතා කළ හැකිය. GMMs කිරීම සඳහා පයිතන් පැකේජයක් මෙන්න (ගූගල් සෙවුමක් කළා) http://www.ar.media.kyoto-u.ac.jp/members/david/softwares/em/

maximaපයිතන් සමඟ රූපවල දේශීය සොයා ගැනීමට හොඳ විකල්පයක් ඇති බව ඔබට කියන්නට අවශ්‍යයි :

from skimage.feature import peak_local_max

හෝ හිස් කබල සඳහා 0.8.0:

from skimage.feature.peak import peak_local_max

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

ජෙට්සිගේ ඇල්ගොරිතම භාවිතා කර ඔබට ටිකක් වංචා කළ හැකි බව පෙනේ. ඔහු පළමු ඇඟිලි තුන හොඳින් සොයාගෙන ඇති අතර, සිව්වැන්න පදනම් වී ඇත්තේ කොහෙන්දැයි ඔබට අනුමාන කළ හැකිය.

සිත්ගන්නා ගැටළුව. මම උත්සාහ කරන විසඳුම පහත දැක්වේ.

1. 2D ගෝස්ෂන් වෙස් මුහුණක් සහිත සම්මුතියක් වැනි අඩු පාස් ෆිල්ටරයක් ​​යොදන්න. මෙය ඔබට (බොහෝ විට, නමුත් අවශ්‍යයෙන්ම පාවෙන ලක්ෂ්‍යයක් නොවේ) අගයන් රාශියක් ලබා දෙනු ඇත.

2. එක් එක් උකස් පෑඩ් (හෝ ඇඟිලි) වල දන්නා ආසන්න අරය භාවිතා කරමින් ද්විමාන උපරිම නොවන මර්ධනයක් සිදු කරන්න.

එකිනෙකට සමීප අපේක්ෂකයන් කිහිප දෙනෙකු නොමැතිව මෙය ඔබට උපරිම තනතුරු ලබා දිය යුතුය. පැහැදිලි කිරීම සඳහා, 1 වන පියවරේ වෙස් මුහුණෙහි අරය ද පියවර 2 හි භාවිතා කරන අරයට සමාන විය යුතුය. මෙම අරය තෝරා ගත හැකි විය හැකිය, නැතහොත් පශු වෛද්‍යවරයාට එය කලින් මැනිය හැකිය (එය වයස / අභිජනනය / යනාදිය අනුව වෙනස් වේ).

යෝජනා කරන ලද සමහර විසඳුම් (මධ්යන්ය මාරුව, ස්නායුක දැල් සහ යනාදිය) බොහෝ දුරට යම් දුරකට ක්රියා කරනු ඇත, නමුත් ඕනෑවට වඩා සංකීර්ණ වන අතර බොහෝ විට පරමාදර්ශී නොවේ.

හොඳයි, මෙන්න සරල හා භයානක කාර්යක්ෂම කේත කිහිපයක්, නමුත් දත්ත කට්ටලයක මෙම ප්‍රමාණය සඳහා එය හොඳයි.

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]

මම මූලික වශයෙන් ඉහළ වමේ පිහිටීම සහ සෑම 2x2 වර්ගයක එකතුව සමඟ අරාවක් සාදා එය එකතුවෙන් වර්ග කරන්නෙමි. මම පසුව 2x2 චතුරස්රය වැඩිම විවාදයකින් තොරව ගෙන, එය bestඅරාව තුළට දමා , දැන් ඉවත් කරන ලද 2x2 චතුරස්රයේ ඕනෑම කොටසක් භාවිතා කළ අනෙකුත් 2x2 වර්ග ඉවත් කරන්නෙමි.

අන්තිම පාදයේ (ඔබේ පළමු පින්තූරයේ දකුණු කෙළවරේ ඇති කුඩාම මුදල සහිත) හැර එය හොඳින් ක්‍රියාත්මක වන බව පෙනේ, විශාල මුදලක් සහිත තවත් සුදුසුකම් ලත් 2x2 වර්ග දෙකක් ඇති බව පෙනේ (ඒවාට සමාන මුදලක් ඇත එකිනෙකා). ඒවායින් එකක් තවමත් ඔබේ 2x2 චතුරස්රයෙන් එක් වර්ගයක් තෝරාගෙන ඇත, නමුත් අනෙක වමට හැරී ඇත. වාසනාවකට මෙන්, වාසනාවකට මෙන් ඔබට අවශ්‍ය තවත් දේ තෝරා ගැනීමට අපි දකිමු, නමුත් මේ සඳහා ඔබට සැබවින්ම අවශ්‍ය දේ ලබා ගැනීමට වෙනත් අදහස් භාවිතා කිරීමට අවශ්‍ය විය හැකිය.

සමහර විට බොළඳ ප්‍රවේශයක් මෙහි ප්‍රමාණවත් වේ: ඔබේ ගුවන් යානයේ ඇති සියලුම වර්ග 2x2 ලැයිස්තුවක් සාදන්න, ඒවායේ එකතුව අනුව ඇණවුම් කරන්න (බැසීමේ අනුපිළිවෙලින්).

පළමුව, ඔබේ "උකස් ලැයිස්තුවට" ඉහළම වටිනාකමක් ඇති චතුරස්රය තෝරන්න. ඉන්පසු, කලින් සොයාගත් කිසිදු චතුරස්රයක් සමඟ නොගැලපෙන ඊළඟ හොඳම චතුරස්රයන් 4 ක් නැවත තෝරා ගන්න.

තාරකා විද්‍යා හා විශ්ව විද්‍යා ප්‍රජාවෙන් ලබා ගත හැකි පුළුල් හා පුළුල් මෘදුකාංග කිහිපයක් තිබේ - මෙය ically තිහාසිකව හා වර්තමානයේ පර්යේෂණයේ වැදගත් ක්ෂේත්‍රයකි.

ඔබ තාරකා විද්‍යා r යෙකු නොවේ නම් කලබල නොවන්න - සමහර ඒවා ක්ෂේත්‍රයෙන් පිටත භාවිතා කිරීමට පහසුය. උදාහරණයක් ලෙස, ඔබට තාරකා විද්‍යාව / ඡායාරූපකරණය භාවිතා කළ හැකිය:

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

[ඔවුන්ගේ කෙටි නියැදි කේතය මෙහි පුනරාවර්තනය කිරීම තරමක් රළු බවක් පෙනේ.]

උනන්දුවක් දැක්විය හැකි ශිල්පීය / පැකේජ / සබැඳි වල අසම්පූර්ණ හා තරමක් පක්ෂග්‍රාහී ලැයිස්තුවක් පහත දැක්වේ - අදහස් දැක්වීම්වල වැඩි යමක් එකතු කරන්න, අවශ්‍ය පරිදි මම මෙම පිළිතුර යාවත්කාලීන කරමි. ඇත්ත වශයෙන්ම ගණනය කිරීමේ සම්පත් හා නිරවද්‍යතාවයේ වෙළඳාමක් තිබේ. [අවංකවම, මේ හා සමාන පිළිතුරක කේත උදාහරණ ලබා දීමට බොහෝ දේ ඇත, එබැවින් මෙම පිළිතුර පියාසර කරයිද නැද්ද යන්න මට විශ්වාස නැත.]

මූලාශ්‍ර නිස්සාරකය https://www.astromatic.net/software/sextractor

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

ASKAP / EMU ප්‍රභව සෙවීමේ අභියෝගය: https://arxiv.org/abs/1509.03931

ඔබට ප්ලෑන්ක් සහ / හෝ ඩබ්ලිව්එම්ඒපී ප්‍රභව-නිස්සාරණ අභියෝග සෙවිය හැකිය.

...

ඔබ පියවරෙන් පියවර ඉදිරියට ගියහොත් කුමක් කළ යුතුද: ඔබ මුලින්ම ගෝලීය උපරිමය සොයා ගන්න, අවට ලකුණු අවශ්‍ය නම් ඒවා ක්‍රියාවට නංවා, සොයාගත් කලාපය බිංදුවට සකසා ඊළඟ එක සඳහා නැවත කරන්න.

මෙය ප්‍රශ්නයට පිළිතුරු සපයන බව මට විශ්වාස නැත, නමුත් ඔබට අසල්වැසියන් නොමැති උසම කඳු මුදුන් සොයා ගත හැකි බව පෙනේ.

මෙන්න සාරාංශය. එය රූබි වල ඇති බව සලකන්න, නමුත් අදහස පැහැදිලි විය යුතුය.

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