python मैं अपने पंजा पहचान में सुधार कैसे कर सकता हूं?




image-processing (3)

प्रत्येक पंजा के अंदर पैर की उंगलियों को खोजने पर मेरे पिछले प्रश्न के बाद, मैंने यह देखने के लिए अन्य मापों को लोड करना शुरू कर दिया कि यह कैसा रहेगा। दुर्भाग्यवश, मैंने पहले के चरणों में से एक के साथ जल्दी से एक समस्या में भाग लिया: पंजा को पहचानना।

आप देखते हैं, अवधारणा के मेरे प्रमाण ने मूल रूप से समय के साथ प्रत्येक सेंसर का अधिकतम दबाव लिया और प्रत्येक पंक्ति के योग की तलाश करना शुरू कर दिया, जब तक कि वह उस पर न मिले! = 0.0। फिर यह कॉलम के लिए समान होता है और जैसे ही इसे 2 से अधिक पंक्तियां मिलती हैं, फिर शून्य होती है। यह कुछ सूचकांक में न्यूनतम और अधिकतम पंक्ति और कॉलम मान संग्रहीत करता है।

जैसा कि आप आंकड़े में देख सकते हैं, यह ज्यादातर मामलों में काफी अच्छा काम करता है। हालांकि, इस दृष्टिकोण के लिए बहुत सारे डाउनसाइड्स हैं (बहुत आदिम होने के अलावा):

  • मनुष्यों के पास 'खोखले पैर' हो सकते हैं जिसका अर्थ है कि पदचिह्न के भीतर कई खाली पंक्तियां हैं। चूंकि मुझे डर था कि यह (बड़े) कुत्तों के साथ भी हो सकता है, मैंने पंजा को काटने से पहले कम से कम 2 या 3 खाली पंक्तियों का इंतजार किया।

    यह एक समस्या पैदा करता है यदि एक अलग कॉलम में एक और कॉल किया जाता है इससे पहले कि यह कई रिक्त पंक्तियों तक पहुंच जाए, इस प्रकार क्षेत्र का विस्तार हो। मुझे लगता है कि मैं कॉलम की तुलना कर सकता हूं और देख सकता हूं कि वे एक निश्चित मूल्य से अधिक हैं, तो उन्हें अलग-अलग पंजे होना चाहिए।

  • जब कुत्ता बहुत छोटा होता है या उच्च गति से चलता है तो समस्या खराब हो जाती है। क्या होता है कि सामने के पंजे के पैर अभी भी संपर्क कर रहे हैं, जबकि हिंड पंजा के पैर की अंगुली सामने के पंजे के समान क्षेत्र में संपर्क करना शुरू कर देती है!

    मेरी सरल लिपि के साथ, यह इन दोनों को विभाजित करने में सक्षम नहीं होगा, क्योंकि यह निर्धारित करना होगा कि उस क्षेत्र के कौन से फ्रेम उस पंजा से संबंधित हैं, जबकि वर्तमान में मुझे केवल सभी फ्रेमों पर अधिकतम मूल्यों को देखना होगा।

उदाहरण कहां गलत हो रहा है:

तो अब मैं पंजे को पहचानने और अलग करने का एक बेहतर तरीका ढूंढ रहा हूं (जिसके बाद मुझे यह तय करने की समस्या होगी कि यह कौन सा पंजा है!)।

अद्यतन करें:

मैं जो के (भयानक!) उत्तर को लागू करने के लिए झुका रहा हूं, लेकिन मुझे अपनी फाइलों से वास्तविक पंजा डेटा निकालने में कठिनाइयों का सामना करना पड़ रहा है।

अधिकतम दबाव छवि (ऊपर देखें) पर लागू होने पर कोडित_पॉज मुझे सभी अलग-अलग पंजे दिखाता है। हालांकि, समाधान प्रत्येक फ्रेम (ओवरलैपिंग पंजा को अलग करने के लिए) पर चला जाता है और चार आयताकार गुण, जैसे निर्देशांक या ऊंचाई / चौड़ाई सेट करता है।

मैं यह नहीं समझ सकता कि इन विशेषताओं को कैसे लेना है और उन्हें कुछ चर में संग्रहीत करना है जिसे मैं माप डेटा पर लागू कर सकता हूं। चूंकि मुझे प्रत्येक पंजा के बारे में जानने की ज़रूरत है, तो इसका स्थान क्या होता है, जिसके दौरान फ्रेम और जोड़े को यह पंजा (सामने / बाएं, बाएं / दाएं) होता है।

तो मैं प्रत्येक पंजा के लिए इन मानों को निकालने के लिए आयत गुणों का उपयोग कैसे कर सकता हूं?

मेरे पास मेरे सार्वजनिक ड्रॉपबॉक्स फ़ोल्डर ( उदाहरण 1 , उदाहरण 2 , उदाहरण 3 ) में प्रश्न सेटअप में उपयोग किए गए माप हैं। किसी भी दिलचस्पी के लिए मैंने आपको अद्यतित रखने के लिए एक ब्लॉग भी स्थापित किया है :-)


मैं छवि पहचान में कोई विशेषज्ञ नहीं हूं, और मुझे पायथन नहीं पता, लेकिन मैं इसे एक सनकी दे दूंगा ...

व्यक्तिगत पंजा का पता लगाने के लिए, आपको सबसे पहले कुछ छोटे थ्रेसहोल्ड से अधिक दबाव वाले सब कुछ का चयन करना चाहिए, बिल्कुल कोई दबाव नहीं है। इस उपरोक्त प्रत्येक पिक्सेल / बिंदु को "चिह्नित" होना चाहिए। फिर, सभी "चिह्नित" पिक्सेल के समीप प्रत्येक पिक्सेल चिह्नित हो जाता है, और यह प्रक्रिया कुछ बार दोहराई जाती है। जो लोग पूरी तरह से जुड़े हुए हैं, उनका गठन किया जाएगा, इसलिए आपके पास अलग-अलग वस्तुएं हैं। फिर, प्रत्येक "ऑब्जेक्ट" में न्यूनतम और अधिकतम x और y मान होता है, इसलिए बाउंडिंग बॉक्स को उनके चारों ओर अच्छी तरह से पैक किया जा सकता है।

स्यूडोकोड:

(MARK) ALL PIXELS ABOVE (0.5)

(MARK) ALL PIXELS (ADJACENT) TO (MARK) PIXELS

REPEAT (STEP 2) (5) TIMES

SEPARATE EACH TOTALLY CONNECTED MASS INTO A SINGLE OBJECT

MARK THE EDGES OF EACH OBJECT, AND CUT APART TO FORM SLICES.

ऐसा करने के बारे में होना चाहिए।


यदि आप केवल (अर्ध) संगत क्षेत्रों की इच्छा रखते हैं, तो पाइथन में पहले से ही एक आसान कार्यान्वयन है: SciPy 's ndimage.morphology मॉड्यूल। यह एक काफी आम छवि morphology ऑपरेशन है।

असल में, आपके पास 5 कदम हैं:

def find_paws(data, smooth_radius=5, threshold=0.0001):
    data = sp.ndimage.uniform_filter(data, smooth_radius)
    thresh = data > threshold
    filled = sp.ndimage.morphology.binary_fill_holes(thresh)
    coded_paws, num_paws = sp.ndimage.label(filled)
    data_slices = sp.ndimage.find_objects(coded_paws)
    return object_slices
  1. यह सुनिश्चित करने के लिए कि पंजा के पास लगातार पदचिह्न है, इनपुट डेटा को थोड़ा सा धुंधला करें। (यह एक बड़े कर्नेल (विभिन्न scipy.ndimage.morphology कार्यों के लिए structure kwarg) का उपयोग करने के लिए और अधिक कुशल होगा, लेकिन यह किसी कारण से ठीक से काम नहीं कर रहा है ...)

  2. सरणी को थ्रेसहोल्ड करें ताकि आपके पास उन स्थानों की एक बूलियन सरणी हो जहां दबाव कुछ थ्रेसहोल्ड मान (यानी thresh = data > value ) पर है

  3. किसी आंतरिक छेद को भरें, ताकि आपके पास क्लीनर क्षेत्र हों ( filled = sp.ndimage.morphology.binary_fill_holes(thresh) )

  4. अलग संगत क्षेत्रों को खोजें ( coded_paws, num_paws = sp.ndimage.label(filled) )। यह संख्या के अनुसार कोडित क्षेत्रों के साथ एक सरणी देता है (प्रत्येक क्षेत्र एक अद्वितीय पूर्णांक (पंजे की संख्या तक 1) के एक संगत क्षेत्र है जहां हर जगह शून्य है)।

  5. data_slices = sp.ndimage.find_objects(coded_paws) का उपयोग कर संगत क्षेत्रों को अलग करें। यह slice ऑब्जेक्ट्स के tuples की एक सूची देता है, ताकि आप प्रत्येक पंजा के लिए [data[x] for x in data_slices] डेटा के लिए डेटा प्राप्त कर [data[x] for x in data_slices] । इसके बजाए, हम इन स्लाइसों के आधार पर एक आयत खींचेंगे, जो थोड़ा और काम लेता है।

नीचे दिए गए दो एनिमेशन आपके "ओवरलैपिंग Paws" और "Grouped Paws" उदाहरण डेटा दिखाते हैं। यह विधि पूरी तरह से काम कर रही प्रतीत होती है। (और जो भी इसके लायक है, यह मेरी मशीन पर नीचे दी गई जीआईएफ छवियों की तुलना में अधिक सुचारू रूप से चलता है, इसलिए पंजा पहचान एल्गोरिदम काफी तेज़ है ...)

यहां एक पूर्ण उदाहरण है (अब अधिक विस्तृत स्पष्टीकरण के साथ)। इसका विशाल बहुमत इनपुट पढ़ रहा है और एक एनीमेशन बना रहा है। वास्तविक पंजा पहचान कोड की केवल 5 पंक्तियां हैं।

import numpy as np
import scipy as sp
import scipy.ndimage

import matplotlib.pyplot as plt
from matplotlib.patches import Rectangle

def animate(input_filename):
    """Detects paws and animates the position and raw data of each frame
    in the input file"""
    # With matplotlib, it's much, much faster to just update the properties
    # of a display object than it is to create a new one, so we'll just update
    # the data and position of the same objects throughout this animation...

    infile = paw_file(input_filename)

    # Since we're making an animation with matplotlib, we need 
    # ion() instead of show()...
    plt.ion()
    fig = plt.figure()
    ax = fig.add_subplot(111)
    fig.suptitle(input_filename)

    # Make an image based on the first frame that we'll update later
    # (The first frame is never actually displayed)
    im = ax.imshow(infile.next()[1])

    # Make 4 rectangles that we can later move to the position of each paw
    rects = [Rectangle((0,0), 1,1, fc='none', ec='red') for i in range(4)]
    [ax.add_patch(rect) for rect in rects]

    title = ax.set_title('Time 0.0 ms')

    # Process and display each frame
    for time, frame in infile:
        paw_slices = find_paws(frame)

        # Hide any rectangles that might be visible
        [rect.set_visible(False) for rect in rects]

        # Set the position and size of a rectangle for each paw and display it
        for slice, rect in zip(paw_slices, rects):
            dy, dx = slice
            rect.set_xy((dx.start, dy.start))
            rect.set_width(dx.stop - dx.start + 1)
            rect.set_height(dy.stop - dy.start + 1)
            rect.set_visible(True)

        # Update the image data and title of the plot
        title.set_text('Time %0.2f ms' % time)
        im.set_data(frame)
        im.set_clim([frame.min(), frame.max()])
        fig.canvas.draw()

def find_paws(data, smooth_radius=5, threshold=0.0001):
    """Detects and isolates contiguous regions in the input array"""
    # Blur the input data a bit so the paws have a continous footprint 
    data = sp.ndimage.uniform_filter(data, smooth_radius)
    # Threshold the blurred data (this needs to be a bit > 0 due to the blur)
    thresh = data > threshold
    # Fill any interior holes in the paws to get cleaner regions...
    filled = sp.ndimage.morphology.binary_fill_holes(thresh)
    # Label each contiguous paw
    coded_paws, num_paws = sp.ndimage.label(filled)
    # Isolate the extent of each paw
    data_slices = sp.ndimage.find_objects(coded_paws)
    return data_slices

def paw_file(filename):
    """Returns a iterator that yields the time and data in each frame
    The infile is an ascii file of timesteps formatted similar to this:

    Frame 0 (0.00 ms)
    0.0 0.0 0.0
    0.0 0.0 0.0

    Frame 1 (0.53 ms)
    0.0 0.0 0.0
    0.0 0.0 0.0
    ...
    """
    with open(filename) as infile:
        while True:
            try:
                time, data = read_frame(infile)
                yield time, data
            except StopIteration:
                break

def read_frame(infile):
    """Reads a frame from the infile."""
    frame_header = infile.next().strip().split()
    time = float(frame_header[-2][1:])
    data = []
    while True:
        line = infile.next().strip().split()
        if line == []:
            break
        data.append(line)
    return time, np.array(data, dtype=np.float)

if __name__ == '__main__':
    animate('Overlapping paws.bin')
    animate('Grouped up paws.bin')
    animate('Normal measurement.bin')

अद्यतन: जहां तक ​​यह पता लगाने के लिए कि कौन सा पंजा सेंसर के संपर्क में है, सबसे सरल समाधान केवल वही विश्लेषण करना है, लेकिन एक ही समय में सभी डेटा का उपयोग करें। (यानी एक 3 डी सरणी में इनपुट को ढेर करें, और व्यक्तिगत समय फ्रेम के बजाय इसके साथ काम करें।) क्योंकि साइपी के एनडिमेज फ़ंक्शन एन-आयामी सरणी के साथ काम करने के लिए हैं, इसलिए हमें मूल पंजा-फ़ंक्शन फ़ंक्शन को संशोधित करने की आवश्यकता नहीं है बिलकुल।

# This uses functions (and imports) in the previous code example!!
def paw_regions(infile):
    # Read in and stack all data together into a 3D array
    data, time = [], []
    for t, frame in paw_file(infile):
        time.append(t)
        data.append(frame)
    data = np.dstack(data)
    time = np.asarray(time)

    # Find and label the paw impacts
    data_slices, coded_paws = find_paws(data, smooth_radius=4)

    # Sort by time of initial paw impact... This way we can determine which
    # paws are which relative to the first paw with a simple modulo 4.
    # (Assuming a 4-legged dog, where all 4 paws contacted the sensor)
    data_slices.sort(key=lambda dat_slice: dat_slice[2].start)

    # Plot up a simple analysis
    fig = plt.figure()
    ax1 = fig.add_subplot(2,1,1)
    annotate_paw_prints(time, data, data_slices, ax=ax1)
    ax2 = fig.add_subplot(2,1,2)
    plot_paw_impacts(time, data_slices, ax=ax2)
    fig.suptitle(infile)

def plot_paw_impacts(time, data_slices, ax=None):
    if ax is None:
        ax = plt.gca()

    # Group impacts by paw...
    for i, dat_slice in enumerate(data_slices):
        dx, dy, dt = dat_slice
        paw = i%4 + 1
        # Draw a bar over the time interval where each paw is in contact
        ax.barh(bottom=paw, width=time[dt].ptp(), height=0.2, 
                left=time[dt].min(), align='center', color='red')
    ax.set_yticks(range(1, 5))
    ax.set_yticklabels(['Paw 1', 'Paw 2', 'Paw 3', 'Paw 4'])
    ax.set_xlabel('Time (ms) Since Beginning of Experiment')
    ax.yaxis.grid(True)
    ax.set_title('Periods of Paw Contact')

def annotate_paw_prints(time, data, data_slices, ax=None):
    if ax is None:
        ax = plt.gca()

    # Display all paw impacts (sum over time)
    ax.imshow(data.sum(axis=2).T)

    # Annotate each impact with which paw it is
    # (Relative to the first paw to hit the sensor)
    x, y = [], []
    for i, region in enumerate(data_slices):
        dx, dy, dz = region
        # Get x,y center of slice...
        x0 = 0.5 * (dx.start + dx.stop)
        y0 = 0.5 * (dy.start + dy.stop)
        x.append(x0); y.append(y0)

        # Annotate the paw impacts         
        ax.annotate('Paw %i' % (i%4 +1), (x0, y0),  
            color='red', ha='center', va='bottom')

    # Plot line connecting paw impacts
    ax.plot(x,y, '-wo')
    ax.axis('image')
    ax.set_title('Order of Steps')


नोट: मैं पिक्सेल कहता हूं, लेकिन यह पिक्सल के औसत का उपयोग कर क्षेत्र हो सकता है। अनुकूलन एक और मुद्दा है ...

लगता है जैसे आपको प्रत्येक पिक्सेल के लिए एक फ़ंक्शन (समय के साथ दबाव) का विश्लेषण करने की आवश्यकता होती है और यह निर्धारित करता है कि फ़ंक्शन कहां बदलता है (जब यह बदलता है> दूसरी दिशा में एक्स को त्रुटियों का सामना करने के लिए एक मोड़ माना जाता है)।

यदि आप जानते हैं कि यह किस फ्रेम में बदल जाता है, तो आप उस फ्रेम को जानेंगे जहां दबाव सबसे कठिन था और आपको पता चलेगा कि यह दो पंजे के बीच कम से कम कठिन था। सिद्धांत रूप में, फिर आप उन दो फ्रेमों को जानेंगे जहां पंजे सबसे कठिन दबाते हैं और उन अंतराल के औसत की गणना कर सकते हैं।

इसके बाद मुझे यह तय करने की समस्या होगी कि यह कौन सा पंजा है!

यह पहले जैसा ही दौरा है, यह जानकर कि जब प्रत्येक पंजा सबसे अधिक दबाव लागू करता है तो आपको निर्णय लेने में मदद मिलती है।







image-processing