def test_zernike_cm():
A = (np.arange(256) % 14).reshape((16, 16))
cm = (8.9,12.4)
slow = _slow_zernike(A, 8., 12, cm)
fast = zernike_moments(A, 8., 12, cm=cm)
delta = np.array(slow) - fast
assert np.abs(delta).max() < 0.001
def test_zernike_cm():
A = (np.arange(256) % 14).reshape((16, 16))
cm = (8.9, 12.4)
slow = _slow_zernike(A, 8., 12, cm)
fast = zernike_moments(A, 8., 12, cm=cm)
delta = np.array(slow) - fast
assert np.abs(delta).max() < 0.001
def _extract_features(self, X, candidate):
row, col, radius = int(candidate[0]), int(candidate[1]), int(
candidate[2])
padded_radius = int(self.padding * radius)
# compute the coordinate of the patch to select
col_min = max(col - padded_radius, 0)
row_min = max(row - padded_radius, 0)
col_max = min(col + padded_radius, X.shape[0] - 1)
row_max = min(row + padded_radius, X.shape[1] - 1)
# extract patch
patch = X[row_min:row_max, col_min:col_max]
resized_patch = resize(patch, (self.resized, self.resized))
# compute Zernike moments
zernike = zernike_moments(patch, radius)
# compute surf descriptors
scale_surf = 2 * self.padding * radius / 20
keypoint = np.array([[row, col, scale_surf, 0.1, 1]])
surf_descriptor = surf.descriptors(X, keypoint,
is_integral=False).ravel()
if not surf_descriptor.size:
surf_descriptor = np.zeros((70,))
# compute haar-like features
haar_features = extract_feature_image(resized_patch, self.feature_type,
self.feature_coord)
return np.hstack((zernike, surf_descriptor, haar_features))
def treatImage(frame):
frame = cv2.resize(frame, (240, 240))
# aplica filtro gaussiano e coloca imagem preto e branco
img_grey = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
img_grey = cv2.GaussianBlur(img_grey, (5, 5), 0)
# aplica otsu para binarizar
ret, img_grey = cv2.threshold(img_grey, 0, 255,
cv2.THRESH_BINARY + cv2.THRESH_OTSU)
#tira o contorno da imagem
contours, heirarchy = cv2.findContours(img_grey, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
borderImg = np.zeros((240, 240, 3), np.uint8)
cv2.drawContours(borderImg, contours, -1, (125, 125, 0), 1)
borderGrey = cv2.cvtColor(borderImg, cv2.COLOR_BGR2GRAY)
# Calculate Moments
moment = cv2.moments(borderGrey)
# Calculate Hu Moments
huMoments = cv2.HuMoments(moment)
# Calcula momento de Zernike
zeMoments = zernike_moments(borderGrey, radius=20)
# cv2.imshow("Imagem capturada", img_grey)
# cv2.waitKey(0)
return huMoments + zeMoments
def _extract_features(self, X, candidate):
y, x, radius = int(candidate[0]), int(candidate[1]), candidate[2]
padded_radius = int(self.padding * radius)
# compute the coordinate of the patch to select
x_min = x - padded_radius
x_min = x_min if x_min < 0 else 0
y_min = y - padded_radius
y_min = y_min if y_min < 0 else 0
x_max = x + padded_radius
x_max = x_max if x_max > X.shape[0] else X.shape[0] - 1
y_max = y + padded_radius
y_max = y_max if y_max > X.shape[1] else X.shape[1] - 1
patch = X[y_min:y_max, x_min:x_max]
# compute Zernike moments
zernike = zernike_moments(patch, radius)
# compute SURF descriptor
keypoint = np.array([[y, x, 1, 0.1, 1]])
surf_descriptor = surf.descriptors(patch, keypoint,
is_integral=False).ravel()
if not surf_descriptor.size:
surf_descriptor = np.zeros((70, ))
return np.hstack((zernike, surf_descriptor))
def _extract_features(self, X, candidate):
y, x, radius = int(candidate[0]), int(candidate[1]), candidate[2]
padded_radius = int(self.padding * radius)
# compute the coordinate of the patch to select
x_min = max(x - padded_radius, 0)
y_min = max(y - padded_radius, 0)
x_max = min(x + padded_radius, X.shape[0] - 1)
y_max = min(y + padded_radius, X.shape[1] - 1)
patch = X[y_min:y_max, x_min:x_max]
# compute Zernike moments
zernike = zernike_moments(patch, radius)
# compute SURF descriptor
scale_surf = radius / self.min_radius
keypoint = np.array([[y, x, scale_surf, 0.1, 1]])
surf_descriptor = surf.descriptors(X, keypoint,
is_integral=False).ravel()
if not surf_descriptor.size:
surf_descriptor = np.zeros((70, ))
return np.hstack((zernike, surf_descriptor))
def extract(self, image, keypoints):
# patch size to build descriptor from
patch_size = self.patch_size
desc_size = self.descriptor_size
# random = np.random.RandomState()
# random.seed(self.sample_seed)
## why 8?
# samples = np.array((patch_size / 5.0) * random.randn(desc_size * 8)).astype(np.int32)
# hps2 = - (patch_size-2) // 2
# samples = samples[(samples < hps) & (samples > hps2)]
# d2 = desc_size*2
# pos0 = samples[:d2].reshape(desc_size, 2)
# pos1 = samples[d2:d2*2].reshape(desc_size, 2)
# pos0 = np.ascontiguousarray(pos0)
# pos1 = np.ascontiguousarray(pos1)
hps = patch_size // 2
self.mask = _mask_border_keypoints(image.shape, keypoints, hps)
self.keypoints = np.array(keypoints[self.mask, :], dtype=np.intp, order="C", copy=False)
self.descriptors = []
for nn in range(self.keypoints.shape[0]):
kx, ky = self.keypoints[nn]
patch = image[kx - hps : kx + hps, ky - hps : ky + hps]
self.descriptors.append(zernike_moments(patch, 8.0, 12))
self.descriptors = np.array(self.descriptors)
def feature_zernike(self,mode = 'all',index=None,outimg=None):
if mode=='all':
output = []
for i in range(self.n_index):
temp_img = self.get1img(i,'gray')
output.append( zernike_moments(temp_img,1) )
return np.array(output)
elif mode=='single':
if index == None and outimg is None:
print("please input index")
return
if outimg is None:
temp_img = self.get1img(index,'gray')
else :
temp_img = outimg
return zernike_moments(temp_img,1)
def get_zernikeMoments(img, name):
ordnung = 8
radius = 200
zernike = features.zernike_moments(img, radius, ordnung)
print()
print("Zernike Momente von " + name +
" der Ordnung {}, Radius in px {}: {}".format(
ordnung, radius, zernike))
return zernike
def _extract_features(self, X, candidate):
row, col, radius = int(candidate[0]), int(candidate[1]), int(
candidate[2])
padded_radius = int(self.padding * radius)
# compute the coordinate of the patch to select
col_min = max(col - padded_radius, 0)
row_min = max(row - padded_radius, 0)
col_max = min(col + padded_radius, X.shape[0] - 1)
row_max = min(row + padded_radius, X.shape[1] - 1)
# extract patch
patch = X[row_min:row_max, col_min:col_max]
patch_edge = filters.sobel(patch)
# compute Zernike moments
zernike = zernike_moments(patch, radius)
zernike_edge = zernike_moments(patch_edge, radius)
return np.hstack((zernike, zernike_edge))
def getZernikeMatchShapes(img0, img1, name0, name1, id):
img0 = invert_image(img0)
img1 = invert_image(img1)
ordnung = 8
radius = 200
zernike1 = features.zernike_moments(img0, radius, ordnung)
zernike2 = features.zernike_moments(img1, radius, ordnung)
zernike_contours_match1 = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0
]
for k in range(0, 24):
zernike_contours_match1[k] = abs(1 / (zernike1[k]) - 1 / (zernike2[k]))
zernike_contours_match2 = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0
]
for w in range(0, 24):
zernike_contours_match2[w] = abs(zernike1[w] - zernike2[w])
zernike_contours_match3 = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0
]
for f in range(0, 24):
zernike_contours_match3[f] = (abs(zernike1[f] - zernike2[f])) / (abs(
zernike1[f]))
zernike_match = [0, 0, 0]
zernike_match[0] = np.sum(zernike_contours_match1)
zernike_match[1] = np.sum(zernike_contours_match2)
zernike_match[2] = np.sum(zernike_contours_match3)
print("\n" + id + ".ZernikeContoursMatch of " + name0 + " and " + name1 +
": {}".format(zernike_match))
return zernike_match
def calculate(self, resource):
#initalizing
except_image_only(resource)
image_uri = resource.image
#image_uri = BQServer().prepare_url(image_uri, remap='gray')
im = image2numpy(image_uri, remap='gray')
im = np.uint8(im)
radius = 8
degree = 8
descritptor = zernike_moments(im, radius, degree)
#initalizing rows for the table
return descritptor
def _calculateStatistics(self, img, haralick=False, zernike=False):
result = []
# 3-bin histogram
result.extend(mquantiles(img))
# First four moments
result.extend([img.mean(), img.var(), skew(img, axis=None), kurtosis(img, axis=None)])
# Haralick features
if haralick:
integerImage = dtype.img_as_ubyte(img)
result.extend(texture.haralick(integerImage).flatten())
# Zernike moments
if zernike:
result.extend(zernike_moments(img, int(self.rows) / 2 + 1))
return result
def _calculateStatistics(self, img, haralick=False, zernike=False):
result = []
#3-bin histogram
result.extend(mquantiles(img))
#First four moments
result.extend([
img.mean(),
img.var(),
skew(img, axis=None),
kurtosis(img, axis=None)
])
#Haralick features
if haralick:
integerImage = dtype.img_as_ubyte(img)
result.extend(texture.haralick(integerImage).flatten())
#Zernike moments
if zernike:
result.extend(zernike_moments(img, int(self.rows) / 2 + 1))
return result
def _describe(self, binary, steps=None):
shape = list(binary.shape) + [3]
kernel = np.ones((40, 40), np.uint8)
closed = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)
im, contours, hierarchy = cv2.findContours(closed, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
# no contours if binary is empty
if len(contours) == 0:
return np.zeros(self.dim)
# compute moments around center of binary
center, radius = cv2.minEnclosingCircle(contours[0])
moments = zernike_moments(binary, radius, cm=center)
if steps is not None:
steps['closed'] = closed
cont_img = np.zeros((binary.shape[0], binary.shape[1], 3))
cv2.drawContours(cont_img, contours, 0, (0, 255, 0), 3)
steps['contour'] = cont_img
return moments
def _calc_features(self):
"""
calculate feature values
:return: feature values
"""
features = {}
props = regionprops(self.bin_img, self.img)
features['Area'] = props[0].area #Number of pixels of the region.
features['BB Area'] = props[
0].bbox_area #Number of pixels of bounding box.
features['Perimeter'] = props[0].perimeter
#Perimeter of object which approximates the contour as a line through the centers of border pixels using a 4-connectivity.
features['Centroid'] = props[0].centroid #Centroid coordinate tuple.
features['Weighted Centroid'] = props[0].weighted_centroid
#Centroid coordinate tuple (row, col) weighted with intensity image.
features['Centroid Divergence'] = np.linalg.norm(
np.array(props[0].centroid) - np.array(props[0].weighted_centroid))
features['Equivalent Diameter'] = props[0].equivalent_diameter
#The diameter of a circle with the same area as the region.
features['Major Axis Length'] = props[0].major_axis_length
#The length of the major axis of the ellipse that has the same normalized second central moments as the region.
features['Minor Axis Length'] = props[0].minor_axis_length
#The length of the minor axis of the ellipse that has the same normalized second central moments as the region.
features['Eccentricity'] = props[0].eccentricity
#Eccentricity of the ellipse that has the same second-moments as the region. The eccentricity is the ratio of the focal distance (distance between focal points).
features['Circularity'] = (4 * props[0].area *
math.pi) / (props[0].perimeter**2)
#Circularity that specifies the roundness of objects.
features['Roundness'] = (4 * props[0].area) / (
np.pi * props[0].major_axis_length**2)
#Like circularity, but does not depend on perimeter/roughness.
features['Aspect Ratio'] = (
props[0].major_axis_length) / props[0].minor_axis_length
#Aspect ratio.
features['Orientation'] = props[0].orientation
#Angle between the 0th axis (rows) and the major axis of the ellipse that has the same second moments as the region, ranging from -pi/2 to pi/2 counter-clockwise.
features['Solidity'] = props[0].solidity
#Ratio of pixels in the region to pixels of the convex hull image.
conv_img = props[0].convex_image #get convex image of ROI
conv_perimeter = regionprops(conv_img.astype(np.uint8))[0].perimeter
features['Roughness'] = props[0].perimeter / conv_perimeter
#Ratio of perimeter of region to perimeter of the convex hull image.
features['Hu Moments'] = (props[0].weighted_moments_hu)
#tuple - Hu moments (translation, scale and rotation invariant) of intensity image.
diam = self.img[0].shape[0]
maxradius = diam / 2
features['Zernike Moments'] = zernike_moments(self.img, maxradius)
#Zernike Moments of Region
return features
def zernike_minimum_enclosing_circle(coords,degree=9): image, center, diameter = minimum_enclosing_circle_shift(coords) return zernike_moments(image, radius=diameter/2, degree=degree, cm=center)
def calculate_zernike_moments(im,
cm=None,
radius=0.3,
norder=8,
label=None,
use_log=False,
show_plot=False):
"""Calculate the Zernike moments of the image.
These moments are useful to single out asymmetries in the image:
for example, when characterizing the beam of the radio telescope using
a map of a calibrator, it is useful to calculate these moments to
understand if the beam is radially symmetric or has distorted side
lobes.
Parameters
----------
im : 2-d array
The image to be analyzed
Other parameters
----------------
cm : [int, int]
'Center of mass' of the image
radius : float
The radius around the center of mass, in percentage of the image
size (0 <= radius <= 0.5)
norder : int
Maximum order of the moments to calculate
use_log: bool
Rescale the image to a log scale before calculating the coefficients.
The scale is the same documented in the ds9 docs, for consistency.
After normalizing the image from 0 to 1, the log-rescaled image is
log(ax + 1) / log a, with ``x`` the normalized image and ``a`` a
constant fixed here at 1000
show_plot : bool, default False
show the plots immediately
Returns
-------
moments_dict : dict
Dictionary containing the order, the sub-index and the moment, e.g.
{0: {0: 0.3}, 1: {1: 1e-16}, 2: {0: 0.95, 2: 6e-19}, ...}
Moments are symmetrical, so only the unique values are reported.
"""
if np.all(np.isnan(im)):
return None
im_to_analyze = im.copy()
im_to_analyze = interpolate_invalid_points_image(im_to_analyze,
zeros_are_invalid=True)
if cm is None or np.any(np.isnan(cm)):
cm = get_center_of_mass(im_to_analyze, radius, approx='max')
if (cm[0] >= im_to_analyze.shape[0]) or (cm[1] >= im_to_analyze.shape[1]) \
or (cm[0] < 1) or (cm[1] < 1):
cm = np.array(im_to_analyze.shape) // 2
if use_log:
im_to_analyze = ds9_like_log_scale(im_to_analyze, 1000)
radius_pix = np.int(np.min(im.shape) * radius)
moments = zernike_moments(im_to_analyze, radius_pix, norder, cm=cm)
count = 0
moments_dict = {}
description_string = \
'Zernike moments (cm: {}, radius: {}):\n'.format(cm, radius_pix)
if HAS_MPL:
fig = plt.figure('Zernike moments', figsize=(10, 10))
x, y = np.int(cm[0]), np.int(cm[1])
shape = im_to_analyze.shape
vmax = np.max(im_to_analyze)
if (x < shape[0]) & (y < shape[1]):
vmax = im_to_analyze[x, y]
plt.imshow(im_to_analyze,
vmin=0,
vmax=vmax,
origin='lower',
cmap='magma')
circle = plt.Circle((y, x), radius_pix, color='r', fill=False)
plt.gca().add_patch(circle)
plt.colorbar()
for i in range(norder + 1):
description_string += str(i) + ': '
moments_dict[i] = {}
for j in range(i + 1):
if (i - j) % 2 == 0:
description_string += "{}/{} {:.1e} ".format(
i, j, moments[count])
moments_dict[i][j] = moments[count]
count += 1
description_string += '\n'
if HAS_MPL:
plt.text(0.05,
0.95,
description_string,
horizontalalignment='left',
verticalalignment='top',
transform=plt.gca().transAxes,
color='white')
if label is None:
label = str(np.random.randint(0, 100000))
plt.savefig('Zernike_debug_' + label + '.png')
if show_plot:
plt.show()
plt.close(fig)
log.debug(description_string)
moments_dict['Description'] = description_string
return moments_dict
def momentsZernique(self):
dis=self.Distancia_Centroide()
raio=mean(dis)
return fea.zernike_moments(self.imagemCinza,raio)
def momentsZernique_tratado(self):
im=self.tratamento_imagem()
raio=max(im.shape)
return fea.zernike_moments(im,raio)
def get_blob_element(mask, rect, skel, num_blob_pixels, color, color_variance, grey, depth, label, is_subblob = False):
# Scale image for scale-invariant shape features
# Make it so the longest edge is equal to SHAPE_FEATURE_SIZE
resized_image = mahotas.imresize(mask,
float(SHAPE_FEATURE_SIZE) / max(mask.shape))
z_moments = zernike_moments(resized_image, SHAPE_FEATURE_SIZE, degree = Z_ORDER)
blob_element = xml.Element(label)
x_1 = rect[0]
y_1 = rect[1]
x_2 = x_1 + rect[2]
y_2 = y_1 + rect[3]
blob_element.attrib['x'] = str(rect[0])
blob_element.attrib['y'] = str(rect[1])
blob_element.attrib['width'] = str(rect[2])
blob_element.attrib['height'] = str(rect[3])
rect_center = (rect[0] + .5 * rect[2],
rect[1] + .5 * rect[3])
if (skel is not None and len(skel) > 0 ):
blob_element.attrib['head_dist'] = str(distance(rect_center,
skel['HEAD']['2d']))
blob_element.attrib['right_hand_dist'] = str(distance(rect_center,
skel['RIGHT_HAND']['2d']))
blob_element.attrib['left_hand_dist'] = str(distance(rect_center,
skel['LEFT_HAND']['2d']))
features_element = xml.Element('features')
blob_element.append(features_element)
size_element = xml.SubElement(features_element, 'size')
xml.SubElement(size_element, 'pixels').text = str(num_blob_pixels)
hu_element = get_hu_moments_element(mask)
features_element.append(hu_element)
grey_masked_image = grey & mask
blob_depth = depth & mask
if is_subblob:
blob_depth_rect = blob_depth
blob_mask_rect = mask
else:
blob_depth_rect = blob_depth[y_1:y_2, x_1:x_2]
blob_mask_rect = mask[y_1:y_2, x_1:x_2]
normal_vector_histogram = get_normal_vector_histogram(blob_depth_rect, blob_mask_rect.astype(numpy.uint8))
#print normal_vector_histogram
if normal_vector_histogram is None:
print 'Error calculating normal_vector_histogram'
return None
normal_histogram_element = xml.Element('normalhistogram')
for i in xrange(normal_vector_histogram.size):
xml.SubElement(normal_histogram_element, 'a_' + str(i)).text = str(normal_vector_histogram[i])
features_element.append(normal_histogram_element)
haralick_element = xml.Element('haralick')
haralick_features = haralick(grey_masked_image)
# Average the rows (the different directions of the features)
haralick_features_averaged = numpy.mean(haralick_features,axis=0)
#print len(haralick_features_averaged)
for i in xrange(NUM_HARALICK_FEATURES):
xml.SubElement(haralick_element, 'a_' + str(i)).text = str(haralick_features_averaged[i])
features_element.append(haralick_element)
zernike_element = xml.Element('zernike')
for i in xrange(Z_FEATURES):
xml.SubElement(zernike_element, 'a_' + str(i)).text = str(z_moments[i])
features_element.append(zernike_element)
rgb_element = xml.Element('rgb')
xml.SubElement(rgb_element, 'r').text = str(color[0])
xml.SubElement(rgb_element, 'g').text = str(color[1])
xml.SubElement(rgb_element, 'b').text = str(color[2])
features_element.append(rgb_element)
rgb_variance_element = xml.Element('rgb_var')
xml.SubElement(rgb_variance_element, 'r').text = str(color_variance[0])
xml.SubElement(rgb_variance_element, 'g').text = str(color_variance[1])
xml.SubElement(rgb_variance_element, 'b').text = str(color_variance[2])
features_element.append(rgb_variance_element)
return blob_element
def step(frame, file_time, output_file = None):
global g_adjacency, g_max, g_prev, g_colors, g_feat, g_gray, g_rgb, g_rgbfeat, g_blobidx, g_blobidxset, g_myrect, g_myhist
global current_frame_time, xml_root
global g_last_depth, g_last_depth_change
#global g_frameidx
#ni.show_frame(frame)
num_kinects = frame['num_kinects']
if num_kinects == 0:
return
depth = numpy.array(frame['depths'][0])
rgb = numpy.array(frame['images'][0])
cvmod.set_depth(depth.ravel())
g_sa = 0.
if g_showall:
g_sa = 1.
var = numpy.array([gx1, gx2, gy1, gy2, gz1, gz2, gd1, gd2, g_sa], dtype=numpy.float)
cvmod.set_vars(var)
if not BATCH_MODE and not BATCH_BLOB_MODE:
cvmod.output3d()
cvmod.process_blob()
adj = numpy.array(g_adjacency, dtype=numpy.uint8) * 255
adj = cv2.erode(adj, None)
adj = cv2.erode(adj, None)
adj = cv2.erode(adj, None)
if not BATCH_MODE and not BATCH_BLOB_MODE:
## cv2.imshow('Depth', depth_change)
## cv2.waitKey(10)
cv2.imshow('ADJ', adj)
cv2.waitKey(10)
max_idx, img, rects = maskblob.createblobmask(adj)
#print 'Rects',rects
if g_prev == None:
g_max, g_prev = max_idx, img
for i in range(max_idx):
g_colors.append(get_rcol())
return
## print "print", g_max, max_idx
new_g_colors = [None]
if not BATCH_MODE:
if g_feat != None:
nextPts, status, err = cv2.calcOpticalFlowPyrLK(g_gray, gorig, g_feat, None, winSize=(15, 15), maxLevel=5)
for i in range(len(nextPts)):
if status[i][0] == 1:
x1, y1 = g_feat[i][0]
#cv2.circle(cmask, (x1, y1), 4., (0, 0, 255), -1)
x2, y2 = nextPts[i][0]
dx = abs(x1-x2)
dy = abs(y1-y2)
#if dx*dx+dy*dy < 70*70:
# cv2.line(cmask, (x1, y1), (x2, y2), (0, 255, 0), 3)
ass_mat = numpy.zeros((max_idx, g_max), dtype=numpy.uint8)
for idx1 in range(1, g_max+1):
bmask = maskblob.getblob(g_prev, idx1)
bmask = cv2.dilate(bmask, None)
for i in range(len(nextPts)):
if status[i][0] == 1:
x1, y1 = g_feat[i][0]
if bmask[y1][x1] > 0:
for idx2 in range(1, max_idx+1):
dmask = maskblob.getblob(img, idx2)
dmask = cv2.dilate(dmask, None)
x2, y2 = nextPts[i][0]
dx = abs(x1-x2)
dy = abs(y1-y2)
if dx*dx+dy*dy < 70*70:
if dmask[y2][x2] > 0:
ass_mat[idx2-1][idx1-1] += 1
cv2.line(cmask, (x1, y1), (x2, y2), (0, 255, 0), 1)
if not BATCH_MODE and not BATCH_BLOB_MODE:
print ass_mat
for i in range(max_idx):
k = ass_mat[i]
if numpy.max(k) > 0:
p = numpy.argmax(k)
blobidxset[i] = g_blobidxset[p]
if not BATCH_MODE and not BATCH_BLOB_MODE:
print blobidxset
# End Batch
if len(rects) > 0:
a0, b0, w0, h0 = rects[0]
a1 = a0+w0
b1 = b0+h0
## cv2.rectangle(cmask, (a0, b0), (a1, b1), (255, 255, 255), 5)
else:
a0 = 0
b0 = 0
a1 = 630
b1 = 470
if g_myrect == None:
g_myrect = a0, b0, a1, b1
g_myhist = get_histogram(rgb, a0, b0, a1, b1)
#show_histogram(g_myhist)
else:
frame_element = xml.SubElement(xml_root,'frame')
frame_element.attrib['timestamp'] = str(current_frame_time)
## frame_element.attrib['confidence'] = str(numpy.std(prob_vector * hsv))
skeleton_element = xml.SubElement(frame_element,'skeleton')
if not (frame['skel'][0]['HEAD']['2d'][0] == 0 and
frame['skel'][0]['HEAD']['2d'][1] == 0):
xmlhelper.generate_skeleton_xml(frame, skeleton_element)
blobs_element = xml.SubElement(frame_element,'blobs')
#print 'Max prob: ', numpy.max(prob)
if output_file is not None:
blue_channel = rgb[:,:,0]
green_channel = rgb[:,:,1]
red_channel = rgb[:,:,2]
for blob_num in range(0, max_idx):
blob_mask = maskblob.getblob(img,blob_num + 1)
num_blob_pixels = numpy.sum(blob_mask, dtype=numpy.int32) / 255
if num_blob_pixels <= 8:
continue
## num_prob_pixels = numpy.sum(prob * blob_mask, dtype=numpy.int32) / 255
x_1 = rects[blob_num][0]
y_1 = rects[blob_num][1]
x_2 = x_1 + rects[blob_num][2]
y_2 = y_1 + rects[blob_num][3]
## blob_prob = prob * (blob_mask / 255)
## blob_attention = numpy.sum(blob_prob) / numpy.sum(prob)
blob_red = red_channel & blob_mask
red_value = numpy.sum(blob_red, dtype=numpy.int32) / num_blob_pixels
red_variance = numpy.std(blob_red[blob_red.nonzero()])
blob_red_rect = blob_red[x_1:x_2, y_1:y_2]
blob_green = green_channel & blob_mask
green_value = numpy.sum(blob_green, dtype=numpy.int32) / num_blob_pixels
green_variance = numpy.std(blob_green[blob_green.nonzero()])
blob_green_rect = blob_green[x_1:x_2, y_1:y_2]
blob_blue = blue_channel & blob_mask
blue_value = numpy.sum(blob_blue, dtype=numpy.int32) / num_blob_pixels
blue_variance = numpy.std(blob_blue[blob_blue.nonzero()])
blob_blue_rect = blob_blue[x_1:x_2, y_1:y_2]
blob_depth = depth & blob_mask
max_depth = numpy.max(blob_depth[blob_depth.nonzero()])
min_depth = numpy.min(blob_depth[blob_depth.nonzero()])
blob_color_rect = numpy.zeros((rects[blob_num][2], rects[blob_num][3], 3), numpy.uint8)
moments = cv2.moments(blob_mask)
hu_moments = cv2.HuMoments(moments)
# Scale image for scale-invariant shape features
resized_image = mahotas.imresize(blob_mask,
float(SHAPE_FEATURE_SIZE) / max(blob_mask.shape))
z_moments = zernike_moments(resized_image, SHAPE_FEATURE_SIZE, degree = Z_ORDER)
blob_element = xml.Element('blob')
blobs_element.append(blob_element)
blob_element.attrib['x'] = str(rects[blob_num][0])
blob_element.attrib['y'] = str(rects[blob_num][1])
blob_element.attrib['width'] = str(rects[blob_num][2])
blob_element.attrib['height'] = str(rects[blob_num][3])
rect_center = (rects[blob_num][0] + .5 * rects[blob_num][2],
rects[blob_num][1] + .5 * rects[blob_num][3])
blob_element.attrib['head_dist'] = str(distance(rect_center,
frame['skel'][0]['HEAD']['2d']))
blob_element.attrib['right_hand_dist'] = str(distance(rect_center,
frame['skel'][0]['RIGHT_HAND']['2d']))
blob_element.attrib['left_hand_dist'] = str(distance(rect_center,
frame['skel'][0]['LEFT_HAND']['2d']))
features_element = xml.Element('features')
blob_element.append(features_element)
size_element = xml.Element('size')
xml.SubElement(size_element, 'pixels').text = str(num_blob_pixels)
features_element.append(size_element)
hu_element = xml.Element('hu')
xml.SubElement(hu_element, 'i_1').text = str(hu_moments[0][0])
xml.SubElement(hu_element, 'i_2').text = str(hu_moments[1][0])
xml.SubElement(hu_element, 'i_3').text = str(hu_moments[2][0])
xml.SubElement(hu_element, 'i_4').text = str(hu_moments[3][0])
xml.SubElement(hu_element, 'i_5').text = str(hu_moments[4][0])
xml.SubElement(hu_element, 'i_6').text = str(hu_moments[5][0])
xml.SubElement(hu_element, 'i_7').text = str(hu_moments[6][0])
features_element.append(hu_element)
zernike_element = xml.Element('zernike')
for i in xrange(Z_FEATURES):
xml.SubElement(zernike_element, 'a_' + str(i)).text = str(z_moments[i])
features_element.append(zernike_element)
rgb_element = xml.Element('rgb')
xml.SubElement(rgb_element, 'r').text = str(red_value)
xml.SubElement(rgb_element, 'g').text = str(green_value)
xml.SubElement(rgb_element, 'b').text = str(blue_value)
features_element.append(rgb_element)
rgb_variance_element = xml.Element('rgb_var')
xml.SubElement(rgb_variance_element, 'r').text = str(red_variance)
xml.SubElement(rgb_variance_element, 'g').text = str(green_variance)
xml.SubElement(rgb_variance_element, 'b').text = str(blue_variance)
features_element.append(rgb_variance_element)
if not BATCH_MODE:
grayrgb = cv2.cvtColor(rgb, cv2.COLOR_BGR2GRAY)
grayrgborig = cv2.cvtColor(rgb, cv2.COLOR_BGR2GRAY)
grayrgbfeat = show_features(grayrgb, 500)
if g_rgbfeat != None:
nextPts, status, err = cv2.calcOpticalFlowPyrLK(g_rgb, grayrgborig, g_rgbfeat, None, winSize=(15, 15), maxLevel=5)
for i in range(len(nextPts)):
if status[i][0] == 1:
x1, y1 = g_rgbfeat[i][0]
#cv2.circle(rgb, (x1, y1), 4., (0, 0, 255), -1)
x2, y2 = nextPts[i][0]
dx = abs(x1-x2)
dy = abs(y1-y2)
if dx*dx+dy*dy < 30*30:
cv2.line(rgb, (x1, y1), (x2, y2), (0, 255, 0), 1)
f = cv2.calcOpticalFlowFarneback(g_rgb, grayrgborig, None, .5, 3, 15, 3, 5, 1.2, 0)
print f.shape
g_rgb = grayrgborig
g_rgbfeat = grayrgbfeat
if not BATCH_BLOB_MODE:
## cv2.imshow('MAS', cmask)
## cv2.waitKey(10)
## cv2.imshow('GAS', gmask)
## cv2.waitKey(10)
cv2.imshow('Gray',g_gray)
cv2.waitKey(10)
cv2.imshow('IMG', rgb)
cv2.waitKey(10)
if BATCH_MODE or BATCH_BLOB_MODE:
print numpy.max(depth)
print cv2.imwrite(file_time + 'rgb.jpg',rgb)
print cv2.imwrite(file_time + 'd.jpg',numpy.divide(depth,12))