def frame(self):
_ = self.stdout.readline()
#print line
#print self.w,self.h
y = self.stdout.read(self.w * self.h)
u = self.stdout.read(self.w * self.h / 4)
v = self.stdout.read(self.w * self.h / 4)
if len(y) < self.w * self.h:
raise EOFError
cv.SetData(self.frame_y, y)
cv.SetData(self.frame_u2, u)
cv.SetData(self.frame_v2, v)
cv.Resize(self.frame_u2, self.frame_u)
cv.Resize(self.frame_v2, self.frame_v)
cv.Merge(self.frame_y, self.frame_u, self.frame_v, None,
self.frame_col)
cv.CvtColor(self.frame_col, self.frame_col, cv.CV_YCrCb2RGB)
out = self.frame_col
if self.size != None:
cv.Resize(self.frame_col, self.frame_resized)
out = self.frame_resized
return pv.Image(self.frame_y), pv.Image(self.frame_u), pv.Image(
self.frame_v), pv.Image(out)
def meanshiftUsingPCA(path):
# Load original image given the image path
im = cv.LoadImageM(path)
#convert image to YUV color space
cv.CvtColor(im, im, cv.CV_BGR2YCrCb)
# Load bank of filters
filterBank = lmfilters.loadLMFilters()
# Resize image to decrease dimensions during clustering
resize_factor = 1
thumbnail = cv.CreateMat(im.height / resize_factor,
im.width / resize_factor, cv.CV_8UC3)
cv.Resize(im, thumbnail)
# now work with resized thumbnail image
response = np.zeros(shape=((thumbnail.height) * (thumbnail.width), 51),
dtype=float)
for f in xrange(0, 48):
filter = filterBank[f]
# Resize the filter with the same factor for the resized image
dst = cv.CreateImage(cv.GetSize(thumbnail), cv.IPL_DEPTH_32F, 3)
resizedFilter = cv.CreateMat(filter.height / resize_factor,
filter.width / resize_factor, filter.type)
cv.Resize(filter, resizedFilter)
# Apply the current filter
cv.Filter2D(thumbnail, dst, resizedFilter)
for j in xrange(0, thumbnail.height):
for i in xrange(0, thumbnail.width):
# Select the max. along the three channels
maxRes = max(dst[j, i])
if math.isnan(maxRes):
maxRes = 0.0
if maxRes > response[thumbnail.width * j + i, f]:
# Store the max. response for the given feature index
response[thumbnail.width * j + i, f] = maxRes
#YUV features
count = 0
for j in xrange(0, thumbnail.height):
for i in xrange(0, thumbnail.width):
response[count, 48] = thumbnail[j, i][0]
response[count, 49] = thumbnail[j, i][1]
response[count, 50] = thumbnail[j, i][2]
count += 1
#get the first 4 primary components using pca
pca = PCA(response)
pcaResponse = zeros([thumbnail.height * thumbnail.width, 4])
for i in xrange(0, thumbnail.height * thumbnail.width):
pcaResponse[i] = pca.getPCA(response[i], 4)
# Create new mean shift instance
ms = MeanShift(bandwidth=10, bin_seeding=True)
# Apply the mean shift clustering algorithm
ms.fit(pcaResponse)
labels = ms.labels_
n_clusters_ = np.unique(labels)
print "Number of clusters: ", len(n_clusters_)
repaintImage(thumbnail, labels)
cv.Resize(thumbnail, im)
return im
def main():
# load the specified image
filename = sys.argv[1]
original = cv.LoadImage(filename)
# resample to W columns wide
aspect = float(original.width) / float(original.height)
print original.width, original.height
print W, int(W / aspect)
resized = cv.CreateImage((W, int(W / aspect)), cv.IPL_DEPTH_8U, 3)
cv.Resize(original, resized, cv.CV_INTER_NN)
quick_show(resized)
resized = extract_v(resized)
for y in range(resized.height - 1):
for x in range(resized.width - 1):
p1 = resized[y, x]
p2 = resized[y, x + 1]
p3 = resized[y + 1, x]
p4 = resized[y + 1, x + 1]
resized[y, x] = abs(p1 - p4) + abs(p2 - p3)
mean = cv.CreateImage((resized.width, resized.height), cv.IPL_DEPTH_8U, 1)
for y in range(1, resized.height - 3):
for x in range(1, resized.width - 3):
a = 0.0
for yy in range(y - 1, y + 3):
for xx in range(x - 1, x + 3):
a += resized[yy, xx]
mean[y, x] = a / 16.0
gray = cv.CreateImage((original.width, original.height), cv.IPL_DEPTH_8U,
1)
cv.Resize(mean, gray)
quick_show(gray)
def dewarp(imagedir):
# Loading from json file
C = CameraParams()
C.load(imagedir+"/params.json")
K = cv.fromarray(C.K)
D = cv.fromarray(C.D)
print "loaded camera parameters"
mapx = None
mapy = None
for f in os.listdir(imagedir):
if (f.find('pgm')<0):
continue
image = imagedir+'/'+f
print image
original = cv.LoadImage(image,cv.CV_LOAD_IMAGE_GRAYSCALE)
dewarped = cv.CloneImage(original);
# setup undistort map for first time
if (mapx == None or mapy == None):
im_dims = (original.width, original.height)
mapx = cv.CreateImage( im_dims, cv.IPL_DEPTH_32F, 1 );
mapy = cv.CreateImage( im_dims, cv.IPL_DEPTH_32F, 1 );
cv.InitUndistortMap(K,D,mapx,mapy)
cv.Remap( original, dewarped, mapx, mapy )
tmp1=cv.CreateImage((im_dims[0]/2,im_dims[1]/2),8,1)
cv.Resize(original,tmp1)
tmp2=cv.CreateImage((im_dims[0]/2,im_dims[1]/2),8,1)
cv.Resize(dewarped,tmp2)
cv.ShowImage("Original", tmp1 )
cv.ShowImage("Dewarped", tmp2)
cv.WaitKey(-1)
def fastResize(I,w,h):
Icv = cv.fromarray(I)
I1cv=cv.CreateMat(h, w, Icv.type)
if w < I.shape[1]:
cv.Resize(Icv,I1cv,interpolation=cv.CV_INTER_AREA)
else:
cv.Resize(Icv,I1cv,interpolation=cv.CV_INTER_CUBIC)
Iout = numpy.asarray(I1cv)
return Iout
def capture_draw():
img = cv.QueryFrame(capture)
# scale your big ole face down to something small
thumb = cv.CreateMat(img.height / SCALE, img.width / SCALE, cv.CV_8UC3)
cv.Resize(img, thumb)
faces = get_face_roi(thumb)
for (x, y, w, h), n in faces:
temp_offset = (x * SCALE, y * SCALE)
cv.SetImageROI(img,
((x) * SCALE, (y) * SCALE, (w) * SCALE, (h) * SCALE))
roi_image = cv.CreateImage(cv.GetSize(img), img.depth, img.nChannels)
cv.Copy(img, roi_image)
cv.ResetImageROI(img)
cv.Rectangle(img, (x * SCALE, y * SCALE),
(x * SCALE + w * SCALE, y * SCALE + h * SCALE),
(255, 0, 0))
cv.PutText(img, 'face', (x * SCALE, y * SCALE), font, (200, 200, 200))
FEATURE_SCALE = (float(roi_image.width) / ROI_TARGET_SIZE[0],
float(roi_image.height) / ROI_TARGET_SIZE[1])
roi_thumb = cv.CreateImage((int(roi_image.width / FEATURE_SCALE[0]),
int(roi_image.height / FEATURE_SCALE[1])),
cv.IPL_DEPTH_8U, 3)
cv.Resize(roi_image, roi_thumb)
features = get_features(roi_thumb)
cv.ShowImage("ROI", roi_image)
for name in features:
if features[name] != None:
for (x1, y1, w1, h1), n1 in features[name]:
cv.SetImageROI(
roi_image,
(x1 * FEATURE_SCALE[0], y1 * FEATURE_SCALE[1],
w1 * FEATURE_SCALE[0], h1 * FEATURE_SCALE[1]))
feature_image = cv.CreateImage(cv.GetSize(roi_image),
roi_image.depth,
roi_image.nChannels)
cv.Copy(roi_image, feature_image)
cv.ResetImageROI(feature_image)
cv.ShowImage(name, feature_image)
cv.PutText(img, name,
(temp_offset[0] + x1 * FEATURE_SCALE[0],
temp_offset[1] + y1 * FEATURE_SCALE[1]), font,
(200, 200, 200))
cv.Rectangle(
img, (temp_offset[0] + x1 * FEATURE_SCALE[0],
temp_offset[1] + y1 * FEATURE_SCALE[1]),
(temp_offset[0] +
(x1 + w1) * FEATURE_SCALE[0], temp_offset[1] +
(y1 + h1) * FEATURE_SCALE[1]), (0, 255, 255))
cv.ShowImage("Whole Image", img)
def rescale_img(I, c):
""" Scales image I by factor C. For instance, to upscale an image
by a factor of 2, pass in c=2.0. """
if c == 1.0:
return cv.CloneImage(I)
w_cur, h_cur = cv.GetSize(I)
w_new, h_new = int(round(w_cur * float(c))), int(round(h_cur * float(c)))
Iout = cv.CreateImage((w_new, h_new), I.depth, I.channels)
if c > 1.0:
# Downsizing
cv.Resize(I, Iout, interpolation=cv.CV_INTER_AREA)
else:
cv.Resize(I, Iout, interpolation=cv.CV_INTER_CUBIC)
return Iout
def fastResize(I, rszFac):
Icv = cv.fromarray(np.copy(I))
I1cv = cv.CreateMat(int(math.floor(I.shape[0] * rszFac)),
int(math.floor(I.shape[1] * rszFac)), Icv.type)
cv.Resize(Icv, I1cv)
Iout = np.asarray(I1cv)
return Iout
def resize_image(
source, size
): #size[0], size[1] represent the new height and width respectively
thumbnail = cv.CreateImage((size[0], size[1]), source.depth,
source.nChannels)
cv.Resize(source, thumbnail, interpolation=cv.CV_INTER_CUBIC)
return thumbnail
def run(self):
while True:
frame = cv.QueryFrame(self.capture)
image_size = cv.GetSize(frame)
gray = cv.CreateImage((image_size[0], image_size[1]), 8, 1)
cv.CvtColor(frame, gray, cv.CV_BGR2GRAY)
# scale input image for faster processing
small_img = cv.CreateImage((cv.Round(image_size[0] / __scale__),
cv.Round(image_size[1] / __scale__)),
8, 1)
cv.Resize(gray, small_img, cv.CV_INTER_LINEAR)
cv.EqualizeHist(small_img, small_img)
s_res = sift(np.array(cv.GetMat(small_img)).flatten('C'))
n_res = np.array(s_res)
for item in n_res:
xx = item[0] * __scale__
yy = item[1] * __scale__
label_sift_point(frame, xx, yy)
cv.ShowImage("CamShiftDemo", frame)
c = cv.WaitKey(7)
if c == 27:
break
elif c == ord("t"):
frame = cv.QueryFrame(self.capture)
self.save(frame)
self.i += 1
def imagen_homografia(n):
global points, width, height,teclado
urllib.urlretrieve("http://192.168.0.100:8080/photo.jpg", "foto.jpg")
foto=cv.LoadImage('foto.jpg')
im_in= cv.CloneImage(foto)
#CALIBRACION
width, height = cv.GetSize(im_in)
im = cv.CloneImage(foto)
if n == 0 and (teclado ==1 or teclado ==3):
cv.ShowImage('Escoger 4 puntos',im)
cv.SetMouseCallback('Escoger 4 puntos', mouse, im)
cv.WaitKey(0)
guardarpoints(points)
h**o = homografia(im_in.width, im_in.height, im.width, im.height)
cv.Save('homography.cvmat', h**o)
else:
points = cargarpoints()
h**o = homografia(im_in.width, im_in.height, im.width, im.height)
out_big = cv.CloneImage(im_in)
cv.WarpPerspective(im_in, out_big, h**o)
out_small = cv.CloneImage(im)
cv.Resize(out_big, out_small)
return out_small, out_big
def render(self, window):
with self.lock:
if self.image and self.image_time + rospy.Duration(2.0) > rospy.Time.now() and self.info_time + rospy.Duration(2.0) > rospy.Time.now():
cv.Resize(self.bridge.imgmsg_to_cv(self.image, 'rgb8'), window)
interval = min(1,(self.interval / self.max_interval))
cv.Rectangle(window,
(int(0.05*window.width), int(window.height*0.9)),
(int(interval*window.width*0.9+0.05*window.width), int(window.height*0.95)),
(0, interval*255, (1-interval)*255), thickness=-1)
cv.Rectangle(window,
(int(0.05*window.width), int(window.height*0.9)),
(int(window.width*0.9+0.05*window.width), int(window.height*0.95)),
(0, interval*255, (1-interval)*255))
cv.PutText(window, self.ns, (int(window.width * .05), int(window.height * 0.1)), self.font1, (0,0,255))
if self.features and self.features.header.stamp + rospy.Duration(4.0) > self.image.header.stamp:
w_scaling = float (window.width) / self.image.width
h_scaling = float (window.height) / self.image.height
if self.features.success:
corner_color = (0,255,0)
for cur_pt in self.features.image_points:
cv.Circle(window, (int(cur_pt.x*w_scaling), int(cur_pt.y*h_scaling)), int(w_scaling*5), corner_color)
else:
window = add_text(window, ["Could not detect", "checkerboard"], False)
else:
window = add_text(window, ["Timed out waiting", "for checkerboard"], False)
else:
# Generate random white noise (for fun)
noise = numpy.random.rand(window.height, window.width)*256
numpy.asarray(window)[:,:,0] = noise;
numpy.asarray(window)[:,:,1] = noise;
numpy.asarray(window)[:,:,2] = noise;
cv.PutText(window, self.ns, (int(window.width * .05), int(window.height * .95)), self.font, (0,0,255))
def preprocessImage(inputPath, outputPath):
image = cv.LoadImage(inputPath, 0)
#Find the most likely face
(x, y, w, h), n = mostLikelyHaar(image, haarFace)
croppedImage = cv.CreateImage((w, h), image.depth, image.nChannels)
scaledImage = cv.CreateImage((256, 256), image.depth, image.nChannels)
src_region = cv.GetSubRect(image, (x, y, w, h))
cv.Copy(src_region, croppedImage)
cv.Resize(croppedImage, scaledImage)
image = scaledImage
#Find each ficudial point
leftEye = ImageObject(image, haarLeftEye,
inPercentRect(image, 0, 0, .6, .5))
leftEyePoints = leftEye.getPoints([(.2, .5), (.8, .5)])
rightEye = ImageObject(image, haarRightEye,
inPercentRect(image, .4, 0, 1, .5))
rightEyePoints = rightEye.getPoints([(.2, .5), (.8, .5)])
mouth = ImageObject(image, haarMouth, inPercentRect(image, 0, .6, 1, 1))
mouthPoints = mouth.getPoints([(0, .3), (.5, .3), (1, .3)])
nose = ImageObject(image, haarNose)
nosePoints = nose.getPoints([(.2, .5), (.5, .5), (.8, .5)])
#rotate each set of points by the tilt of the face
tiltAngle = math.atan2(rightEyePoints[0][1] - leftEyePoints[0][1],
rightEyePoints[0][0] - leftEyePoints[0][0])
leftEyePoint = tiltPoints(tiltAngle, leftEyePoints)
rightEyePoints = tiltPoints(tiltAngle, rightEyePoints)
mouthPoints = tiltPoints(tiltAngle, mouthPoints)
nosePoints = tiltPoints(tiltAngle, nosePoints)
image = rotateImage(image, tiltAngle, (w / 2, h / 2))
leftEye = ImageObject(image, haarLeftEye,
inPercentRect(image, 0, 0, .6, .5))
rightEye = ImageObject(image, haarRightEye,
inPercentRect(image, .4, 0, 1, .5))
mouth = ImageObject(image, haarMouth, inPercentRect(image, 0, .6, 1, 1))
nose = ImageObject(image, haarNose)
rotation = math.log(leftEye.w) - math.log(rightEye.w)
print rotation
info = {
'image': outputPath,
'lbp-left-eye': calcLBP(image, leftEye),
'left-eye': leftEye.getTuple(),
'lbp-right-eye': calcLBP(image, rightEye),
'right-eye': rightEye.getTuple(),
'lbp-mouth': calcLBP(image, mouth),
'mouth': mouth.getTuple(),
'tilt': tiltAngle,
'rotation': rotation
}
#save image of the cropped face
cv.SaveImage(outputPath, image)
return info
def overlay_image(frame, image, x, y, w, h):
"""resize and overlay an image where a feature is detected
This resizes the corresponding image to a matched feature, then loops
through all of its pixels to superimpose the image on the frame
"""
# resize the image to fit the detected feature
new_feature = cv.CreateImage((w, h), 8, 3)
cv.Resize(image, new_feature, interpolation=cv.CV_INTER_AREA)
# overlay the image on the frame
for py in xrange(h):
for px in xrange(w):
pixel = cv.Get2D(new_feature, py, px)
# don't map the whitespace surrounding the image
if pixel != (255.0, 255.0, 255.0, 0.0):
if image is tophat:
# above feature
new_y = y - py
elif image is moustache:
# bottom half of feature
new_y = (h / 2) + y + py
else:
# over feature
new_y = y + py
new_x = x + px
# make sure the image is in the frame
if 0 < new_x < frame.width and 0 < new_y < frame.height:
cv.Set2D(frame, new_y, new_x, pixel)
def draw_vertical_sample_boundaries(curr_image_cv, warp_matrix, square_length):
#TODO: IF THIS IS EVER USED, DO NOT USE THIS VALUE
assert (False)
scale_factor = 0.5
curr_image = np.array(curr_image_cv)
full_width = curr_image.shape[1]
full_height = curr_image.shape[0]
width = int(curr_image.shape[1] * scale_factor)
height = int(curr_image.shape[0] * scale_factor)
full_left_bound = int(full_width * (0.5 - square_length / 2))
full_right_bound = int(full_width * (0.5 + square_length / 2))
left_bound = int(full_left_bound * scale_factor)
right_bound = int(full_right_bound * scale_factor)
full_line1 = ((full_left_bound, 0), (full_left_bound, full_height - 1))
full_line2 = ((full_right_bound, 0), (full_right_bound, full_height - 1))
line1 = ((left_bound, 0), (left_bound, height - 1))
line2 = ((right_bound, 0), (right_bound, height - 1))
if curr_image.ndim == 2:
sample_image = curr_image[:, :, np.newaxis]
sample_image = np.tile(sample_image, (1, 1, 3))
sample_image = cv.fromarray(sample_image)
resized_sample_image = cv.CreateMat(height, width, sample_image.type)
cv.Resize(sample_image, resized_sample_image)
cv.Line(resized_sample_image, line1[0], line1[1], cv.CV_RGB(0, 255, 0))
cv.Line(resized_sample_image, line2[0], line2[1], cv.CV_RGB(0, 255, 0))
boundary_pts = line1 + line2
return resized_sample_image, \
cvutils.reorder_boundary_points(
np.array(full_line1 + full_line2))
def _selectTrackingPoints(self,frame):
'''
This uses the OpenCV get good features to track to initialize a set of tracking points_b.
'''
quality = 0.01
min_distance = 15
w,h = self.tile_size
tw = w//self.grid
th = h//self.grid
for i in range(self.grid):
for j in range(self.grid):
ul = pv.Point(i*tw,j*th)
rect = pv.Rect(i*tw,j*th,tw,th)
count = 0
for pt in self.tracks:
if rect.containsPoint(pt):
count += 1
if count < self.min_points:
gray = cv.CreateImage ((tw,th), 8, 1)
faceim = cv.GetSubRect(frame, rect.asOpenCV())
cv.Resize(faceim,gray)
eig = cv.CreateImage ((tw,th), 32, 1)
temp = cv.CreateImage ((tw,th), 32, 1)
# search the good points_b
points_b = cv.GoodFeaturesToTrack (gray, eig, temp, 2*self.min_points, quality, min_distance, None, 3, 0, 0.04)
for pt in points_b:
self.tracks.append(ul+pv.Point(pt))
def detect_and_draw(img, cascade):
gray = cv.CreateImage((img.width,img.height), 8, 1)
small_img = cv.CreateImage((cv.Round(img.width / image_scale),
cv.Round (img.height / 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(cascade):
t = cv.GetTickCount()
faces = cv.HaarDetectObjects(small_img, cascade, cv.CreateMemStorage(0),
haar_scale, min_neighbors, haar_flags, min_size)
index = 0
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
x1, y1 = (int(x * image_scale), int(y * image_scale))
x2, y2 = (int((x + w) * image_scale), int((y + h) * image_scale))
pi = Image.fromstring("L", cv.GetSize(gray), gray.tostring())
pi = pi.crop((x1, y1, x2, y2))
pi = pi.resize((64, 64), Image.ANTIALIAS)
path = os.path.join(sys.argv[1])
pi.save(path)
index += 1
else:
os.remove(sys.argv[1])
def load_sets(base_dir, set_names):
cards = []
for dir, subdirs, fnames in os.walk(base_dir):
set = os.path.split(dir)[1]
if set in set_names:
print "Loading set %s" % (set)
for fname in fnames:
path = os.path.join(dir, fname)
#img = cv.LoadImage(path.encode('utf-8'),0)
try:
img = cv.LoadImage(path,0)
except IOError:
print >> sys.stderr, "\tload_sets() Loading image %s failed" % (path)
next
if cv.GetSize(img) != (223, 310):
tmp = cv.CreateImage((223, 310), 8, 1)
cv.Resize(img,tmp)
img = tmp
phash = dct_hash(img)
cards.append((
fname.replace('.full.jpg',''),
set,
phash
))
print "\tDone loading set %s" % (set)
return cards
def angle(self, img):
# extract position of red blue yellow markers
# find distance between pairs
# return angle from inverse cosine
imgHSV = cv.CreateImage(cv.GetSize(img), 8, 3)
cv.CvtColor(img, imgHSV, cv.CV_BGR2HSV)
cv.NamedWindow("red", cv.CV_WINDOW_AUTOSIZE)
cv.MoveWindow("red", 800, 0)
cv.NamedWindow("blue", cv.CV_WINDOW_AUTOSIZE)
cv.MoveWindow("blue", 800, 100)
cv.NamedWindow("yellow", cv.CV_WINDOW_AUTOSIZE)
cv.MoveWindow("yellow", 800, 200)
dot_coords = []
# use the corresponding thresholds for each color of marker #
for h_low, h_high, col in [self.red_hues, self.yellow_hues, self.blue_hues]:
imgThresh = cv.CreateImage(cv.GetSize(img), 8, 1)
cv.InRangeS(imgHSV, cv.Scalar(h_low, 70, 70), cv.Scalar(h_high, 255, 255), imgThresh)
moments = cv.Moments(cv.GetMat(imgThresh))
x_mov = cv.GetSpatialMoment(moments, 1, 0)
y_mov = cv.GetSpatialMoment(moments, 0, 1)
area = cv.GetCentralMoment(moments, 0, 0)
small_thresh = cv.CreateImage((self.fit_camera_width, self.fit_camera_height), 8, 1)
cv.Resize(imgThresh, small_thresh)
if col == "r":
cv.ShowImage("red", small_thresh)
elif col == "b":
cv.ShowImage("blue", small_thresh)
elif col == "y":
cv.ShowImage("yellow", small_thresh)
if area > 0:
posX = float(x_mov)/float(area)
posY = float(y_mov)/float(area)
else:
posX = 0
posY = 0
dot_coords.append([posX, posY])
r = dot_coords[0]
y = dot_coords[1]
b = dot_coords[2]
# get side lengths
y_r = self.dist(r[0], r[1], y[0], y[1])
r_b = self.dist(b[0], b[1], r[0], r[1])
y_b = self.dist(b[0], b[1], y[0], y[1])
# apply law of cosines
angle_in_rads = math.pow(y_r, 2) + math.pow(r_b, 2) - math.pow(y_b, 2)
denom = 2.0 * y_r * r_b
if denom > 0:
angle_in_rads /= 2.0 * y_r * r_b
else:
angle_in_rads = 0
rads = math.acos(angle_in_rads)
# convert to degrees
degs = rads * float(180.0 / math.pi)
if degs < 0 or degs > 360:
degs = 0
return degs
def blob_to_input_instance(image, blob, classification_window_width):
patch_size = classification_window_width * 2 + 1
small_r = blob_to_rect(
blob, classification_window_width=classification_window_width)
big_r = blob_to_rect(
blob, classification_window_width=classification_window_width * 2)
if big_r == None or small_r == None:
return None
small_patch = cv.CloneMat(cv.GetSubRect(image, small_r.as_cv_rect()))
big_patch = cv.CloneMat(cv.GetSubRect(image, big_r.as_cv_rect()))
#cv.ShowImage('patch', small_patch)
#cv.ShowImage('big_patch', big_patch)
big_patch_rescaled = cv.CreateImage((int(classification_window_width / 2),
int(classification_window_width / 2)),
8, 3)
cv.Resize(big_patch, big_patch_rescaled, cv.CV_INTER_LINEAR)
np_patch_small = np.asarray(small_patch)
np_patch_big = ad.cv2array(big_patch_rescaled)
np_resized_small = np.matrix(
np_patch_small.reshape(patch_size * patch_size * 3, 1))
np_resized_big = np.matrix(
np_patch_big.reshape(np_patch_big.shape[0] * np_patch_big.shape[1] * 3,
1))
return np.concatenate((np_resized_small, np_resized_big), axis=0)
def CompositeThumbnail(img, regions, thumb_size=100):
'''extract a composite thumbnail for the regions of an image
The composite will consist of N thumbnails side by side
'''
composite = cv.CreateImage((thumb_size*len(regions), thumb_size),8,3)
for i in range(len(regions)):
(x1,y1,x2,y2) = regions[i].tuple()
midx = (x1+x2)/2
midy = (y1+y2)/2
if (x2-x1) > thumb_size or (y2-y1) > thumb_size:
# we need to shrink the region
rsize = max(x2+1-x1, y2+1-y1)
src = cuav_util.SubImage(img, (midx-rsize/2,midy-rsize/2,rsize,rsize))
thumb = cv.CreateImage((thumb_size, thumb_size),8,3)
cv.Resize(src, thumb)
else:
x1 = midx - thumb_size/2
y1 = midy - thumb_size/2
thumb = cuav_util.SubImage(img, (x1, y1, thumb_size, thumb_size))
cv.SetImageROI(composite, (thumb_size*i, 0, thumb_size, thumb_size))
cv.Copy(thumb, composite)
cv.ResetImageROI(composite)
return composite
def __init__(self, image_name, cascade):
try:
image = cv.LoadImage(image_name, 1)
except IOError:
return
except:
return
else:
self.faces = []
#Allocate Space for grayscale image and tiny image
#Dramatically reduces computation time in exchange for temporary space
grayscale = cv.CreateImage((image.width, image.height), 8, 1)
img = cv.CreateImage((cv.Round(image.width / IMAGE_SCALE),
cv.Round(image.height / IMAGE_SCALE)), 8, 1)
cv.CvtColor(image, grayscale, cv.CV_BGR2GRAY)
cv.Resize(grayscale, img, cv.CV_INTER_LINEAR)
cv.EqualizeHist(img, img)
matches = cv.HaarDetectObjects(img, cascade,
cv.CreateMemStorage(0), HAAR_SCALE,
IMAGE_SCALE, HAAR_FLAGS, MIN_SIZE)
for ((x, y, width, height), wat) in matches:
self.faces.append({
"x": x,
"y": y,
"width": width,
"height": height
})
self.name = image_name
def detect_and_draw(img, cascade):
# allocate temporary images
gray = cv.CreateImage((img.width, img.height), 8, 1)
small_img = cv.CreateImage((cv.Round(
img.width / image_scale), cv.Round(img.height / 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 (cascade):
t = cv.GetTickCount()
faces = cv.HaarDetectObjects(small_img, cascade,
cv.CreateMemStorage(0), haar_scale,
min_neighbors, haar_flags, min_size)
t = cv.GetTickCount() - t
print "detection time = %gms" % (t / (cv.GetTickFrequency() * 1000.))
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))
cv.Rectangle(img, pt1, pt2, cv.RGB(255, 0, 0), 3, 8, 0)
cv.ShowImage("result", img)
def resize_mat(mat, shape, rszFac=None):
""" Takes in an NxM matrix 'mat', and either truncates or pads
it so that it has the 'shape'.
Input:
obj mat: an NxM numpy array
tuple shape: (h,w)
float rszFac: If given, then this first rescales MAT by RSZFAC,
followed by truncation/padding.
Output:
An hxw sized array.
"""
h, w = mat.shape
if rszFac is not None:
w_new, h_new = int(round(rszFac * w)), int(round(rszFac * h))
if w_new != w or h_new != h:
Icv = cv.fromarray(mat)
Icv_rsz = cv.CreateMat(h_new, w_new, Icv.type)
cv.Resize(Icv, Icv_rsz, cv.CV_INTER_CUBIC)
mat_rsz = np.asarray(Icv_rsz)
else:
mat_rsz = mat
else:
mat_rsz = mat
out = np.zeros(shape, dtype=mat_rsz.dtype)
i = min(mat_rsz.shape[0], out.shape[0])
j = min(mat_rsz.shape[1], out.shape[1])
out[0:i, 0:j] = mat_rsz[0:i, 0:j]
return out
def crop(im, size, pos=(0, 0)):
"""
This function is very similar to :func:`sample()` in that it returns a specified subsection of the image. The main difference here is that if the region is too big to fit, the returned image is made smaller. There is no size default here and pos defaults to the top-left corner of the image.
**Parameters:**
* im (cvArr) - The source image.
* size (tuple) - The cropped image size (w, h).
* pos (tuple) - The position of the top-left corner of the cropped image.
**Returns:**
The cropped image.
.. seealso::
:func:`sample()`
"""
warn = False
if pos[0] + size[0] > im.width:
size = (im.width - 1 - pos[0], size[1])
warn = True
if pos[1] + size[1] > im.height:
size = (size[0], im.height - 1 - pos[1])
warn = True
if warn:
warnings.warn(
"Cropped region went off the edge of the image. The cropped size has been reduced to %dx%d."
% (size[0], size[1]),
stacklevel=2)
rect = (pos[0], pos[1], size[0], size[1])
cropped = create(im, size=size)
dst = cv.GetSubRect(im, rect)
cv.Resize(dst, cropped)
return cropped
def fastResize(I, rszFac, sig=-1):
""" Resizes the input image I by factor 'rszFac'. 'rszFac' should be
a float greater than 0.0, where smaller values leads to shrunken
versions of I, and values greater than 1.0 lead to bigger-versions of
I.
Input:
obj I: scipy img
float rszFac:
Output:
A resized image Iout.
"""
if rszFac == 1:
return I
else:
# Almost certain that this np.copy(I) is not necessary, since cv.Resize
# will interpolate new pixel values in Iout. Removing np.copy(I) didn't
# seem to affect results, and speeds things up. -- EK
# Icv=cv.fromarray(np.copy(I))
if not I.flags.c_contiguous:
# numpy requires arrays be contiguous in memory - when you
# pass it to OpenCV, then try to re-convert back to numpy,
# you get an error in np.asarray if I isn't contiguous.
I = np.copy(I) # Makes I contiguous
Icv = cv.fromarray(I)
I1cv = cv.CreateMat(int(math.floor(I.shape[0] * rszFac)),
int(math.floor(I.shape[1] * rszFac)), Icv.type)
cv.Resize(Icv, I1cv, interpolation=cv.CV_INTER_AREA)
Iout = np.asarray(I1cv)
if sig > 0:
Iout = gaussian_filter(Iout, sig)
return Iout
def normalisation(src):
res = []
# On fait une copie l'image pour le traitement (en gris)
gris = cv.CreateImage((src.width, src.height), cv.IPL_DEPTH_8U, 1)
normal = cv.CreateImage((NORM_W, NORM_H), cv.IPL_DEPTH_8U, 1)
cv.CvtColor(src, gris, cv.CV_BGR2GRAY)
# On detecte les visages (objects) sur l'image copiee
faces = cv.HaarDetectObjects(gris, face_path, cv.CreateMemStorage())
print "Nombre faces detectes : " + str(len(faces))
for (x, y, w, h), n in faces:
tmp = cv.CreateImage((w, h), cv.IPL_DEPTH_8U, 1)
cv.GetRectSubPix(gris, tmp, (float(x + w / 2), float(y + h / 2)))
cv.Resize(tmp, normal)
cv.EqualizeHist(normal, normal)
#Detection oeil nez bouche sur l'image source:
d = detection(normal)
# On detecte au moins 2 yeux "normaux", au moins un oeil avec lunette, au moins une bouche et au moins un nez
if ((len(d['eyes']) >= 2 or len(d['eyes2']) >= 1)
and len(d['mouth']) >= 1 and len(d['nose']) >= 1):
print "Visage detecte dans la photo"
res.append((normal, (x, y, w, h)))
return res
def listen(self):
if isinstance(self.background, np.ndarray):
bgimg = cv.CreateImage(self.background.shape[:2], 8, 3)
img = cv.CreateImage(self.background.shape[:2], 8, 3)
theWidth = self.background.shape[1]
theHeight = self.background[0]
else:
bgimg = cv.CreateImage(
(self.background.width, self.background.height), 8, 3)
img = cv.CreateImage(
(self.background.width, self.background.height), 8, 3)
theWidth = self.background.width
theHeight = self.background.height
cv.Copy(self.background, bgimg)
smallimg = cv.CreateImage(
(theWidth / self.zoom, theHeight / self.zoom), 8, 3)
cv.GetRectSubPix(bgimg, smallimg,
(theWidth / (2 * self.zoom) + self.offset[0],
theHeight / (2 * self.zoom) + self.offset[1]))
cv.Resize(smallimg, img)
if (self.cp != False):
cv.Circle(img, self.zoomPt(self.cp.x, self.cp.y), 3,
cv.RGB(0, 255, 0), -1)
cv.Line(img, (self.ch_x - 25, self.ch_y), (self.ch_x + 25, self.ch_y),
cv.RGB(255, 255, 0))
cv.Line(img, (self.ch_x, self.ch_y - 25), (self.ch_x, self.ch_y + 25),
cv.RGB(255, 255, 0))
cv.ShowImage(self.name, img)
cv.WaitKey(25)
def detect_and_save(img, cascade, output_name):
# allocate temporary images
gray = cv.CreateImage((img.width, img.height), 8, 1)
small_img = cv.CreateImage((cv.Round(
img.width / image_scale), cv.Round(img.height / 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 (cascade):
t = cv.GetTickCount()
faces = cv.HaarDetectObjects(small_img, cascade,
cv.CreateMemStorage(0), haar_scale,
min_neighbors, haar_flags, min_size)
t = cv.GetTickCount() - t
print "detection time = %gms" % (t / (cv.GetTickFrequency() * 1000.))
f = open(output_name, 'w')
if faces:
for ((x, y, w, h), n) in faces:
f.write("%d %d %d %d\n" % (x, y, w, h))
def DetectFace(self,image, faceCascade):
min_size = (20,20)
image_scale = 2
haar_scale = 1.1
min_neighbors = 3
haar_flags = 0
# Allocate the temporary images
grayscale = cv.CreateImage((image.width, image.height), 8, 1)
#grayscale = cv.CreateImage((image.shape[1], image.shape[0]), 8, 1)
smallImage = cv.CreateImage(
(
cv.Round(image.width / image_scale),
cv.Round(image.height / image_scale)
), 8 ,1)
# Convert color input image to grayscale
cv.CvtColor(image, grayscale, cv.CV_BGR2GRAY)
# Scale input image for faster processing
cv.Resize(grayscale, 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
)
# If faces are found
if faces:
payload=targets()
payload.ref_img_width=smallImage.width
payload.ref_img_height=smallImage.height
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(image, pt1, pt2, cv.RGB(255, 0, 0), 5, 8, 0)
fbox=face_box()
fbox.top_left.x=float(x)/float(smallImage.width)
fbox.top_left.y=float(y)/float(smallImage.height)
fbox.width_height.x=float(w)/float(smallImage.width)
fbox.width_height.y=float(h)/float(smallImage.height)
payload.faces.append(fbox)
#fpt=Point()
#fpt.x=(float(x) + float(w)/2.0)/float(smallImage.width)
#fpt.y=(float(y) + float(h)/2.0)/float(smallImage.height)
#payload.faces.append(fpt)
msg = payload
rospy.loginfo(msg)
self.pub.publish(msg)
return image
