Si solo quieres regiones (semi) contiguas, ya hay una implementación fácil en Python: SciPy's ndimage.morphology módulo. Esta es una operación bastante común image morphology.
Básicamente, usted tiene 5 pasos:
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
falta de definición de los datos de entrada un poco para asegurarse de que las patas tienen una huella continua. (Sería más eficiente de usar sólo un núcleo más grande (el structure kwarg a las diversas funciones scipy.ndimage.morphology), pero esto no es del todo funciona correctamente por alguna razón ...)
Umbral de la matriz para que tenga una matriz booleana de los lugares donde la presión es más de un cierto valor umbral (es decir thresh = data > value)
Rellene los agujeros internos, para que tenga regiones más limpios (filled = sp.ndimage.morphology.binary_fill_holes(thresh))
Encuentra las regiones contiguas separadas (coded_paws, num_paws = sp.ndimage.label(filled)). Esto devuelve una matriz con las regiones codificadas por número (cada región es un área contigua de un entero único (1 hasta el número de patas) con ceros en cualquier otro lugar)).
Aislar las regiones contiguas usando data_slices = sp.ndimage.find_objects(coded_paws). Esto devuelve una lista de tuplas de objetos slice, por lo que podría obtener la región de los datos para cada pata con [data[x] for x in data_slices]. En su lugar, dibujaremos un rectángulo basado en estas divisiones, lo que requiere un poco más de trabajo.
Las dos animaciones de abajo muestran sus patas "superposición" y "agrupados" Patas de datos de ejemplo. Este método parece estar funcionando perfectamente. (Y por si sirve de algo, esto va mucho más suavemente que las imágenes GIF a continuación en mi máquina, por lo que el algoritmo de detección de la pata es bastante rápido ...)
Aquí hay una completa ejemplo (ahora con explicaciones mucho más detalladas). La gran mayoría de esto es leer la entrada y hacer una animación. La detección real de la pata es solo 5 líneas de código.
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')
Actualización: En cuanto a la identificación de la que la pata está en contacto con el sensor en qué momento, la solución más sencilla es simplemente hacer el mismo análisis, pero el uso de todos los datos a la vez. (es decir, apilar la entrada en una matriz 3D y trabajar con ella, en lugar de los marcos de tiempo individuales). Debido a que las funciones de nimagen de SciPy están pensadas para trabajar con matrices n-dimensionales, no tenemos que modificar la función original de búsqueda de la pata en absoluto.
# 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')
Parece que tendría que dar la espalda al algoritmo de fila/columna que está limitando una información útil. –
¡Guau! Software de control de gato? – alxx
Son datos de perros en realidad @alxx ;-) ¡Pero sí, se usarán para diagnosticarlos! –