def merge(*channels):
debug = False
assert len(channels) > 0
firstDepth = channels[0].depth
assert all([channel.depth == firstDepth for channel in channels])
firstSize = cv.GetSize(channels[0])
assert all([cv.GetSize(channel) == firstSize for channel in channels])
chans = 3 if len(channels) == 2 else len(
channels
) #For filling up the 3rd chan when there are 2 imgs, add room for this 3rd channel
if debug: print "merging %i channels" % chans
out = cv.CreateImage(cv.GetSize(channels[0]), channels[0].depth, chans)
#print out
if len(channels) == 4:
cv.Merge(channels[0], channels[1], channels[2], channels[3], out)
elif len(channels) == 3:
cv.Merge(channels[0], channels[1], channels[2], None, out)
elif len(channels) == 2:
filler = cv.CreateImage(cv.GetSize(channels[0]), channels[0].depth, 1)
cv.Merge(channels[0], channels[1], filler, None,
out) #TODO: make pos of filler configable
elif len(channels) == 1:
cv.Merge(channels[0], None, None, None, out)
return out
def hist_eq(self, frame):
cv.Split(frame, self.B, self.G, self.R, None)
cv.EqualizeHist(self.R, self.R)
cv.EqualizeHist(self.R, self.B)
cv.EqualizeHist(self.G, self.G)
cv.Merge(self.B, self.G, self.R, None, self.Ieq)
return self.Ieq
def mask(self, mask, r, g, b):
cv.Mul(r, mask, self.thres_red_img)
cv.Mul(g, mask, self.thres_green_img)
cv.Mul(b, mask, self.thres_blue_img)
cv.Merge(self.thres_blue_img, self.thres_green_img, self.thres_red_img,
None, self.merged_frame)
return self.merged_frame
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 update_mhi(img, dst, diff_threshold):
global last
global mhi
global mask
timestamp = time.clock() / CLOCKS_PER_SEC # get current time in seconds
size = cv.GetSize(img) # get current frame size
idx1 = last
if not mhi or cv.GetSize(mhi) != size:
for i in range(N):
buf[i] = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1)
cv.Zero(buf[i])
mhi = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
cv.Zero(mhi) # clear MHI at the beginning
mask = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1)
cv.CvtColor(img, buf[last], cv.CV_BGR2GRAY) # convert frame to grayscale
idx2 = (last + 1) % N # index of (last - (N-1))th frame
last = idx2
silh = buf[idx2]
cv.AbsDiff(buf[idx1], buf[idx2], silh) # get difference between frames
cv.Threshold(silh, silh, diff_threshold, 1,
cv.CV_THRESH_BINARY) # and threshold it
cv.UpdateMotionHistory(silh, mhi, timestamp, MHI_DURATION) # update MHI
cv.CvtScale(mhi, mask, 255. / MHI_DURATION,
(MHI_DURATION - timestamp) * 255. / MHI_DURATION)
cv.Zero(dst)
cv.Merge(mask, None, None, None, dst)
def get_mask_with_contour(img,
ret_img=False,
ret_cont=False,
with_init_mask=False,
cont_color=cv.RGB(255, 50, 50),
normalize=True,
skin_version=1,
strong=False):
if normalize:
img = normalize_rgb(img, aggressive=0.005)
mask = skin_mask(img) if skin_version == 1 else skin_mask2(img)
di_mask = image_empty_clone(mask)
cv.Dilate(mask, di_mask)
seqs = cv.FindContours(cv.CloneImage(di_mask), memory(),
cv.CV_RETR_EXTERNAL)
c_img = image_empty_clone(mask)
cv.DrawContours(c_img, seqs, 255, 255, 10, -1)
er_img = image_empty_clone(c_img)
cv.Erode(c_img, er_img, iterations=2)
seqs = cv.FindContours(cv.CloneImage(er_img), memory(),
cv.CV_RETR_EXTERNAL)
if not seqs:
print "no areas"
return img, None
seqs = cv.ApproxPoly(seqs,
memory(),
cv.CV_POLY_APPROX_DP,
parameter=3,
parameter2=1)
result = []
if ret_img:
# er_seq_img = cv.CreateImage(sizeOf(er_img), 8, 3)
# cv.Zero(er_seq_img)
er_seq_img = cv.CloneImage(img)
if with_init_mask:
cv.Merge(mask, mask, mask, None, er_seq_img)
if strong:
cv.DrawContours(er_seq_img, seqs, cont_color, 0, 10, thickness=3)
cv.DrawContours(er_seq_img,
seqs,
cv.RGB(0, 0, 0),
0,
10,
thickness=1)
else:
cv.DrawContours(er_seq_img, seqs, cont_color, 0, 10, thickness=1)
result.append(er_seq_img)
if ret_cont:
result.append(seqs)
return result
def update_mhi(img, dst, diff_threshold):
global last
global mhi
global storage
global mask
global orient
global segmask
timestamp = time.clock() / CLOCKS_PER_SEC # get current time in seconds
size = cv.GetSize(img) # get current frame size
idx1 = last
if not mhi or cv.GetSize(mhi) != size:
for i in range(N):
buf[i] = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1)
cv.Zero(buf[i])
mhi = cv.CreateImage(size,cv. IPL_DEPTH_32F, 1)
cv.Zero(mhi) # clear MHI at the beginning
orient = cv.CreateImage(size,cv. IPL_DEPTH_32F, 1)
segmask = cv.CreateImage(size,cv. IPL_DEPTH_32F, 1)
mask = cv.CreateImage(size,cv. IPL_DEPTH_8U, 1)
cv.CvtColor(img, buf[last], cv.CV_BGR2GRAY) # convert frame to grayscale
idx2 = (last + 1) % N # index of (last - (N-1))th frame
last = idx2
silh = buf[idx2]
cv.AbsDiff(buf[idx1], buf[idx2], silh) # get difference between frames
cv.Threshold(silh, silh, diff_threshold, 1, cv.CV_THRESH_BINARY) # and threshold it
cv.UpdateMotionHistory(silh, mhi, timestamp, MHI_DURATION) # update MHI
cv.CvtScale(mhi, mask, 255./MHI_DURATION,
(MHI_DURATION - timestamp)*255./MHI_DURATION)
cv.Zero(dst)
cv.Merge(mask, None, None, None, dst)
cv.CalcMotionGradient(mhi, mask, orient, MAX_TIME_DELTA, MIN_TIME_DELTA, 3)
if not storage:
storage = cv.CreateMemStorage(0)
seq = cv.SegmentMotion(mhi, segmask, storage, timestamp, MAX_TIME_DELTA)
for (area, value, comp_rect) in seq:
if comp_rect[2] + comp_rect[3] > 100: # reject very small components
color = cv.CV_RGB(255, 0,0)
silh_roi = cv.GetSubRect(silh, comp_rect)
mhi_roi = cv.GetSubRect(mhi, comp_rect)
orient_roi = cv.GetSubRect(orient, comp_rect)
mask_roi = cv.GetSubRect(mask, comp_rect)
angle = 360 - cv.CalcGlobalOrientation(orient_roi, mask_roi, mhi_roi, timestamp, MHI_DURATION)
count = cv.Norm(silh_roi, None, cv.CV_L1, None) # calculate number of points within silhouette ROI
if count < (comp_rect[2] * comp_rect[3] * 0.05):
continue
magnitude = 30.
center = ((comp_rect[0] + comp_rect[2] / 2), (comp_rect[1] + comp_rect[3] / 2))
cv.Circle(dst, center, cv.Round(magnitude*1.2), color, 3, cv.CV_AA, 0)
cv.Line(dst,
center,
(cv.Round(center[0] + magnitude * cos(angle * cv.CV_PI / 180)),
cv.Round(center[1] - magnitude * sin(angle * cv.CV_PI / 180))),
color,
3,
cv.CV_AA,
0)
def image_callback(data):
global running
if (running):
image = bridge.imgmsg_to_cv(data, "bgr8")
#normalize image
cv.Split(image, rgb_r, rgb_g, rgb_b, None)
red_mean = cv2.mean(np.asarray(rgb_r[:, :]))
cv.Div(src2=cv.fromarray(np.ones((480, 640))),
src1=rgb_r,
dst=scaled_r,
scale=128 / red_mean[0])
green_mean = cv2.mean(np.asarray(rgb_g[:, :]))
cv.Div(src2=cv.fromarray(np.ones((480, 640))),
src1=rgb_g,
dst=scaled_g,
scale=128 / green_mean[0])
blue_mean = cv2.mean(np.asarray(rgb_b[:, :]))
cv.Div(src2=cv.fromarray(np.ones((480, 640))),
src1=rgb_b,
dst=scaled_b,
scale=128 / blue_mean[0])
cv.Merge(scaled_r, scaled_g, scaled_b, None, cv_image)
cv.CvtColor(cv_image, hsv, cv.CV_BGR2HSV) # --convert from BGR to HSV
cv.CvtColor(cv_image, lab, cv.CV_BGR2Lab)
cv.Split(hsv, hsv_h, hsv_s, hsv_v, None)
cv.Split(cv_image, rgb_r, rgb_g, rgb_b, None)
cv.Split(lab, lab_l, lab_a, lab_b, None)
cv.Split(luv, luv_l, luv_u, luv_v, None)
cv.Split(hls, hls_h, hls_l, hls_s, None)
cv.Split(xyz, xyz_x, xyz_y, xyz_x, None)
cv.Split(ycrcb, ycrcb_y, ycrcb_cr, ycrcb_cb, None)
cv.Not(lab_a, a_not)
cv.Sub(hsv_s, a_not, sa)
cv.Sub(luv_u, hls_h, test)
cv.Sub(hls_s, hls_h, sminh)
threshold_red(sa)
cv.ShowImage("red", red_dilated_image)
red_contours, _ = cv2.findContours(image=np.asarray(
red_dilated_image[:, :]),
mode=cv.CV_RETR_EXTERNAL,
method=cv.CV_CHAIN_APPROX_SIMPLE)
print_lidar_projections(cv_image)
circles = extract_circles(red_contours, [1, 0, 0])
for x, y, radius in circles:
cv.Circle(cv_image, (x, y), radius, [0, 0, 1], 3)
cv.SetMouseCallback("camera feed", mouse_callback, hsv_image)
cv.ShowImage("camera feed", cv_image)
cv.WaitKey(3)
def scanline_numbers_to_planes(self, scanline_numbers):
rows = scanline_numbers.height
cols = scanline_numbers.width
normal_vectors_x = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Set(normal_vectors_x, -1)
normal_vectors_y = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Set(normal_vectors_y, 0)
normal_vectors_z = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Copy(scanline_numbers, normal_vectors_z)
cv.ConvertScale(normal_vectors_z,
normal_vectors_z,
scale=self.pixels_per_scanline)
cv.AddS(normal_vectors_z, -self.center_pixel, normal_vectors_z)
cv.ConvertScale(normal_vectors_z,
normal_vectors_z,
scale=1.0 / self.projector_model.fx())
normal_vectors = cv.CreateMat(rows, cols, cv.CV_32FC3)
cv.Merge(normal_vectors_x, normal_vectors_y, normal_vectors_z, None,
normal_vectors)
# Bring the normal vectors into camera coordinates
cv.Transform(normal_vectors, normal_vectors,
self.projector_to_camera_rotation_matrix)
normal_vectors_split = [None] * 3
for i in range(3):
normal_vectors_split[i] = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Split(normal_vectors, normal_vectors_split[0],
normal_vectors_split[1], normal_vectors_split[2], None)
n_dot_p = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.SetZero(n_dot_p)
for i in range(3):
cv.ScaleAdd(normal_vectors_split[i],
self.projector_to_camera_translation_vector[i],
n_dot_p, n_dot_p)
planes = cv.CreateMat(rows, cols, cv.CV_32FC4)
cv.Merge(normal_vectors_split[0], normal_vectors_split[1],
normal_vectors_split[2], n_dot_p, planes)
return planes
def anaglyph(left_color, right_color):
left_mono = cv.CreateImage(cv.GetSize(left_color), cv.IPL_DEPTH_8U, 1)
right_mono = cv.CreateImage(cv.GetSize(right_color), cv.IPL_DEPTH_8U, 1)
green = cv.CreateImage(cv.GetSize(right_color), cv.IPL_DEPTH_8U, 1)
result = cv.CreateImage(cv.GetSize(right_color), cv.IPL_DEPTH_8U, 3)
cv.CvtColor(left_color, left_mono, cv.CV_RGB2GRAY)
cv.CvtColor(right_color, right_mono, cv.CV_RGB2GRAY)
cv.Merge(left_mono, green, right_mono, None, result)
return result
def get_pixel_associations(self):
col_associations = self.get_projector_line_associations(0)
row_associations = self.get_projector_line_associations(1)
rospy.loginfo("Merging data...")
pixel_associations = cv.CreateMat(self.camera_info.height,
self.camera_info.width, cv.CV_32SC2)
cv.Merge(col_associations, row_associations, None, None,
pixel_associations)
return pixel_associations
def run(self):
while True:
img = cv.QueryFrame( self.capture )
#blur the source image to reduce color noise
cv.Smooth(img, img, cv.CV_BLUR, 3);
#convert the image to hsv(Hue, Saturation, Value) so its
#easier to determine the color to track(hue)
hsv_img = cv.CreateImage(cv.GetSize(img), 8, 3)
cv.CvtColor(img, hsv_img, cv.CV_BGR2HSV)
#limit all pixels that don't match our criteria, in this case we are
#looking for purple but if you want you can adjust the first value in
#both turples which is the hue range(120,140). OpenCV uses 0-180 as
#a hue range for the HSV color model
thresholded_img = cv.CreateImage(cv.GetSize(hsv_img), 8, 1)
cv.InRangeS(hsv_img, (115, 75, 75), (135, 255, 255), thresholded_img)
#determine the objects moments and check that the area is large
#enough to be our object
thresholded_img2 = cv.GetMat(thresholded_img)
moments = cv.Moments(thresholded_img2,0)
area = cv.GetCentralMoment(moments, 0, 0)
#there can be noise in the video so ignore objects with small areas
if(area > 100000):
#determine the x and y coordinates of the center of the object
#we are tracking by dividing the 1, 0 and 0, 1 moments by the area
x = cv.GetSpatialMoment(moments, 1, 0)/area
y = cv.GetSpatialMoment(moments, 0, 1)/area
# print 'x: ' + str(x) + ' y: ' + str(y) + ' area: ' + str(area)
x = int(x)
y = int(y)
#create an overlay to mark the center of the tracked object
overlay = cv.CreateImage(cv.GetSize(img), 8, 3)
cv.Circle(overlay, (x, y), 2, (255, 255, 255), 20)
cv.Add(img, overlay, img)
#add the thresholded image back to the img so we can see what was
#left after it was applied
cv.Merge(thresholded_img, None, None, None, img)
#display the image
cv.ShowImage(color_tracker_window, img)
if cv.WaitKey(10) == 27:
break
def process_motion(self,img):
center = (-1, -1)
# a lot of stuff from this section was taken from the code motempl.py,
# openCV's python sample code
timestamp = time.clock() / self.clocks_per_sec # get current time in seconds
idx1 = self.last
cv.CvtColor(img, self.buf[self.last], cv.CV_BGR2GRAY) # convert frame to grayscale
idx2 = (self.last + 1) % self.n_frames
self.last = idx2
silh = self.buf[idx2]
cv.AbsDiff(self.buf[idx1], self.buf[idx2], silh) # get difference between frames
cv.Threshold(silh, silh, 30, 1, cv.CV_THRESH_BINARY) # and threshold it
cv.UpdateMotionHistory(silh, self.mhi, timestamp, self.mhi_duration) # update MHI
cv.ConvertScale(self.mhi, self.mask, 255./self.mhi_duration,
(self.mhi_duration - timestamp)*255./self.mhi_duration)
cv.SetZero(img)
cv.Merge(self.mask, None, None, None, img)
cv.CalcMotionGradient(self.mhi, self.mask, self.orient, self.max_time_delta, self.min_time_delta, 3)
seq = cv.SegmentMotion(self.mhi, self.segmask, self.storage, timestamp, self.max_time_delta)
inc = 0
a_max = 0
max_rect = -1
# there are lots of things moving around
# in this case just find find the biggest change on the image
for (area, value, comp_rect) in seq:
if comp_rect[2] + comp_rect[3] > 60: # reject small changes
if area > a_max:
a_max = area
max_rect = inc
inc += 1
# found it, now just do some processing on the area.
if max_rect != -1:
(area, value, comp_rect) = seq[max_rect]
color = cv.CV_RGB(255, 0,0)
silh_roi = cv.GetSubRect(silh, comp_rect)
# calculate number of points within silhouette ROI
count = cv.Norm(silh_roi, None, cv.CV_L1, None)
# this rectangle contains the overall motion ROI
cv.Rectangle(self.motion, (comp_rect[0], comp_rect[1]),
(comp_rect[0] + comp_rect[2],
comp_rect[1] + comp_rect[3]), (0,0,255), 1)
# the goal is to report back a center of movement contained in a rectangle
# adjust the height based on the number generated by the slider bar
h = int(comp_rect[1] + (comp_rect[3] * (float(self.height_value) / 100)))
# then calculate the center
center = ((comp_rect[0] + comp_rect[2] / 2), h)
return center
def add_alpha_channel(bgr, alpha_val):
w, h = cv.GetSize(bgr)
bgra = cv.CreateImage((w, h), cv.IPL_DEPTH_8U, 4)
alpha = cv.CreateImage((w, h), cv.IPL_DEPTH_8U, 1)
chan1 = cv.CreateImage((w, h), cv.IPL_DEPTH_8U, 1)
chan2 = cv.CreateImage((w, h), cv.IPL_DEPTH_8U, 1)
chan3 = cv.CreateImage((w, h), cv.IPL_DEPTH_8U, 1)
[cv.Set(c, 0) for c in [chan1, chan2, chan3, bgra, alpha]]
cv.Split(bgr, chan1, chan2, chan3, None)
cv.Set(alpha, (alpha_val))
cv.Merge(chan1, chan2, chan3, alpha, bgra)
return bgra
def merge_images(img0, img1, img2):
""" takes images in bgr order """
images = profile.evaluate(lambda: load_images([img0, img1, img2]),
"Image loading")
for i in images:
assert i.depth == cv.IPL_DEPTH_8U
images = profile.evaluate(lambda: resize(images), "Image resizing")
mergedImage = cv.CreateImage(min_size(images), cv.IPL_DEPTH_8U, 3)
profile.evaluate(
lambda: cv.Merge(images[0], images[1], images[2], None, mergedImage),
"Image merging")
return mergedImage
def remove_channels(in_bgra, channel_indices):
w, h = cv.GetSize(in_bgra)
chan1 = cv.CreateImage((w, h), cv.IPL_DEPTH_8U, 1)
chan2 = cv.CreateImage((w, h), cv.IPL_DEPTH_8U, 1)
chan3 = cv.CreateImage((w, h), cv.IPL_DEPTH_8U, 1)
chan4 = cv.CreateImage((w, h), cv.IPL_DEPTH_8U, 1)
bgra = cv.CreateImage((w, h), cv.IPL_DEPTH_8U, 4)
[cv.Set(c, 0) for c in [chan1, chan2, chan3, chan4, bgra]]
cv.Split(in_bgra, chan1, chan2, chan3, chan4)
chan_list = [chan1, chan2, chan3, chan4]
for i in channel_indices:
chan_list[i] = None
chan_list.append(bgra)
cv.Merge(*tuple(chan_list))
return bgra
def doCanny_3(im, low, high, aperture, out=None):
in1 = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_8U, 1)
in2 = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_8U, 1)
in3 = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_8U, 1)
cv.Split(im, in1, in2, in3, None)
out1 = canny(in1, low, high, aperture)
out2 = canny(in2, low, high, aperture)
out3 = canny(in3, low, high, aperture)
if not out: out = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_8U, 3)
cv.Merge(out1, out2, out3, None, out)
return out
def clone(src, _type='gray2bgr'):
"""
Clone the image.
@param _type: a string, and it can be one of the following:
"gray2bgr"
@returns: the cloned image
"""
if _type.lower() == "gray2bgr":
ret = cv.CreateImage((src.width, src.height), cv.IPL_DEPTH_8U, 3)
r = cv.CloneImage(src)
g = cv.CloneImage(src)
b = cv.CloneImage(src)
cv.Merge(r, g, b, None, ret)
return ret
else:
raise ValueError("Unknown _type value.")
def process_image(self, image, texture_type):
spare = image
#return image
# get the size of the current image
size = (image.width, image.height)
cv.Smooth(spare, spare, cv.CV_GAUSSIAN, BLUR_SIZE, BLUR_SIZE)
#out = cv.CreateImage( size, 8, 1)
cannyB = cv.CreateImage(size, 8, 1)
cannyR = cv.CreateImage(size, 8, 1)
sobel = cv.CreateImage(size, 8, 1)
yuv = cv.CreateImage(size, 8, 3)
dest_canny = cv.CreateImage(size, 8, 3)
gray = cv.CreateImage(size, 8, 1)
cv.CvtColor(spare, yuv, cv.CV_BGR2YCrCb)
cv.Split(yuv, gray, None, None, None)
cv.Canny(gray, cannyB, 5, 50, 3)
cv.Canny(gray, cannyR, 5, 150, 3)
cv.Sobel(gray, sobel, 1, 0, 3)
#cv.ConvertScale(sobel, sobel, -1, 255 )
#cv.ConvertScale(cannyR, cannyR, -1, 155 )
#cv.ConvertScale(gray, gray, -1, 255 )
#cv.ConvertScale(cannyB, cannyB, -1, 255 )
cv.Smooth(cannyR, cannyR, cv.CV_GAUSSIAN, 3, 3)
cv.Smooth(cannyB, cannyB, cv.CV_GAUSSIAN, 3, 3)
#cv.CvtColor( canny, canny, cv.CV_YCrCb2BGR )
#cv.Merge(sobel, gray, sobel, None, dest)
cv.Merge(cannyR, cannyB, gray, None, dest_canny)
#cv.Merge(sobel, sobel, sobel, None, dest_sobel)
#cv.Smooth( dest, dest, cv.CV_GAUSSIAN, BLUR_SIZE, BLUR_SIZE )
#cv.ShowImage( 'canny', dest)
#cv.Merge
#cv.Smooth( dest_canny, dest_canny, cv.CV_GAUSSIAN, BLUR_SIZE, BLUR_SIZE )
#success = True
self.prevImage = image
options = {'normal': dest_canny, 'post': dest_canny}
#return yuv
return options[texture_type]
def combine_images(self, images):
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1.4, 1.4, 0, 2, 8)
for i,(image, name) in enumerate(images):
if image.nChannels == 1:
cv.Merge(image, image, image, None, self.temp)
else:
cv.Copy(image, self.temp)
xoffset = (i % self.xwindows) * self.smallsize[0]
yoffset = (i / self.xwindows) * self.smallsize[1]
cv.SetImageROI(self.combined, (xoffset, yoffset, self.smallsize[0],
self.smallsize[1]))
cv.Copy(self.temp, self.combined)
cv.PutText(self.combined, name, (5, 40), font, (30, 200, 200))
cv.ResetImageROI(self.combined)
return self.combined
def run_tesseract(image):
if not tesseract_api.Init(tessdata_prefix, 'eng', tesseract.OEM_DEFAULT):
print >> sys.stderr, "Error initializing tesseract"
exit(1)
tesseract_api.SetPageSegMode(tesseract.PSM_SINGLE_LINE)
# api.SetPageSegMode(tesseract.PSM_AUTO)
# cvimg = cv2.imread('test.png')
# tesseract_api.SetImage(cvimg)
# return "123", np.array([60])
source = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_8U, 3)
cv.Merge(image, image, image, None, source)
tesseract_api.SetImage(cv2num(source))
text = tesseract_api.GetUTF8Text()
text = text.encode('ascii', 'ignore').strip()
score = np.array(tesseract_api.AllWordConfidences())
tesseract_api.Clear()
return text, score
def saturate(frame):
cv.CvtColor(frame, frame, cv.CV_BGR2HSV)
hue = cv.CreateImage(cv.GetSize(frame), 8, 1)
sat = cv.CreateImage(cv.GetSize(frame), 8, 1)
val = cv.CreateImage(cv.GetSize(frame), 8, 1)
cv.Split(frame, hue, sat, val, None)
for y in range(0, frame.height):
for x in range(0, frame.width):
saturation = cv.GetReal2D(sat, y, x)
if (saturation < 200):
saturation = saturation + 50
cv.SetReal2D(sat, y, x, saturation)
cv.Merge(hue, sat, val, None, frame)
del hue
del sat
del val
cv.CvtColor(frame, frame, cv.CV_HSV2BGR)
return (frame)
def hsv_normalise(self, frame):
"""Should normalise scene lighting
Works by setting the HSV Value component to a constant.
However, turns out that this does not adequately remove shadows.
Maybe parameter tweaking the Value constant might do something? TODO
"""
tmp = cv.CreateImage(cv.GetSize(frame), 8, 3)
cv.CvtColor(frame, tmp, cv.CV_BGR2HSV)
H, S, V = [cv.CreateImage(cv.GetSize(frame), 8, 1) for _ in range(3)]
cv.Split(tmp, H, S, V, None)
cv.Set(V, 140)
cv.Merge(H, S, V, None, tmp)
cv.CvtColor(tmp, tmp, cv.CV_HSV2BGR),
out = tmp
return out
def project_pixels_to_3d_rays(pixels, model):
x = cv.CreateMat(pixels.height, pixels.width, cv.CV_32FC1)
y = cv.CreateMat(pixels.height, pixels.width, cv.CV_32FC1)
cv.Split(pixels, x, y, None, None)
x_squared = cv.CreateMat(pixels.height, pixels.width, cv.CV_32FC1)
cv.Pow(x, x_squared, 2)
y_squared = cv.CreateMat(pixels.height, pixels.width, cv.CV_32FC1)
cv.Pow(y, y_squared, 2)
inverse_norm = cv.CreateMat(pixels.height, pixels.width, cv.CV_32FC1)
cv.Add(x_squared, y_squared, inverse_norm)
cv.AddS(inverse_norm, 1, inverse_norm)
cv.Pow(inverse_norm, inverse_norm, -0.5)
cv.Mul(x, inverse_norm, x)
cv.Mul(y, inverse_norm, y)
result = cv.CreateMat(pixels.height, pixels.width, cv.CV_32FC3)
cv.Merge(x, y, inverse_norm, None, result)
return result
def combine_images(self, images):
""" render a list of images into one opencv frame """
comb_width = self.smallwidth * XWINDOWS
comb_height = self.smallheight * int(
math.ceil(len(images) / float(XWINDOWS)))
print '%d %d' % (comb_height, self.smallheight)
self.combined = cv.CreateImage((comb_width, comb_height),
cv.IPL_DEPTH_8U, 3)
for i, image in enumerate(images):
if image.nChannels == 1:
cv.Merge(image, image, image, None, self.temp3)
else:
cv.Copy(image, self.temp3)
xoffset = (i % XWINDOWS) * self.smallsize[0]
yoffset = (i / XWINDOWS) * self.smallsize[1]
cv.SetImageROI(
self.combined,
(xoffset, yoffset, self.smallsize[0], self.smallsize[1]))
cv.Copy(self.temp3, self.combined)
cv.ResetImageROI(self.combined)
return self.combined
def track_blobs(self, frame):
spare = cv.CloneImage(frame)
size = cv.GetSize(frame)
hsv = cv.CreateImage(size, cv.IPL_DEPTH_8U, 3)
out = cv.CreateImage(size, cv.IPL_DEPTH_8U, 3)
thresh = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1)
print self.min_hue, self.value_dict['min_hue']
cv.Smooth(spare, spare, cv.CV_BLUR, 22, 22)
cv.CvtColor(spare, hsv, cv.CV_BGR2HSV)
cv.InRangeS(hsv, cv.Scalar(self.min_hue, self.min_sat, self.min_val),
cv.Scalar(self.max_hue, self.max_sat, self.max_val),
thresh)
cv.Merge(thresh, thresh, thresh, None, out)
contours = cv.FindContours(thresh, self.storage, cv.CV_RETR_LIST,
cv.CV_CHAIN_APPROX_SIMPLE)
try:
M = cv.Moments(contours)
except:
return out
m0 = cv.GetCentralMoment(M, 0, 0)
if m0 > 1.0:
self.cx = cv.GetSpatialMoment(M, 1, 0) / m0
self.cy = cv.GetSpatialMoment(M, 0, 1) / m0
cv.Circle(frame, (int(self.cx), int(self.cy)), 2, (255, 0, 0), 20)
if self.show_frame is not True:
return out
else:
return frame
pass
def normalizeImage(frame):
redChannel = cv.CreateImage(cv.GetSize(frame), 8, 1)
greenChannel = cv.CreateImage(cv.GetSize(frame), 8, 1)
blueChannel = cv.CreateImage(cv.GetSize(frame), 8, 1)
redAvg = cv.CreateImage(cv.GetSize(frame), 8, 1)
greenAvg = cv.CreateImage(cv.GetSize(frame), 8, 1)
blueAvg = cv.CreateImage(cv.GetSize(frame), 8, 1)
resImg = cv.CreateImage(cv.GetSize(frame), 8, 3)
cv.Split(frame, blueChannel, greenChannel, redChannel, None)
hsvImg = cv.CreateImage(cv.GetSize(frame), 8, 3)
cv.CvtColor(frame, hsvImg, cv.CV_BGR2HSV)
hueChannel = cv.CreateImage(cv.GetSize(frame), 8, 1)
satChannel = cv.CreateImage(cv.GetSize(frame), 8, 1)
valChannel = cv.CreateImage(cv.GetSize(frame), 8, 1)
cv.Split(hsvImg, hueChannel, satChannel, valChannel, None)
for y in range(0, frame.height):
for x in range(0, frame.width):
redValue = cv.GetReal2D(redChannel, y, x)
greenValue = cv.GetReal2D(greenChannel, y, x)
blueValue = cv.GetReal2D(blueChannel, y, x)
sum = redValue + greenValue + blueValue + 0.0
if (sum < 1.0):
sum = 1.0
cv.SetReal2D(redAvg, y, x, redValue / sum * 255)
cv.SetReal2D(greenAvg, y, x, greenValue / sum * 255)
cv.SetReal2D(blueAvg, y, x, blueValue / sum * 255)
cv.Merge(blueAvg, greenAvg, redAvg, None, resImg)
del redChannel
del greenChannel
del blueChannel
del redAvg
del greenAvg
del blueAvg
return (resImg)
def combine_images(self, images):
""" render a list of images into one opencv frame """
comb_width = self.smallwidth * XWINDOWS
comb_height = self.smallheight * int(
math.ceil(len(images) / float(XWINDOWS)))
self.combined = cv.CreateImage((comb_width, comb_height),
cv.IPL_DEPTH_8U, 3)
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 0.3, 0.3)
for i, (image, name) in enumerate(images):
if image.nChannels == 1:
cv.Merge(image, image, image, None, self.temp)
else:
cv.Copy(image, self.temp)
xoffset = (i % XWINDOWS) * self.smallsize[0]
yoffset = (i / XWINDOWS) * self.smallsize[1]
cv.SetImageROI(
self.combined,
(xoffset, yoffset, self.smallsize[0], self.smallsize[1]))
cv.Copy(self.temp, self.combined)
cv.PutText(self.combined, name, (5, 10), font, (30, 200, 200))
cv.ResetImageROI(self.combined)
return self.combined
def ray_plane_intersections(rays, planes):
rows = rays.height
cols = rays.width
rays_split = [None] * 3
for i in range(3):
rays_split[i] = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Split(rays, rays_split[0], rays_split[1], rays_split[2], None)
planes_split = [None] * 4
for i in range(4):
planes_split[i] = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Split(planes, planes_split[0], planes_split[1], planes_split[2],
planes_split[3])
n_dot_v = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.SetZero(n_dot_v)
for i in range(3):
temp = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Mul(planes_split[i], rays_split[i], temp)
cv.Add(temp, n_dot_v, n_dot_v)
depth = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Div(planes_split[3], n_dot_v, depth)
intersection_points_split = [None] * 3
for i in range(3):
intersection_points_split[i] = cv.CreateMat(rows, cols, cv.CV_32FC1)
for i in range(3):
cv.Mul(depth, rays_split[i], intersection_points_split[i])
intersection_points = cv.CreateMat(rows, cols, cv.CV_32FC3)
cv.Merge(intersection_points_split[0], intersection_points_split[1],
intersection_points_split[2], None, intersection_points)
return intersection_points
def capture(self):
blank = self.get_picture_of_projection(self.blank_projection)
positive = self.get_picture_of_projection(
self.positive_chessboard_projection)
negative = self.get_picture_of_projection(
self.negative_chessboard_projection)
difference = cv.CreateMat(self.camera_info.height,
self.camera_info.width, cv.CV_8UC1)
cv.Sub(positive, negative, difference)
cv.NamedWindow("blank", flags=0)
cv.ShowImage("blank", blank)
cv.WaitKey(300)
cv.NamedWindow("difference", flags=0)
cv.ShowImage("difference", difference)
cv.WaitKey(300)
camera_image_points, camera_object_points = detect_chessboard(
blank, self.printed_chessboard_corners_x,
self.printed_chessboard_corners_y, self.printed_chessboard_spacing,
self.printed_chessboard_spacing)
if camera_image_points is None:
return False
cv.UndistortPoints(camera_image_points, camera_image_points,
self.camera_model.intrinsicMatrix(),
self.camera_model.distortionCoeffs())
homography = cv.CreateMat(3, 3, cv.CV_32FC1)
cv.FindHomography(camera_image_points, camera_object_points,
homography)
object_points, dummy = detect_chessboard(
difference, self.projected_chessboard_corners_x,
self.projected_chessboard_corners_y, None, None)
if object_points is None:
return False
cv.UndistortPoints(object_points, object_points,
self.camera_model.intrinsicMatrix(),
self.camera_model.distortionCoeffs())
cv.PerspectiveTransform(object_points, object_points, homography)
object_points_3d = cv.CreateMat(
1, self.projected_chessboard_corners_x *
self.projected_chessboard_corners_y, cv.CV_32FC3)
x = cv.CreateMat(
1, self.projected_chessboard_corners_x *
self.projected_chessboard_corners_y, cv.CV_32FC1)
y = cv.CreateMat(
1, self.projected_chessboard_corners_x *
self.projected_chessboard_corners_y, cv.CV_32FC1)
cv.Split(object_points, x, y, None, None)
z = cv.CreateMat(
1, self.projected_chessboard_corners_x *
self.projected_chessboard_corners_y, cv.CV_32FC1)
cv.SetZero(z)
cv.Merge(x, y, z, None, object_points_3d)
self.object_points.append(object_points_3d)
self.image_points.append(self.get_scene_image_points())
self.number_of_scenes += 1
return True
