def segmentize(self, input_img):
histogram = self.__calculate_histogram(input_img)
(peaks, bottoms) = find_peaks(histogram, max(histogram) / 8)
for peak in peaks:
if between(peak, self.expectations['table']):
self.ranges['table'] = find_hill(histogram, peak, 0.01)
break #stop searching, we want the first peak since that is the highest large object.
if not 'table' in self.ranges:
if self.verbose:
cv.ShowImage("histogram", self.__render_histogram(histogram))
return None
self.ranges['objects'] = (1, self.ranges['table'][0] - 1)
print self.ranges
if self.verbose:
cv.ShowImage("histogram", self.__render_histogram(histogram))
objects_img = create_empty_image((input_img.width, input_img.height))
cv.SetImageROI(objects_img, cv.GetImageROI(input_img))
cv.InRangeS(input_img, cv.Scalar(self.ranges['objects'][0]),
cv.Scalar(self.ranges['objects'][1]), objects_img)
table_img = create_empty_image((input_img.width, input_img.height))
cv.SetImageROI(table_img, cv.GetImageROI(input_img))
cv.InRangeS(input_img, cv.Scalar(self.ranges['table'][0]),
cv.Scalar(self.ranges['table'][1]), table_img)
return {'objects': objects_img, 'table': table_img}
def size_image(img, imgsize):
# check if we need to crop out ROI
roiWidth = img.width
roiHeight = img.height
if (img.width > imgsize[1]):
roiWidth = imgsize[1]
if (img.height > imgsize[0]):
roiHeight = imgsize[0]
roi = (0, 0, roiWidth, roiHeight)
cv.SetImageROI(img, roi)
imgTrim = cv.CreateImage((roi[2], roi[3]), img.depth, img.nChannels)
cv.Copy(img, imgTrim)
# check if we need to pad
padSize = 0
padSize = max(padSize, imgsize[0] - imgTrim.height)
padSize = max(padSize, imgsize[1] - imgTrim.width)
if padSize == 0: # no padding needed
return imgTrim
else:
padSize = int(round((padSize + .5) / 2.))
# copy make border
imgPad = cv.CreateImage(
(imgTrim.width + 2 * padSize, imgTrim.height + 2 * padSize),
img.depth, img.nChannels)
cv.CopyMakeBorder(imgTrim, imgPad, (0, 0), 0)
roi = (0, 0, imgsize[1], imgsize[0])
cv.SetImageROI(imgPad, roi)
imgFinal = cv.CreateImage((roi[2], roi[3]), img.depth, img.nChannels)
cv.Copy(imgPad, imgFinal)
return imgFinal
def removeBadBackground(seg):
threshUp = cv.CreateImage(cv.GetSize(seg), cv.IPL_DEPTH_8U, 1)
comparison = cv.CreateImage(cv.GetSize(seg), cv.IPL_DEPTH_8U, 1)
visitMask = cv.CreateImage(cv.GetSize(seg), cv.IPL_DEPTH_8U, 1)
ffMask = cv.CreateImage((seg.width + 2, seg.height + 2), cv.IPL_DEPTH_8U,
1)
cv.Threshold(seg, threshUp, 1, 255, cv.CV_THRESH_BINARY)
cv.Zero(visitMask)
cv.Zero(ffMask)
for x in xrange(seg.width):
for y in xrange(seg.height):
if seg[y, x] != 96 or visitMask[y, x] == 255: continue
comp = cv.FloodFill(threshUp, (x, y), 0, 0, 0,
4 + cv.CV_FLOODFILL_MASK_ONLY + (255 << 8),
ffMask)
rect = comp[2]
cv.SetImageROI(ffMask, cap.shiftRect(rect, 1, 1))
cv.OrS(ffMask, 1, ffMask)
cv.SetImageROI(seg, rect)
cv.SetImageROI(comparison, rect)
cv.Cmp(
seg, ffMask, comparison,
cv.CV_CMP_EQ) # 'comparison' does not need to be zeroed later
intersect = cv.CountNonZero(comparison)
cv.SetImageROI(visitMask, rect)
cv.Or(visitMask, ffMask, visitMask)
cv.ResetImageROI(visitMask)
if intersect == 0:
cv.Set(seg, 0, ffMask)
cv.Zero(ffMask)
cv.ResetImageROI(seg)
cv.ResetImageROI(ffMask)
return seg
def draw(self, img, pixmapper):
'''draw the icon on the image'''
if self.trail is not None:
self.trail.draw(img, pixmapper)
icon = self.img()
(px, py) = pixmapper(self.latlon)
# find top left
px -= icon.width / 2
py -= icon.height / 2
w = icon.width
h = icon.height
(px, py, sx, sy, w, h) = self.clip(px, py, w, h, img)
cv.SetImageROI(icon, (sx, sy, w, h))
cv.SetImageROI(img, (px, py, w, h))
cv.Add(icon, img, img)
cv.ResetImageROI(img)
cv.ResetImageROI(icon)
# remember where we placed it for clicked()
self.posx = px + w / 2
self.posy = py + h / 2
def crop(image, offset, size):
w, h = size
# If there will be a border, use CopyMakeBorder.
# Setting ROI, no border is created and resulting image is smaller
if offset[0]>0 or \
offset[1]>0 or \
offset[0]+cv.GetSize(image)[0]<w or \
offset[1]+cv.GetSize(image)[1]<h:
finalImg = cv.CreateImage((w, h), cv.IPL_DEPTH_8U, 3)
# offset may have negative values, if there will be a right/bottom border
useOffset = (max(0, offset[0]), max(0, offset[1]))
# Need to crop first as CopyMakeBorder will complain if the source is too big for the destination
# (The ROI is the opposite of the offset)
cv.SetImageROI(image, (-offset[0], -offset[1], w, h))
cv.CopyMakeBorder(image, finalImg, useOffset, GAP_BORDER)
return finalImg
else:
cv.SetImageROI(image, (-offset[0], -offset[1], w, h))
return image
def publish_debug(img, results):
imgsize = cv.GetSize(img)
sizelist = [cv.GetSize(tmp[1]) for tmp in templates]
width = max(imgsize[0], sum([s[0] for s in sizelist]))
height = imgsize[1] + max([s[1] for s in sizelist])
output = cv.CreateImage((width, height), cv.IPL_DEPTH_8U, 1)
cv.Zero(output)
cur_x = 0
view_rect = (0, height-imgsize[1], imgsize[0], imgsize[1])
cv.SetImageROI(output, view_rect)
cv.Copy(img, output)
for template in templates:
size = cv.GetSize(template[1])
cv.SetImageROI(output, (cur_x, 0, size[0], size[1]))
cv.Copy(template[1], output)
cur_x += size[0]
#cv.PutText(output, tempname, (0,size[1]-16), font, cv.CV_RGB(255,255,255))
#cv.PutText(output, str(tempthre)+'<'+str(status[1]), (0,size[1]-8), font, cv.CV_RGB(255,255,255))
for _,status in [s for s in results if s[0] == template[3]]:
print status
cv.PutText(output, template[3], (0,size[1]-42), font, cv.CV_RGB(255,255,255))
cv.PutText(output, "%7.5f"%(status[0]), (0,size[1]-24), font, cv.CV_RGB(255,255,255))
cv.PutText(output, "%7.5f"%(status[2]), (0,size[1]-8), font, cv.CV_RGB(255,255,255))
if status[3] :
cv.Rectangle(output, (0, 0), size, cv.RGB(255,255,255), 9)
cv.SetImageROI(output, view_rect)
for _,status in [s for s in results if s[0] == template[3]]:
pt2 = (status[1][0]+size[0], status[1][1]+size[1])
if status[3] :
cv.Rectangle(output, status[1], pt2, cv.RGB(255,255,255), 5)
cv.ResetImageROI(output)
debug_pub.publish(bridge.cv_to_imgmsg(output, encoding="passthrough"))
def SubImage(img, region):
'''return a subimage as a new image. This allows
for the region going past the edges.
region is of the form (x1,y1,width,height)'''
(x1, y1, width, height) = region
zeros = numpy.zeros((height, width, 3), dtype='uint8')
ret = cv.GetImage(cv.fromarray(zeros))
(img_width, img_height) = cv.GetSize(img)
if x1 < 0:
sx1 = 0
xofs = -x1
else:
sx1 = x1
xofs = 0
if y1 < 0:
sy1 = 0
yofs = -y1
else:
sy1 = y1
yofs = 0
if sx1 + width <= img_width:
w = width
else:
w = img_width - sx1
if sy1 + height <= img_height:
h = height
else:
h = img_height - sy1
cv.SetImageROI(img, (sx1, sy1, w - xofs, h - yofs))
cv.SetImageROI(ret, (xofs, yofs, w - xofs, h - yofs))
cv.Copy(img, ret)
cv.ResetImageROI(img)
cv.ResetImageROI(ret)
return ret
def update_histogram(self, region):
cv.SetImageROI(self.hue, region)
cv.SetImageROI(self.sat, region)
cv.CalcArrHist([self.hue, self.sat], self.face_hist, 1)
#cv.NormalizeHist(self.face_hist, 255)
cv.ResetImageROI(self.hue)
cv.ResetImageROI(self.sat)
def findCCs(image, erasecol=0, doContinue=None, doSkip=None, bRange=0, connectivity=8):
"""
Finds all connected components in the image.
doContinue is a function applied to the color of every new pixel in the image.
If it is true, this pixel is ignored. Default: <= 128
doSkip is a function applied to every new connected component found by the
function. If it is true, this component will not be included in the result.
Default: do not skip anything.
"""
if doContinue is None:
doContinue = lambda col: col <= 128
if doSkip is None:
doSkip = lambda comp: False
mask = cv.CreateImage((image.width + 2, image.height + 2), cv.IPL_DEPTH_8U, 1)
cv.Zero(mask)
components = []
for x in range(image.width):
for y in range(image.height):
if doContinue(image[y, x]):
continue
comp = cv.FloodFill(image, (x, y), 0, bRange, bRange, connectivity + cv.CV_FLOODFILL_MASK_ONLY + (255 << 8), mask) # here 3rd argument is ignored
region = shiftRect(comp[2], 1, 1)
if not doSkip(comp):
seg = cvext.getSubImage(mask, region)
components.append((comp[0], comp[1], comp[2], seg))
cv.SetImageROI(image, comp[2])
cv.SetImageROI(mask, region)
cv.Set(image, erasecol, mask)
cv.Zero(mask)
cv.ResetImageROI(image)
cv.ResetImageROI(mask)
return components
def repaintCCs(image, doRepaint=None, returnMask=False, resizeMask=True, doFillBackground=True, bgPoint=(0, 0), newcol=255, connectivity=4):
if doRepaint is None:
doRepaint = lambda comp, col: False
resultMask = cv.CreateImage((image.width + 2, image.height + 2), image.depth, image.nChannels)
tempMask = cv.CreateImage((image.width + 2, image.height + 2), image.depth, image.nChannels)
visitMask = cv.CreateImage((image.width + 2, image.height + 2), image.depth, image.nChannels)
cv.Zero(resultMask)
cv.Zero(tempMask)
cv.Zero(visitMask)
if doFillBackground:
cv.FloodFill(image, bgPoint, 0, 0, 0, connectivity + cv.CV_FLOODFILL_MASK_ONLY + (255 << 8), visitMask)
for x in xrange(image.width):
for y in xrange(image.height):
if visitMask[y + 1, x + 1] == 255:
continue
comp = cv.FloodFill(image, (x, y), 0, 0, 0, connectivity + cv.CV_FLOODFILL_MASK_ONLY + (255 << 8), tempMask)
region = shiftRect(comp[2], 1, 1)
cv.SetImageROI(tempMask, region)
cv.SetImageROI(visitMask, region)
cv.Or(tempMask, visitMask, visitMask)
if doRepaint(comp, image[y, x]):
cv.SetImageROI(resultMask, region)
cv.Or(tempMask, resultMask, resultMask)
cv.ResetImageROI(resultMask)
cv.Zero(tempMask)
cv.ResetImageROI(tempMask)
cv.ResetImageROI(visitMask)
if returnMask:
if resizeMask: return cap.getSubImage(resultMask, (1, 1, image.width, image.height))
else: return resultMask
else:
cv.SetImageROI(resultMask, (1, 1, image.width, image.height))
cv.Set(image, newcol, resultMask)
return image
def minmax_cv(imgpaths,
do_align=False,
rszFac=1.0,
trfm_type='rigid',
minArea=np.power(2, 16),
bbs_map=None,
imgCache=None):
""" Generates min/max overlays for IMGPATHS. If DO_ALIGN is
True, then this also aligns every image to the first image in
IMGPATHS.
Input:
list IMGPATHS: [str imgpath_i, ...]
bool DO_ALIGN:
float RSZFAC: Resizing factor for alignment.
dict BBS_MAP: maps {str imgpath: (x1,y1,x2,y2)}
Output:
cvMat minimg, cvMat maximg.
"""
def load_image(imgpath):
if imgCache == None:
return cv.LoadImage(imgpath, cv.CV_LOAD_IMAGE_GRAYSCALE)
else:
((img, imgpath), isHit) = imgCache.load(imgpath)
return img
if bbs_map == None:
bbs_map = {}
imgpath = imgpaths[0]
bb0 = bbs_map.get(imgpath, None)
Imin = load_image(imgpath)
if bb0:
coords = (bb0[0], bb0[1], bb0[2] - bb0[0], bb0[3] - bb0[1])
coords = tuple(map(int, coords))
cv.SetImageROI(Imin, coords)
Imax = cv.CloneImage(Imin)
#Iref = np.asarray(cv.CloneImage(Imin)) if do_align else None
Iref = (iplimage2np(cv.CloneImage(Imin)) / 255.0) if do_align else None
for imgpath in imgpaths[1:]:
I = load_image(imgpath)
bb = bbs_map.get(imgpath, None)
if bb:
bb = tuple(map(int, bb))
cv.SetImageROI(I, (bb[0], bb[1], bb[2] - bb[0], bb[3] - bb[1]))
Iout = matchsize(I, Imax)
if do_align:
tmp_np = iplimage2np(cv.CloneImage(Iout)) / 255.0
H, Ireg, err = imagesAlign(tmp_np,
Iref,
trfm_type=trfm_type,
fillval=0,
rszFac=rszFac,
minArea=minArea)
Ireg *= 255.0
Ireg = Ireg.astype('uint8')
Iout = np2iplimage(Ireg)
cv.Max(Iout, Imax, Imax)
cv.Min(Iout, Imin, Imin)
return Imin, Imax
def estimate_ballot_rot(I, Imarkfull, bbs, MAX_THETA=2.0, K=5):
roi_prev = cv.GetImageROI(I)
w_markfull, h_markfull = cv.GetSize(Imarkfull)
theta_tm = None
for bb in bbs:
roi_cur = tuple(
map(lambda x: int(round(x)),
(roi_prev[0] + bb[0], roi_prev[1] + bb[1], bb[2] - bb[0],
bb[3] - bb[1])))
cv.SetImageROI(I, roi_cur)
w_cur, h_cur = cv.GetSize(I)
if DEBUG_SAVEIMGS:
print_dbg("<><><><> Saving '_Imiddle.png' <><><><>")
cv.SaveImage("_Imiddle.png", I)
pdb.set_trace()
matches = tempmatch.get_tempmatches(
Imarkfull, [I],
T=0.9,
do_smooth=tempmatch.SMOOTH_BOTH_BRD,
xwinI=5,
ywinI=5,
xwinA=5,
ywinA=5)[0]
matches = sorted(matches, key=lambda t: t[0])
if matches:
xs = np.array([t[0] for t in matches])
ys = np.array([cv.GetSize(I)[1] - t[1] for t in matches])
if len(xs) <= 1:
print_dbg("==== Couldn't find enough marks in '_Imiddle.png'.")
continue
# Filter out any obvious outliers
lonely_idxs = detect_lonely_vals(ys, h_markfull)
xs = np.delete(xs, lonely_idxs)
ys = np.delete(ys, lonely_idxs)
if len(xs) <= 1:
print_dbg("==== Couldn't find enough marks in '_Imiddle.png'.")
continue
# Discovered marks must take up at least K*w_markfull space.
x_area = max(xs) - min(xs)
if x_area < (K * w_markfull):
print_dbg(
"==== Marks only took up {0}, too small space.".format(
x_area))
else:
theta_tm_ = estimate_rotation(xs, ys)
if abs(theta_tm_) > MAX_THETA:
print_dbg(
"==== Theta was too large: {0}".format(theta_tm_))
else:
theta_tm = theta_tm_
break
else:
print_dbg("==== Couldn't find any marks in '_Imiddle.png'.")
cv.SetImageROI(I, roi_prev)
return theta_tm
def threshold(self):
for x in range(0, self.size[0], 30):
for y in range(0, self.size[1], 30):
cv.SetImageROI(self.gray_img, (x, y, 30, 30))
cv.SetImageROI(self.bw_img, (x, y, 30, 30))
cv.Threshold(
self.gray_img, self.bw_img, 127, 255, cv.CV_THRESH_OTSU)
cv.ResetImageROI(self.gray_img)
cv.ResetImageROI(self.bw_img)
def red_eye(self):
self.load_cascade_file()
faces = [
face for face in self.context.request.focal_points
if face.origin == 'Face Detection'
]
if faces:
engine = self.context.modules.engine
mode, data = engine.image_data_as_rgb()
mode = mode.lower()
sz = engine.size
image = cv.CreateImageHeader(sz, cv.IPL_DEPTH_8U, 3)
cv.SetData(image, data)
for face in faces:
face_x = int(face.x - face.width / 2)
face_y = int(face.y - face.height / 2)
face_roi = (int(face_x), int(face_y), int(face.width),
int(face.height))
cv.SetImageROI(image, face_roi)
eyes = cv.HaarDetectObjects(image, self.cascade,
cv.CreateMemStorage(0), HAAR_SCALE,
MIN_NEIGHBORS, HAAR_FLAGS,
MIN_SIZE)
for (x, y, w, h), other in self.filter_eyes(eyes):
# Set the image Region of interest to be the eye area [this reduces processing time]
cv.SetImageROI(image, (face_x + x, face_y + y, w, h))
if self.context.request.debug:
cv.Rectangle(image, (0, 0), (w, h),
cv.RGB(255, 255, 255), 2, 8, 0)
for pixel in self.get_pixels(image, w, h, mode):
green_blue_avg = (pixel['g'] + pixel['b']) / 2
if not green_blue_avg:
red_intensity = RED_THRESHOLD
else:
# Calculate the intensity compared to blue and green average
red_intensity = pixel['r'] / green_blue_avg
# If the red intensity is greater than 2.0, lower the value
if red_intensity >= RED_THRESHOLD:
new_red_value = (pixel['g'] + pixel['b']) / 2
# Insert the new red value for the pixel to the image
cv.Set2D(
image, pixel['y'], pixel['x'],
cv.RGB(new_red_value, pixel['g'], pixel['b']))
# Reset the image region of interest back to full image
cv.ResetImageROI(image)
self.context.modules.engine.set_image_data(image.tostring())
def minmax_cv_v2(imgpaths,
Iref_imP=None,
do_align=False,
rszFac=1.0,
trfm_type='rigid',
minArea=np.power(2, 16),
bbs_map=None):
""" Computes the overlays of IMGPATHS, but uses the IREF_IMP as the
reference image to align against, if DO_ALIGN is True. Mainly a
function written for the parallel version (minmax_cv is still fine for
single-process use).
"""
bbs_map = {} if bbs_map == None else bbs_map
if do_align:
Iref = cv.LoadImage(Iref_imP, cv.CV_LOAD_IMAGE_GRAYSCALE)
bbRef = bbs_map.get(Iref_imP, None)
if bbRef:
coords = tuple(
map(int, (bbRef[0], bbRef[1], bbRef[2] - bbRef[0],
bbRef[3] - bbRef[1])))
cv.SetImageROI(Iref)
else:
Iref = None
# 0.) Prep first image
imgpath0 = imgpaths[0]
Imin = cv.LoadImage(imgpath0, cv.CV_LOAD_IMAGE_GRAYSCALE)
bb0 = bbs_map.get(imgpath0, None)
if bb0:
coords = tuple(
map(int, (bb0[0], bb0[1], bb0[2] - bb0[0], bb0[3] - bb0[1])))
cv.SetImageROI(Imin)
Imax = cv.CloneImage(Imin)
Iref_np = (iplimage2np(cv.CloneImage(Iref)) / 255.0) if do_align else None
for imgpath in imgpaths[1:]:
I = cv.LoadImage(imgpath, cv.CV_LOAD_IMAGE_GRAYSCALE)
bb = bbs_map.get(imgpath, None)
if bb:
bb = tuple(map(int, bb))
cv.SetImageROI(I, (bb[0], bb[1], bb[2] - bb[0], bb[3] - bb[1]))
Iout = matchsize(I, Imax)
if do_align:
tmp_np = iplimage2np(cv.CloneImage(Iout)) / 255.0
H, Ireg, err = imagesAlign(tmp_np,
Iref,
trfm_type=type,
fillval=0,
rszFac=rszFac,
minArea=minArea)
Ireg *= 255.0
Ireg = Ireg.astype('uint8')
Iout = np2iplimage(Ireg)
cv.Max(Iout, Imax, Imax)
cv.Min(Iout, Imin, Imin)
return Imin.tostring(), Imax.tostring(), cv.GetSize(Imin)
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 points_process_images(images,
roi,
cam_degree=30,
color=True,
color_images=[],
threshold=220,
intrinsics=None,
distortion=None):
"""
extract 3d pixels and colors from either left or right set of images
"""
angles = [
math.radians(i * (360.00 / len(images)))
for i in range(0, len(images))
]
points = []
xypoints = []
w, h = roi[2:4]
for i, path in enumerate(images):
img = cv.LoadImage(path)
if intrinsics and distortion:
source = cv.CloneImage(source_color)
cv.Undistort2(source, img, intrinsics, distortion)
cv.SetImageROI(img, roi)
xy = points_max_cols(img, threshold=threshold)
xyz = [
points_triangulate((x - (w / 2), y), angles[i], cam_degree)
for x, y in xy
]
if color:
color = cv.LoadImage(color_images[i])
if intrinsics and distortion:
source = cv.CloneImage(color)
cv.Undistort2(source, color, intrinsics, distortion)
cv.SetImageROI(color, roi)
colors = [list(color[y, x]) for x, y in xy]
[xyz[i].extend([r, g, b]) for i, (b, g, r) in enumerate(colors)]
else:
xyz = [[x, y, z, 1.0, 1.0, 1.0] for x, y, z in xyz]
points.extend(xyz)
return points
def is_backside(decodings, mark_locs, I, Izero):
""" Applies Sequoia-specific knowledge. A backside ballot side has
the following 'barcode' values (assume right-side-up):
UpperLeft: "0"
UpperRight: "" (Just a black bar)
LowerLeft: "0"
LowerRight: "0"
Note: This doesn't detect empty backsides. Assumes that the decoder
is 'good enough' such that it will not spuriously return "" or "0"
for an real front-side barcode.
Output:
bool isBack, bool isFlip
"""
if decodings[0] == "0" and decodings[1] == "":
# Possibly up-right backside.
return True, False
elif decodings[0] == "0" and decodings[1] == "0":
return True, True
# Try to handle if ballot is partially-cutoff.
_roi = cv.GetImageROI(I)
cv.ResetImageROI(I)
w_img, h_img = cv.GetSize(I)
w_fact, h_fact = 0.19, 0.13
w_patch, h_patch = int(round(w_img * w_fact)), int(round(h_img * h_fact))
if decodings[0] == "":
# LHS is possibly cut-off
cv.SetImageROI(I, (w_img - w_patch, h_img - h_patch, w_patch, h_patch))
x1, y1, score = tempmatch.bestmatch(
Izero, [I], do_smooth=tempmatch.SMOOTH_IMG_BRD)[0]
cv.SetImageROI(I, _roi)
if score >= 0.9:
return True, True if decodings[1] == "" else False
else:
# No idea! What? Definitely a strange case...
print "...Wow, this is unexpected!"
return False, None
elif decodings[1] == "" and decodings[0] == "0":
# RHS is possibly cut-off
cv.SetImageROI(I, (0, h_img - h_patch, w_patch, h_patch))
x1, y1, score = tempmatch.bestmatch(
Izero, [I], do_smooth=tempmatch.SMOOTH_IMG_BRD)[0]
cv.SetImageROI(I, _roi)
if score >= 0.9:
return True, False
else:
return True, True
return False, None
def merge_images(img1, img2, vertical=None):
w, h = sizeOf(img2)
new_size, second_roi = ((w * 2, h),
(w, 0, w,
h)) if h * 1.3 > w and not vertical else ((w,
h * 2),
(0, h,
w, h))
merged = cv.CreateImage(new_size, img1.depth, img1.channels)
cv.SetImageROI(merged, (0, 0, w, h))
cv.Copy(img1, merged)
cv.SetImageROI(merged, second_roi)
cv.Copy(img2, merged)
cv.ResetImageROI(merged)
return merged
def mean(img, x, y, size=10):
oldRoi = cv.GetImageROI(img)
#make sure roi is within image bounds
x = min(x, img.width - 1)
x = max(x, 0)
y = min(y, img.height - 1)
y = max(y, 0)
cv.SetImageROI(img, (x - size / 2, y - size / 2, size, size))
avg = cv.Avg(img)
cv.SetImageROI(img, oldRoi)
return (avg[0] + avg[1] + avg[2]) / 3.0
def pitch_detect(intrinsics, dist_coeffs, dst0):
capture = cv.CaptureFromCAM(0)
src = cv.QueryFrame(capture)
cv.SetImageROI(dst0, (0, 0, 640, 480))
cv.Undistort2(src, dst0, intrinsics, dist_coeffs)
cv.SetImageROI(dst0, image_ROI)
dst = GetImage(dst0)
hsv = cv.CreateImage(size, 8, 3)
CvtColor(dst, hsv, CV_RGB2HSV)
cv.Split(hsv, hue, sat, val, None)
hist = cv.CreateHist([32, 64], CV_HIST_ARRAY, [[0, 180], [0, 256]], 1)
cv.CalcHist([hue, sat], hist, 0, None)
values = cv.GetMinMaxHistValue(hist)
tweak = values[3][0]
return tweak
def acquire(self, img):
self.found_data = False
cv.SetImageROI(img, self.rect.ToCvRect())
self.internal_img = cv.CreateImage(cv.GetSize(img), img.depth,
img.nChannels)
cv.Copy(img, self.internal_img)
cv.ResetImageROI(img)
def getIris(frame):
iris = []
copyImg = cv.CloneImage(frame)
resImg = cv.CloneImage(frame)
grayImg = cv.CreateImage(cv.GetSize(frame), 8, 1)
mask = cv.CreateImage(cv.GetSize(frame), 8, 1)
storage = cv.CreateMat(frame.width, 1, cv.CV_32FC3)
cv.CvtColor(frame, grayImg, cv.CV_BGR2GRAY)
cv.Canny(grayImg, grayImg, 5, 70, 3)
cv.Smooth(grayImg, grayImg, cv.CV_GAUSSIAN, 7, 7)
circles = getCircles(grayImg)
iris.append(resImg)
for circle in circles:
rad = int(circle[0][2])
global radius
radius = rad
cv.Circle(mask, centroid, rad, cv.CV_RGB(255, 255, 255), cv.CV_FILLED)
cv.Not(mask, mask)
cv.Sub(frame, copyImg, resImg, mask)
x = int(centroid[0] - rad)
y = int(centroid[1] - rad)
w = int(rad * 2)
h = w
cv.SetImageROI(resImg, (x, y, w, h))
cropImg = cv.CreateImage((w, h), 8, 3)
cv.Copy(resImg, cropImg)
cv.ResetImageROI(resImg)
return (cropImg)
return (resImg)
def sample_frame(self, frame):
# Get an average of the green channel in on the forehead
cv.SetImageROI(frame, self.face_tracker.get_forehead())
sample = cv.Avg(frame)[1]
cv.ResetImageROI(frame)
return sample
def drawHistogram(self, image, chnum, hist_arr, plateaus):
positions = (0, (self.Ihist.height + 10), 2 * self.Ihist.height + 20)
colour_values = _blue, _green, _red
colour = colour_values[chnum]
Y = positions[chnum]
cv.Set(self.Ihist, _trans)
bin_w = cv.Round(float(self.Ihist.width) / self.hist_size)
# min_value, max_value, pmin, pmax = cv.GetMinMaxHistValue(hist)
X = image.width - self.Ihist.width
rect = (X, Y, self.Ihist.width, self.Ihist.height)
cv.SetImageROI(image, rect)
scaling = self.Ihist.height / max(hist_arr)
hist_arr *= scaling
for i, v in enumerate(hist_arr):
cv.Rectangle(self.Ihist, (i * bin_w, self.Ihist.height),
((i + 1) * bin_w, self.Ihist.height - round(v)),
colour, -1, 8, 0)
for i in plateaus[chnum]:
cv.Rectangle(
self.Ihist, (i * bin_w, self.Ihist.height),
((i + 1) * bin_w, self.Ihist.height - round(hist_arr[i])),
_white, -1, 8, 0)
cv.AddWeighted(image, 1 - self.hist_visibility, self.Ihist,
self.hist_visibility, 0.0, image)
cv.ResetImageROI(image)
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 do1Image(self, image, prevpoints):
#http://www.aishack.in/2010/07/tracking-colored-objects-in-opencv/
#http://nashruddin.com/OpenCV_Region_of_Interest_(ROI)
#http://opencv-users.1802565.n2.nabble.com/Python-cv-Moments-Need-Help-td6044177.html
#http://stackoverflow.com/questions/5132874/change-elements-in-a-cvseq-in-python
img = self.getThreshold(image)
points = []
for i in range(4):
cv.SetImageROI(img, (int(
self.RectanglePoints[i][0]), int(self.RectanglePoints[i][1]),
int(self.RectanglePoints[i][2]),
int(self.RectanglePoints[i][3])))
storage = cv.CreateMemStorage(0)
contours = cv.FindContours(img, storage)
moments = cv.Moments(contours)
moment10 = cv.GetSpatialMoment(moments, 1, 0)
moment01 = cv.GetSpatialMoment(moments, 0, 1)
area = cv.GetCentralMoment(moments, 0, 0)
cv.ResetImageROI(img)
if (area != 0):
x = self.RectanglePoints[i][0] + (moment10 / area)
y = self.RectanglePoints[i][1] + (moment01 / area)
else:
if (prevpoints[i][0] == 0):
x = self.RectanglePoints[i][0]
y = self.RectanglePoints[i][1]
else:
x = prevpoints[i][0]
y = prevpoints[i][1]
points.append([x, y])
return points
def rotacion_y_posicion_robot(self,robo_x=200,robo_y=100,robo_th=80): """ \brief graficar el robot en el lienzo de mapa \param self no se necesita incluirlo al utilizar la funcion ya que se lo pone solo por ser la definicion de una clase \param robo_x coordenada x de la odometria del robot \param robo_y coordenada y de la odometria del robot \param robo_th Valor Th del robot \return Nada """ image_mapa=cv.LoadImage(self.nombre_archivo1, cv.CV_LOAD_IMAGE_COLOR) dimensiones_robot=self.dimensiones_robot image1=cv.CreateImage(dimensiones_robot,8,3) image_mascara=cv.CreateImage(dimensiones_robot,8,1) ##rotacion #Rotar el robot src_center=dimensiones_robot[0]/2,dimensiones_robot[1]/2 rot_mat=cv.CreateMat( 2, 3, cv.CV_32FC1 ) cv.GetRotationMatrix2D(src_center, robo_th, 1.0,rot_mat); cv.WarpAffine(self.robot,image1,rot_mat) #crear filtro para negro cv.InRangeS(image1,cv.RGB(0,0,0),cv.RGB(14,14,14),image_mascara) cv.Not(image_mascara,image_mascara) #cv.ReleaseImage(image1) #reducir y posicion cv.SetImageROI(image_mapa,(robo_x,robo_y, dimensiones_robot[0], dimensiones_robot[1])); cv.Copy(image1,image_mapa,mask=image_mascara) cv.ResetImageROI(image_mapa); cv.SaveImage(self.nombre_archivo, image_mapa) #Saves the image#
def OverlayImage(img, img2, x, y):
'''overlay a 2nd image on a first image, at position x,y
on the first image'''
(w, h) = cv.GetSize(img2)
cv.SetImageROI(img, (x, y, w, h))
cv.Copy(img2, img)
cv.ResetImageROI(img)
def find_corner_in_full_scale(self,point):
point= self.m_d.scale_up(point)
scale = self.m_d.scale
self.m_d.set_scale(0)
gray_img = self.m_d.gray_img
canny_img = self.m_d.canny_img
x,y = point
cr = correct_rectangle((x-5,y-5,10,10), cv.GetSize(gray_img))
for img in [gray_img,canny_img]:
cv.SetImageROI(img, cr)
cv.Canny(gray_img, canny_img, 300, 500)
conts = cv.FindContours(canny_img, cv.CreateMemStorage(),
cv.CV_RETR_LIST,(cr[0],cr[1]))
db.DrawContours(self.m_d.tmp_img, conts, (255,255,255), (128,128,128), 10)
min =10
min_point = None
while conts:
for c in conts:
vec = vector(point,c)
len =length(vec)
if len<min:
min = len
min_point = c
conts.h_next()
self.m_d.set_scale(scale)
return min_point
