def computeSphericalCoordinates(self):
self.gammaG = 0.33333334
self.gammaR = 0.33333334
self.gammaB = 0.33333334
self.theta = np.arctan((algo.G - self.gammaG) / (algo.R - self.gammaR))
self.phi = np.arctan(
(algo.B - self.gammaB) / cv2.sqrt((algo.G - self.gammaG)**2 +
(algo.R - self.gammaR)**2))
self.radius = cv2.sqrt((algo.B - self.gammaB)**2 +
(algo.G - self.gammaG)**2 +
(algo.R - self.gammaR)**2)
self.deltaP = np.hstack(
(algo.theta.reshape(-1, 1), algo.phi.reshape(-1, 1)))
def convert_to_nearest_label(label_path, image_size, apply_ignore=True):
"""
Convert RGB label image to onehot label image
:param label_path: File path of RGB label image
:param image_size: Size to resize result image
:param apply_ignore: Apply ignore
:return:
"""
label = np.array(
Image.open(label_path).resize((image_size[0], image_size[1]),
Image.ANTIALIAS))[:, :, :3]
label = label.astype(np.float32)
stacked_label = list()
for index, mask in enumerate(label_mask):
length = np.sum(cv2.pow(label - mask, 2), axis=2, keepdims=False)
length = cv2.sqrt(length)
stacked_label.append(length)
stacked_label = np.array(stacked_label)
stacked_label = np.transpose(stacked_label, [1, 2, 0])
converted_to_classes = np.argmin(stacked_label, axis=2).astype(np.uint8)
if apply_ignore:
ignore_mask = (converted_to_classes == (len(label_mask) - 1)).astype(
np.uint8)
ignore_mask *= (256 - len(label_mask))
converted_to_classes += ignore_mask
return converted_to_classes
def Pyramid(img): YUV = cv2.cvtColor(img,cv2.COLOR_BGR2YCR_CB) YUV = cv2.resize(YUV,(40,40)) Y,U,V = cv2.split(YUV) YUV = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) img = cv2.resize(YUV,(26,26)) kernel1 = np.ones((3,1),np.float32) kernel2 = np.ones((1,3),np.float32) kernel1[0] = -1 kernel1[1] = 0 kernel2[0] = [-1,0,1] dst = cv2.filter2D(img,cv2.CV_16S,kernel1) dstv1 = np.int16(dst) dstv2 = cv2.pow(dstv1,2) dst = cv2.filter2D(img,cv2.CV_16S,kernel2) dsth1 = np.int16(dst) dsth2 = cv2.pow(dsth1,2) dst1 = dsth2 + dstv2 dst1 = np.float32(dst1) dstfinal = cv2.sqrt(dst1).astype(np.uint8) finalh = dsth1 finalv = dstv1 finalm = dstfinal UporDown = (finalv > 0 ).astype(int) LeftorRight = 2*(finalh > 0).astype(int) absh = map(abs, finalh) absv = map(abs, finalv) absv[:] = [x*1.732 for x in absv] absh = np.float32(absh) absv = np.float32(absv) high = 4*(absv > absh).astype(int) out = high + LeftorRight + UporDown features = [] for x in range(6): hrt = np.zeros(out.shape[:2],np.uint8) features.append(hrt) for x in range(out.shape[:2][0]): for y in range(out.shape[:2][1]): z = out[x][y] if z == 4 or z == 6: # print "a",z features[4][x][y] = finalm[x][y] elif z == 5 or z == 7: features[5][x][y] = finalm[x][y] # print "b",z else: features[z][x][y] = finalm[x][y] # print z kernelg1 = 0.125*np.ones((4,4),np.float32) kernelg2 = 0.25*np.ones((2,2),np.float32) lastFeatures = [] for img in features: tote = cv2.sumElems(img) tote = tote/img.size img = img/tote print img print cv2.sumElems(img) print img.size lastFeatures.append(img1) return lastFeatures
def Corner(img, THRESHOLD):
image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY).astype(np.float32)
image *= 1. / 255
Ix = cv2.Sobel(image, -1, 1, 0, ksize=3)
Iy = cv2.Sobel(image, -1, 0, 1, ksize=3)
Ix2 = Ix**2
Iy2 = Iy**2
Ixy = Ix * Iy
Ix2 = cv2.GaussianBlur(Ix2, (3, 3), 0)
Iy2 = cv2.GaussianBlur(Iy2, (3, 3), 0)
Ixy = cv2.GaussianBlur(Ixy, (3, 3), 0)
determinant = Ix2 * Iy2 - Ixy * Ixy
trace = Ix2 + Iy2
response = np.divide(determinant, trace)
response[np.isnan(response)] = 0
magnitude = cv2.sqrt(Ix**2 + Iy**2)
orientations = np.arctan2(Iy, Ix)
# response = nonMaxSup(respons)
keypoints = np.argwhere(response > THRESHOLD)
keypoints = [
cv2.KeyPoint(x[1], x[0], response[x[0], x[1]]) for x in keypoints
]
outImage = cv2.drawKeypoints(img, keypoints, img)
# keyp = adaptiveNonMaxSup(image, response, 4)
return keypoints, magnitude, np.rad2deg(orientations), outImage
def GetFlowGradientMagnitude(flow, img_grad_x, img_grad_y):
x1, x2 = cv2.split(cv2.Sobel(flow, cv2.CV_64F, 1, 0, ksize=5))
y1, y2 = cv2.split(cv2.Sobel(flow, cv2.CV_64F, 0, 1, ksize=5))
flow_grad_x = AbsoluteMaximum([x1, x2])
flow_grad_y = AbsoluteMaximum([y1, y2])
flow_gradient_magnitude = cv2.sqrt((flow_grad_x * flow_grad_x) +
(flow_grad_y * flow_grad_y))
reliability = np.zeros((flow.shape[0], flow.shape[1]))
for x in tqdm(range(0, flow.shape[0]),
leave=True,
ascii=True,
desc="by one image length"):
for y in range(1, flow.shape[1]):
magn = (img_grad_x[x, y] * img_grad_x[x, y]) + (img_grad_y[x, y] *
img_grad_y[x, y])
gradient_dir = np.array((img_grad_y[x, y], img_grad_x[x, y]))
if (np.linalg.norm(gradient_dir) == 0):
reliability[x, y] = 0
continue
gradient_dir = gradient_dir / np.linalg.norm(gradient_dir)
center_pixel = np.array((x, y))
p0 = center_pixel + gradient_dir
p1 = center_pixel - gradient_dir
if p0[0] < 0 or p1[0] < 0 or p0[1] < 0 or p1[1] < 0 or p0[
0] >= flow.shape[0] or p0[1] >= flow.shape[1] or p1[
0] >= flow.shape[0] or p1[1] >= flow.shape[1]:
reliability[x, y] = -1000
continue
f0 = flow[int(p0[0]), int(p0[1])].dot(gradient_dir)
f1 = flow[int(p1[0]), int(p1[1])].dot(gradient_dir)
reliability[x, y] = f1 - f0
return flow_gradient_magnitude, reliability
def initial_ETF(input_img, size):
global flowField
global refinedETF
global gradientMag
src = cv2.imread(input_img, COLOUR_OR_GRAY)
src_n = np.zeros(size, dtype = np.float32)
src_n = cv2.normalize(src.astype('float32'), None, 0.0, 1.0, cv2.NORM_MINMAX)
#Generate grad_x and grad_y
grad_x = []
grad_y = []
grad_x = cv2.Sobel(src_n, cv2.CV_32FC1, 1, 0, ksize=5)
grad_y = cv2.Sobel(src_n, cv2.CV_32FC1, 0, 1, ksize=5)
#Compute gradient
gradientMag = cv2.sqrt(grad_x**2.0 + grad_y**2.0)
gradientMag = cv2.normalize(gradientMag.astype('float32'), None, 0.0, 1.0, cv2.NORM_MINMAX)
h,w = src.shape[0], src.shape[1]
for i in range(h):
for j in range(w):
u = grad_x[i][j]
v = grad_y[i][j]
n = np.array([v, u, 0.0])
cv2.normalize(np.array([v, u, 0.0]).astype('float32'), n)
flowField[i][j] = n
rotateFlow(flowField, flowField, 90.0)
def sobel(img):
sobelx = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=5)
sobely = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=5)
sobel_intensity = cv2.sqrt(
cv2.addWeighted(cv2.pow(sobelx, 2.0), 1.0, cv2.pow(sobely, 2.0), 1.0,
0.0))
return sobel_intensity
def farthest_point(defects, contour, centroid):
if defects is not None and centroid is not None:
s = defects[:, 0][:, 0]
cx, cy = centroid
x = np.array(contour[s][:, 0][:, 0], dtype=np.float)
y = np.array(contour[s][:, 0][:, 1], dtype=np.float)
xp = cv2.pow(cv2.subtract(x, cx), 2)
yp = cv2.pow(cv2.subtract(y, cy), 2)
dist = cv2.sqrt(cv2.add(xp, yp))
dist_max_i = np.argmax(dist)
if dist_max_i < len(s):
farthest_defect = s[dist_max_i]
farthest_point = contour[farthest_defect][0]
# squeeze the farthest point in the direction of the centroid
# define the percentage of the centroid to squeeze
pct_sq = 0.05
if (farthest_point[0] > cx + (cx * pct_sq)):
farthest_point[0] = farthest_point[0] - cx * pct_sq
elif (farthest_point[0] < cx - (cx * pct_sq)):
farthest_point[0] = farthest_point[0] + cx * pct_sq
if (farthest_point[1] > cy + (cy * pct_sq)):
farthest_point[1] = farthest_point[1] - cy * pct_sq
elif (farthest_point[1] < cy - (cy * pct_sq)):
farthest_point[1] = farthest_point[1] + cy * pct_sq
return tuple(farthest_point)
else:
return None
def getCentroidandFingertip(self, contour, frame):
if contour is not None:
hull = cv2.convexHull(contour, returnPoints=False)
self.defects = cv2.convexityDefects(contour, hull)
moments = cv2.moments(contour)
if moments['m00'] != 0:
cx = int(moments['m10'] / moments['m00'])
cy = int(moments['m01'] / moments['m00'])
self.centroid = cx, cy
cv2.circle(frame, self.centroid, 5, [255, 0, 255], -1)
if self.centroid is not None and self.defects is not None:
shape = self.defects[:, 0][:, 0]
cx, cy = self.centroid
x = np.array(contour[shape][:, 0][:, 0], dtype=np.float)
y = np.array(contour[shape][:, 0][:, 1], dtype=np.float)
pointX = cv2.pow(cv2.subtract(x, cx), 2)
pointY = cv2.pow(cv2.subtract(y, cy), 2)
distance = cv2.sqrt(cv2.add(pointX, pointY))
maxDistanceIndex = np.argmax(distance)
if maxDistanceIndex < len(shape):
far_defect = shape[maxDistanceIndex]
far_point = tuple(contour[far_defect][0])
cv2.circle(frame, far_point, 5, [0, 0, 255], -1)
return far_point
else:
return None
def preprocess(self):
start = time()
channel = self.chan_combo.currentIndex()
if channel == 0:
img = cv.cvtColor(self.image, cv.COLOR_BGR2GRAY)
elif channel == 4:
b, g, r = cv.split(self.image.astype(np.float64))
img = cv.sqrt(cv.pow(b, 2) + cv.pow(g, 2) + cv.pow(r, 2))
else:
img = self.image[:, :, 3 - channel]
kernel = 3
border = kernel // 2
shape = (img.shape[0] - kernel + 1, img.shape[1] - kernel + 1, kernel,
kernel)
strides = 2 * img.strides
patches = np.lib.stride_tricks.as_strided(img,
shape=shape,
strides=strides)
patches = patches.reshape((-1, kernel, kernel))
mask = np.full((kernel, kernel), 255, dtype=np.uint8)
mask[border, border] = 0
output = np.array([self.minmax_dev(patch, mask)
for patch in patches]).reshape(shape[:-2])
output = cv.copyMakeBorder(output, border, border, border, border,
cv.BORDER_CONSTANT)
self.low = output == -1
self.high = output == +1
self.process()
self.info_message.emit(
self.tr('Min/Max Deviation = {}'.format(elapsed_time(start))))
def __calc_gradient_image(self, img, image_depth=cv2.CV_8UC1):
deriv_img = cv2.GaussianBlur(img, self.__gauss_kernel_size, self.__gauss_sigma)
sx = cv2.Sobel(deriv_img, image_depth, 1, 0, ksize=self.__ksize_gradient)
sy = cv2.Sobel(deriv_img, image_depth, 0, 1, ksize=self.__ksize_gradient)
self.__deriv_img = cv2.sqrt(cv2.add(cv2.pow(sx, 2), cv2.pow(sy, 2)))
# self.__deriv_img = cv2.Laplacian(deriv_img, image_depth, ksize=self.__ksize_gradient)
return self.__deriv_img
def flow2RGB(flow, max_flow_mag=5):
""" Color-coded visualization of optical flow fields
# Arguments
flow: array of shape [:,:,2] containing optical flow
max_flow_mag: maximal expected flow magnitude used to normalize. If max_flow_mag < 0 the maximal
magnitude of the optical flow field will be used
"""
hsv_mat = np.ones(shape=(flow.shape[0], flow.shape[1], 3),
dtype=np.float32) * 255
ee = cv2.sqrt(flow[:, :, 0] * flow[:, :, 0] +
flow[:, :, 1] * flow[:, :, 1])
angle = np.arccos(flow[:, :, 0] / ee)
angle[flow[:, :, 0] == 0] = 0
angle[flow[:, :, 1] == 0] = 6.2831853 - angle[flow[:, :, 1] == 0]
angle = angle * 180 / 3.141
hsv_mat[:, :, 0] = angle
if max_flow_mag < 0:
max_flow_mag = ee.max()
hsv_mat[:, :, 1] = ee * 220.0 / max_flow_mag
ret, hsv_mat[:, :, 1] = cv2.threshold(src=hsv_mat[:, :, 1],
maxval=255,
thresh=255,
type=cv2.THRESH_TRUNC)
rgb_mat = cv2.cvtColor(hsv_mat.astype(np.uint8), cv2.COLOR_HSV2BGR)
return rgb_mat
def compute_error(flow, gt_flow, invalid_mask):
mag_flow = cv2.sqrt(gt_flow[:, :, 0] * gt_flow[:, :, 0] +
gt_flow[:, :, 1] * gt_flow[:, :, 1])
ret, mask_to_large = cv2.threshold(src=mag_flow,
thresh=900,
maxval=1,
type=cv2.THRESH_BINARY_INV)
total_inp_mask = invalid_mask[:, :,
0] + invalid_mask[:, :,
1] + invalid_mask[:, :, 2]
ret, fg_mask = cv2.threshold(src=invalid_mask[:, :, 1],
thresh=0.5,
maxval=1,
type=cv2.THRESH_BINARY)
ret, total_mask = cv2.threshold(src=total_inp_mask,
thresh=0.5,
maxval=1,
type=cv2.THRESH_BINARY)
#mask_to_large = np.ones(fg_mask.shape)
bg_mask = total_mask - fg_mask
ee_base = computeEE(flow, gt_flow)
result = dict()
result["FG"] = computer_errors(ee_base, fg_mask * mask_to_large)
result["BG"] = computer_errors(ee_base, bg_mask * mask_to_large)
result["Total"] = computer_errors(ee_base, total_mask * mask_to_large)
return result
def findFarPoint(res, cx, cy, defects, max_con):
try:
s = defects[:,0][:,0]
x = np.array(max_con[s][:,0][:,0], dtype = np.float)
y = np.array(max_con[s][:,0][:,1], dtype = np.float)
xp = cv.pow(cv.subtract(x, cx), 2)
yp = cv.pow(cv.subtract(y, cy), 2)
dist = cv.sqrt(cv.add(xp, yp))
dist_max_i = np.argmax(dist)
if dist_max_i < len(s):
farthest_defect = s[dist_max_i]
farthest_point = tuple(max_con[farthest_defect][0])
cv.line(res, (cx,cy), farthest_point, (0,255,255), 2)
return farthest_point
except:
farthest_point = 0
return farthest_point
def farthest(deflects, contour, center):
"""Megkeresi a középponttól legmesszebb levő convexity deflect-et,
ennek koordinátáival tér vissza"""
if center is not None and deflects is not None:
# pontok meghatározása
d = deflects[:, 0][:, 0]
cx, cy = center
x = np.array(contour[d][:, 0][:, 0], dtype=np.float)
y = np.array(contour[d][:, 0][:, 1], dtype=np.float)
# tavolság számítása
dx = cv2.pow(cv2.subtract(x, center[0]), 2)
dy = cv2.pow(cv2.subtract(y, center[1]), 2)
distance = cv2.sqrt(cv2.add(dx, dy))
# visszatérés a legmesszebbi ponttal
max_distance = np.argmax(distance)
if max_distance < len(d):
f_deflect = d[max_distance]
return tuple(contour[d[max_distance]][0])
else:
return None
else:
return None
def filter_img(target_img, filter_type):
"""
Performs the given edge detector on the given image
Arguments:
`target_img`: The image to detect edges from
`filter_type`: The filter to be applied to the target image. Can be one
of 'canny', 'sobel' or 'none', if the image is to be
used as-is.
Returns:
An image containing the edges of the target image
"""
blurred_img = cv2.GaussianBlur(target_img, (5, 5), 1.4)
filtered_img = None
if filter_type == 'none':
return target_img
if filter_type == 'canny':
filtered_img = cv2.Canny(blurred_img, 70, 210)
else:
dx = cv2.Sobel(blurred_img, cv2.CV_64F, 1, 0)
dy = cv2.Sobel(blurred_img, cv2.CV_64F, 0, 1)
edge_detected = cv2.sqrt(dx * dx + dy * dy)
filtered_img = cv2.convertScaleAbs(edge_detected)
return filtered_img
def LaplaceofGaussianClicked(self):
img = cv2.imread('1.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
img_out = cv2.GaussianBlur(gray, (5,5),0)
x = np.array([[0, -1, 0], [-1, 4, -1], [0, -1, 0]])
y = np.array([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]])
sx = cv2.filter2D(img_out, cv2.CV_64F, x)
sy = cv2.filter2D(img_out, cv2.CV_64F, y)
hitung = cv2.sqrt((sx * sx) + (sy * sy))
h, w = hitung.shape[:2]
for i in np.arange(h):
for j in np.arange(w):
a = hitung.item(i, j)
if a > 255:
a = 255
elif a < 0:
a = 0
else:
a = a
plt.imshow(hitung, cmap='gray', interpolation='bicubic')
plt.xticks([]), plt.yticks([])
print(hitung)
plt.show()
def getFurthestPoint(contourDefects, contour, centroid):
""" get defect point furthest from centroid
"""
furthestPoint = None
if contourDefects.any() and all(centroid): #data-structures have values
defectsIndices = contourDefects[:,
0][:,
0] # [all_defects, defectData][all_defects, contour_index_of_defectStartpoint]
x_bar, y_bar = centroid
x = np.array(contour[defectsIndices][:, 0][:, 0], dtype=np.float)
y = np.array(contour[defectsIndices][:, 0][:, 0], dtype=np.float)
x_sqDev = cv2.pow(cv2.subtract(x, x_bar), 2)
y_sqDev = cv2.pow(cv2.subtract(y, y_bar), 2)
distance = cv2.sqrt(cv2.add(x_sqDev, y_sqDev))
maxDistIndex = np.argmax(distance)
if maxDistIndex < len(defectsIndices):
furthestDefect = defectsIndices[maxDistIndex]
furthestPoint = tuple(contour[furthestDefect][0])
return furthestPoint
def create_std_dev_img(img):
blur1 = cv2.multiply(cv2.blur(img[:,:,0],(3,3)),cv2.blur(img[:,:,0],(3,3)),None,1,cv2.CV_64F)
blur3 = cv2.multiply(cv2.blur(img[:,:,1],(3,3)),cv2.blur(img[:,:,1],(3,3)),None,1,cv2.CV_64F)
blur5 = cv2.multiply(cv2.blur(img[:,:,2],(3,3)),cv2.blur(img[:,:,2],(3,3)),None,1,cv2.CV_64F)
blur2 = cv2.multiply(img[:,:,0],img[:,:,0],0,1,cv2.CV_64F)
blur2 = cv2.blur(blur2,(3,3))
blur4 = cv2.multiply(img[:,:,1],img[:,:,1],0,1,cv2.CV_64F)
blur4 = cv2.blur(blur4,(3,3))
blur6 = cv2.multiply(img[:,:,2],img[:,:,2],0,1,cv2.CV_64F)
blur6 = cv2.blur(blur6,(3,3))
blur_output = cv2.sqrt(cv2.absdiff(blur2,blur1))+cv2.sqrt(cv2.absdiff(blur4,blur3))+cv2.sqrt(cv2.absdiff(blur6,blur5))
blur_output = np.uint8(blur_output)
return blur_output
def std_filter(image, kernel):
assert (
type(image) is np.ndarray and image.dtype == np.uint8 and len(image.shape) == 2
), "The input image has to be a uint8 2D numpy array."
assert len(kernel) == 2, "The 'kernel' should be a tuple of 2 integers."
image = image.astype(np.float)
image = cv2.sqrt(cv2.blur(image ** 2, kernel) - cv2.blur(image, kernel) ** 2)
return image
def compute_DELTAE(imagename1,imagename2):
img1 = cv2.imread(imagename1)
img2 = cv2.imread(imagename2)
img1 = cv2.cvtColor(img1, cv2.COLOR_RGB2LAB)
img2 = cv2.cvtColor(img2, cv2.COLOR_RGB2LAB)
#cv2.imwrite(imagename2+".png",img1)
# s1 = cv2.absdiff(img1,img2)
# s1 = np.float32(s1)
# s1 = cv2.multiply(s1,s1)
# s1 = cv2.sqrt(s1)
L1,a1,b1 = cv2.split(img1)
L2,a2,b2 = cv2.split(img2)
dL = L1 - L2
da = a1-a2
db = b1-b2
# cv2.imwrite(imagename2+".png",dL)
# dL_2 = cv2.multiply(dL,dL)
# da_2 = cv2.multiply(da,da)
# db_2 = cv2.multiply(db,db)
# dL_2 = np.float32(dL_2)
# da_2 = np.float32(da_2)
# db_2 = np.float32(db_2)
# dE = cv2.sqrt( (dL_2) + (da_2) + (db_2))
# mde = cv2.mean(dE)
# print mde
c1 = np.sqrt(cv2.multiply(a1,a1) + cv2.multiply(b1,b1))
c2 = np.sqrt(cv2.multiply(a2,a2) + cv2.multiply(b2,b2))
dCab = c1-c2
dH = np.sqrt(cv2.multiply(da,da) + cv2.multiply(db,db)- cv2.multiply(db,db))
sL = 1
K1 = 0.045 #can be changed
K2 = 0.015 #can be changed
sC = 1+K1*c1
sH = 1+K2 *c1
kL = 1 #can be changed
t1 = cv2.divide(dL,kL*sL)
t2 = cv2.divide(dCab,sC)
t3 = cv2.divide(dH,sH)
t1 = cv2.multiply(t1,t1)
t2 = cv2.multiply(t2,t2)
t3 = cv2.multiply(t3,t3)
t1 = np.float32(t1)
t2 = np.float32(t2)
t3 = np.float32(t3)
dE = cv2.sqrt(t1+t2+t3)
mde = cv2.mean(dE)
return "{0:.4f}".format(mde[0])
def local_sd(img, ksize=(3,3)):
fimg = img.astype(np.float)
# mean
m = cv.blur(fimg, ksize)
# mean squared
m2 = cv.blur(np.multiply(fimg, fimg), ksize)
# NB numerically instable
sd = cv.sqrt(m2 - m*m)
return sd
def prewitt(image):
kernelx = np.array([[1, 1, 1], [0, 0, 0], [-1, -1, -1]])
kernely = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]])
vertical = ndimage.convolve(image.astype('double'), kernelx)
horizontal = ndimage.convolve(image.astype('double'), kernely)
return cv2.sqrt(cv2.pow(horizontal, 2) +
cv2.pow(vertical, 2)).astype('uint8')
def multi_frame_differecing(Frames_five):
Threshold = 180
height, width = Frames_five[0].shape
# Which frame is computed
cur_frame = 2
# Values especified by the paper
LAO1 = np.zeros((height, width), np.uint8)
LAO2 = np.zeros((height, width), np.uint8)
D = np.zeros((4, height, width), np.float32)
Dif = np.zeros((4, height, width), np.float32)
D[0] = Frames_five[cur_frame - 2] - Frames_five[cur_frame]
D[1] = Frames_five[cur_frame - 1] - Frames_five[cur_frame]
D[2] = Frames_five[cur_frame + 1] - Frames_five[cur_frame]
D[3] = Frames_five[cur_frame + 2] - Frames_five[cur_frame]
Dif[0] = cv.sqrt(cv.pow(D[0], 2))
Dif[1] = cv.sqrt(cv.pow(D[1], 2))
Dif[2] = cv.sqrt(cv.pow(D[2], 2))
Dif[3] = cv.sqrt(cv.pow(D[3], 2))
Dif[0] = (Dif[0]).astype('uint8')
Dif[1] = (Dif[1]).astype('uint8')
Dif[2] = (Dif[2]).astype('uint8')
Dif[3] = (Dif[3]).astype('uint8')
ret, Dif[0] = cv.threshold(Dif[0], Threshold, 255, cv.THRESH_BINARY)
ret, Dif[1] = cv.threshold(Dif[1], Threshold, 255, cv.THRESH_BINARY)
ret, Dif[2] = cv.threshold(Dif[2], Threshold, 255, cv.THRESH_BINARY)
ret, Dif[3] = cv.threshold(Dif[3], Threshold, 255, cv.THRESH_BINARY)
LAO1 = D[1, :, :] * D[2, :, :]
LAO2 = D[0, :, :] * D[3, :, :]
MR = np.zeros((height, width), np.uint8)
MR = cv.bitwise_or(LAO1, LAO2)
MR = MR.astype('uint8')
return MR
def localSD(mat, n):
mat=np.float32(mat)
mu = cv2.blur(mat,(n,n))
mdiff=mu-mat
mat2=cv2.blur(np.float64(mdiff*mdiff),(n,n))
sd = np.float32(cv2.sqrt(mat2))
sdn=normalize(sd)
return sdn
def localSD(mat, n):
mat = np.float32(mat)
mu = cv2.blur(mat, (n, n))
mdiff = mu - mat
mat2 = cv2.blur(np.float64(mdiff * mdiff), (n, n))
sd = np.float32(cv2.sqrt(mat2))
sdn = normalize(sd)
return sdn
def roberts(image):
roberts_cross_v = np.array([[0, 0, 0], [0, 1, 0], [0, 0, -1]])
roberts_cross_h = np.array([[0, 0, 0], [0, 0, 1], [0, -1, 0]])
vertical = ndimage.convolve(image.astype('double'), roberts_cross_v)
horizontal = ndimage.convolve(image.astype('double'), roberts_cross_h)
return cv2.sqrt(cv2.pow(horizontal, 2) +
cv2.pow(vertical, 2)).astype('uint8')
def get_sobel(img, kernel=None):
sobelx = None
sobely = None
if kernel is not None:
sobelx = cv2.Sobel(img, ddepth=-1, dx=1, dy=0, ksize=kernel)
sobely = cv2.Sobel(img, ddepth=-1, dx=0, dy=1, ksize=kernel)
else:
sobelx = cv2.Sobel(img, ddepth=-1, dx=1, dy=0)
sobely = cv2.Sobel(img, ddepth=-1, dx=0, dy=1)
return cv2.sqrt(sobelx**2 + sobely**2)
def __thresh(self, img, tval=None):
fram = cv2.absdiff(img, self.meancol).astype(np.float32)
fram = cv2.multiply(fram, fram)
fram = cv2.add(fram[:,:,1], fram[:,:,2])
fram = (cv2.sqrt(fram)/2).astype(np.uint8)
fram = fram/np.max(fram)
fram = fram.astype(np.float32)
fram = np.exp(-fram*10)
if tval is not None:
t,fram = cv2.threshold(fram, tval, 1.0, cv2.THRESH_BINARY)
return fram
def get_fingertip(defects_start_points, contour, centroid, frame_shape):
farthest_points = []
cx = centroid[0]
cy = centroid[1] # center point coordinates of hand contour:
finger_tip_x = 0
finger_tip_y = 0
# retrieve the x and y coordinates of the defects start points:
x = np.array(contour[defects_start_points][:, 0][:, 0], dtype=np.float)
y = np.array(contour[defects_start_points][:, 0][:, 1], dtype=np.float)
# calculate the euclidean distance from the centre to start points:
Xpoints_subtract_Xcenter = cv2.pow(cv2.subtract(x, cx), 2)
Ypoints_subtract_Ycenter = cv2.pow(cv2.subtract(y, cy), 2)
distance = cv2.sqrt(
cv2.add(Xpoints_subtract_Xcenter, Ypoints_subtract_Ycenter))
max_distance_index = np.argmax(
distance
) # fingertip point locates at the most distance from the center hand palm
if max_distance_index < len(defects_start_points):
finger_tip_index = defects_start_points[max_distance_index]
finger_tip_x = contour[finger_tip_index][0][0]
finger_tip_y = contour[finger_tip_index][0][1]
# if fingertip point lies below the hand contour center point:
if finger_tip_y > cy:
find_finger_tip = False
# Find all points that it is a distance from the center equal farthest_x_margin (right/left)
for index in range(len(x)):
x_p = int(x[index])
y_p = int(y[index])
if (x_p > cx - farthest_x_margin) and (
x_p < cx + farthest_x_margin) and (y_p < cy):
farthest_points.append((x_p, y_p))
# then find from the farthest points the closest one from the center and lies up to the center of the hand palm.
for j in range(3):
closest_x = closest_x_margin + j * 4
for i in range(len(farthest_points)):
if (farthest_points[i][0] > cx - closest_x) and (
farthest_points[i][0] < cx + closest_x):
finger_tip_x = farthest_points[i][0]
finger_tip_y = farthest_points[i][1]
find_finger_tip = True
break
if find_finger_tip:
break
# update the finger tip point coordinate within the detection rectangle coordinates.
finger_tip_x += int(detection_rec_x_start * frame_shape[1])
finger_tip_y += int(detection_rec_y_start * frame_shape[0])
finger_tip = (finger_tip_x, finger_tip_y)
return finger_tip
def contours(imgs):
img, original = imgs
height, width = img.shape
mask = np.zeros((height, width), np.uint8)
# ret, thresh = cv.threshold(img, 127, 255, cv.THRESH_BINARY)
contours, hierarchy = cv.findContours(img, cv.RETR_CCOMP, 4)
img = rgb((img, original))
height, width, channels = img.shape
# search below this coordinates
h_max = height * 4 / 5
# maximum box width with respect to image width (proportion)
w_max = width * 3 / 4
selected_boxes = []
# final_boxes = []
for cnt in contours:
rect = cv.minAreaRect(cnt)
box = cv.boxPoints(rect)
box = np.int0(box)
y_max = box[np.argsort(box[:, 1])][-1][1]
if y_max > h_max:
x_min = box[np.argsort(box[:, 0])][0][0]
x_max = box[np.argsort(box[:, 0])][-1][0]
y_min = box[np.argsort(box[:, 1])][0][1]
dx = x_max - x_min
if dx < w_max:
dy = y_max - y_min
if dx > 0:
d = dy / dx
area = dx * dy
mask = cv.drawContours(mask, [box], 0, 255, cv.FILLED)
masked = cv.bitwise_and(original, original, mask=mask)
mean = cv.mean(masked)
l = cv.sqrt(mean[0] ** 2 + mean[1] ** 2 + mean[2] ** 2)[0]
if 0.05 < d < 0.3 and 1200 < area and l < 50:
selected_boxes.append(box)
# n²: relation between boxes
# for b0, b1 in [(x, y) for x in box for y in box]:
return img
img = original
for box in selected_boxes:
img = cv.drawContours(img, [box], 0, (0, 255, 0), 2)
return img
def get_farthest_point(defects, max_contour, centroid):
"""
@params
- defects : each convexity defect is represented as [[start_index, end_index, farthest_pt_index, fixpt_depth]]. Any deviation of the object from this hull can be considered as convexity defect.
- max_contour : contour that has the biggest area. Ex : [[[272 233]], [[271 234]]]
- centroid : centroid of the max contour area
@returns
- farthest_point : farthest point from the centroid
@description:
Get the farthest point from the centroid (center of the hand). That point should be the logically the vertice of the index finger.
"""
if defects is not None and centroid is not None:
# np.array([[[1,2,3,4]], [[5,6,7,8]], [[9,10,11,12]]]) => x[:, 0][:, 0] => array([1, 5, 9])
contours_start_indexes_defects = defects[:, 0][:, 0]
x_of_contour_points = np.array(
max_contour[contours_start_indexes_defects][:, 0][:, 0],
dtype=np.float)
y_of_contour_points = np.array(
max_contour[contours_start_indexes_defects][:, 0][:, 1],
dtype=np.float)
cx, cy = centroid
xp = cv.pow(cv.subtract(x_of_contour_points, cx), 2)
yp = cv.pow(cv.subtract(y_of_contour_points, cy), 2)
dist = cv.sqrt(cv.add(xp, yp))
index_max_distance = -1
not_blocking_counter = 0
# To focus the index, the position of the point needs to be above the centroid of the hand
condition_above = False
while condition_above == False and not_blocking_counter < 5:
not_blocking_counter += 1
# index of point from the contour which has the biggest distance from one point of the contour to the centroid of the hand
index_max_distance = np.argmax(dist)
# !! Don't change it, this is how it works !!
if index_max_distance < len(y_of_contour_points):
if y_of_contour_points[index_max_distance] < cy:
condition_above = True
else:
dist[index_max_distance] = -1
if condition_above == False:
return None
else:
if index_max_distance < len(contours_start_indexes_defects):
farthest_defect = contours_start_indexes_defects[
index_max_distance]
farthest_point = tuple(max_contour[farthest_defect][0])
return farthest_point
else:
return None
def logspectrum(frame):
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
h, w = frame.shape[:2]
realInput = frame.astype(numpy.float64)
dft_M = cv2.getOptimalDFTSize(w)
dft_N = cv2.getOptimalDFTSize(h)
dft_A = numpy.zeros((dft_N, dft_M, 2), dtype=numpy.float64)
dft_A[:h, :w, 0] = realInput
cv2.dft(dft_A, dst=dft_A, nonzeroRows=h)
image_Re, image_Im = cv2.split(dft_A)
magnitude = cv2.sqrt(image_Re**2.0 + image_Im**2.0)
log_spectrum = cv2.log(1.0 + magnitude)
return log_spectrum
def pearson(x, y, shape=(3, 3)):
"""Pearson Correlation Coeff filter"""
mu_x = cv2.blur(x, shape)
mu_y = cv2.blur(y, shape)
xy = cv2.multiply(x, y)
mu_xy = cv2.blur(xy, shape)
cov = mu_xy - cv2.multiply(mu_x, mu_y)
mu_x2 = cv2.blur(cv2.multiply(x, x), shape)
mu_y2 = cv2.blur(cv2.multiply(y, y), shape)
var_x = mu_x2 - cv2.multiply(mu_x, mu_x)
var_x = var_x.astype(np.float64)
sigma_x = cv2.sqrt(var_x)
var_y = mu_y2 - cv2.multiply(mu_y, mu_y)
var_y = var_y.astype(np.float64)
sigma_y = cv2.sqrt(var_y)
rho = cov / (cv2.multiply(sigma_x, sigma_y))
return rho
def varianceFilter(raw, isGaussian, ksize, gsigma, absnorm):
raw64F = np.float64(raw)
if isGaussian:
mean = cv2.GaussianBlur(raw64F, (ksize, ksize), gsigma)
meanSqr = cv2.GaussianBlur(raw64F**2, (ksize, ksize), gsigma)
variance = cv2.absdiff(meanSqr, mean**2)
variance = cv2.sqrt(variance)
if absnorm <= 0:
varianceNormed = cv2.normalize(variance,
None,
alpha=0,
beta=255,
norm_type=cv2.NORM_MINMAX)
variance8Bit = np.uint8(varianceNormed)
else:
varianceNormed = variance / absnorm
variance8Bit = np.uint8(varianceNormed)
else:
#KPY: this condition doesn't run -> cv2.Blur not in cv2.cv2 module ??!
mean = cv2.Blur(raw64F, (ksize, ksize))
meanSqr = cv2.Blur(raw64F**2, (ksize, ksize))
variance = cv2.absdiff(meanSqr, mean**2)
variance = cv2.sqrt(variance)
if absnorm <= 0:
varianceNormed = cv2.normalize(variance,
None,
alpha=0,
beta=255,
norm_type=cv2.NORM_MINMAX)
variance8Bit = np.uint8(varianceNormed)
else:
varianceNormed = variance / absnorm
variance8Bit = np.uint8(varianceNormed)
return variance8Bit
def contour_properties(cls):
# get contour
image = cv.imread("../lib/images/hand.png", 0)
ret, image_thre = cv.threshold(image, 0, 255,
cv2.THRESH_BINARY_INV + cv.THRESH_OTSU)
hand_img_thr, hand_contours, hierarchy = cv.findContours(
image_thre, cv.RETR_TREE, cv.CHAIN_APPROX_NONE)
contour = hand_contours[0]
cv.drawContours(image, [contour], -1, 0, 2)
cv.imshow("Image", image)
# high-weight rate
x, y, w, h = cv.boundingRect(contour)
print "h-w rate:", float(h) / w
# extent
cnt_area = cv.contourArea(contour)
rect_area = w * h
print "extent:", float(cnt_area) / rect_area
# solidity
hull = cv.convexHull(contour)
hull_area = cv.contourArea(hull)
print "solidity:", float(cnt_area) / hull_area
# Equivalent Diameter
equi_diameter = cv.sqrt(4 * cnt_area / np.pi)
# Direction
(x, y), (MA, ma), angle = cv.fitEllipse(contour)
print "direction:", angle
# all pixel of contour-mask
mask = cv.zeros(image.shape[0:2], np.uint8)
cv.drawContours(mask, [contour], 0, 255, -1)
pixel_points = cv.transpose(np.array(np.nonzero(mask)))
print pixel_points
# max and min pixel location
min_val, max_val, min_loc, max_loc = cv.minMaxLoc(image, mask=mask)
print "min value ", min_val, "at", min_loc, "\n", "max value ", max_val, "at", max_loc
# pole
leftmost = tuple(contour[contour[:, :, 0].argmin()][0])
rightmost = tuple(contour[contour[:, :, 0].argmax()][0])
topmost = tuple(contour[contour[:, :, 1].argmin()][0])
bottommost = tuple(contour[contour[:, :, 1].argmax()][0])
print leftmost, rightmost, topmost, bottommost
cv.waitKey(0)
def get_std_dev_image(image, side = 5):
# get the standard deviation for each pixel w.r.t. a side x side window
# work with floats
imgf = image.astype(np.float32)
# get the mean
mean = cv2.blur(imgf, (side, side))
# get the mean of the squared image
mean_sq = cv2.blur(cv2.multiply(imgf, imgf), (side, side))
# std deviation = sqrt( expectation(x^2) - (expecation(x)^2) )
std = cv2.sqrt(mean_sq - cv2.multiply(mean, mean))
return std
def calculate_parameters_from_mat(stack_of_y):
weight = 1.0 / len(stack_of_y)
yshape = stack_of_y[0].shape
mean_y = np.zeros(yshape, dtype=np.float32)
for y in stack_of_y:
mean_y = cv2.addWeighted(mean_y, 1.0, y, weight, 0)
mean_corrected_y = [y - mean_y for y in stack_of_y]
element_wise_y_squared = [np.float32(y) * y for y in mean_corrected_y]
mean_corrected_y_squared = np.zeros(yshape, dtype=np.float32)
for y_squared in element_wise_y_squared:
mean_corrected_y_squared = cv2.add(mean_corrected_y_squared, y_squared)
mean_corrected_y_norm = cv2.sqrt(mean_corrected_y_squared)
return mean_y, mean_corrected_y, mean_corrected_y_squared, mean_corrected_y_norm
def farthest_point(defects, contour, centroid): s = defects[:,0][:,0] cx, cy = centroid x = np.array(contour[s][:,0][:,0], dtype=np.float) y = np.array(contour[s][:,0][:,1], dtype=np.float) xp = cv2.pow(cv2.subtract(x, cx), 2) yp = cv2.pow(cv2.subtract(y, cy), 2) dist = cv2.sqrt(cv2.add(xp, yp)) dist_max_i = np.argmax(dist) if dist_max_i < len(s): farthest_defect = s[dist_max_i] farthest_point = tuple(contour[farthest_defect][0]) return farthest_point else: return None
def show_specturm(self, dft_result):
"""
Show spectrun graph.
"""
# Split fourier into real and imaginary parts
image_Re, image_Im = cv2.split(dft_result)
# Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2)
magnitude = cv2.sqrt(image_Re ** 2.0 + image_Im ** 2.0)
# Compute log(1 + Mag)
log_spectrum = cv2.log(1.0 + magnitude)
# Rearrange the quadrants of Fourier image so that the origin is at
# the image center
# shift_dft(log_spectrum, log_spectrum)
# normalize and display the results as rgb
cv2.normalize(log_spectrum, log_spectrum, 0.0, 1.0, cv2.cv.CV_MINMAX)
# plt.imshow(log_spectrum)
# plt.show()
cv2.imshow(self.spectrum_winname, log_spectrum)
def remove_slp(img, gstd1=GSTD1, gstd2=GSTD2, gstd3=GSTD3, ksize=KSIZE, w=W):
"""Remove the SLP from kinect IR image
The input image should be a float32 numpy array, and should NOT be a square root image
Parameters
------------------
img : (M, N) float ndarray
Kinect NIR image with SLP pattern
gstd1 : float
Standard deviation of gaussian kernel 1
gstd2 : float
Standard deviation of gaussian kernel 2
gstd3 : float
Standard deviation of gaussian kernel 3
ksize : int
Size of kernel (should be odd)
w : float
Weighting factor
Returns
------------------
img_noslp : (M,N) float ndarray
Input image with SLP removed
"""
gf1 = cv2.getGaussianKernel(ksize, gstd1)
gf2 = cv2.getGaussianKernel(ksize, gstd2)
gf3 = cv2.getGaussianKernel(ksize, gstd3)
sqrtimg = cv2.sqrt(img)
p1 = cv2.sepFilter2D(sqrtimg, -1, gf1, gf1)
p2 = cv2.sepFilter2D(sqrtimg, -1, gf2, gf2)
maxarr = np.maximum(0, (p1 - p2) / p2)
minarr = np.minimum(w * maxarr, 1)
p = 1 - minarr
nc = cv2.sepFilter2D(p, -1, gf3, gf3) + EPS
output = cv2.sepFilter2D(p*sqrtimg, -1, gf3, gf3)
output = (output / nc) ** 2 # Since input is sqrted
return output
def dftSkew(im):
# convert to grayscale
# im = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
h, w = im.shape[:2]
realInput = im.astype(np.float64)
# perform an optimally sized dft
dft_M = cv2.getOptimalDFTSize(w)
dft_N = cv2.getOptimalDFTSize(h)
# copy A to dft_A and pad dft_A with zeros
dft_A = np.zeros((dft_N, dft_M, 2), dtype=np.float64)
dft_A[:h, :w, 0] = realInput
# no need to pad bottom part of dft_A with zeros because of
# use of nonzeroRows parameter in cv2.dft()
cv2.dft(dft_A, dst=dft_A, nonzeroRows=h)
cv2.imshow("win", im)
# Split fourier into real and imaginary parts
image_Re, image_Im = cv2.split(dft_A)
# Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2)
magnitude = cv2.sqrt(image_Re ** 2.0 + image_Im ** 2.0)
# Compute log(1 + Mag)
log_spectrum = cv2.log(1.0 + magnitude)
# Rearrange the quadrants of Fourier image so that the origin is at
# the image center
shift_dft(log_spectrum, log_spectrum)
# normalize and display the results as rgb
cv2.normalize(log_spectrum, log_spectrum, 0.0, 1.0, cv2.NORM_MINMAX)
magMat = log_spectrum * 255
magMat = np.uint8(np.around(magMat))
cv2.imwrite("dft.png", magMat)
rows = h
cols = w
# //imwrite("imageText_mag.jpg",magImg);
# //Turn into binary image
(_, magImg) = cv2.threshold(magMat, 160, 255, cv2.THRESH_BINARY)
cv2.imwrite("dft1.png", magImg)
# //imwrite("imageText_bin.jpg",magImg);
# //Find lines with Hough Transformation
pi180 = np.pi / 180
linImg = np.zeros(magImg.shape)
lines = cv2.HoughLines(magImg, 1, pi180, 100, 0, 0)
print lines
for line in lines[0]:
rho = line[0]
theta = line[1]
a = np.cos(theta)
b = np.sin(theta)
x0 = a * rho
y0 = b * rho
pt1 = (int(x0 + 1000 * (-b)), int(y0 + 1000 * (a)))
pt2 = (int(x0 - 1000 * (-b)), int(y0 - 1000 * (a)))
cv2.line(linImg, pt1, pt2, (255), 1)
cv2.imwrite("dlines.png", linImg)
# //imwrite("imageText_line.jpg",linImg);
# if(lines.size() == 3){
# cout << "found three angels:" << endl;
# cout << lines[0][1]*180/CV_PI << endl << lines[1][1]*180/CV_PI << endl << lines[2][1]*180/CV_PI << endl << endl;
# }
# //Find the proper angel from the three found angels
angel = 0
piThresh = np.pi / 90
pi2 = np.pi / 2
for line in lines[0]:
theta = line[1]
if abs(theta) < piThresh or abs(theta - pi2) < piThresh:
continue
else:
angel = theta
break
# //Calculate the rotation angel
# //The image has to be square,
# //so that the rotation angel can be calculate right
if angel < pi2:
angel = angel
else:
angel = angel - np.pi
if angel != pi2:
angelT = rows * tan(angel) / cols
angel = np.arctan(angelT)
angelD = angel * 180 / np.pi
# Rotate the image to recover
rotMat = cv2.getRotationMatrix2D((cols / 2, rows / 2), angelD, 1.0)
dstImg = cv2.warpAffine(im, rotMat, (cols, rows))
cv2.imwrite("dresult.png", dstImg)
__author__ = 'phillg07'
import cv2
import numpy as np
img = cv2.imread('/Users/phillg07/Pictures/tennis2.jpg', 0).astype(float)
mu = cv2.GaussianBlur(img, (41, 41), 20)
mu_2 = cv2.multiply(mu, mu)
mu_2g = cv2.GaussianBlur(mu_2, (41, 41), 20)
mu_sub = cv2.subtract(mu_2g, mu_2)
sigma = cv2.sqrt(mu_sub)
cv2.imshow('image', sigma)
cv2.waitKey(0)
cv2.destroyAllWindows()
def distance_points(self, start, end): return cv2.sqrt(cv2.add(cv2.pow(int(start[0]-end[0]),2),cv2.pow(int(start[1]-end[1]),2)))[0][0]
import cv2
import numpy as np
#import hist
img = cv2.imread('sofseam.jpg',0)
im = cv2.imread('sofseam.jpg')
rows,cols = img.shape
dx = cv2.Sobel(img,cv2.CV_32F,1,0)
dy = cv2.Sobel(img,cv2.CV_32F,0,1)
dz = np.zeros(img.shape,np.float32)
dx2 = cv2.accumulateSquare(dx,dz)
dy2 = cv2.accumulateSquare(dy,dz)
lap = cv2.sqrt(dz)
#lap = cv2.convertScaleAbs(lap)
t = np.zeros(img.shape,np.float32)
t[0,:] = lap[0,:]
for r in xrange(1,rows):
for c in xrange(0,cols):
i = lap.item(r,c)
if c==0:
j = min(t[r-1,c:c+2])
elif c==cols-1:
j = min(t[r-1,c-1:c+1])
else:
j = min(t[r-1,c-1:c+2])
def ReducedRun(img): img = cv2.resize(img,(40,40)) YUV = cv2.cvtColor(img,cv2.COLOR_BGR2YCR_CB) Y,U,V = cv2.split(YUV) r,g,b = cv2.split(img) kernel1 = np.ones((3,1),np.float32) kernel2 = np.ones((1,3),np.float32) kernel1[0] = -1 kernel1[1] = 0 kernel2[0] = [-1,0,1] dst = cv2.filter2D(img,cv2.CV_16S,kernel1) rv,gv,bv = cv2.split(dst) rv1 = np.int16(rv) gv1 = np.float32(gv) bv1 = np.float32(bv) rv1 = cv2.pow(rv1,2) gv1 = cv2.pow(gv1,2) bv1 = cv2.pow(bv1,2) dst = cv2.filter2D(img,cv2.CV_16S,kernel2) rh,gh,bh = cv2.split(dst) rh1 = np.int16(rh) gh1 = np.float32(gh) bh1 = np.float32(bh) rh1 = cv2.pow(rh1,2) gh1 = cv2.pow(gh1,2) bh1 = cv2.pow(bh1,2) r1 = rh1 + rv1 g1 = gh1 + gv1 b1 = bh1 + bv1 r1 = np.float32(r1) g1 = np.float32(g1) b1 = np.float32(b1) rfinal = cv2.sqrt(r1).astype(np.uint8) bfinal = cv2.sqrt(g1).astype(np.uint8) gfinal = cv2.sqrt(b1).astype(np.uint8) red = (rfinal > bfinal) & (rfinal > gfinal) red = red.astype(np.uint8) blue = (bfinal > rfinal) & (bfinal > gfinal) blue = blue.astype(np.uint8) green = (gfinal > bfinal) & (gfinal > rfinal) green = green.astype(np.uint8) redfh = red*rh bluefh = blue*bh greenfh = green*gh redfv = red*rv bluefv = blue*bv greenfv = green*gv redm = red*rfinal bluem = blue*bfinal greenm = green*gfinal finalh = redfh + bluefh + greenfh finalv = redfv + bluefv + greenfv finalm = redm + bluem + greenm UporDown = (finalv > 0 ).astype(int) LeftorRight = 2*(finalh > 0).astype(int) absh = map(abs, finalh) absv = map(abs, finalv) absv[:] = [x*1.732 for x in absv] absh = np.float32(absh) absv = np.float32(absv) high = 4*(absv > absh).astype(int) out = high + LeftorRight + UporDown features = [] for x in range(6): hrt = np.zeros(out.shape[:2],np.uint8) features.append(hrt) for x in range(out.shape[:2][0]): for y in range(out.shape[:2][1]): z = out[x][y] if z == 4 or z == 6: features[4][x][y] = finalm[x][y] elif z == 5 or z == 7: features[5][x][y] = finalm[x][y] else: features[z][x][y] = finalm[x][y] lastFeatures = [] kernelg = np.ones((5,5),np.float32) for img in features: img1 = cv2.filter2D(img,-1,kernelg) lastFeatures.append(img1) lastFeatures.append(finalm) lastFeatures.append(Y) lastFeatures.append(U) lastFeatures.append(V) return lastFeatures
def describe(self, image): #Convert to graysacale im = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) features = [] h, w = im.shape[:2] realInput = im.astype(np.float64) # perform an optimally sized dft dft_M = cv2.getOptimalDFTSize(w) dft_N = cv2.getOptimalDFTSize(h) # copy A to dft_A and pad dft_A with zeros dft_A = np.zeros((dft_N, dft_M, 2), dtype=np.float64) dft_A[:h, :w, 0] = realInput # no need to pad bottom part of dft_A with zeros because of # use of nonzeroRows parameter in cv2.dft() cv2.dft(dft_A, dst=dft_A, nonzeroRows=h) # Split fourier into real and imaginary parts image_Re, image_Im = cv2.split(dft_A) # Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2) magnitude = cv2.sqrt(image_Re**2.0 + image_Im**2.0) # Compute log(1 + Mag) log_spectrum = cv2.log(1.0 + magnitude) # Rearrange the quadrants of Fourier image so that the origin is at # the image center self.shift_dft(log_spectrum, log_spectrum) # normalize and display the results as rgb cv2.normalize(log_spectrum, log_spectrum, 0.0, 1.0, cv2.NORM_MINMAX) h, w = log_spectrum.shape[:2] #Calcula media com uma mascara de 3x3 if(self.maskSize == 3): i_h = 1 while i_h < h: i_w = 1 while i_w < w: s = log_spectrum[i_h-1, i_w-1] + log_spectrum[i_h-1, i_w] + log_spectrum[i_h-1, i_w+1] + log_spectrum[i_h, i_w-1] + log_spectrum[i_h, i_w] + log_spectrum[i_h, i_w+1] + log_spectrum[i_h+1, i_w-1] + log_spectrum[i_h+1, i_w] + log_spectrum[i_h+1, i_w+1] p = s / 9 features.append(p) i_w += 3 i_h += 3 #Calcula media com uma mascara de 5x5 elif(self.maskSize == 5): i_h = 2 while i_h < h: i_w = 2 while i_w < w: s = log_spectrum[i_h-2, i_w-2] + log_spectrum[i_h-2, i_w-1] + log_spectrum[i_h-2, i_w+1] + log_spectrum[i_h-2, i_w] + log_spectrum[i_h-2, i_w+1] + log_spectrum[i_h-2, i_w+2] s += log_spectrum[i_h-1, i_w-2] + log_spectrum[i_h-1, i_w-1] + log_spectrum[i_h-1, i_w+1] + log_spectrum[i_h-1, i_w] + log_spectrum[i_h-1, i_w+1] + log_spectrum[i_h-1, i_w+2] s += log_spectrum[i_h, i_w-2] + log_spectrum[i_h, i_w-1] + log_spectrum[i_h, i_w+1] + log_spectrum[i_h, i_w] + log_spectrum[i_h, i_w+1] + log_spectrum[i_h, i_w+2] s += log_spectrum[i_h+1, i_w-2] + log_spectrum[i_h+1, i_w-1] + log_spectrum[i_h+1, i_w+1] + log_spectrum[i_h+1, i_w] + log_spectrum[i_h+1, i_w+1] + log_spectrum[i_h+1, i_w+2] s += log_spectrum[i_h+2, i_w-2] + log_spectrum[i_h+2, i_w-1] + log_spectrum[i_h+2, i_w+1] + log_spectrum[i_h+2, i_w] + log_spectrum[i_h+2, i_w+1] + log_spectrum[i_h+2, i_w+2] p = s / 25 features.append(p) i_w += 5 i_h += 5 #Calcula media com uma mascara de 7x7 elif(self.maskSize == 7): i_h = 3 while i_h < h - 7: i_w = 3 while i_w < w - 7: s = log_spectrum[i_h-3, i_w-3] + log_spectrum[i_h-3, i_w-2] + log_spectrum[i_h-3, i_w-1] + log_spectrum[i_h-3, i_w] + log_spectrum[i_h-3, i_w+1] + log_spectrum[i_h-3, i_w+2] + log_spectrum[i_h-3, i_w+3] s += log_spectrum[i_h-2, i_w-3] + log_spectrum[i_h-2, i_w-2] + log_spectrum[i_h-2, i_w-1] + log_spectrum[i_h-2, i_w] + log_spectrum[i_h-2, i_w+1] + log_spectrum[i_h-2, i_w+2] + log_spectrum[i_h-2, i_w+3] s += log_spectrum[i_h-1, i_w-3] + log_spectrum[i_h-1, i_w-2] + log_spectrum[i_h-1, i_w-1] + log_spectrum[i_h-1, i_w] + log_spectrum[i_h-1, i_w+1] + log_spectrum[i_h-1, i_w+2] + log_spectrum[i_h-1, i_w+3] s += log_spectrum[i_h, i_w-3] + log_spectrum[i_h, i_w-2] + log_spectrum[i_h, i_w-1] + log_spectrum[i_h, i_w] + log_spectrum[i_h, i_w+1] + log_spectrum[i_h, i_w+2] + log_spectrum[i_h, i_w+3] s += log_spectrum[i_h+1, i_w-3] + log_spectrum[i_h+1, i_w-2] + log_spectrum[i_h+1, i_w-1] + log_spectrum[i_h+1, i_w] + log_spectrum[i_h+1, i_w+1] + log_spectrum[i_h+1, i_w+2] + log_spectrum[i_h+1, i_w+3] s += log_spectrum[i_h+2, i_w-3] + log_spectrum[i_h+2, i_w-2] + log_spectrum[i_h+2, i_w-1] + log_spectrum[i_h+2, i_w] + log_spectrum[i_h+2, i_w+1] + log_spectrum[i_h+2, i_w+2] + log_spectrum[i_h+2, i_w+3] s += log_spectrum[i_h+3, i_w-3] + log_spectrum[i_h+3, i_w-2] + log_spectrum[i_h+3, i_w-1] + log_spectrum[i_h+3, i_w] + log_spectrum[i_h+3, i_w+1] + log_spectrum[i_h+3, i_w+2] + log_spectrum[i_h+3, i_w+3] p = s / 49 features.append(p) i_w += 7 i_h += 7 return features
fgmask = cv2.medianBlur(fgmask, 7)
oldFgmask = fgmask.copy()
image, contours, hierarchy = cv2.findContours(fgmask, cv2.RETR_EXTERNAL,1)
for contour in contours:
x,y,w,h = cv2.boundingRect(contour)
if w>40 and h>90:
cv2.rectangle(frame,(x,y),(x+w,y+h),(0,255,0),2, lineType=cv2.LINE_AA)
point = (int(x+w/2.0), int(y+h/2.0))
points.add(point)
for point in points:
(xnew, ynew) = point
if line1(xnew, ynew) > 0 and line2(xnew, ynew) < 0:
pointInMiddle.add(point)
for prevPoint in prev:
(xold, yold) = prevPoint
dist = cv2.sqrt((xnew-xold)*(xnew-xold)+(ynew-yold)*(ynew-yold))
if dist[0] <= 120:
if line1(xnew, ynew) >= 0 and line2(xnew, ynew) <= 0:
if line1(xold, yold) < 0: # Point entered from line above
pointFromAbove.add(point)
elif line2(xold, yold) > 0: # Point entered from line below
pointFromBelow.add(point)
else: # Point was inside the block
if prevPoint in pointFromBelow:
pointFromBelow.remove(prevPoint)
pointFromBelow.add(point)
elif prevPoint in pointFromAbove:
pointFromAbove.remove(prevPoint)
pointFromAbove.add(point)
def RunG(img): YUV = cv2.cvtColor(img,cv2.COLOR_BGR2YCR_CB) YUV = cv2.resize(YUV,(26,26)) Y,U,V = cv2.split(YUV) YUV = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) img = cv2.resize(YUV,(26,26)) kernel1 = np.ones((3,1),np.float32) kernel2 = np.ones((1,3),np.float32) kernel1[0] = -1 kernel1[1] = 0 kernel2[0] = [-1,0,1] dst = cv2.filter2D(img,cv2.CV_16S,kernel1) dstv1 = np.int16(dst) dstv2 = cv2.pow(dstv1,2) dst = cv2.filter2D(img,cv2.CV_16S,kernel2) dsth1 = np.int16(dst) dsth2 = cv2.pow(dsth1,2) dst1 = dsth2 + dstv2 dst1 = np.float32(dst1) dstfinal = cv2.sqrt(dst1).astype(np.uint8) finalh = dsth1 finalv = dstv1 finalm = dstfinal UporDown = (finalv > 0 ).astype(int) LeftorRight = 2*(finalh > 0).astype(int) absh = map(abs, finalh) absv = map(abs, finalv) absv[:] = [x*1.732 for x in absv] absh = np.float32(absh) absv = np.float32(absv) high = 4*(absv > absh).astype(int) out = high + LeftorRight + UporDown features = [] for x in range(6): hrt = np.zeros(out.shape[:2],np.uint8) features.append(hrt) kernelg = np.ones((6,6),np.float32) for x in range(out.shape[:2][0]): for y in range(out.shape[:2][1]): z = out[x][y] if z == 4 or z == 6: # print "a",z features[4][x][y] = finalm[x][y] elif z == 5 or z == 7: features[5][x][y] = finalm[x][y] # print "b",z else: features[z][x][y] = finalm[x][y] # print z lastFeatures = [] for img in features: img1 = cv2.filter2D(img,-1,kernelg) lastFeatures.append(img1) lastFeatures.append(finalm) lastFeatures.append(Y) lastFeatures.append(U) lastFeatures.append(V) integrals = [] for img in lastFeatures: integ = cv2.integral(img) integrals.append(integ) print integ.shape[:2] height, width = integ.shape[:2] a = readFeatures(26,26) results = [] results = Evaluate(a, integrals,0,0) return results
# copy A to dft_A and pad dft_A with zeros
dft_A = np.zeros((dft_N, dft_M, 2), dtype=np.float64)
dft_A[:h, :w, 0] = realInput
# no need to pad bottom part of dft_A with zeros because of
# use of nonzeroRows parameter in cv2.dft()
cv2.dft(dft_A, dst=dft_A, nonzeroRows=h)
cv2.imshow("win", im)
# Split fourier into real and imaginary parts
image_Re, image_Im = cv2.split(dft_A)
# Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2)
magnitude = cv2.sqrt(image_Re**2.0 + image_Im**2.0)
# Compute log(1 + Mag)
log_spectrum = cv2.log(1.0 + magnitude)
# Rearrange the quadrants of Fourier image so that the origin is at
# the image center
shift_dft(log_spectrum, log_spectrum)
# normalize and display the results as rgb
cv2.normalize(log_spectrum, log_spectrum, 0.0, 1.0, cv2.NORM_MINMAX)
cv2.imshow("magnitude", log_spectrum)
cv2.waitKey(0)
cv2.destroyAllWindows()
def find_hand_farthest_point(frame, hist, bill_center):
MAX_DISTANCE_FROM_CENTER = 200
hand_isolated_frame = hist_filter(frame, hist)
gray = cv2.cvtColor(hand_isolated_frame, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray, 0, 255, 0)
#_,contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
if contours is not None and len(contours) > 0:
max_i = 0
max_area = 0
for i in range(len(contours)):
cnt = contours[i]
area = cv2.contourArea(cnt)
if area > max_area:
max_area = area
max_i = i
largest_contour = contours[max_i]
hull = cv2.convexHull(largest_contour)
moments = cv2.moments(largest_contour)
centroid = None
if moments['m00'] != 0:
cx = int(moments['m10']/moments['m00'])
cy = int(moments['m01']/moments['m00'])
centroid = (cx,cy)
defects = None
non_returnpoints_hull = cv2.convexHull(largest_contour, returnPoints=False)
if non_returnpoints_hull is not None and len(non_returnpoints_hull) > 3 and len(largest_contour) > 3:
defects = cv2.convexityDefects(largest_contour, non_returnpoints_hull)
if centroid is not None and defects is not None and len(defects) > 0:
s = defects[:,0][:,0]
cx, cy = centroid
x = np.array(largest_contour[s][:,0][:,0], dtype=np.float)
y = np.array(largest_contour[s][:,0][:,1], dtype=np.float)
to_delete = []
for i in range(len(x)):
if (x[i] - bill_center[0]) * (x[i] - bill_center[0])\
+ (y[i] - bill_center[1]) * (y[i] - bill_center[1])\
> MAX_DISTANCE_FROM_CENTER * MAX_DISTANCE_FROM_CENTER:
to_delete.append(i)
x = np.delete(x, to_delete)
y = np.delete(y, to_delete)
if len(x) > 0:
xp = cv2.pow(cv2.subtract(x, cx), 2)
yp = cv2.pow(cv2.subtract(y, cy), 2)
dist = cv2.sqrt(cv2.add(xp, yp))
dist_max_i = np.argmax(dist)
if dist_max_i < len(s):
farthest_defect = s[dist_max_i]
farthest_point = tuple(largest_contour[farthest_defect][0])
for cnt in contours:
if cnt is not largest_contour:
cv2.drawContours(hand_isolated_frame, cnt, -1, (255,0,0), 3)
else:
cv2.drawContours(hand_isolated_frame, cnt, -1, (0,255,0), 3)
cv2.circle(hand_isolated_frame, centroid, 5, [0,255,0], -1)
cv2.circle(hand_isolated_frame, farthest_point, 5, [0,0,255], -1)
cv2.imshow("hand", hand_isolated_frame)
return dist[dist_max_i], farthest_point, hand_isolated_frame
return None, None, None
