def Example1(ilog): # This illustrates how images keep weak refs through affine # transformation to avoid an accumulation of errors through multiple # transformations. fname = os.path.join(pv.__path__[0], 'data', 'nonface', 'NONFACE_13.jpg') im = pv.Image(fname) im = pv.Image(im.asPIL().resize((320, 240))) im.annotateLabel(pv.Point(10, 10), "ScaleTest: Original image.") ilog.log(im) w, h = im.size # Create a small version of the image aff_small = pv.AffineScale(0.2, (w / 5, h / 5)) tmp1 = aff_small.transformImage(im) tmp1.annotateLabel(pv.Point(10, 10), "Small") ilog.log(tmp1) # Scale the image back to its original size without using the original aff_big = pv.AffineScale(5.0, (w, h)) tmp2 = aff_big.transformImage(tmp1, use_orig=False) tmp2.annotateLabel(pv.Point(10, 10), "ScaleTest: use_orig=False") tmp2.annotateLabel(pv.Point(20, 20), "This image should be blurry.") ilog.log(tmp2) # Use the affine class to produce a transform that maps the original # directly to the final image and therefore keeps most of the detail. tmp3 = (aff_big * aff_small).transformImage(im) tmp3.annotateLabel(pv.Point(10, 10), "ScaleTest: aff_big*aff_small") tmp3.annotateLabel(pv.Point(20, 20), "This image should be sharp.") ilog.log(tmp3) # Scale the image back to its original size using the original tmp4 = aff_big.transformImage(tmp1, use_orig=True) tmp4.annotateLabel(pv.Point(10, 10), "ScaleTest: use_orig=True") tmp4.annotateLabel(pv.Point(20, 20), "This image should be sharp.") ilog.log(tmp4) # Now remove the reverence to the im instance. The weak references within # tmp1 do not hold onto the original data so now there is no choice but to # use the scaled down image. del im tmp5 = aff_big.transformImage(tmp1, use_orig=True) tmp5.annotateLabel(pv.Point(10, 10), "ScaleTest: use_orig=True") tmp5.annotateLabel(pv.Point(20, 20), "This image should be blurry") tmp5.annotateLabel(pv.Point(20, 30), "because the original has be") tmp5.annotateLabel(pv.Point(20, 40), "removed from memory.") ilog.log(tmp5)
def generateTransforms(self, detection): # Transform the face affine = pv.AffineFromRect(detection, self.tile_size) w, h = self.tile_size if self.perturbations: # Randomly rotate, translate and scale the images center = pv.AffineTranslate(-0.5 * w, -0.5 * h, self.tile_size) rotate = pv.AffineRotate(random.uniform(-pi / 8, pi / 8), self.tile_size) scale = pv.AffineScale(random.uniform(0.9, 1.1), self.tile_size) translate = pv.AffineTranslate(random.uniform(-0.05 * w, 0.05 * w), random.uniform(-0.05 * h, 0.05 * h), self.tile_size) inv_center = pv.AffineTranslate(0.5 * w, 0.5 * h, self.tile_size) affine = inv_center * translate * scale * rotate * center * affine #affine = affine*center*rotate*scale*translate*inv_center lx = self.left_center.X() - self.subtile_size[0] / 2 ly = self.left_center.Y() - self.subtile_size[1] / 2 rx = self.right_center.X() - self.subtile_size[0] / 2 ry = self.right_center.Y() - self.subtile_size[1] / 2 laffine = pv.AffineFromRect( pv.Rect(lx, ly, self.subtile_size[0], self.subtile_size[1]), self.subtile_size) * affine raffine = pv.AffineFromRect( pv.Rect(rx, ry, self.subtile_size[0], self.subtile_size[1]), self.subtile_size) * affine return laffine, raffine
def addTraining(self, left_eye, right_eye, im): '''Train an eye detector givin a full image and the eye coordinates.''' # determine the face rect true_rect = face_from_eyes(left_eye, right_eye) # run the face detector rects = self.face_detector.detect(im) # find the best detection if there is one for pred_rect in rects: if is_success(pred_rect, true_rect): # Transform the face affine = pv.AffineFromRect(pred_rect, self.tile_size) w, h = self.tile_size if self.perturbations: # Randomly rotate, translate and scale the images center = pv.AffineTranslate(-0.5 * w, -0.5 * h, self.tile_size) rotate = pv.AffineRotate(random.uniform(-pi / 8, pi / 8), self.tile_size) scale = pv.AffineScale(random.uniform(0.9, 1.1), self.tile_size) translate = pv.AffineTranslate( random.uniform(-0.05 * w, 0.05 * w), random.uniform(-0.05 * h, 0.05 * h), self.tile_size) inv_center = pv.AffineTranslate(0.5 * w, 0.5 * h, self.tile_size) affine = inv_center * translate * scale * rotate * center * affine #affine = affine*center*rotate*scale*translate*inv_center cropped = affine.transformImage(im) cropped = pv.meanStd(cropped) # Mark the eyes leye = affine.transformPoint(left_eye) reye = affine.transformPoint(right_eye) # Add training data to locators self.training_labels.append((leye, reye)) self.normalize.addTraining(0.0, cropped) #self.left_locator.addTraining(cropped,leye) #self.right_locator.addTraining(cropped,reye) # Just use the first success return # The face was not detected self.detection_failures += 1
def test_scale(self): transform = pv.AffineScale(1.5, (640, 480)) _ = transform.transformImage(self.test_image) #im_a.show() pt = transform.transformPoint(pv.Point(320, 240)) self.assertAlmostEqual(pt.X(), 480.) self.assertAlmostEqual(pt.Y(), 360.) pt = transform.invertPoint(pv.Point(320, 240)) self.assertAlmostEqual(pt.X(), 213.33333333333331) self.assertAlmostEqual(pt.Y(), 160.)
def test_prev_ref2(self): fname = os.path.join(pv.__path__[0], 'data', 'nonface', 'NONFACE_13.jpg') im_a = pv.Image(fname) #im_a.show() w, h = im_a.size # Try scaling down and then scaling back up tmp1 = pv.AffineScale(0.1, (w / 10, h / 10)).transformImage(im_a) #tmp1.show() tmp2 = pv.AffineScale(10.0, (w, h)).transformImage(tmp1, use_orig=False) tmp2.annotateLabel(pv.Point(10, 10), "This image should be blurry.") #tmp2.show() tmp3 = pv.AffineScale(10.0, (w, h)).transformImage(tmp1, use_orig=True) tmp3.annotateLabel(pv.Point(10, 10), "This image should be sharp.") #tmp3.show() del im_a tmp4 = pv.AffineScale(10.0, (w, h)).transformImage(tmp1, use_orig=True) tmp4.annotateLabel(pv.Point(10, 10), "This image should be blurry.")
import os.path from Image import composite, LINEAR import pyvision as pv from pyvision.edge.sobel import sobel #from pyvision.edge.canny import canny from pyvision.point.DetectorSURF import DetectorSURF import cv if __name__ == '__main__': ilog = pv.ImageLog() source_name = os.path.join(pv.__path__[0], 'data', 'misc', 'p5240019.jpg') #Load source image and resize to smaller scale im = pv.Image(source_name) print "Size before affine scale: %s" % str(im.size) im = pv.AffineScale(0.25, (320, 240)).transformImage(im) print "Size after scaling: %s" % str(im.size) ilog.log(im, 'Input') #im.show(window='Input', pos=(0,0)) #Generate edge image using sobel edge detector edges = sobel(im, 1, 0, 3, 0) ilog.log(edges, 'Edges') #edges.show(window='Edges', pos=(360,0)) #Generate threshold mask, shows numpy integration mat = im.asMatrix2D() high = mat > 180 low = mat < 50 mask = high #+low ilog.log(pv.Image(1.0 * mask), 'Mask')
def test_prev_ref3(self): fname = os.path.join(pv.__path__[0], 'data', 'nonface', 'NONFACE_13.jpg') torig = tprev = im_a = pv.Image(fname) #im_a.show() w, h = im_a.size # Scale aff = pv.AffineScale(0.5, (w / 2, h / 2)) accu = aff torig = aff.transformImage(torig) tprev = aff.transformImage(tprev, use_orig=False) taccu = accu.transformImage(im_a) torig.annotateLabel(pv.Point(10, 10), "use_orig = True") tprev.annotateLabel(pv.Point(10, 10), "use_orig = False") taccu.annotateLabel(pv.Point(10, 10), "accumulated") #torig.show() #tprev.show() #taccu.show() # Translate aff = pv.AffineTranslate(20, 20, (w / 2, h / 2)) accu = aff * accu torig = aff.transformImage(torig) tprev = aff.transformImage(tprev, use_orig=False) taccu = accu.transformImage(im_a) torig.annotateLabel(pv.Point(10, 10), "use_orig = True") tprev.annotateLabel(pv.Point(10, 10), "use_orig = False") taccu.annotateLabel(pv.Point(10, 10), "accumulated") #torig.show() #tprev.show() #taccu.show() # Rotate aff = pv.AffineRotate(np.pi / 4, (w / 2, h / 2)) accu = aff * accu torig = aff.transformImage(torig) tprev = aff.transformImage(tprev, use_orig=False) taccu = accu.transformImage(im_a) torig.annotateLabel(pv.Point(10, 10), "use_orig = True") tprev.annotateLabel(pv.Point(10, 10), "use_orig = False") taccu.annotateLabel(pv.Point(10, 10), "accumulated") #torig.show() #tprev.show() #taccu.show() # Translate aff = pv.AffineTranslate(100, -10, (w / 2, h / 2)) accu = aff * accu torig = aff.transformImage(torig) tprev = aff.transformImage(tprev, use_orig=False) taccu = accu.transformImage(im_a) torig.annotateLabel(pv.Point(10, 10), "use_orig = True") tprev.annotateLabel(pv.Point(10, 10), "use_orig = False") taccu.annotateLabel(pv.Point(10, 10), "accumulated") #torig.show() #tprev.show() #taccu.show() # Scale aff = pv.AffineScale(2.0, (w, h)) accu = aff * accu torig = aff.transformImage(torig) tprev = aff.transformImage(tprev, use_orig=False) taccu = accu.transformImage(im_a) torig.annotateLabel(pv.Point(10, 10), "use_orig = True") tprev.annotateLabel(pv.Point(10, 10), "use_orig = False") taccu.annotateLabel(pv.Point(10, 10), "accumulated")
if options.log_dir != None: print("Creating Image Log...") ilog = pv.ImageLog(options.log_dir) # For each image run face and eye detection face_detect = CascadeDetector(image_scale=1.3*options.scale) locate_eyes = FilterEyeLocator()#locator_filename) c = 0 for pathname in image_names: c += 1 im = pv.Image(pathname) scale = options.log_scale log_im = pv.AffineScale(scale,(int(scale*im.width),int(scale*im.height))).transformImage(im) results = processFaces(im,face_detect,locate_eyes) if options.rotate: rot_image = pv.Image(im.asPIL().transpose(PIL.Image.ROTATE_90)) more_results = processFaces(rot_image,face_detect,locate_eyes) for face,eye1,eye2 in more_results: results.append([pv.Rect(im.width-face.y-face.h, face.x, face.h, face.w), pv.Point(im.width-eye1.Y(),eye1.X()), pv.Point(im.width-eye2.Y(),eye2.X())]) rot_image = pv.Image(im.asPIL().transpose(PIL.Image.ROTATE_180))