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_translate(self):
transform = pv.AffineTranslate(10., 15., (640, 480))
_ = transform.transformImage(self.test_image)
#im_a.show()
pt = transform.transformPoint(pv.Point(320, 240))
self.assertAlmostEqual(pt.X(), 330.)
self.assertAlmostEqual(pt.Y(), 255.)
pt = transform.invertPoint(pv.Point(320, 240))
self.assertAlmostEqual(pt.X(), 310.)
self.assertAlmostEqual(pt.Y(), 225.)
def lbp(im, pattern=LBP_CLASSIC):
im = pv.Image(im.asOpenCVBW()) #TODO: Use opencv for speed
mat = im.asMatrix2D()
lbp = np.zeros(mat.shape, dtype=np.uint8)
w, h = mat.shape
bit = 1
for dx, dy in pattern:
affine = pv.AffineTranslate(-dx, -dy, (w, h))
mat2 = affine.transformImage(im).asMatrix2D()
lbp += bit * (mat < mat2)
bit = bit * 2
return lbp
def crop(self, rect, size=None, interpolation=None, return_affine=False):
'''
Crops an image to the given rectangle. Rectangle parameters are rounded to nearest
integer values. High quality resampling. The default behavior is to use cv.GetSubRect
to crop the image. This returns a slice the OpenCV image so modifying the resulting
image data will also modify the data in this image. If a size is provide a new OpenCV
image is created for that size and cv.Resize is used to copy the image data. If the
bounds of the rectangle are outside the image, an affine transform (pv.AffineFromRect)
is used to produce the croped image to properly handle regions outside the image.
In this case the downsampling quality may not be as good. #
@param rect: a Rectangle defining the region to be cropped.
@param size: a new size for the returned image. If None the result is not resized.
@param interpolation: None = Autoselect or one of CV_INTER_AREA, CV_INTER_NN, CV_INTER_LINEAR, CV_INTER_BICUBIC
@param return_affine: If True, also return an affine transform that can be used to transform points.
@returns: a cropped version of the image or if return affine a tuple of (image,affine)
@rtype: pv.Image
'''
# Notes: pv.Rect(0,0,w,h) should return the entire image. Since pixel values
# are indexed by zero this means that upper limits are not inclusive: x from [0,w)
# and y from [0,h)
x, y, w, h = rect.asTuple()
x = int(np.round(x))
y = int(np.round(y))
w = int(np.round(w))
h = int(np.round(h))
# Check the bounds for cropping
if x < 0 or y < 0 or x + w > self.size[0] or y + h > self.size[1]:
if size is None:
size = (w, h)
affine = pv.AffineFromRect(pv.Rect(x, y, w, h), size)
im = affine(self)
if return_affine:
return im, affine
else:
return im
# Get the image as opencv
cvim = self.asOpenCV()
# Set up ROI
subim = cv.GetSubRect(cvim, (x, y, w, h))
affine = pv.AffineTranslate(-x, -y, (w, h))
if size is None:
size = (w, h)
# Copy to new image
new_image = cv.CreateImage(size, cvim.depth, cvim.nChannels)
if interpolation is None:
if size[0] < w or size[1] < y:
# Downsampling so use area interpolation
interpolation = cv.CV_INTER_AREA
else:
# Upsampling so use linear
interpolation = cv.CV_INTER_CUBIC
# Resize to the correct size
cv.Resize(subim, new_image, interpolation)
affine = pv.AffineNonUniformScale(
float(size[0]) / w,
float(size[1]) / h, size) * affine
# Return the result as a pv.Image
if return_affine:
return pv.Image(new_image), affine
else:
return pv.Image(new_image)
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")
