def main(): root = "/Users/soswow/Documents/Face Detection/test/negative" # root = "/Users/soswow/Documents/Face Detection/test/sets/negative" # root = "/Users/soswow/Documents/Face Detection/test/edge_view/positive" # root = "/Users/soswow/Documents/Face Detection/test/sobel/positive" # root = "/Users/soswow/Documents/Face Detection/test/sets/positive" # root = "/Users/soswow/Documents/Face Detection/test/falses" for folder in os.listdir(root): path = p.join(root, folder) if p.isdir(path): sum = cv.CreateMat(32, 32, cv.CV_32F) cv.Zero(sum) k = 0 for path, _ in directory_files(path): try: img = cv.LoadImage(path, iscolor=False) except IOError: continue mat = cv.CreateMat(32, 32, cv.CV_32F) cv.Zero(mat) cv.Convert(cv.GetMat(img), mat) cv.Add(mat, sum, sum) k += 1 avg = cv.CreateMat(32, 32, cv.CV_32F) cv.Zero(avg) count = cv.CreateMat(32, 32, cv.CV_32F) cv.Zero(count) cv.Set(count, k) cv.Div(sum, count, avg) new_img = cv.CreateImage((32, 32), 8, 0) cv.Zero(new_img) cv.Convert(avg, new_img) cv.SaveImage(p.join(root, "%s-avg.png" % folder), new_img)
def main(): if len(sys.argv) < 1: print "Come on, give me some files to play with" return print "Reading image " + sys.argv[1] incoming = cv.LoadImageM(sys.argv[1]) w, h = (incoming.cols, incoming.rows) nw, nh = (int(w * 1.5 + 0.5), int(h * 1.5 + 0.5)) img = cv.CreateImage(cv.GetSize(incoming), cv.IPL_DEPTH_32F, 3) cv.Convert(incoming, img) n = 0 for f in sys.argv[1:]: incoming = cv.LoadImageM(f) w, h = (incoming.cols, incoming.rows) nw, nh = (int(w * 1.5 + 0.5), int(h * 1.5 + 0.5)) new = cv.CreateImage(cv.GetSize(incoming), cv.IPL_DEPTH_32F, 3) cv.Convert(incoming, new) n += 1 print "Read in image [%04d] [%s]" % (n, f) img = imageBlend(img, new, 1.0 / n) del (new) out = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_16U, 3) cv.ConvertScale(img, out, 256.) cv.SaveImage("out-16-up.png", out) print "Written out-16-up.png"
def get_normalized_rgb_planes(r, g, b): size = cv.GetSize(r) # r,g,b = get_three_planes(img) nr_plane = cv.CreateImage(size, 8, 1) ng_plane = cv.CreateImage(size, 8, 1) nb_plane = cv.CreateImage(size, 8, 1) r32 = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) g32 = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) b32 = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) sum = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) cv.Zero(sum) cv.Convert(r, r32) cv.Convert(g, g32) cv.Convert(b, b32) cv.Add(r32, g32, sum) cv.Add(b32, sum, sum) tmp = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) cv.Div(r32, sum, tmp) cv.ConvertScale(tmp, nr_plane, scale=255) cv.Div(g32, sum, tmp) cv.ConvertScale(tmp, ng_plane, scale=255) cv.Div(b32, sum, tmp) cv.ConvertScale(tmp, nb_plane, scale=255) # res = image_empty_clone(img) # cv.Merge(nr_plane,ng_plane,nb_plane,None,res) return nr_plane, ng_plane, nb_plane
def EarthMovers_dist(s1, s2): x = np.array(s1) y = np.array(s2) #print("x = ", x ," y = " , y) a = np.zeros((len(x), 2)) b = np.zeros((len(y), 2)) for i in range(0, len(a)): a[i][0] = x[i] a[i][1] = i + 1.0 for i in range(0, len(b)): b[i][0] = y[i] b[i][1] = i + 1.0 #print("a = ", a ," b = " , b) # Convert from numpy array to CV_32FC1 Mat a64 = cv.fromarray(a) a32 = cv.CreateMat(a64.rows, a64.cols, cv.CV_32FC1) cv.Convert(a64, a32) b64 = cv.fromarray(b) b32 = cv.CreateMat(b64.rows, b64.cols, cv.CV_32FC1) cv.Convert(b64, b32) # Calculate Earth Mover's dis = cv.CalcEMD2( a32, b32, cv.CV_DIST_L1 ) #CV_DIST_L2 -- Euclidean Distance, CV_DIST_L1 --- Manhattan Distance return dis
def edge_threshold(image, roi=None, debug=0): thresholded = cv.CloneImage(image) horizontal = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_16S, 1) magnitude32f = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_32F, 1) vertical = cv.CloneImage(horizontal) v_edge = cv.CloneImage(image) magnitude = cv.CloneImage(horizontal) storage = cv.CreateMemStorage(0) mag = cv.CloneImage(image) cv.Sobel(image, horizontal, 0, 1, 1) cv.Sobel(image, vertical, 1, 0, 1) cv.Pow(horizontal, horizontal, 2) cv.Pow(vertical, vertical, 2) cv.Add(vertical, horizontal, magnitude) cv.Convert(magnitude, magnitude32f) cv.Pow(magnitude32f, magnitude32f, 0.5) cv.Convert(magnitude32f, mag) if roi: cv.And(mag, roi, mag) cv.Normalize(mag, mag, 0, 255, cv.CV_MINMAX, None) cv.Threshold(mag, mag, 122, 255, cv.CV_THRESH_BINARY) draw_image = cv.CloneImage(image) and_image = cv.CloneImage(image) results = [] threshold_start = 17 for window_size in range(threshold_start, threshold_start + 1, 1): r = 20 for threshold in range(0, r): cv.AdaptiveThreshold(image, thresholded, 255, \ cv.CV_ADAPTIVE_THRESH_MEAN_C, cv.CV_THRESH_BINARY_INV, window_size, threshold) contour_image = cv.CloneImage(thresholded) contours = cv.FindContours(contour_image, storage, cv.CV_RETR_LIST) cv.Zero(draw_image) cv.DrawContours(draw_image, contours, (255, 255, 255), (255, 255, 255), 1, 1) if roi: cv.And(draw_image, roi, draw_image) cv.And(draw_image, mag, and_image) m1 = np.asarray(cv.GetMat(draw_image)) m2 = np.asarray(cv.GetMat(mag)) total = mag.width * mag.height #cv.Sum(draw_image)[0] coverage = cv.Sum(and_image)[0] / (mag.width * mag.height) if debug: print threshold, coverage cv.ShowImage("main", draw_image) cv.ShowImage("main2", thresholded) cv.WaitKey(0) results.append((coverage, threshold, window_size)) results.sort(lambda x, y: cmp(y, x)) _, threshold, window_size = results[0] cv.AdaptiveThreshold(image, thresholded, 255, cv.CV_ADAPTIVE_THRESH_MEAN_C, \ cv.CV_THRESH_BINARY, window_size, threshold) return thresholded
def histEMD(hist1, hist2, hist1weights, hist2weights): a64 = cv.fromarray(np.hstack((hist1weights, hist1)).copy()) a32 = cv.CreateMat(a64.rows, a64.cols, cv.CV_32FC1) cv.Convert(a64, a32) b64 = cv.fromarray(np.hstack((hist2weights, hist2)).copy()) b32 = cv.CreateMat(b64.rows, b64.cols, cv.CV_32FC1) cv.Convert(b64, b32) return cv.CalcEMD2(a32, b32, cv.CV_DIST_L2)
def edgedetect(I_np, LOW_T=75, RATIO=3): I_cv = cv.fromarray(I_np) I_cv8U = cv.CreateMat(I_cv.rows, I_cv.cols, cv.CV_8U) cv.Convert(I_cv, I_cv8U) edges = cv.CreateMat(I_cv8U.rows, I_cv8U.cols, cv.CV_8U) cv.Canny(I_cv8U, edges, LOW_T, LOW_T * RATIO) edges_32f = cv.CreateMat(edges.rows, edges.cols, cv.CV_32F) cv.Convert(edges, edges_32f) edges_np = np.array(edges_32f) return edges_np
def sobel(im, xorder=1, yorder=0, aperture_size=3, sigma=None): ''' void cv.Sobel(src, dst, xorder, yorder, apertureSize = 3) @param im: Input image @param xorder: The order of the x derivative (see cv.Sobel openCV docs) @param yorder: The order of the y derivative (see cv.Sobel openCV docs) @param aperture_size: How large a convolution window to use @param sigma: Optional smoothing parameter to be applied prior to detecting edges ''' gray = im.asOpenCVBW() edges = cv.CreateImage(cv.GetSize(gray), 8, 1) if sigma != None: cv.Smooth(gray, gray, cv.CV_GAUSSIAN, int(sigma) * 4 + 1, int(sigma) * 4 + 1, sigma, sigma) #sobel requires a destination image with larger bit depth... #...so we have to convert it back to 8 bit for the pv Image... dst32f = cv.CreateImage(cv.GetSize(gray), cv.IPL_DEPTH_32F, 1) cv.Sobel(gray, dst32f, xorder, yorder, aperture_size) cv.Convert(dst32f, edges) edges = pv.Image(edges) return edges
def loadVectTransFromFile(self,filename): #print mnemosyne_dir+filename self.VectTrans = cv.Load(mnemosyne_dir+filename, cv.CreateMemStorage(), name="Translation") if self.VectTrans.type==5: #Everything should be in CV_64FC1 tmpVectTrans = self.VectTrans self.VectTrans = cv.CreateMat(3,1,cv.CV_64FC1) cv.Convert(tmpVectTrans, self.VectTrans)
def ConvertForEmd(histogram): array = [(histogram[i][0], i) for i in xrange(HISTOGRAM_BIN_N) if histogram[i] > 0] f64 = cv.fromarray(numpy.array(array)) f32 = cv.CreateMat(f64.rows, f64.cols, cv.CV_32FC1) cv.Convert(f64, f32) return f32
def extractContour(segmented_image, orig_img): contour_img = [] contour_img = zeros( (segmented_image.shape[0], segmented_image.shape[1], 1), uint8) # Create a new image container for contour image image_with_border = [] image_with_border = cv.CreateMat( orig_img.height, orig_img.width, cv.CV_8UC3) # Create a new image container for final image cv.Convert(orig_img, image_with_border) # Copy original image to this container for loopVar1 in range(0, segmented_image.shape[0]): # Loop for all pixels for loopVar2 in range(0, segmented_image.shape[1]): if any(segmented_image[loopVar1] [loopVar2]) == True: # For each non-zero pixel value try: # Check if any 4-connected pixel is zero, if yes, then make it 255 (border pixel) if (any(segmented_image[loopVar1 - 1][loopVar2]) == False or any(segmented_image[loopVar1 + 1][loopVar2]) == False or any(segmented_image[loopVar1][loopVar2 - 1]) == False or any(segmented_image[loopVar1][loopVar2 + 1]) == False): contour_img[loopVar1][loopVar2] = 255 else: # If its not a border pixel, make it zero. contour_img[loopVar1][loopVar2] = 0 except IndexError: # If its a border pixel, then all 4 neighbors won't exist, then make it zero contour_img[loopVar1][loopVar2] = 0 image_with_border[loopVar1, loopVar2] = [255, 255, 255] else: # If its not a border pixel, make it zero in both contour and final image contour_img[loopVar1][loopVar2] = 0 image_with_border[loopVar1, loopVar2] = [0, 0, 0] print loopVar1 return contour_img, image_with_border # Return contour and final images
def edge_magnitude(image): magnitude32f = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_32F, 1) horizontal = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_16S, 1) vertical = cv.CloneImage(horizontal) magnitude = cv.CloneImage(horizontal) mag = cv.CloneImage(image) cv.Sobel(image, horizontal, 0, 1, 1) cv.Sobel(image, vertical, 1, 0, 1) cv.Pow(horizontal, horizontal, 2) cv.Pow(vertical, vertical, 2) cv.Add(vertical, horizontal, magnitude) cv.Convert(magnitude, magnitude32f) cv.Pow(magnitude32f, magnitude32f, 0.5) cv.Convert(magnitude32f, mag) return mag
def loadVectRotFromFile(self,filename): #print mnemosyne_dir+filename print (mnemosyne_dir+filename) self.VectRot = cv.Load(mnemosyne_dir+filename, cv.CreateMemStorage(), name="Rotation") if self.VectRot.type==5: #Everything should be in CV_64FC1 tmpVectRot = self.VectRot self.VectRot = cv.CreateMat(3,1,cv.CV_64FC1) cv.Convert(tmpVectRot, self.VectRot)
def get_mask(self): width = self.reference.width height = self.reference.height mask = zeros([height, width], dtype=int32) cvmask = cv.CreateMat(height, width, cv.CV_8UC1) mask[self.ypos:self.ypos + self.size, self.xpos:self.xpos + self.size] = 255 cv.Convert(mask, cvmask) return cvmask
def vers_iplimage(self, profondeur=cv.IPL_DEPTH_8U): "Renvoie l'iplimage équivalente (format OpenCV)" temp = cv.CreateImage((self.largeur, self.hauteur), cv.IPL_DEPTH_64F, 1) for (i, ligne) in enumerate(self.tab): for (j, valeur) in enumerate(ligne): cv.Set2D(temp, i, j, valeur) img = cv.CreateImage((self.largeur, self.hauteur), profondeur, 1) cv.Convert(temp, img) return img
def main(): '''Testing Main method''' import sys, cv if len(sys.argv) == 1: print 'No image.' sys.exit(1) im_file = sys.argv[1] image = cv.LoadImageM(im_file, cv.CV_LOAD_IMAGE_GRAYSCALE) size = 3 ori = (pi * 1) / 4 ste = 0.75 kern = cv.fromarray(SteerableFilter.get_filter(ori, size, False, ste)) kern_t = cv.fromarray(SteerableFilter.get_filter(ori, size, True, ste)) kernel = cv.CreateMat(size, size, cv.CV_32F) kernel_t = cv.CreateMat(size, size, cv.CV_32F) cv.Convert(kern, kernel) cv.Convert(kern_t, kernel_t) dst = cv.CreateMat(image.rows, image.cols, image.type) dst_t = cv.CreateMat(image.rows, image.cols, image.type) cv.Filter2D(image, dst, kernel) cv.Filter2D(image, dst_t, kernel_t) cv.ShowImage('Source', image) cv.ShowImage('Result', dst) cv.ShowImage('Result (Transpose)', dst_t) cv.WaitKey(0) cv.WaitKey(0) cv.WaitKey(0)
def FFT(image, flag=0): w = image.width h = image.height iTmp = cv.CreateImage((w, h), cv.IPL_DEPTH_32F, 1) cv.Convert(image, iTmp) iMat = cv.CreateMat(h, w, cv.CV_32FC2) mFFT = cv.CreateMat(h, w, cv.CV_32FC2) for i in range(h): for j in range(w): if flag == 0: num = -1 if (i + j) % 2 == 1 else 1 else: num = 1 iMat[i, j] = (iTmp[i, j] * num, 0) cv.DFT(iMat, mFFT, cv.CV_DXT_FORWARD) return mFFT
def test_ConvertIPLImage32FToPvImage(self): im = pv.Image(pv.LENA) im = im.resize((512, 400)) cv_im = im.asOpenCV() mat = im.asMatrix3D() cv_32 = cv.CreateImage(cv.GetSize(cv_im), cv.IPL_DEPTH_32F, 3) cv.Convert(cv_im, cv_32) for x in range(50): for y in range(50): for c in range(3): self.assertAlmostEqual(cv_im[y, x][2 - c], mat[c, x, y]) self.assertAlmostEqual(cv_im[y, x][2 - c], cv_32[y, x][2 - c]) _ = pv.Image(cv_32)
def __produce_gradient_image(self, i, scale): size = cv.GetSize(i) grey_image = cv.CreateImage(size, 8, 1) size = [s / scale for s in size] grey_image_small = cv.CreateImage(size, 8, 1) cv.CvtColor(i, grey_image, cv.CV_RGB2GRAY) df_dx = cv.CreateImage(cv.GetSize(i), cv.IPL_DEPTH_16S, 1) cv.Sobel(grey_image, df_dx, 1, 1) cv.Convert(df_dx, grey_image) cv.Resize(grey_image, grey_image_small) #, interpolation=cv.CV_INTER_NN) cv.Resize(grey_image_small, grey_image) #, interpolation=cv.CV_INTER_NN) return grey_image
def get_average(self, imagesArray): bitDepth = imagesArray[0].depth if bitDepth > 8: print 'ERROR: Image bit depth too large. Adjust get_average method parameters.' sys.exit() imageSize = cv.GetSize(imagesArray[0]) averageImage = cv.CreateImage(imageSize, cv.IPL_DEPTH_16U, 3) cv.Set(averageImage,0) for image in imagesArray: imageExpansion = cv.CreateImage(imageSize, cv.IPL_DEPTH_16U, 3) cv.Convert(image, imageExpansion) cv.Add(averageImage, imageExpansion, averageImage) nImages = 1/float(len(imagesArray)) imageReduction = cv.CreateImage(imageSize, cv.IPL_DEPTH_8U, 3) cv.CvtScale(averageImage,imageReduction,nImages) return imageReduction
def analyse(self, painting): data = super(SimpleRHOG, self).analyse(painting) segmented = numpy.ones((10, 10), numpy.float32) for i in range(1, 10): for j in range(1, 10): avg = 0 for x in range(1, int(data.rows / 10)): for y in range(1, int(data.cols / 10)): (val, _, _, _) = cv.Get2D(data, x * i, y * j) avg += val avg /= int(data.rows / 10) * int(data.cols / 10) segmented[i - 1][j - 1] = avg segs = cv.fromarray(segmented) grad_img = cv.CreateImage((segs.rows, segs.cols), cv.IPL_DEPTH_32F, segs.channels) cv.Convert(segs, grad_img) hist = cv.CreateHist([15], cv.CV_HIST_ARRAY, [[0, 2 * math.pi]]) cv.CalcHist([grad_img], hist) return hist
def drawDepthImage(self): """ Draw the caputered image to the screen. This is very slooow, so ommit this function in competition """ image = self.depthImage if image != 0: # make sure 8 bit image is displayed if image.depth == 16: newImage = cv.CreateImage((640, 480), cv.IPL_DEPTH_8U, 1) cv.Convert(image, newImage) image = newImage # generate pygame image image_rgb = cv.CreateMat(image.height, image.width, cv.CV_8UC3) cv.CvtColor(image, image_rgb, cv.CV_GRAY2RGB) pygameImage = pygame.image.frombuffer(image_rgb.tostring(), cv.GetSize(image_rgb), "RGB") # draw the image self.screen.blit(pygameImage, (0, 0))
def avgnimages(il,n,ngood=2): global maxlen global off global scale global correction if(n>maxlen): n = maxlen print "Error: avgnimages: n>maxlen" for i in range(n-ngood): #capture n more images il.appendleft(cv.CreateImage((list(il)[0].width,list(il)[0].height),list(il)[0].depth,list(il)[0].nChannels)) FormatImage(cv.QueryFrame(capture),list(il)[0],off,scale,correction) ideep = cv.CreateImage((list(il)[0].width,list(il)[0].height),cv.IPL_DEPTH_16U,list(il)[0].nChannels) cv.SetZero(ideep) itmp = cv.CreateImage((list(il)[0].width,list(il)[0].height),cv.IPL_DEPTH_16U,list(il)[0].nChannels) for i in range(n): cv.Convert(list(il)[i],itmp) cv.Add(itmp,ideep,ideep) cv.ConvertScale(ideep,list(il)[0],1/float(n))
def getAverageValues(self, images): """ get the average values over all the images adds them all together and then divides them with the numb. images """ if len(images) == 0: return None if len(images) == 1: return images[0] imageSize = (images[0].width, images[0].height) sumImage = cv.CreateImage(imageSize, cv.IPL_DEPTH_32S, 1) cv.Set(sumImage, 0) for image in images: tempImage = cv.CreateImage(imageSize, cv.IPL_DEPTH_32S, 1) cv.Convert(image, tempImage) cv.Add(sumImage, tempImage, sumImage) nImages = 1 / float(len(images)) meanImage = cv.CreateImage(imageSize, cv.IPL_DEPTH_8U, 1) cv.CvtScale(sumImage, meanImage, nImages) return meanImage
def detect(image, debug=False, display=None): work_image = cv.CreateImage((image.width, image.height), 8, 1) cv.CvtColor(image, work_image, cv.CV_BGR2GRAY) image = work_image edge = cv.CloneImage(image) thresholded = cv.CloneImage(image) v_edges = cv.CloneImage(image) h_edges = cv.CloneImage(image) vertical = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_16S, 1) cv.Sobel(image, vertical, 1, 0, 1) cv.Abs(vertical, vertical) cv.Convert(vertical, v_edges) storage = cv.CreateMemStorage(0) result = np.asarray(cv.GetMat(v_edges), dtype=np.float) threshold = 6 rects = [] while len(rects) < 1 and threshold > 0: rects = [] cv.Convert(vertical, v_edges) cv.AdaptiveThreshold(v_edges, v_edges, 255, cv.CV_ADAPTIVE_THRESH_MEAN_C, cv.CV_THRESH_BINARY_INV, 17, threshold) threshold -= 1 storage = cv.CreateMemStorage(0) contour_image = cv.CloneImage(v_edges) contours = cv.FindContours(contour_image, storage, cv.CV_RETR_LIST, cv.CV_CHAIN_APPROX_NONE, (0, 0)) ext.filter_contours(contours, 30, ext.LESSTHAN) max_size = int(image.width * image.height * 0.1) # ext.filter_contours(contours, 200**2, ext.GREATERTHAN) ext.filter_contours(contours, max_size, ext.GREATERTHAN) if display: cv.Merge(v_edges, v_edges, v_edges, None, display) seeds = [] if contours: seq = contours rects = [] while seq: c = ext.as_contour(ext.wrapped(seq)) r = (c.rect.x, c.rect.y, c.rect.width, c.rect.height) rects.append(r) if display: cv.Rectangle( display, (c.rect.x, c.rect.y), (c.rect.x + c.rect.width, c.rect.y + c.rect.height), (0, 0, 255), 1) seq = seq.h_next() rects.sort(lambda x, y: cmp(x[0] + x[2] / 2, y[0] + y[2] / 2)) seeds = rects[:] seeds.sort(lambda x, y: cmp(y[2] * y[3], x[2] * x[3])) groups = [] skip = False for seed in seeds: if seed not in rects: break found = False for group in groups: if seed in group: found = True if found: continue r = seed start = seed start_index = rects.index(seed) groups.append([seed]) i = start_index - 1 # delta = max(150, seed[2]/2) delta = seed[2] * 0.66 if debug: print "left", seed, delta col = (randint(0, 255), randint(0, 255), randint(0, 255)) cv.Rectangle(display, (r[0], r[1]), (r[0] + r[2], r[1] + r[3]), (255, 255, 255), 3) cv.Rectangle(display, (r[0], r[1]), (r[0] + r[2], r[1] + r[3]), col, -1) cv.ShowImage("main", display) if not skip: c = cv.WaitKey(0) if c == ord("a"): skip = True # scan left while 1: if i < 0: break rect = rects[i] if rect[0] + rect[2] < seed[0] - delta: if debug: print "esc1", rect break if in_vertical(seed, start, rect): seed = rect groups[-1].append(rect) r = rect if debug: print rect cv.Rectangle(display, (r[0], r[1]), (r[0] + r[2], r[1] + r[3]), col, -1) cv.ShowImage("main", display) if not skip: c = cv.WaitKey(0) if c == ord("a"): skip = True else: if debug: print "rej1", rect i -= 1 # scan right seed = start start_index = rects.index(seed) i = start_index + 1 if debug: print print "right", seed while 1: if i >= len(rects): break rect = rects[i] if rect[0] > seed[0] + seed[2] + delta: if debug: print "esc2", rect, rect[0] + rect[2] / 2, seed[ 0] + seed[2] / 2 + delta break if in_vertical(seed, start, rect): seed = rect groups[-1].append(rect) r = rect if debug: print rect cv.Rectangle(display, (r[0], r[1]), (r[0] + r[2], r[1] + r[3]), col, -1) cv.ShowImage("main", display) if not skip: c = cv.WaitKey(0) if c == ord("a"): skip = True else: if debug: print "rej2", rect i += 1 if debug: print # find min and max extent of group group_rects = [] for group in groups: min_x, min_y = 1E6, 1E6 max_x, max_y = -1, -1 dev = [] col = (randint(0, 255), randint(0, 255), randint(0, 255)) for rect in group: r = rect if display: if r == group[0]: cv.Rectangle(display, (r[0], r[1]), (r[0] + r[2], r[1] + r[3]), (255, 255, 255), 3) cv.Rectangle(display, (r[0], r[1]), (r[0] + r[2], r[1] + r[3]), col, -1) min_x = min(min_x, r[0]) min_y = min(min_y, r[1]) max_x = max(max_x, r[0] + r[2]) max_y = max(max_y, r[1] + r[3]) if display: cv.Rectangle(display, (min_x, min_y), (max_x, max_y), (0, 255, 0), 1) width = max_x - min_x height = max_y - min_y rect = (min_x, min_y, width, height) group_rects.append(rect) return group_rects
def segment_rect(image, rect, debug=False, display=None, target_size=None, group_range=(3, 25)): global next skip = False best_chars = [] best_threshold = None thresholded = cv.CloneImage(image) contour_image = cv.CloneImage(image) edges = cv.CloneImage(image) min_x, min_y, width, height = rect # cv.SetImageROI(thresholded, rect) cv.SetImageROI(contour_image, rect) cv.SetImageROI(image, rect) cv.SetImageROI(edges, rect) horizontal = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_16S, 1) magnitude32f = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_32F, 1) vertical = cv.CloneImage(horizontal) magnitude = cv.CloneImage(horizontal) cv.Sobel(image, horizontal, 0, 1, 3) cv.Sobel(image, vertical, 1, 0, 3) cv.Pow(horizontal, horizontal, 2) cv.Pow(vertical, vertical, 2) cv.Add(vertical, horizontal, magnitude) cv.Convert(magnitude, magnitude32f) cv.Pow(magnitude32f, magnitude32f, 0.5) cv.Convert(magnitude32f, edges) original_rect = rect if display: cv.SetImageROI(display, rect) for threshold in range(1, 20, 1): cv.SetImageROI(thresholded, original_rect) #for i in range(30, 60, 1): if display: cv.Merge(image, image, image, None, display) cv.Copy(image, thresholded) #cv.Threshold(thresholded, thresholded, i, 255, cv.CV_THRESH_BINARY_INV) cv.AdaptiveThreshold(thresholded, thresholded, 255, cv.CV_ADAPTIVE_THRESH_MEAN_C, cv.CV_THRESH_BINARY_INV, 17, threshold) #cv.AdaptiveThreshold(thresholded, thresholded, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY_INV, 5, i) # skip rects greater than 50% thresholded summed = cv.Norm(thresholded, None, cv.CV_L1, None) / 255 / thresholded.width / thresholded.height if summed > 0.5: continue if debug: cv.ShowImage("edge", thresholded) storage = cv.CreateMemStorage(0) cv.Copy(thresholded, contour_image) contours = cv.FindContours(contour_image, storage, cv.CV_RETR_LIST, cv.CV_CHAIN_APPROX_SIMPLE, (0, 0)) ext.filter_contours(contours, 20, ext.LESSTHAN) groups = [] rects = [] edge_counts = [] overlappings = {} if contours: seq = contours while seq: c = ext.as_contour(ext.wrapped(seq)) r = (c.rect.x, c.rect.y, c.rect.width, c.rect.height) rects.append(r) seq = seq.h_next() similarity = 0.45 #0.3 rects.sort(lambda x, y: cmp(y[2] * y[3], x[2] * x[3])) for rect in rects: if debug: print print "R", rect, len(groups) cv.SetImageROI(edges, (original_rect[0] + rect[0], original_rect[1] + rect[1], rect[2], rect[3])) edge_count = cv.Sum(edges)[0] / 255 / (rect[2] * rect[3]) edge_counts.append(edge_count) # cv.ShowImage("edges", edges) # cv.WaitKey(0) if debug and target_size: print "X", target_size, rect print(target_size[0] - rect[2]) / target_size[0] print(target_size[1] - rect[3]) / target_size[1] if rect[2] > rect[3] or float(rect[3])/rect[2] < 3./3 or edge_count < 0.1\ or (rect[2] == image.width and rect[3] == image.height) \ or (target_size and not 0 < (target_size[0] - rect[2]) / target_size[0] < 0.3 \ and not 0 < (target_size[1] - rect[3]) / target_size[1] < 0.05): if debug: print "rej", rect[2], ">", rect[3], "edge=", edge_count cv.Rectangle(display, (rect[0], rect[1]), (rect[0] + rect[2], rect[1] + rect[3]), (0, 0, 255), 1) cv.ShowImage("main", display) if not skip and not next: c = cv.WaitKey(0) if c == ord("a"): skip = True if c == ord("z"): next = True continue added = False for group_id, group in enumerate(groups): avg_width, avg_height, avg_y = 0, 0, 0 overlap = None c = 0 for r in group: avg_y += r[1] + r[3] / 2.0 avg_width += r[2] avg_height += r[3] irect = intersect(r, rect) if irect[2] * irect[3] > 0.2 * r[2] * r[3]: overlappings.setdefault(group_id, []).append([r, rect]) avg_y /= float(len(group)) avg_width /= float(len(group)) avg_height /= float(len(group)) if debug: print group if (abs(avg_width - rect[2]) / avg_width < similarity or \ (rect[2] < avg_width)) and \ abs(avg_height - rect[3])/ avg_height < similarity and \ abs(avg_y - (rect[1] + rect[3]/2.0)) / avg_y < similarity: group.append(rect) added = True else: pass if not added: # first char in group groups.append([rect]) if debug: print "now:" for g in groups: print g cv.Rectangle(display, (rect[0], rect[1]), (rect[0] + rect[2], rect[1] + rect[3]), (255, 0, 0), 1) cv.ShowImage("main", display) if not skip and not next: c = cv.WaitKey(0) if c == ord("a"): skip = True if c == ord("z"): next = True if groups: #handle overlapping regions, default to average width match for group_id, over in overlappings.items(): group = groups[group_id] avg_width = 0 avg_height = 0 for r in group: avg_width += r[2] avg_height += r[3] avg_width /= float(len(group)) avg_height /= float(len(group)) for r1, r2 in over: if r2 not in group or r1 not in group: continue if debug: print "over", r1, r2, r1[2] * r1[3], r2[2] * r2[ 3], avg_width d1 = abs(r1[2] - avg_width) + abs(r1[3] - avg_height) d2 = abs(r2[2] - avg_width) + abs(r2[3] - avg_height) if d1 < d2: group.remove(r2) else: group.remove(r1) #group = max(groups, key=len) # from longest groups, find largest area groups.sort(key=len) groups.reverse() max_area = 0 mad_index = -1 for i, g in enumerate(groups[:5]): area = 0 for r in g: area += r[2] * r[3] if area > max_area: max_area = area max_index = i group = groups[max_index] # vertical splitting avg_width, avg_height, avg_y = 0, 0, 0 if debug: print "G", group for r in group: avg_y += r[1] + r[3] / 2.0 avg_width += r[2] avg_height += r[3] avg_y /= float(len(group)) avg_width /= float(len(group)) avg_height /= float(len(group)) band_rects = [] bound = bounding_rect(group) for i, rect in enumerate(rects): if edge_counts[i] < 0.1: continue if (abs(avg_width - rect[2]) / avg_width < similarity or \ (rect[2] < avg_width)) and \ (abs(avg_height - rect[3]) / avg_height < similarity or \ (rect[3] < avg_height)) and \ abs(avg_y - (rect[1] + rect[3]/2.0)) < avg_height/2: band_rects.append(rect) band_rects.sort(lambda x, y: cmp(y[2] * y[3], x[2] * x[3])) for i, rect_a in enumerate(band_rects[:-1]): if rect_a[2] * rect_a[3] < 0.2 * avg_width * avg_height: continue merge_rects = [] for rect_b in band_rects[i + 1:]: w = avg_width m1 = rect_a[0] + rect_a[2] / 2 m2 = rect_b[0] + rect_b[2] / 2 if abs(m1 - m2) < w: merge_rects.append(rect_b) if debug: print "M", merge_rects if merge_rects: merge_rects.append(rect_a) rect = bounding_rect(merge_rects) area = 0 for r in merge_rects: area += r[2] * r[3] if (abs(avg_width - rect[2]) / avg_width < similarity or \ (rect[2] < avg_width)) and \ abs(avg_height - rect[3])/ avg_height < similarity and \ area > 0.5*(avg_width*avg_height) and \ abs(avg_y - (rect[1] + rect[3]/2.0)) / avg_y < similarity: for r in merge_rects: if r in group: group.remove(r) # merge into group new_group = [] merged = False for gr in group: area2 = max(gr[2] * gr[3], rect[2] * rect[3]) isect = intersect(gr, rect) if isect[2] * isect[3] > 0.4 * area2: x = min(gr[0], rect[0]) y = min(gr[1], rect[1]) x2 = max(gr[0] + gr[2], rect[0] + rect[2]) y2 = max(gr[1] + gr[3], rect[1] + rect[3]) new_rect = (x, y, x2 - x, y2 - y) new_group.append(new_rect) merged = True else: new_group.append(gr) if not merged: new_group.append(rect) group = new_group cv.Rectangle(display, (rect[0], rect[1]), (rect[0] + rect[2], rect[1] + rect[3]), (255, 0, 255), 2) # avoid splitting split = False # select higher threshold if innovates significantly best_width = 0.0 if best_chars: best_area = 0.0 for rect in best_chars: best_area += rect[2] * rect[3] best_width += rect[2] best_width /= len(best_chars) area = 0.0 overlapped = 0.0 avg_width = 0.0 avg_height = 0.0 for rect in group: area += rect[2] * rect[3] avg_width += rect[2] avg_height += rect[3] for char in best_chars: section = intersect(rect, char) if section[2] * section[3] > 0: overlapped += section[2] * section[3] avg_width /= len(group) avg_height /= len(group) quotient = overlapped / area quotient2 = (area - overlapped) / best_area if debug: print area, overlapped, best_area print group print "QUO", quotient print "QUO2", quotient2 else: quotient = 0 quotient2 = 1 best_area = 0 group.sort(lambda x, y: cmp(x[0] + x[2] / 2, y[0] + y[2] / 2)) best_chars.sort(lambda x, y: cmp(x[0] + x[2] / 2, y[0] + y[2] / 2)) if group_range[0] <= len(group) <= group_range[1] and avg_width > 5 and avg_height > 10 and \ ((quotient2 > 0.05 and (best_area == 0 or abs(area - best_area)/best_area < 0.4)) or (quotient2 > 0.3 and area > best_area)): if debug: print "ASSIGNED", group best_chars = group best_threshold = threshold #get_patch(thresholded, original_rect) else: if debug: print "not", quotient2, len( group), avg_width, avg_height, area, best_area # best_chars = groups if debug: for rect in best_chars: cv.Rectangle(display, (rect[0], rect[1]), (rect[0] + rect[2], rect[1] + rect[3]), (0, 255, 0), 1) cv.ShowImage("main", display) if not skip and not next: c = cv.WaitKey(0) if c == ord("a"): skip = True if c == ord("z"): next = True best_chars.sort(lambda x, y: cmp(x[0], y[0])) cv.ResetImageROI(thresholded) cv.ResetImageROI(contour_image) cv.ResetImageROI(image) cv.ResetImageROI(edges) if display: cv.ResetImageROI(display) return best_chars, best_threshold
# -*- coding: utf-8 -*- """ Created on Tue May 22 16:41:21 2012 @author: IntelligentSystems """ import cv import os import glob count = 0 average = None path = 'Clips/' for infile in glob.glob(os.path.join(path, '*.bmp')): image = cv.LoadImage(infile, False) if average is None: average = cv.CreateImage(cv.GetSize(image), 32, 1) image_aux = cv.CloneImage(average) cv.Convert(image, average) else: count = count + 1 scale = 1 / count cv.Convert(image, image_aux) cv.Sub(image_aux, average, image_aux) cv.Scale(image_aux, image_aux, scale) cv.Add(average, image_aux, average) cv.Convert(average, image) cv.SaveImage('background.bmp', image)
def old_GeneratePerceptualHash(path): # I think what I should be doing here is going cv2.imread( path, flags = cv2.CV_LOAD_IMAGE_GRAYSCALE ) # then efficiently resize thumbnail = GeneratePILImage(path) # convert to 32 x 32 greyscale if thumbnail.mode == 'P': thumbnail = thumbnail.convert( 'RGBA' ) # problem with some P images converting to L without RGBA step in between if thumbnail.mode == 'RGBA': # this is some code i picked up somewhere # another great example of PIL failing; it turns all alpha to pure black on a RGBA->RGB thumbnail.load() canvas = PILImage.new('RGB', thumbnail.size, (255, 255, 255)) canvas.paste(thumbnail, mask=thumbnail.split()[3]) thumbnail = canvas thumbnail = thumbnail.convert('L') thumbnail = thumbnail.resize((32, 32), PILImage.ANTIALIAS) # convert to mat numpy_thumbnail_8 = cv.CreateMatHeader(32, 32, cv.CV_8UC1) cv.SetData(numpy_thumbnail_8, thumbnail.tostring()) numpy_thumbnail_32 = cv.CreateMat(32, 32, cv.CV_32FC1) cv.Convert(numpy_thumbnail_8, numpy_thumbnail_32) # compute dct dct = cv.CreateMat(32, 32, cv.CV_32FC1) cv.DCT(numpy_thumbnail_32, dct, cv.CV_DXT_FORWARD) # take top left 8x8 of dct dct = cv.GetSubRect(dct, (0, 0, 8, 8)) # get mean of dct, excluding [0,0] mask = cv.CreateMat(8, 8, cv.CV_8U) cv.Set(mask, 1) mask[0, 0] = 0 channel_averages = cv.Avg(dct, mask) average = channel_averages[0] # make a monochromatic, 64-bit hash of whether the entry is above or below the mean bytes = [] for i in range(8): byte = 0 for j in range(8): byte <<= 1 # shift byte one left value = dct[i, j] if value > average: byte |= 1 bytes.append(byte) answer = str(bytearray(bytes)) # we good return answer
def find_loop(input_data, IterationClosing=6): """ This function detect support (or loop) and return the coordinates if there is a detection, and -1 if not. in : filename : string image Filename / Format accepted : in : IterationClosing : int : Number of iteration for closing contour procedure Out : tupple of coordiante : (string, coordinate X, coordinate Y) where string take value 'Coord' or 'No loop detected depending if loop was detected or not. If no loop was detected coordinate X and coordinate y take the value -1. """ #Definition variable Global global AIRE_MIN_REL global AIRE_MIN global NORM_IMG global NiteClosing global pointRef #Chargement image try: if type(input_data) == str: #Image filename is passed img_ipl = cv.LoadImageM(input_data) elif type(input_data) == np.ndarray: img_ipl = cv.fromarray(input_data) else: print "ERROR : Input image could not be opened, check format or path" return ( "ERROR : Input image could not be opened, check format or path", -10, -10) except: print "ERROR : Input image could not be opened, check format or path" return ( "ERROR : Input image could not be opened, check format or path", -10, -10) img_cont = img_ipl # img used for NORM_IMG = img_ipl.width * img_ipl.height AIRE_MIN = NORM_IMG * AIRE_MIN_REL #traitement #Converting input image in Grey scale image img_gray_ini = cv.CreateImage((img_ipl.width, img_ipl.height), 8, 1) cv.CvtColor(img_ipl, img_gray_ini, cv.CV_BGR2GRAY) #Removing Offset from image img_gray_resize = cv.CreateImage( (img_ipl.width - 2 * Offset[0], img_ipl.height - 2 * Offset[1]), 8, 1) cv.SetImageROI(img_gray_ini, (Offset[0], Offset[1], img_ipl.width - 2 * Offset[0], img_ipl.height - 2 * Offset[1])) cv.Copy(img_gray_ini, img_gray_resize) # #creat image used for treatment img_gray = cv.CreateImage((img_gray_resize.width, img_gray_resize.height), 8, 1) img_trait = cv.CreateImage((img_gray.width, img_gray.height), 8, 1) # image used for treatment is the same than img_gray_resize cv.Copy(img_gray_resize, img_gray) #Img is smooth with asymetric kernel cv.Smooth(img_gray, img_gray, param1=11, param2=9) cv.Canny(img_gray, img_trait, 40, 60) # Laplacian treatment # Creating buffer image img_lap_ini = cv.CreateImage((img_gray.width, img_gray.height), 32, 1) img_lap = cv.CreateImage((img_lap_ini.width - 2 * Offset[0], img_lap_ini.height - 2 * Offset[1]), 32, 1) # Creating buffer img img_lap_tmp = cv.CreateImage((img_lap.width, img_lap.height), 32, 1) #Computing laplacian cv.Laplace(img_gray, img_lap_ini, 5) #Applying Offset to avoid border effect cv.SetImageROI(img_lap_ini, (Offset[0], Offset[1], img_lap_ini.width - 2 * Offset[0], img_lap_ini.height - 2 * Offset[1])) #Copying laplacian treated image to final laplacian image cv.Copy(img_lap_ini, img_lap) #Apply an asymetrique smoothing cv.Smooth(img_lap, img_lap, param1=21, param2=11) #Define the Kernel for closing algorythme MKernel = cv.CreateStructuringElementEx(7, 3, 3, 1, cv.CV_SHAPE_RECT) # Closing contour procedure cv.MorphologyEx(img_lap, img_lap, img_lap_tmp, MKernel, cv.CV_MOP_CLOSE, NiteClosing) # Conveting img in 8bit image img_lap8_ini = cv.CreateImage((img_lap.width, img_lap.height), 8, 1) cv.Convert(img_lap, img_lap8_ini) # Add white border to image mat_bord = WhiteBorder(np.asarray(img_lap8_ini[:]), XSize, YSize) img_lap8 = cv.CreateImage( (img_lap.width + 2 * XSize, img_lap.height + 2 * YSize), 8, 1) img_lap8 = cv.fromarray(mat_bord) #Compute threshold seuil_tmp = Seuil_var(img_lap8) #If Seuil_tmp is not null if seuil_tmp != 0: seuil = seuil_tmp #Else seuil is fixed to 20, which prevent from wrong positiv detection else: seuil = 20 #Compute thresholded image img_lap_bi = cv.CreateImage((img_lap8.width, img_lap8.height), 8, 1) img_lap_color = cv.CreateImage((img_lap8.width, img_lap8.height), 8, 3) img_trait_lap = cv.CreateImage((img_lap8.width, img_lap8.height), 8, 1) #Compute thresholded image cv.Threshold(img_lap8, img_lap_bi, seuil, 255, cv.CV_THRESH_BINARY) #Gaussian smoothing on laplacian cv.Smooth(img_lap_bi, img_lap_bi, param1=11, param2=11) #Convert grayscale laplacian image to binarie image using "seuil" as threshold value cv.Threshold(img_lap_bi, img_lap_bi, 1, 255, cv.CV_THRESH_BINARY_INV) cv.CvtColor(img_lap_bi, img_lap_color, cv.CV_GRAY2BGR) #Compute edge in laplacian image cv.Canny(img_lap_bi, img_trait_lap, 0, 2) #Find contour seqlapbi = cv.FindContours(img_trait_lap, cv.CreateMemStorage(), cv.CV_RETR_TREE, cv.CV_CHAIN_APPROX_SIMPLE) #contour is filtered try: contour_list = parcourt_contour(seqlapbi, img_lap_color) except: # If error is traped then there is no loop detected return (0, 0, ("No loop detected", -1, -1)) # If there contours's list is not empty NCont = len(contour_list) if (NCont > 0): # The CvSeq is inversed : X(i) became i(X) indice = MapCont(contour_list[0], img_lap_color.width, img_lap_color.height) # The coordinate of target is computed in the traited image point_shift = integreCont(indice, contour_list[0]) # The coordinate in original image are computed taken into account Offset and white bordure point = (point_shift[0], point_shift[1] + 2 * Offset[0] - XSize, point_shift[2] + 2 * Offset[1] - YSize) else: #Else no loop is detected point = ("No loop detected", -1, -1) Aire_Max = 0 return point
# Otsu threshold image = loadGreyscale() cv.Threshold(image, image, threshold, color, cv.CV_THRESH_OTSU) showWindow("Otsu threshold") # Dilation image = loadGreyscale() element_shape = cv.CV_SHAPE_RECT pos = 1 element = cv.CreateStructuringElementEx(pos * 2 + 1, pos * 2 + 1, pos, pos, element_shape) cv.Dilate(image, image, element, 2) showWindow("Dilate") # Erosion image = loadGreyscale() cv.Erode(image, image, element, 2) showWindow("Erode") # Morphology image = loadGreyscale() cv.MorphologyEx(image, image, image, element, cv.CV_MOP_CLOSE, 2) showWindow("Morphology") # Laplace image = loadGreyscale() dst_16s2 = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_16S, 1) cv.Laplace(image, dst_16s2) cv.Convert(dst_16s2, image) showWindow('Laplace')