def detect_no_draw(self, img): # allocate temporary images gray = cv.CreateImage((img.width, img.height), 8, 1) small_img = cv.CreateImage((cv.Round(img.width / self.image_scale), cv.Round(img.height / self.image_scale)), 8, 1) # convert color input image to grayscale cv.CvtColor(img, gray, cv.CV_BGR2GRAY) # scale input image for faster processing cv.Resize(gray, small_img, cv.CV_INTER_LINEAR) cv.EqualizeHist(small_img, small_img) if self.cascade: t = cv.GetTickCount() faces = cv.HaarDetectObjects(small_img, self.cascade, cv.CreateMemStorage(0), self.haar_scale, self.min_neighbors, self.haar_flags, self.min_size) t = cv.GetTickCount() - t if faces: return True else: return False
def DetectFace(image, faceCascade): #modified from: http://www.lucaamore.com/?p=638 min_size = (20, 20) image_scale = 1 haar_scale = 1.1 min_neighbors = 3 haar_flags = 0 # Allocate the temporary images smallImage = cv2.CreateImage((cv2.Round( image.width / image_scale), cv2.Round(image.height / image_scale)), 8, 1) # Scale input image for faster processing cv2.Resize(image, smallImage, cv2.CV_INTER_LINEAR) # Equalize the histogram cv2.EqualizeHist(smallImage, smallImage) # Detect the faces faces = cv2.HaarDetectObjects(smallImage, faceCascade, cv2.CreateMemStorage(0), haar_scale, min_neighbors, haar_flags, min_size) # If faces are found if faces: for ((x, y, w, h), n) in faces: # the input to cv.HaarDetectObjects was resized, so scale the # bounding box of each face and convert it to two CvPoints pt1 = (int(x * image_scale), int(y * image_scale)) pt2 = (int((x + w) * image_scale), int((y + h) * image_scale)) cv2.Rectangle(image, pt1, pt2, cv2.RGB(255, 0, 0), 5, 8, 0) return image
def detect_and_draw(self, img): # allocate temporary images gray = cv.CreateImage((img.width, img.height), 8, 1) small_img = cv.CreateImage((cv.Round(img.width / self.image_scale), cv.Round(img.height / self.image_scale)), 8, 1) # convert color input image to grayscale cv.CvtColor(img, gray, cv.CV_BGR2GRAY) # scale input image for faster processing cv.Resize(gray, small_img, cv.CV_INTER_LINEAR) cv.EqualizeHist(small_img, small_img) if self.cascade: t = cv.GetTickCount() faces = cv.HaarDetectObjects(small_img, self.cascade, cv.CreateMemStorage(0), self.haar_scale, self.min_neighbors, self.haar_flags, self.min_size) t = cv.GetTickCount() - t # print "time taken for detection = %gms" % (t/(cv.GetTickFrequency()*1000.)) if faces: face_found = True for ((x, y, w, h), n) in faces: # the input to cv.HaarDetectObjects was resized, so scale the # bounding box of each face and convert it to two CvPoints pt1 = (int(x * self.image_scale), int(y * self.image_scale)) pt2 = (int((x + w) * self.image_scale), int((y + h) * self.image_scale)) cv.Rectangle(img, pt1, pt2, cv.RGB(255, 0, 0), 3, 8, 0) else: face_found = False cv.ShowImage("video", img) return face_found
cv.Canny(im, dst, 200, 200) cv.Threshold(dst, dst, 100, 255, cv.CV_THRESH_BINARY) #---- Standard ---- color_dst_standard = cv.CreateImage(cv.GetSize(im), 8, 3) cv.CvtColor(im, color_dst_standard, cv.CV_GRAY2BGR) #Create output image in RGB to put red lines lines = cv.HoughLines2(dst, cv.CreateMemStorage(0), cv.CV_HOUGH_STANDARD, 1, pi / 180, 100, 0, 0) for (rho, theta) in lines[:100]: a = math.cos(theta) #Calculate orientation in order to print them b = math.sin(theta) x0 = a * rho y0 = b * rho pt1 = (cv.Round(x0 + 1000 * (-b)), cv.Round(y0 + 1000 * (a))) pt2 = (cv.Round(x0 - 1000 * (-b)), cv.Round(y0 - 1000 * (a))) cv.Line(color_dst_standard, pt1, pt2, cv.CV_RGB(255, 0, 0), 2, 4) #Draw the line #---- Probabilistic ---- color_dst_proba = cv.CreateImage(cv.GetSize(im), 8, 3) cv.CvtColor(im, color_dst_proba, cv.CV_GRAY2BGR) # idem rho = 1 theta = pi / 180 thresh = 50 minLength = 120 # Values can be changed approximately to fit your image edges maxGap = 20 lines = cv.HoughLines2(dst, cv.CreateMemStorage(0), cv.CV_HOUGH_PROBABILISTIC,
def detectFace(self, cam_img, faceCascade, eyeCascade, mouthCascade): # cam_img should be cv2.cv.iplcam_img min_size = (20, 20) image_scale = 2 haar_scale = 1.2 min_neighbors = 2 haar_flags = 0 image_width = int(cam_img.get(cv.CV_CAP_PROP_FRAME_WIDTH)) image_height = int(cam_img.get(cv.CV_CAP_PROP_FRAME_HEIGHT)) # Allocate the temporary images gray = cv.CreateImage((image_width, image_height), 8, 1) # tuple as the first arg smallImage = cv.CreateImage((cv.Round(image_width / image_scale), cv.Round(image_height / image_scale)), 8, 1) (ok, img) = cam_img.read() # print 'gray is of ',type(gray) >>> gray is of <type 'cv2.cv.iplimage'> # print type(smallImage) >>> <type 'cv2.cv.iplimage'> # print type(image) >>> <type 'cv2.VideoCapture'> # print type(img) >>> <type 'numpy.ndarray'> # convert numpy.ndarray to iplimage ipl_img = cv2.cv.CreateImageHeader((img.shape[1], img.shape[0]), cv.IPL_DEPTH_8U, 3) cv2.cv.SetData(ipl_img, img.tostring(), img.dtype.itemsize * 3 * img.shape[1]) # Convert color input image to grayscale cv.CvtColor(ipl_img, gray, cv.CV_BGR2GRAY) # Scale input image for faster processing cv.Resize(gray, smallImage, cv.CV_INTER_LINEAR) # Equalize the histogram cv.EqualizeHist(smallImage, smallImage) # Detect the faces faces = cv.HaarDetectObjects(smallImage, faceCascade, cv.CreateMemStorage(0), haar_scale, min_neighbors, haar_flags, min_size) # => The function returns a list of tuples, (rect, neighbors) , where rect is a CvRect specifying the object’s extents and neighbors is a number of neighbors. # => CvRect cvRect(int x, int y, int width, int height) # If faces are found if faces: face = faces[0] self.faceX = face[0][0] self.faceY = face[0][1] for ((x, y, w, h), n) in faces: # the input to cv.HaarDetectObjects was resized, so scale the # bounding box of each face and convert it to two CvPoints pt1 = (int(x * image_scale), int(y * image_scale)) pt2 = (int((x + w) * image_scale), int((y + h) * image_scale)) cv.Rectangle(ipl_img, pt1, pt2, cv.RGB(0, 0, 255), 3, 8, 0) # face_region = cv.GetSubRect(ipl_img,(x,int(y + (h/4)),w,int(h/2))) cv.SetImageROI(ipl_img, (pt1[0], pt1[1], pt2[0] - pt1[0], int((pt2[1] - pt1[1]) * 0.7))) eyes = cv.HaarDetectObjects(ipl_img, eyeCascade, cv.CreateMemStorage(0), haar_scale, min_neighbors, haar_flags, (15, 15)) if eyes: # For each eye found for eye in eyes: # Draw a rectangle around the eye cv.Rectangle(ipl_img, # image (eye[0][0], # vertex pt1 eye[0][1]), (eye[0][0] + eye[0][2], # vertex pt2 opposite to pt1 eye[0][1] + eye[0][3]), cv.RGB(255, 0, 0), 1, 4, 0) # color,thickness,lineType(8,4,cv.CV_AA),shift cv.ResetImageROI(ipl_img) return ipl_img
cv.SetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_WIDTH, 1280) cv.SetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_HEIGHT, 720) frame = cv.QueryFrame(capture) test = cv.CreateImage(cv.GetSize(frame), 8, 3) cv.NamedWindow("output") previous_x = 0 previous_y = 0 while (1): frame = cv.QueryFrame(capture) cv.Flip(frame, frame, 1) # we make all drawings on imdraw. imdraw = cv.CreateImage(cv.GetSize(frame), 8, 3) # we get coordinates from imgyellowthresh imgyellowthresh = getthresholdedimg(frame) # eroding removes small noises cv.Erode(imgyellowthresh, imgyellowthresh, None, 1) (leftmost, rightmost, topmost, bottommost) = getpositions(imgyellowthresh) if (leftmost - rightmost != 0) or (topmost - bottommost != 0): lastx = posx lasty = posy posx = cv.Round((rightmost + leftmost) / 2) posy = cv.Round((bottommost + topmost) / 2) if lastx != 0 and lasty != 0: win32api.SetCursorPos((posx, posy)) cv.Add(test, imdraw, test) cv.ShowImage("output", test) if cv.WaitKey(10) >= 0: break cv.DestroyWindow("output")
while (True): # Capture frame-by-frame result, frame = capture.read() #frame = cv.QueryFrame(cap) if not frame: cv.waitKey(0) break if not frame_copy: frame_copy = cv.CreateImage((frame.width, frame.height), cv.IPL_DEPTH_8U, frame.nChannels) if frame.origin == cv.IPL_ORIGIN_TL: cv.Flip(frame, frame, -1) # Our operations on the frame come here gray = cv.CreateImage((frame.width, frame.height), 8, 1) small_img = cv.CreateImage((cv.Round( frame.width / image_scale), cv.Round(frame.height / image_scale)), 8, 1) # convert color input image to grayscale cv.CvtColor(frame, gray, cv.CV_BGR2GRAY) # scale input image for faster processing cv.Resize(gray, small_img, cv.CV_INTER_LINEAR) cv.EqualizeHist(small_img, small_img) midFace = None if (cascade): t = cv.GetTickCount() # HaarDetectObjects takes 0.02s
def process_image(self, slider_pos): global cimg, source_image1, ellipse_size, maxf, maxs, eoc, lastcx,lastcy,lastr """ This function finds contours, draws them and their approximation by ellipses. """ stor = cv.CreateMemStorage() # Create the destination images cimg = cv.CloneImage(self.source_image) cv.Zero(cimg) image02 = cv.CloneImage(self.source_image) cv.Zero(image02) image04 = cv.CreateImage(cv.GetSize(self.source_image), cv.IPL_DEPTH_8U, 3) cv.Zero(image04) # Threshold the source image. This needful for cv.FindContours(). cv.Threshold(self.source_image, image02, slider_pos, 255, cv.CV_THRESH_BINARY) # Find all contours. cont = cv.FindContours(image02, stor, cv.CV_RETR_LIST, cv.CV_CHAIN_APPROX_NONE, (0, 0)) maxf = 0 maxs = 0 size1 = 0 for c in contour_iterator(cont): if len(c) > ellipse_size: PointArray2D32f = cv.CreateMat(1, len(c), cv.CV_32FC2) for (i, (x, y)) in enumerate(c): PointArray2D32f[0, i] = (x, y) # Draw the current contour in gray gray = cv.CV_RGB(100, 100, 100) cv.DrawContours(image04, c, gray, gray,0,1,8,(0,0)) if iter == 0: strng = segF + '/' + 'contour1.png' cv.SaveImage(strng,image04) color = (255,255,255) (center, size, angle) = cv.FitEllipse2(PointArray2D32f) # Convert ellipse data from float to integer representation. center = (cv.Round(center[0]), cv.Round(center[1])) size = (cv.Round(size[0] * 0.5), cv.Round(size[1] * 0.5)) if iter == 1: if size[0] > size[1]: size2 = size[0] else: size2 = size[1] if size2 > size1: size1 = size2 size3 = size # Fits ellipse to current contour. if eoc == 0 and iter == 2: rand_val = abs((lastr - ((size[0]+size[1])/2))) if rand_val > 20 and float(max(size[0],size[1]))/float(min(size[0],size[1])) < 1.5: lastcx = center[0] lastcy = center[1] lastr = (size[0]+size[1])/2 if rand_val > 20 and float(max(size[0],size[1]))/float(min(size[0],size[1])) < 1.4: cv.Ellipse(cimg, center, size, angle, 0, 360, color,2, cv.CV_AA, 0) cv.Ellipse(source_image1, center, size, angle, 0, 360, color,2, cv.CV_AA, 0) elif eoc == 1 and iter == 2: (int,cntr,rad) = cv.MinEnclosingCircle(PointArray2D32f) cntr = (cv.Round(cntr[0]), cv.Round(cntr[1])) rad = (cv.Round(rad)) if maxf == 0 and maxs == 0: cv.Circle(cimg, cntr, rad, color, 1, cv.CV_AA, shift=0) cv.Circle(source_image1, cntr, rad, color, 2, cv.CV_AA, shift=0) maxf = rad elif (maxf > 0 and maxs == 0) and abs(rad - maxf) > 30: cv.Circle(cimg, cntr, rad, color, 2, cv.CV_AA, shift=0) cv.Circle(source_image1, cntr, rad, color, 2, cv.CV_AA, shift=0) maxs = len(c) if iter == 1: temp3 = 2*abs(size3[1] - size3[0]) if (temp3 > 40): eoc = 1
def drawGraph(arraySrc, nArrayLength, imageDst, minV=0, maxV=0, width=0, height=0, graphLabel='', showScale=True): w, h, b = width, height, 10 w = nArrayLength + b * 2 if w <= 20 else w h = 220 if h <= 20 else h s, xscale = h - b * 2, 1.0 if nArrayLength > 1: xscale = (w - b * 2) / float(nArrayLength - 1) # Assume imageDst is a numpy array if not imageDst: imageGraph = Image.new('RGB', (w, h), WHITE) # imageGraph.show() else: imageGraph = imageDst if not imageGraph: print 'Error in drawGraph' return colorGraph = getGraphColor() if abs(minV) < 1e-7 and abs(maxV) < 1e-7: for i in range(nArrayLength): v = arraySrc[i] minV = v if v < minV else minV maxV = v if v > maxV else maxV diffV = maxV - minV diffV = 1e-7 if diffV == 0 else diffV fscale = float(s) / diffV # Draw the horizontal and vertical axis y0 = cv2.Round(minV * fscale) cv2.Line(imageGraph, (b, h - (b - y0)), (w - b, h - (b - y0)), BLACK) cv2.Line(imageGraph, (b, h - b), (b, h - (b + s)), BLACK) # Write the scale of the y and x axis if showScale: #cv2.putText(frame, text, (int(x), int(y)), cv2.FONT_HERSHEY_SIMPLEX, size, color, thickness) cv2.putText(imageGraph, '%.1f' % maxV, (1, b + 4), cv2.FONT_HERSHEY_PLAIN, 2, GREY, 0.1) cv2.putText(imageGraph, '%d' % (nArrayLength - 1), (w - b + 4 - 5 * 2, h / 2 + 10), cv2.FONT_HERSHEY_PLAIN, 2, GREY, 0.1) # Draw the values ptPrev = (b, h - (b - y)) for i in range(nArrayLength): y = cv2.Round((arraySrc[i] - minV) * fscale) x = cv2.Round(i * xscale) ptNew = (b + x, h - (b + y)) cv2.Line(imageGraph, ptPrev, ptNew, colorGraph, 1, cv2.CV_AA) ptPrev = ptNew # Write the graph label if graphLabel != None and graphLabel != '': cv2.putText(imageGraph, graphLabel, (30, 10), cv2.FONT_HERSHEY_PLAIN, 2, GREY, 0.1) return imageGraph
def rectify_uncalibrated(x1, x2, F, imsize, threshold=5): """ Compute rectification homography for two images. This is based on algo 11.12.3 of HZ2 This is also heavily inspired by cv::stereoRectifyUncalibrated Args: - imsize is (width, height) """ U, W, V = la.svd(F) # Enforce rank 2 on fundamental matrix W[2] = 0 W = np.diag(W) F = U.dot(W).dot(V) # Filter points based on their distance to epipolar lines if threshold > 0: lines1 = epipolar_lines(x1, F) lines2 = epipolar_lines(x2, F.T) def epi_threshold(i): return (abs(x1[0,i]*lines2[0,i] + x1[1,i]*lines2[1,i] + lines2[2,i]) <= threshold) and \ (abs(x2[0,i]*lines1[0,i] + x2[1,i]*lines1[1,i] + lines1[2,i]) <= threshold) inliers = filter(epi_threshold, range(x1.shape[1])) else: inliers = range(x1.shape[1]) assert len(inliers) > 0 x1 = x1[:, inliers] x2 = x2[:, inliers] # HZ2 11.12.1 : Compute H = GRT where : # - T is a translation taking point x0 to the origin # - R is a rotation about the origin taking the epipole e' to (f,0,1) # - G is a mapping taking (f,0,1) to infinity # e2 is the left null vector of F (the one corresponding to the singular # value that is 0 => the third column of U) e2 = U[:, 2] # TODO: They do this in OpenCV, not sure why if e2[2] < 0: e2 *= -1 # Translation bringing the image center to the origin # FIXME: This is kind of stupid, but to get the same results as OpenCV, # use cv.Round function, which has a strange behaviour : # cv.Round(99.5) => 100 # cv.Round(132.5) => 132 cx = cv2.Round((imsize[0] - 1) * 0.5) cy = cv2.Round((imsize[1] - 1) * 0.5) T = np.array([[1, 0, -cx], [0, 1, -cy], [0, 0, 1]], dtype=float) e2 = T.dot(e2) mirror = e2[0] < 0 # Compute rotation matrix R that should bring e2 to (f,0,1) # 2D norm of the epipole, avoid division by zero d = max(np.sqrt(e2[0] * e2[0] + e2[1] * e2[1]), 1e-7) alpha = e2[0] / d beta = e2[1] / d R = np.array([[alpha, beta, 0], [-beta, alpha, 0], [0, 0, 1]], dtype=float) e2 = R.dot(e2) # Compute G : mapping taking (f,0,1) to infinity invf = 0 if abs(e2[2]) < 1e-6 * abs(e2[0]) else -e2[2] / e2[0] G = np.array([[1, 0, 0], [0, 1, 0], [invf, 0, 1]], dtype=float) # Map the origin back to the center of the image iT = np.array([[1, 0, cx], [0, 1, cy], [0, 0, 1]], dtype=float) H2 = iT.dot(G.dot(R.dot(T))) # HZ2 11.12.2 : Find matching projective transform H1 that minimize # leaste-square distance between reprojected points e2 = U[:, 2] # TODO: They do this in OpenCV, not sure why if e2[2] < 0: e2 *= -1 e2_x = np.array( [[0, -e2[2], e2[1]], [e2[2], 0, -e2[0]], [-e2[1], e2[0], 0]], dtype=float) e2_111 = np.array( [[e2[0], e2[0], e2[0]], [e2[1], e2[1], e2[1]], [e2[2], e2[2], e2[2]]], dtype=float) H0 = H2.dot(e2_x.dot(F) + e2_111) # Minimize \sum{(a*x_i + b*y_i + c - x'_i)^2} (HZ2 p.307) # Compute H1*x1 and H2*x2 x1h = homg.to_homg(x1) x2h = homg.to_homg(x2) A = H0.dot(x1h).T # We want last (homogeneous) coordinate to be 1 (coefficient of c # in the equation) A = (A.T / A[:, 2]).T # for some reason, A / A[:,2] doesn't work B = H2.dot(x2h) B = B / B[2, :] # from homogeneous B = B[0, :] # only interested in x coordinate X, _, _, _ = la.lstsq(A, B) # Build Ha (HZ2 eq. 11.20) Ha = np.array([[X[0], X[1], X[2]], [0, 1, 0], [0, 0, 1]], dtype=float) H1 = Ha.dot(H0) if mirror: mm = np.array([[-1, 0, cx * 2], [0, -1, cy * 2], [0, 0, 1]], dtype=float) H1 = mm.dot(H1) H2 = mm.dot(H2) return H1, H2 #Source: https://github.com/julienr/cvscripts/tree/master/rectification