def hsv_orange_red_threshold(input_image):
blur_image = cv.CreateMat(input_image.rows, input_image.cols, cv.CV_8UC3)
cv.Smooth(input_image, blur_image, cv.CV_BLUR, 10, 10)
proc_image = cv.CreateMat(input_image.rows, input_image.cols, cv.CV_8UC3)
cv.CvtColor(blur_image, proc_image, cv.CV_BGR2HSV)
split_image = [
cv.CreateMat(input_image.rows, input_image.cols, cv.CV_8UC1),
cv.CreateMat(input_image.rows, input_image.cols, cv.CV_8UC1),
cv.CreateMat(input_image.rows, input_image.cols, cv.CV_8UC1)
]
cv.Split(proc_image, split_image[0], split_image[1], split_image[2], None)
thresh_0 = cv.CreateMat(input_image.rows, input_image.cols, cv.CV_8UC1)
thresh_1 = cv.CreateMat(input_image.rows, input_image.cols, cv.CV_8UC1)
thresh_2 = cv.CreateMat(input_image.rows, input_image.cols, cv.CV_8UC1)
red_orange = cv.CreateMat(input_image.rows, input_image.cols, cv.CV_8UC1)
cv.Threshold(split_image[1], thresh_0, 128, 255,
cv.CV_THRESH_BINARY) # > 50% saturation
cv.Threshold(split_image[0], thresh_1, 220, 255,
cv.CV_THRESH_BINARY) # > Purple
cv.Threshold(split_image[0], thresh_2, 10, 255,
cv.CV_THRESH_BINARY_INV) # < Yellow-Orange
cv.Add(thresh_1, thresh_2, red_orange)
cv.And(red_orange, thresh_0, red_orange)
return red_orange
def main(args):
if args.output_directory:
directory = args.output_directory
else:
directory = os.path.dirname(args.input_image)
print "No output directory specified. Defaulting to %s" % directory
if not os.path.exists(directory):
os.makedirs(directory)
if args.output_prefix:
prefix = args.output_prefix
extension = os.path.splitext(os.path.basename(args.input_image))[1]
else:
prefix, extension = os.path.splitext(os.path.basename(
args.input_image))
print "No output prefix selected. Defaulting to %s" % prefix
output_file = "%s/%s%s" % (directory, prefix, extension)
image = cv.LoadImage(args.input_image)
input_image = cv.LoadImage(args.input_image)
mask = cv.CreateImage(cv.GetSize(input_image), 8, 1)
image_hue = cv.CreateImage(cv.GetSize(input_image), 8, 1)
image_hsv = cv.CreateImage(cv.GetSize(input_image), 8, 3)
cv.CvtColor(input_image, image_hsv, cv.CV_BGR2HSV)
cv.Split(image_hsv, image_hue, None, None, None)
upper_thresh = cv.CreateImage(cv.GetSize(input_image), 8, 1)
lower_thresh = cv.CreateImage(cv.GetSize(input_image), 8, 1)
cv.Threshold(image_hue, upper_thresh, args.hue_max, 255,
cv.CV_THRESH_BINARY)
cv.Threshold(image_hue, lower_thresh, args.hue_min, 255,
cv.CV_THRESH_BINARY_INV)
cv.Or(upper_thresh, lower_thresh, mask)
cv.SaveImage(output_file, mask)
def createMask(image, thresh):
b, g, r = doSplit(image)
cv.Threshold(b, b, thresh, 255, cv.CV_THRESH_BINARY)
cv.Threshold(g, g, thresh, 255, cv.CV_THRESH_BINARY)
cv.Threshold(r, r, thresh, 255, cv.CV_THRESH_BINARY)
cv.And(b, g, b, None)
cv.And(b, r, b, None)
return b
def count(img, upper_thresh, lower_thresh): img = cv.LoadImage(img, 0) assert img.depth == cv.IPL_DEPTH_8U cv.Threshold(img, img, upper_thresh, 0, cv.CV_THRESH_TOZERO_INV) cv.Threshold(img, img, lower_thresh, 0, cv.CV_THRESH_TOZERO) return cv.CountNonZero(img)
def removeLightColors(image):
b = cv.CreateImage(cv.GetSize(image), image.depth, 1)
g = cv.CreateImage(cv.GetSize(image), image.depth, 1)
r = cv.CreateImage(cv.GetSize(image), image.depth, 1)
cv.Split(image, b, g, r, None)
cv.Threshold(b, b, 154, 255, cv.CV_THRESH_BINARY)
cv.Threshold(g, g, 154, 255, cv.CV_THRESH_BINARY)
cv.Threshold(r, r, 154, 255, cv.CV_THRESH_BINARY)
cv.Or(b, g, b)
cv.Or(b, r, b)
cv.Set(image, cv.ScalarAll(255), b)
return image
def get_diff(old, new):
""" Returns the difference between two BGR images.
"""
size = cv.GetSize(old)
diff = cv.CreateImage(size, 8, 1)
old_grayscale = cv.CreateImage(size, 8, 1)
new_grayscale = cv.CreateImage(size, 8, 1)
cv.CvtColor(old, old_grayscale, cv.CV_BGR2GRAY)
cv.CvtColor(new, new_grayscale, cv.CV_BGR2GRAY)
cv.AbsDiff(old_grayscale, new_grayscale, diff)
cv.Smooth(diff, diff, smoothtype=cv.CV_GAUSSIAN, param1=3, param2=3)
cv.Threshold(diff, diff, 16, 255, cv.CV_THRESH_BINARY)
cv.Smooth(diff, diff, smoothtype=cv.CV_GAUSSIAN, param1=13, param2=13)
cv.Threshold(diff, diff, 200, 255, cv.CV_THRESH_BINARY)
return diff
def showThresholdedImage(src,
dst,
Threshold,
show=True,
method=cv.CV_THRESH_BINARY):
n = src.nChannels
m = Threshold
if (n > 1):
src2 = cv.CreateImage((src.width, src.height), src.depth, 1)
cv.ConvertImage(src, src2, cv.CV_BGR2GRAY)
else:
src2 = src
cv.Threshold(src2, dst, m, 255, method)
i = 0
if (show):
cv.NamedWindow("Original", 1)
cv.NamedWindow("Thresholded", 1)
while (i < 6000):
cv.ShowImage("Original", src2)
cv.ShowImage("Thresholded", dst)
cv.WaitKey(300)
i = i + 1
return
def clearNoise(image, tLetter=64, rBright=30):
if tLetter <= 0:
raise ValueError("tLetter = " + str(tLetter))
if rBright <= 0:
raise ValueError("rBright = " + str(rBright))
def doThis():
result = cv.CloneImage(image)
for x in xrange(result.width):
for y in xrange(result.height):
if result[y, x] == 0:
continue
if result[y, x] < tLetter:
cv.FloodFill(result, (x, y), 0, rBright, rBright, 8, None)
if result[0, 0] != image[0, 0] or \
result[result.height - 1, 0] != image[image.height - 1, 0] or \
result[0, result.width - 1] != image[0, image.width - 1] or \
result[result.height - 1, result.width - 1] != image[image.height - 1, image.width - 1]:
return None
return result
result = doThis()
while result is None:
rBright -= 1
result = doThis()
cv.Threshold(result, result, 1, 255, cv.CV_THRESH_BINARY_INV)
return result
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 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 change_threshold(value):
'''change displayed threshold'''
global img_thresh, imgf, threshold
threshold = value
cv.Threshold(imgf, img_thresh, value / 65536.0, 0, cv.CV_THRESH_TOZERO)
cv.ShowImage('Threshold', img_thresh)
return img_thresh
def first_bigger_then_second(a, b):
sub = image_empty_clone(a)
cv.Sub(a, b, sub) #Thouse with R < G will become 0
binary = image_empty_clone(a)
#Make binary image
cv.Threshold(sub, binary, 1, 255, cv.CV_THRESH_BINARY)
return binary
def extract_bright(grey_img, histogram=False):
"""
Extracts brightest part of the image.
Expected to be the LEDs (provided that there is a dark background)
Returns a Thresholded image
histgram defines if we use the hist calculation to find the best margin
"""
## Searches for image maximum (brightest pixel)
# We expect the LEDs to be brighter than the rest of the image
[minVal, maxVal, minLoc, maxLoc] = cv.MinMaxLoc(grey_img)
print "Brightest pixel val is %d" % (maxVal)
#We retrieve only the brightest part of the image
# Here is use a fixed margin (80%), but you can use hist to enhance this one
if 0:
## Histogram may be used to wisely define the margin
# We expect a huge spike corresponding to the mean of the background
# and another smaller spike of bright values (the LEDs)
hist = grey_histogram(img, nBins=64)
[hminValue, hmaxValue, hminIdx, hmaxIdx] = cv.GetMinMaxHistValue(hist)
margin = 0 # statistics to be calculated using hist data
else:
margin = 0.8
thresh = int(maxVal * margin) # in pix value to be extracted
print "Threshold is defined as %d" % (thresh)
thresh_img = cv.CreateImage(cv.GetSize(img), img.depth, 1)
cv.Threshold(grey_img, thresh_img, thresh, 255, cv.CV_THRESH_BINARY)
return thresh_img
def get_motion_mask(self, img, diff_threshold=30):
self.timestamp = time.clock(
) / self.CLOCKS_PER_SEC # get current time in seconds
size = cv.GetSize(img) # get current frame size
idx1 = self.last
if not self.mhi or cv.GetSize(self.mhi) != size:
for i in range(self.N):
self.buf[i] = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1)
cv.Zero(self.buf[i])
self.mhi = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
cv.Zero(self.mhi) # clear MHI at the beginning
self.orient = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
self.segmask = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
self.mask = cv.CreateImage(size, 8, 1)
self.test = cv.CreateImage(size, 8, 3)
cv.CvtColor(img, self.buf[self.last],
cv.CV_BGR2GRAY) # convert frame to grayscale
#self.buf[self.last] = cv.CloneImage(img)
idx2 = (self.last + 1) % self.N # index of (last - (N-1))th frame
self.last = idx2
self.silh = self.buf[idx2]
cv.AbsDiff(self.buf[idx1], self.buf[idx2],
self.silh) # get difference between frames
cv.Threshold(self.silh, self.silh, diff_threshold, 1,
cv.CV_THRESH_BINARY) # and threshold it
cv.UpdateMotionHistory(self.silh, self.mhi, self.timestamp,
self.MHI_DURATION) # update MHI
cv.CvtScale(self.mhi, self.mask, 255. / self.MHI_DURATION,
(self.MHI_DURATION - self.timestamp) * 255. /
self.MHI_DURATION)
#cv.ShowImage("motion mask", self.mask)
max_rect = self.segment_motion()
return self.mask
def edge_threshold(image, roi=None, debug=0):
thresholded = cv.CloneImage(image)
horizontal = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_16S, 1)
magnitude32f = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_32F, 1)
vertical = cv.CloneImage(horizontal)
v_edge = cv.CloneImage(image)
magnitude = cv.CloneImage(horizontal)
storage = cv.CreateMemStorage(0)
mag = cv.CloneImage(image)
cv.Sobel(image, horizontal, 0, 1, 1)
cv.Sobel(image, vertical, 1, 0, 1)
cv.Pow(horizontal, horizontal, 2)
cv.Pow(vertical, vertical, 2)
cv.Add(vertical, horizontal, magnitude)
cv.Convert(magnitude, magnitude32f)
cv.Pow(magnitude32f, magnitude32f, 0.5)
cv.Convert(magnitude32f, mag)
if roi:
cv.And(mag, roi, mag)
cv.Normalize(mag, mag, 0, 255, cv.CV_MINMAX, None)
cv.Threshold(mag, mag, 122, 255, cv.CV_THRESH_BINARY)
draw_image = cv.CloneImage(image)
and_image = cv.CloneImage(image)
results = []
threshold_start = 17
for window_size in range(threshold_start, threshold_start + 1, 1):
r = 20
for threshold in range(0, r):
cv.AdaptiveThreshold(image, thresholded, 255, \
cv.CV_ADAPTIVE_THRESH_MEAN_C, cv.CV_THRESH_BINARY_INV, window_size, threshold)
contour_image = cv.CloneImage(thresholded)
contours = cv.FindContours(contour_image, storage, cv.CV_RETR_LIST)
cv.Zero(draw_image)
cv.DrawContours(draw_image, contours, (255, 255, 255),
(255, 255, 255), 1, 1)
if roi:
cv.And(draw_image, roi, draw_image)
cv.And(draw_image, mag, and_image)
m1 = np.asarray(cv.GetMat(draw_image))
m2 = np.asarray(cv.GetMat(mag))
total = mag.width * mag.height #cv.Sum(draw_image)[0]
coverage = cv.Sum(and_image)[0] / (mag.width * mag.height)
if debug:
print threshold, coverage
cv.ShowImage("main", draw_image)
cv.ShowImage("main2", thresholded)
cv.WaitKey(0)
results.append((coverage, threshold, window_size))
results.sort(lambda x, y: cmp(y, x))
_, threshold, window_size = results[0]
cv.AdaptiveThreshold(image, thresholded, 255, cv.CV_ADAPTIVE_THRESH_MEAN_C, \
cv.CV_THRESH_BINARY, window_size, threshold)
return thresholded
def main():
"""main method"""
print "Start"
# open video file
filepath = "ocup.avi"
data = openfile(filepath)
# DEBUG: just to skip some frames
# for f in xrange(300):
# frame = cv.QueryFrame(data["video"])
# TODO: last image is empty?
for f in xrange(data["fcount"] - 1):
# for f in xrange(1):
# query next frame from video
frame = cv.QueryFrame(data["video"])
# create images to store... well... images...
framebw = cv.CreateImage((frame.width, frame.height), cv.IPL_DEPTH_8U,
1)
framebin = cv.CreateImage((frame.width, frame.height), cv.IPL_DEPTH_8U,
1)
frameedges = cv.CreateImage((frame.width, frame.height),
cv.IPL_DEPTH_8U, 1)
frameout = cv.CreateImage((frame.width, frame.height), cv.IPL_DEPTH_8U,
1)
frameoutcol = cv.CreateImage((frame.width, frame.height),
cv.IPL_DEPTH_8U, 3)
# rgb to grayscale
cv.CvtColor(frame, framebw, cv.CV_BGR2GRAY)
# grayscale to binary
cv.Threshold(framebw, framebin, 150, 255, cv.CV_THRESH_BINARY)
# detect edges with canny...
# cv.Canny(framebin,frameedges,150,300,3)
# cv.Canny(framebin,frameedges,150,100,3)
cv.Copy(framebin, frameout)
cv.CvtColor(frameout, frameoutcol, cv.CV_GRAY2RGB)
# check the image and get result if street is straight or curved
result = checkimage(framebin, frameoutcol)
# TODO: implement state machine or something
if result == 0:
print "straight"
if result == -1:
print "left"
if result == 1:
print "right"
cv.ShowImage("window", frameoutcol)
cv.WaitKey(50000)
# delete used ressources
deleteRessources(data)
print "Done"
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 przygotuj_zdjecie(self, src, ROI, white_level, dark_level):
img = cv.LoadImageM(src, cv.CV_LOAD_IMAGE_COLOR)
size = cv.GetSize(img)
print size
gray = cv.CreateImage(size, 8, 1)
cv.CvtColor(img, gray, cv.CV_RGB2GRAY)
print ROI
if ROI != [-1, -1, -1, -1]:
cv.SetImageROI(gray, (ROI[0], ROI[1], ROI[2], ROI[3]))
cv.Threshold(gray, gray, white_level, 255, cv.CV_THRESH_BINARY)
cv.Smooth(gray, gray, cv.CV_BLUR, 9, 9)
cv.Threshold(gray, gray, white_level * 0.8, 255, cv.CV_THRESH_BINARY)
cv.Smooth(gray, gray, cv.CV_BLUR, 5, 5)
#cv.Dilate(gray,gray)
#cv.Canny( gray, gray, 1.0, 1.0, 3)
size = cv.GetSize(gray)
return gray, size
def clearNoise(self, image):
for x in range(image.width):
for y in range(image.height):
if image[y, x] == 0:
continue
if image[y, x] < self.tLetter:
cv.FloodFill(image, (x, y), 0, self.rBright, self.rBright, 8, None)
cv.Threshold(image, image, 1, 255, cv.CV_THRESH_BINARY_INV)
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 FrameMask(old_frame, frame):
if MovingHead():
return None
mask = cv.CloneImage(old_frame)
cv.AbsDiff(old_frame, frame, mask)
cv.Threshold(mask,mask, 15, 255, cv.CV_THRESH_BINARY)
return mask
def subtract(self, thres_chan):
cv.RunningAvg(thres_chan, self.accumulator, self.adaptation_rate)
cv.CvtScale(thres_chan, self.green32_img)
cv.Sub(self.green32_img, self.accumulator, self.difference_img)
cv.Threshold(self.difference_img, self.thresholded_img, self.threshold,
1, cv.CV_THRESH_BINARY)
cv.Dilate(self.thresholded_img, self.thresholded_img, iterations=1)
blob.remove_large_blobs(self.thresholded_img, max_area=self.max_area)
return self.thresholded_img
def dothreshold(I):
# bins := [ 9358 83 67 119 991 2183 153 64 141 12377]
# binsizes: [ 0. 25.5 51. 76.5 102. 127.5 153. 178.5 204. 229.5 255. ]
newI = cv.CreateImage(cv.GetSize(I), I.depth, I.channels)
#I_mat = iplimage2cvmat(I)
#I_np = np.asarray(I_mat)
#bins, binsizes = np.histogram(I_np)
cv.Threshold(I, newI, 35, 255.0, cv.CV_THRESH_BINARY)
return newI
def get_hands(image):
""" Returns the hand as white on black. Uses value in HSV to determine
hands."""
size = cv.GetSize(image)
hsv = cv.CreateImage(size, 8, 3)
hue = cv.CreateImage(size, 8, 1)
sat = cv.CreateImage(size, 8, 1)
val = cv.CreateImage(size, 8, 1)
hands = cv.CreateImage(size, 8, 1)
cv.CvtColor(image, hsv, cv.CV_BGR2HSV)
cv.Split(hsv, hue, sat, val, None)
cv.ShowImage('Live', image)
cv.ShowImage('Hue', hue)
cv.ShowImage('Saturation', sat)
cv.Threshold(
hue, hue, 10, 255,
cv.CV_THRESH_TOZERO) #set to 0 if <= 10, otherwise leave as is
cv.Threshold(
hue, hue, 244, 255,
cv.CV_THRESH_TOZERO_INV) #set to 0 if > 244, otherwise leave as is
cv.Threshold(hue, hue, 0, 255,
cv.CV_THRESH_BINARY_INV) #set to 255 if = 0, otherwise 0
cv.Threshold(
sat, sat, 64, 255,
cv.CV_THRESH_TOZERO) #set to 0 if <= 64, otherwise leave as is
cv.EqualizeHist(sat, sat)
cv.Threshold(sat, sat, 64, 255,
cv.CV_THRESH_BINARY) #set to 0 if <= 64, otherwise 255
cv.ShowImage('Saturation threshold', sat)
cv.ShowImage('Hue threshold', hue)
cv.Mul(hue, sat, hands)
#smooth + threshold to filter noise
# cv.Smooth(hands, hands, smoothtype=cv.CV_GAUSSIAN, param1=13, param2=13)
# cv.Threshold(hands, hands, 200, 255, cv.CV_THRESH_BINARY)
cv.ShowImage('Hands', hands)
return hands
def processFrame(self):
startTime = time.time()
logging.debug("Frame %d at %s", self.N, self.formatTime(startTime))
self.N += 1
logging.debug("Capturing a frame")
frame = self.capture.getFrame()
logging.debug("Entering preprocessing")
standard = self.pre.get_standard_form(frame)
bgsub_vals, bgsub_mask = self.pre.bgsub(standard)
logging.debug("Entering feature extraction")
hist_props_bgsub = self.histogram.calcHistogram(standard)
hist_props_abs = self.histogram.calcHistogram(bgsub_vals)
self.threshold.updateBGSubThresholds(hist_props_bgsub)
#self.threshold.updateAbsThresholds(hist_props_abs)
ents = self.featureEx.features(bgsub_vals, self.threshold)
logging.debug("Detected entities:", ents)
logging.debug("Entering interpreter")
self.interpreter.interpret(ents)
logging.debug("Entering World")
self.world.update(startTime, ents)
logging.debug("Updating GUI")
if not self.headless:
try:
bgsub = self.pre.remove_background(standard)
self.gui.updateWindow('raw', frame)
self.gui.updateWindow('mask', bgsub_mask)
self.gui.updateWindow('foreground', bgsub_vals)
self.gui.updateWindow('bgsub', bgsub)
self.gui.updateWindow('standard', standard)
canny = cv.CreateImage(self.pre.cropSize, 8, 1)
# adaptive = cv.CreateImage(self.pre.cropSize, 32,3)
# tmp = cv.CreateImage(self.pre.cropSize, 8,3)
# cv.Convert(standard, adaptive)
cv.CvtColor(bgsub, canny, cv.CV_BGR2GRAY)
cv.Threshold(canny, canny, 150, 255, cv.CV_THRESH_OTSU)
# cv.Threshold(canny, canny, 100, 255, cv.CV_ADAPTIVE_THRESH_GAUSSIAN_C)
# cv.Sobel(adaptive, adaptive, 1,1,1)
# cv.Convert(adaptive, tmp)
# cv.ConvertScale(tmp, tmp, 10)
# cv.CvtColor(tmp, canny, cv.CV_BGR2GRAY)
# cv.Threshold(canny,canny, 50, 255, cv.CV_THRESH_BINARY)
#cv.Canny(canny,canny, 100, 180,3)
cv.CvtColor(canny, bgsub, cv.CV_GRAY2BGR)
new = self.featureEx.detectCircles(bgsub)
self.gui.updateWindow('adaptive', canny)
self.gui.updateWindow('new', new)
self.gui.draw(ents, startTime)
except Exception, e:
logging.error("GUI failed: %s", e)
if self.debug:
raise
def processMotion(self):
"""
Take a raw input image frame from the camera and perform motion detection using
the current frame plus considering several previous frames and return the CV
image that should be given to the Region network.
"""
#find motion image, then find feature corners from that
if self._prevIplImage:
cv.AbsDiff(self._inputImage, self._prevIplImage, self._diffImage)
else:
cv.Copy(self._inputImage, self._diffImage)
cv.Copy(self._inputImage, self._prevIplImage) #save as t-1 image for next frame
#(src, dest, threshold, maxVal, type)
cv.Threshold(self._diffImage, self._threshImage, 16.0, 255.0, cv.CV_THRESH_BINARY)
#For now, disable segmentMotion and return all motion in frame...
if self._threshImage!=None:
return (0,0, self._threshImage.width, self._threshImage.height)
###Experimental: segment motion to return only the most 'interesting' area
tsec = clock()
#(silhouette, mhi, timestamp, duration)
cv.UpdateMotionHistory(self._threshImage, self._historyImage, tsec, 0.3)
#(mhi, segMask, storage, timestamp, segThresh)
#return: [tuple(area, value, rect)], (float, CvScalar, CvRect)
seqs = cv.SegmentMotion(self._historyImage, self._segMaskImage, \
self._memStorage, tsec, 1.0)
#cv.Copy(self._threshImage, self._inputImage)
#cv.Threshold(self._segMaskImage, self._threshImage, 0.0, 250.0, CV_THRESH_BINARY)
rects = []
for seq in seqs:
seqRect = seq[2] #CvRect = tuple (x, y, width, height)
if(seqRect[2] > 4 and seqRect[3] > 4):
rects.append(seqRect)
#find the 3rd largest area and only keep those rects
if len(rects) > 0:
areas = [x[2]*x[3] for x in rects]
areas.sort()
minArea = areas[0]
if len(areas) > 1:
minArea = areas[len(areas)-1]
rectsOk = [x for x in rects if x[2]*x[3] >= minArea]
rect = rectsOk[0]
#center the largest rect
cRect = (rect[0]+(rect[2]/2), rect[1]+(rect[3]/2))
return rect
return None #none means no motion bounding box detected
def loop(self, lock):
print('starting thread - ProcessContours')
self.active = True
self.loops = 0
while self.active:
self.loops += 1
print('.....contours thread... locking, convert scale...')
lock.acquire()
#lock.release() # bug was here
cv.CvtColor(self.depth8, self.DEPTH640, cv.CV_GRAY2RGB)
cv.Resize(self.DEPTH640, self.DEPTH240, False)
lock.release() # fixed Dec 6th 2011
print('.....contours thread ok.....')
# blur helps?
#cv.Smooth( self.depth8, self.depth8, cv.CV_BLUR, 16, 16, 0.1, 0.1 )
#cv.Smooth( self.depth8, self.depth8, cv.CV_GAUSSIAN, 13, 13, 0.1, 0.1 )
thresh = Kinect.sweep_begin
index = 0
#for img in self.sweep_thresh:
for i in range(int(Kinect.sweeps)):
if thresh >= 255: break
img = self.sweep_images[i]
cv.ClearMemStorage(self.storage)
cv.Threshold(self.depth8, img, thresh, 255,
cv.CV_THRESH_BINARY_INV)
#cv.Canny( img, img, 0, 255, 3 ) # too slow
seq = cv.CvSeq()
contours = ctypes.pointer(seq.POINTER)
cv.FindContours(img, self.storage, contours,
ctypes.sizeof(cv.Contour.CSTRUCT),
cv.CV_RETR_EXTERNAL, cv.CV_CHAIN_APPROX_SIMPLE,
(0, 0))
#print( contours.contents.contents.total )
_total = 0
try:
_total = contours.contents.contents.total
except ValueError: #ValueError: NULL pointer access
thresh += int(Kinect.sweep_step)
continue
P = ReducedPolygon(contours.contents, index, thresh)
lock.acquire()
Kinect.BUFFER.append(P)
lock.release()
index += 1
thresh += int(Kinect.sweep_step)
print('==========proc shapes.iterate============')
self.proc_shapes.iterate(lock)
time.sleep(0.01)
print('thread exit - ProcessContours', self.loops)
def threshold_lines(self,lines):
all_lines=sum(lines,[])
tmp=cv.CreateImage((len(all_lines),1), 8, 1)
for i,p in enumerate(all_lines):
tmp[0,i]=p
cv.Threshold(tmp, tmp, 0, 1, cv.CV_THRESH_OTSU)
j=0
for l in lines:
for i in range(len(l)):
l[i]=tmp[0,j]
j+=1
def sat_threshold(image, min_sat):
image_hsv = cv.CloneImage(image)
cv.CvtColor(image, image_hsv, cv.CV_RGB2HSV)
image_sat = cv.CreateImage(cv.GetSize(image_hsv), 8, 1)
cv.Split(image_hsv, None, image_sat, None, None)
sat_thresh = cv.CloneImage(image_sat)
cv.Threshold(image_sat, sat_thresh, min_sat, 255, cv.CV_THRESH_BINARY)
image_out = cv.CloneImage(image)
cv.Zero(image_out)
cv.Copy(image, image_out, sat_thresh)
return image_out
def track(bgr_image, threshold=100):
'''Accepts BGR image and optional object threshold between 0 and 255 (default = 100).
Returns: (x,y) coordinates of centroid if found
(-1,-1) if no centroid was found
None if user hit ESC
'''
# Extract bytes, width, and height
bgr_bytes = bgr_image.tostring()
width = bgr_image.width
height = bgr_image.height
# Create separate red, green, and blue image matrices from bytes
r_image = _create_grayscale_mat(bgr_bytes, width, height, 2)
b_image = _create_grayscale_mat(bgr_bytes, width, height, 0)
g_image = _create_grayscale_mat(bgr_bytes, width, height, 1)
# Remove 1/3 of red and blue components from green
threes_image = cv.CreateImage((width,height), cv.IPL_DEPTH_8U, 1)
cv.Set(threes_image, 3)
_div_and_sub(g_image, r_image, threes_image)
_div_and_sub(g_image, b_image, threes_image)
# Threshold and erode green image
cv.Threshold(g_image, g_image, threshold, 255, cv.CV_THRESH_BINARY)
cv.Erode(g_image, g_image)
# Find centroid of eroded image
moments = cv.Moments(cv.GetMat(g_image), 1) # binary flag
centroid_x = _centroid(moments, 1, 0)
centroid_y = _centroid(moments, 0, 1)
# Assume no centroid
ctr = (width/2,height/2)
err = ctr
# Use centroid if it exists
if centroid_x != None and centroid_y != None:
ctr = (centroid_x, centroid_y)
# Put black circle in at centroid in image
cv.Circle(bgr_image, ctr, 4, (0,0,0))
# Display full-color image
cv.NamedWindow(WINDOW_NAME)
cv.ShowImage(WINDOW_NAME, bgr_image)
# Force image display, setting centroid to None on ESC key input
if cv.WaitKey(5) == 27:
ctr = None
# Return coordinates of centroid
return ctr if ctr != err else None
