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 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 rg_filter(r, g, rg_diff=11, b=None):
#Checking rule: R > G
rg_sub_binary = first_bigger_then_second(r, g)
#Checking rule: R > B
rb_sub_binary = first_bigger_then_second(r, b) if b else None
#Checking rule: |R - G| >= 11
rg_diff_thres = abs_diff_threshold(r, g, rg_diff)
res = image_empty_clone(r)
cv.And(rg_diff_thres, rg_sub_binary, res)
if rb_sub_binary:
cv.And(res, rb_sub_binary, res)
return res
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 get_dirmarker(img, angle, Dist, radius):
X, Y = entCenter(robot)
Len, _ = entSize(robot)
point = (X + (Dist + Len / 2.0) * cos(angle),
Y - (Dist + Len / 2.0) * sin(angle))
point = intPoint(point)
#For visualisation:
# cv.Circle( frame, point, radius, (0,200,200), 1 )
point2 = point[0] - nhood[0], point[1] - nhood[1]
out = cv.CloneImage(img)
cv.Zero(out)
cv.Circle(out, point2, radius, (255, 255, 255), -1)
cv.And(out, img2, out)
center1 = self.centralMoment(out)
count1 = cv.CountNonZero(out)
cv.Erode(out, out)
center2 = self.centralMoment(out)
count2 = cv.CountNonZero(out)
if count2 == 0 and count1 > 10:
return center1
else:
return center2
def findFirstColorPattern(img, pattern):
"""
try to test if one pixel is in our pattern
"""
channels = [None, None, None]
channels[0] = cv.CreateImage(cv.GetSize(img), 8, 1) #blue
channels[1] = cv.CreateImage(cv.GetSize(img), 8, 1) #green
channels[2] = cv.CreateImage(cv.GetSize(img), 8, 1) #red
ch0 = cv.CreateImage(cv.GetSize(img), 8, 1) #blue
ch1 = cv.CreateImage(cv.GetSize(img), 8, 1) #green
ch2 = cv.CreateImage(cv.GetSize(img), 8, 1) #red
cv.Split(img, ch0, ch1, ch2, None)
dest0 = cv.CreateImage(cv.GetSize(img), 8, 1)
dest1 = cv.CreateImage(cv.GetSize(img), 8, 1)
dest2 = cv.CreateImage(cv.GetSize(img), 8, 1)
dest3 = cv.CreateImage(cv.GetSize(img), 8, 1)
cv.Smooth(ch0, channels[0], cv.CV_GAUSSIAN, 3, 3, 0)
cv.Smooth(ch1, channels[1], cv.CV_GAUSSIAN, 3, 3, 0)
cv.Smooth(ch2, channels[2], cv.CV_GAUSSIAN, 3, 3, 0)
result = []
for i in range(3):
lower = pattern[i][2] - 25
upper = pattern[i][2] + 25
cv.InRangeS(channels[0], lower, upper, dest0)
lower = pattern[i][1] - 25
upper = pattern[i][1] + 25
cv.InRangeS(channels[1], lower, upper, dest1)
lower = pattern[i][0] - 25
upper = pattern[i][0] + 25
cv.InRangeS(channels[2], lower, upper, dest2)
cv.And(dest0, dest1, dest3)
temp = cv.CreateImage(cv.GetSize(img), 8, 1)
cv.And(dest2, dest3, temp)
result.append(temp)
cv.ShowImage("result0", result[0])
cv.WaitKey(0)
cv.ShowImage("result1", result[1])
cv.WaitKey(0)
cv.ShowImage("result2", result[2])
cv.WaitKey(0)
cv.Or(result[0], result[1], dest0)
cv.Or(dest0, result[2], dest3)
cv.NamedWindow("result", cv.CV_WINDOW_AUTOSIZE)
cv.ShowImage("result", dest3)
cv.WaitKey(0)
return dest3
def checkRange(self, src, lowBound, highBound):
size = im.size(src)
mask = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1)
gt_low = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1)
cv.CmpS(src, lowBound, gt_low, cv.CV_CMP_GT)
lt_high = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1)
cv.CmpS(src, highBound, lt_high, cv.CV_CMP_LT)
cv.And(gt_low, lt_high, mask)
return mask
def norm_rg_filter(r, g, b):
nr, ng, _ = get_normalized_rgb_planes(r, g, b)
nr_mask = get_filtered_plane(nr, ((0.33, 0.6), ), probability_to_255)
ng_mask = get_filtered_plane(ng, ((0.25, 0.37), ), probability_to_255)
res = image_empty_clone(nr)
cv.And(nr_mask, ng_mask, res)
return res
def find_blobs(self, frame, debug_image):
'''Find blobs in an image.
Hopefully this gets blobs that correspond with
buoys, but any intelligent checking is done outside of this function.
'''
# Get Channels
hsv = cv.CreateImage(cv.GetSize(frame), 8, 3)
cv.CvtColor(frame, hsv, cv.CV_BGR2HSV)
saturation = libvision.misc.get_channel(hsv, 1)
red = libvision.misc.get_channel(frame, 2)
# Adaptive Threshold
cv.AdaptiveThreshold(
saturation,
saturation,
255,
cv.CV_ADAPTIVE_THRESH_MEAN_C,
cv.CV_THRESH_BINARY_INV,
self.saturation_adaptive_thresh_blocksize -
self.saturation_adaptive_thresh_blocksize % 2 + 1,
self.saturation_adaptive_thresh,
)
cv.AdaptiveThreshold(
red,
red,
255,
cv.CV_ADAPTIVE_THRESH_MEAN_C,
cv.CV_THRESH_BINARY,
self.red_adaptive_thresh_blocksize -
self.red_adaptive_thresh_blocksize % 2 + 1,
-1 * self.red_adaptive_thresh,
)
kernel = cv.CreateStructuringElementEx(9, 9, 4, 4, cv.CV_SHAPE_ELLIPSE)
cv.Erode(saturation, saturation, kernel, 1)
cv.Dilate(saturation, saturation, kernel, 1)
cv.Erode(red, red, kernel, 1)
cv.Dilate(red, red, kernel, 1)
buoys_filter = cv.CreateImage(cv.GetSize(frame), 8, 1)
cv.And(saturation, red, buoys_filter)
if debug_image:
svr.debug("Saturation", saturation)
svr.debug("Red", red)
svr.debug("AdaptiveThreshold", buoys_filter)
# Get blobs
labeled_image = cv.CreateImage(cv.GetSize(buoys_filter), 8, 1)
blobs = libvision.blob.find_blobs(buoys_filter, labeled_image,
MIN_BLOB_SIZE, 10)
return blobs, labeled_image
def sub_intersection(amap, apoly, maxwidth, maxheight):
polymap = cv.CreateImage((maxwidth,
maxheight),
cv.IPL_DEPTH_8U,1)
cv.FillPoly(polymap, [apoly], im.color.blue)
intersection = cv.CreateImage((maxwidth,
maxheight),
cv.IPL_DEPTH_8U,1)
cv.And(polymap, amap, intersection)
cv.Sub(amap, intersection, amap)
def filter_by_hsv(img, ranges):
h, s, v = get_hsv_planes(img)
h_mask = get_filtered_plane(h, ranges["h"], h2cv_values)
s_mask = get_filtered_plane(s, ranges["s"], probability_to_255)
v_mask = get_filtered_plane(v, ranges["v"], probability_to_255)
hsv_mask = image_empty_clone(v_mask)
cv.And(v_mask, s_mask, hsv_mask, mask=h_mask)
return hsv_mask
def has_intersection(amap, apoly, maxwidth, maxheight):
polymap = cv.CreateImage((maxwidth,
maxheight),
cv.IPL_DEPTH_8U,1)
cv.FillPoly(polymap, [apoly], im.color.blue)
intersection = cv.CreateImage((maxwidth,
maxheight),
cv.IPL_DEPTH_8U,1)
cv.And(polymap, amap, intersection)
m=cv.Moments(cv.GetMat(intersection), True)
return bool(cv.GetSpatialMoment(m, 0, 0))
def _detectSkin(self, bgrimg):
hsvimg = im.bgr2hsv(bgrimg)
h, s, v = im.split3(bgrimg)
skin_mask = cv.CreateImage(im.size(hsvimg), cv.IPL_DEPTH_8U, 1)
h_mask = cv.CreateImage(im.size(hsvimg), cv.IPL_DEPTH_8U, 1)
v_mask = cv.CreateImage(im.size(hsvimg), cv.IPL_DEPTH_8U, 1)
v_mask = self.checkRange(v, self.v_low, self.v_high)
h_mask = self.checkRange(h, self.h_low, self.h_high)
cv.And(h_mask, v_mask, skin_mask)
return skin_mask
def process_image(filename):
print(filename)
orig = cv.LoadImage(filename)
output = cv.LoadImage(filename)
print("Not filename error")
# create tmp images
rrr = cv.CreateImage((orig.width, orig.height), cv.IPL_DEPTH_8U, 1)
ggg = cv.CreateImage((orig.width, orig.height), cv.IPL_DEPTH_8U, 1)
bbb = cv.CreateImage((orig.width, orig.height), cv.IPL_DEPTH_8U, 1)
processed = cv.CreateImage((orig.width, orig.height), cv.IPL_DEPTH_8U, 1)
storage = cv.CreateMat(orig.width, 1, cv.CV_32FC3)
print("Checkpoint 1", storage)
#split image into RGB components
cv.Split(orig, rrr, ggg, bbb, None)
#process each component
channel_processing(rrr)
channel_processing(ggg)
channel_processing(bbb)
#combine images using logical 'And' to avoid saturation
cv.And(rrr, ggg, rrr)
cv.And(rrr, bbb, processed)
#cv.ShowImage('before canny', processed)
#cv.SaveImage('case3_processed.jpg',processed)
#use canny, as HoughCircles seems to prefer ring like circles to filled ones.
cv.Canny(processed, processed, 5, 70, 3)
#smooth to reduce noise a bit more
cv.Smooth(processed, processed, cv.CV_GAUSSIAN, 7, 7)
print("Checkpoint 2")
#cv.ShowImage('processed', processed)
#find circles, with parameter search
storage = find_circles(processed, storage, 100)
print("Checkpoint 3")
cir = get_circles(storage)
if (len(cir) == 1):
draw_circles(storage, output)
cv.ShowImage("original with circles", output)
cv.SaveImage('output_' + filename, output)
cv.WaitKey(0)
return cir[0]
def skin_mask(img):
r, g, b = get_rgb_planes(img)
hsv_mask = filter_by_hsv(img, {
"h": ((0, 50), (340, 360)),
"s": ((0.12, 0.7), ),
"v": ((0.3, 1), )
})
rg_mask = rg_filter(r, g)
nr_ng_mask = norm_rg_filter(r, g, b)
tmp = image_empty_clone(hsv_mask)
total_mask = image_empty_clone(hsv_mask)
cv.And(hsv_mask, rg_mask, tmp)
cv.And(tmp, nr_ng_mask, total_mask)
#TODO What is this?
th = image_empty_clone(total_mask)
cv.Smooth(total_mask, total_mask, cv.CV_MEDIAN, 5, 5)
cv.Threshold(total_mask, th, 25, 255, cv.CV_THRESH_BINARY)
return total_mask
def rects_intersection(rects, maxwidth, maxheight):
if not rects:
return
intersection = cv.CreateImage((maxwidth,
maxheight),
cv.IPL_DEPTH_8U,1)
cv.FillPoly(intersection, [rects[0]], im.color.blue)
for r in rects:
canvas = cv.CreateImage((maxwidth,
maxheight),
cv.IPL_DEPTH_8U,1)
cv.FillPoly(canvas, [r], im.color.blue)
cv.And(canvas, intersection, intersection)
return im.find_contour(intersection)
def remove_background_values(self, frame):
self.Imask = self.remove_background(frame)
logging.debug(
"Using thresholded background subtracted image as a mask")
#cv.ShowImage("ASD", self.Imask)
self.Igray = self.threshold.foreground(self.Imask)
cv.CvtColor(self.Imask, self.Igray, cv.CV_BGR2GRAY)
cv.Threshold(self.Igray, self.Igray, 200, 255, cv.CV_THRESH_OTSU)
#cv.EqualizeHist(self.Igray, self.Igray)
cv.CvtColor(self.Igray, self.Imask, cv.CV_GRAY2BGR)
#Finally, return the salient bits of the original frame
cv.And(self.Imask, frame, self.Iobjects)
return self.Iobjects, self.Igray
def run(self):
while not self._stop.isSet():
task = self.q.get()
if task != None:
obj, image = task
rect = cv.BoundingRect(obj.cont)
siftimage = siftfastpy.Image(rect[2], rect[3])
cv.CvtColor(image, self.gray, cv.CV_BGR2GRAY)
cv.SetZero(self.mask)
cv.FillPoly(self.mask, [obj.cont], cv.Scalar(255))
cv.And(self.gray, self.mask, self.gray)
gnp = np.asarray(cv.GetSubRect(self.gray, rect))
siftimage.SetData(gnp)
t0 = time.time()
# compute keypoints and time how long it takes
frames,desc = siftfastpy.GetKeypoints(siftimage)
self.stats.append((rect[2]*rect[3], time.time() - t0))
# compute feature vector
tmp = np.concatenate((frames[:,2:4], desc), axis=1).astype('float64')
# search in the flann tree for the feature vectors
n = 2
thr = 1.5
result, dists = self.flann.nn_index(tmp, n, checks=32)
# ismatch contains the indices in the testset for which a match is found
ismatch = dists[:,1] > thr * dists[:,0]
# meta contains the index to object-ID mapping
obj.ids = []
for i, res in enumerate(result):
if ismatch[i]:
obj.ids.append(self.meta[res[0]][0])
# obj.ids = [self.meta[res][0] for i, res in enumerate(result) if ismatch[i]]
# transfer keypoints back to full frame coordinates
frames[:,0] += rect[0]
frames[:,1] += rect[1]
obj.frames = frames
obj.desc = desc
def _detectSkin(self, bgrimg):
#hsvimg = im.bgr2hsv(bgrimg)
hsvimg = cv.CreateImage((bgrimg.width, bgrimg.height), 8, 3)
cv.CvtColor(bgrimg, hsvimg, cv.CV_RGB2HSV)
#h,s,v = im.split3(bgrimg)
skin_mask = cv.CreateImage((bgrimg.width, bgrimg.height), 8, 1)
low = (self.h_low, self.v_low, 0)
high = (self.h_high, self.v_high, 256)
cv.InRangeS(hsvimg, low, high, skin_mask)
#cv.ShowImage("inrange", skin_mask)
face_mask = face.blockfacemask(bgrimg)
cv.And(skin_mask, face_mask, skin_mask)
#h_mask = cv.CreateImage(im.size(hsvimg), cv.IPL_DEPTH_8U, 1)
#s_mask = cv.CreateImage(im.size(hsvimg), cv.IPL_DEPTH_8U, 1)
#print self.v_low, self.v_high, self.h_low, self.h_high
#s_mask = self.checkRange(s, self.v_low, self.v_high)
#h_mask = self.checkRange(h, self.h_low, self.h_high)
#cv.And(h_mask, s_mask, skin_mask)
return skin_mask
def main(args):
image = cv.LoadImage(args.image)
prefix, extension = os.path.splitext(args.image)
output_path = "%s.mask.png" % (prefix)
if os.path.exists(output_path):
mask = cv.LoadImage(output_path, cv.CV_LOAD_IMAGE_GRAYSCALE)
else:
mask = cv.CreateImage((image.width, image.height), 8, 1)
cv.Set(mask, 255)
if args.threshold:
print "Thresholding"
image_hue = cv.CreateImage(cv.GetSize(image), 8, 1)
image_sat = cv.CreateImage(cv.GetSize(image), 8, 1)
image_val = cv.CreateImage(cv.GetSize(image), 8, 1)
image_hsv = cv.CreateImage(cv.GetSize(image), 8, 3)
mask_hue = cv.CreateImage((image.width, image.height), 8, 1)
mask_val = cv.CreateImage((image.width, image.height), 8, 1)
mask_new = cv.CreateImage((image.width, image.height), 8, 1)
cv.CvtColor(image, image_hsv, cv.CV_BGR2HSV)
cv.Split(image_hsv, image_hue, image_sat, image_val, None)
upper_thresh_hue = cv.CreateImage(cv.GetSize(image), 8, 1)
lower_thresh_hue = cv.CreateImage(cv.GetSize(image), 8, 1)
upper_thresh_val = cv.CreateImage(cv.GetSize(image), 8, 1)
lower_thresh_val = cv.CreateImage(cv.GetSize(image), 8, 1)
cv.Threshold(image_hue, upper_thresh_hue, args.hue_max, 255,
cv.CV_THRESH_BINARY)
cv.Threshold(image_hue, lower_thresh_hue, args.hue_min, 255,
cv.CV_THRESH_BINARY_INV)
cv.Threshold(image_val, upper_thresh_val, 235, 255,
cv.CV_THRESH_BINARY)
cv.Threshold(image_val, lower_thresh_val, 30, 255,
cv.CV_THRESH_BINARY_INV)
cv.Or(upper_thresh_hue, lower_thresh_hue, mask_hue)
cv.Or(upper_thresh_val, lower_thresh_val, mask_val)
cv.Or(mask_hue, mask_val, mask_new)
cv.And(mask, mask_new, mask)
MaskWindow(image, mask, output_path, args.brush_size, args.zoom_out)
def get_near_region_mask(self, blds):
regions = [bd.near_region_poly for bd in blds]
c = cg.rects_intersection(regions, self.label_img.width,
self.label_img.height)
# subtract buildings
equ_class_region = cv.CreateImage(
(self.label_img.width, self.label_img.height), cv.IPL_DEPTH_8U, 1)
canvas = cv.CloneImage(self.label_img)
cv.FillPoly(equ_class_region, [c], im.color.blue)
cv.CmpS(canvas, 0, canvas, cv.CV_CMP_EQ)
cv.And(equ_class_region, canvas, equ_class_region)
# subtract near of near's neighbor
near_of_near = set(self.buildings)
for bd in blds:
near_of_near = near_of_near.union(bd.near_set)
near_of_near.difference_update(set(blds))
near_regions = [bd.near_region_poly for bd in near_of_near]
for reg, bd in zip(near_regions, near_of_near):
if cg.has_intersection(equ_class_region, reg, self.label_img.width,
self.label_img.height):
cg.sub_intersection(equ_class_region, reg,
self.label_img.width,
self.label_img.height)
# equ_class_region -= near of near via nearest
for bd in near_of_near:
eq_region = self.get_equivalent_region_via_nearest(bd)
c = im.find_contour(eq_region)
while c:
if cg.has_intersection(equ_class_region, list(c),
self.label_img.width,
self.label_img.height):
cg.sub_intersection(equ_class_region, list(c),
self.label_img.width,
self.label_img.height)
c = c.h_next()
return equ_class_region
frameDiffFundoSaida = cv.CloneImage(frameDiff)
cv.Threshold(frameDiff, frameDiff, p_diffThreshold, 255,
cv.CV_THRESH_BINARY)
#for i in range(2): cv.Erode(frameDiff,frameDiff)
#zera diferenca onde ha sombra
frameSemSombra = cv.CloneImage(imgSombra)
# dilata sombra para pegar qualquer borada de sombra
#for i in range(2): cv.Erode(frameSemSombra,frameSemSombra)
for i in range(2):
cv.Dilate(frameSemSombra, frameSemSombra)
# inverte e faz um AND
cv.Not(frameSemSombra, frameSemSombra)
cv.And(frameSemSombra, frameDiff, frameSemSombra)
frameDiff = cv.CloneImage(frameSemSombra)
frameDiffSemSombra = cv.CloneImage(frameDiff)
'''
Faca uma copia da imagem.
De um cvSmooth com metodo CV_MEDIAN para tirar ruidos da copia.
De open (erode + dilate) na copia.
O Erode deve eliminar os ruidos restantes. Voce pode usar um kernel horizontal e depois um vertical.
Faca os dilates terem 1 grau a mais que o erode (na imagem final o branco que restara e maior que na original)
Faca um AND da imagem original com a imagem do Open.
def pegarIris(orig, nameFoto="teste.bmp"):
orig2 = cv.CloneImage(orig)
# create tmp images
grey_scale = cv.CreateImage(cv.GetSize(orig), 8, 1)
processedPupila = cv.CreateImage(cv.GetSize(orig), 8, 1)
processedIris = cv.CreateImage(cv.GetSize(orig), 8, 1)
cv.Smooth(orig, orig, cv.CV_GAUSSIAN, 3, 3)
cv.CvtColor(orig, grey_scale, cv.CV_RGB2GRAY)
cv.CvtColor(orig, processedIris, cv.CV_RGB2GRAY)
cv.Smooth(grey_scale, processedPupila, cv.CV_GAUSSIAN, 15, 15)
cv.Canny(processedPupila, processedPupila, 5, 70, 3)
cv.Smooth(processedPupila, processedPupila, cv.CV_GAUSSIAN, 15, 15)
#cv.ShowImage("pupila_processada", processedPupila)
cv.Smooth(grey_scale, processedIris, cv.CV_GAUSSIAN, 15, 15)
cv.Canny(processedIris, processedIris, 5, 70, 3)
cv.Smooth(processedIris, processedIris, cv.CV_GAUSSIAN, 15, 15)
cv.Smooth(processedIris, processedIris, cv.CV_GAUSSIAN, 15, 15)
#cv.ShowImage("pupila_processada2", processedIris)
#cv.Erode(processedIris, processedIris, None, 10)
#cv.Dilate(processedIris, processedIris, None, 10)
#cv.Canny(processedIris, processedIris, 5, 70, 3)
#cv.Smooth(processedIris, processedIris, cv.CV_GAUSSIAN, 15, 15)
#cv.Smooth(processedIris, processedIris, cv.CV_GAUSSIAN, 15, 15)
#cv.Smooth(processedPupila, processedIris, cv.CV_GAUSSIAN, 15, 15)
#cv.ShowImage("Iris_processada", processedIris)
#cv.Dilate(processedIris, processedIris, None, 10)
storagePupila = cv.CreateMat(orig.width, 1, cv.CV_32FC3)
storageIris = cv.CreateMat(orig.width, 1, cv.CV_32FC3)
# these parameters need to be adjusted for every single image
HIGH = 30
LOW = 20
HIGH2 = 120
LOW2 = 60
imgBranca = cv.CreateImage(cv.GetSize(orig), 8, 3)
imgPreta = cv.CreateImage(cv.GetSize(orig), 8, 3)
cv.Zero(imgPreta)
cv.Not(imgPreta, imgBranca)
imagemMaskPupila = cv.CreateImage(cv.GetSize(orig), 8, 3)
imagemMaskPupila = cv.CloneImage(imgBranca)
imagemMaskIris = cv.CreateImage(cv.GetSize(orig), 8, 3)
imagemMaskIris = cv.CloneImage(imgPreta)
#try:
# extract circles
#cv2.cv.HoughCircles(processedIris, storageIris, cv.CV_HOUGH_GRADIENT, 3, 100.0,LOW,HIGH, LOW2, HIGH2)
cv2.cv.HoughCircles(processedPupila, storagePupila, cv.CV_HOUGH_GRADIENT,
2, 100.0, LOW, HIGH)
cv2.cv.HoughCircles(processedIris, storageIris, cv.CV_HOUGH_GRADIENT, 3,
100.0, LOW, HIGH, LOW2, HIGH2)
#Circulos da pupila
#for i in range(0, len(np.asarray(storagePupila))):
RadiusPupila = int(np.asarray(storagePupila)[0][0][2])
xPupila = int(np.asarray(storagePupila)[0][0][0])
yPupila = int(np.asarray(storagePupila)[0][0][1])
centerPupila = (xPupila, yPupila)
#print "RadiusPupila %d" %RadiusPupila
cv.Circle(imagemMaskPupila, centerPupila, RadiusPupila, cv.CV_RGB(0, 0, 0),
-1, 8, 0)
cv.Circle(orig, centerPupila, 1, cv.CV_RGB(0, 255, 0), -1, 8, 0)
cv.Circle(orig, centerPupila, RadiusPupila, cv.CV_RGB(255, 0, 0), 3, 8, 0)
#cv.ShowImage("pupila"+str(0), orig)
orig = cv.CloneImage(orig2)
#cv.WaitKey(0)
#Circulos da Iris
#for i in range(0, len(np.asarray(storageIris))):
RadiusIris = int(np.asarray(storageIris)[0][0][2])
xIris = int(np.asarray(storageIris)[0][0][0])
yIris = int(np.asarray(storageIris)[0][0][1])
centerIris = (xIris, yIris)
#print "RadiusIris %d" %RadiusIris
cv.Circle(imagemMaskIris, centerIris, RadiusIris, cv.CV_RGB(255, 255, 255),
-1, 8, 0)
cv.Circle(orig, centerIris, 1, cv.CV_RGB(0, 255, 0), -1, 8, 0)
cv.Circle(orig, centerIris, RadiusIris, cv.CV_RGB(255, 0, 0), 3, 8, 0)
#cv.ShowImage("Iris"+str(0), orig)
orig = cv.CloneImage(orig2)
#cv.WaitKey(0)
#except:
# print "nothing found"
# pass
#criando imagem final
finalAux = cv.CreateImage(cv.GetSize(orig), 8, 3)
final = cv.CreateImage(cv.GetSize(orig), 8, 3)
#pegando a iris toda
cv.And(orig, imagemMaskPupila, finalAux)
cv.And(finalAux, imagemMaskIris, final)
cv.SaveImage(nameFoto, final)
#cv.ShowImage("original with circles", final)
#cv.WaitKey(0)
return final
def DetectaSombra(frame, bg):
dbg = 1
if dbg:
t1 = time.time()
print 'Detectando sombras na imagem...'
# gera as imagens de cada canal RGB
imgCinza = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
imgHSV = cv.CloneImage(frame)
imgH = cv.CloneImage(imgCinza)
imgS = cv.CloneImage(imgCinza)
imgV = cv.CloneImage(imgCinza)
imgR = cv.CloneImage(imgCinza)
imgG = cv.CloneImage(imgCinza)
imgB = cv.CloneImage(imgCinza)
bgCinza = cv.CreateImage(cv.GetSize(bg), cv.IPL_DEPTH_8U, 1)
bgHSV = cv.CloneImage(bg)
bgH = cv.CloneImage(bgCinza)
bgS = cv.CloneImage(bgCinza)
bgV = cv.CloneImage(bgCinza)
bgR = cv.CloneImage(bgCinza)
bgG = cv.CloneImage(bgCinza)
bgB = cv.CloneImage(bgCinza)
# gera as imagens de cada frame e backgroun nos canais de HSV e RGB
cv.CvtColor(frame, imgHSV, cv.CV_BGR2HSV)
cv.Split(imgHSV, imgH, imgS, imgV, None)
cv.Split(frame, imgR, imgG, imgB, None)
cv.CvtColor(bg, bgHSV, cv.CV_BGR2HSV)
cv.Split(bgHSV, bgH, bgS, bgV, None)
cv.Split(bg, bgR, bgG, bgB, None)
# inicio de calculos para descobrir sombras.
ivbv = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
cv.Div(imgV, bgV, ivbv, 255)
isbs = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
cv.Sub(imgS, bgS, isbs)
ihbh = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
cv.AbsDiff(imgH, bgH, ihbh)
# parametros de deteccao de sombra
alfa = 190
beta = 210
thrSat = 20
thrHue = 50
alfa = 220
beta = 240
thrSat = 90
thrHue = 90
nErode = 0
nDilate = 0
# trata ivbv
imgThr_ivbv = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
# deixa apenas os menores que beta
cv.Threshold(ivbv, imgThr_ivbv, beta, 255, cv.CV_THRESH_TRUNC)
# deixa apenas os maiores que alfa
cv.Threshold(imgThr_ivbv, imgThr_ivbv, alfa, 255, cv.CV_THRESH_TOZERO)
# binariza
cv.Threshold(imgThr_ivbv, imgThr_ivbv, alfa, 255, cv.CV_THRESH_BINARY)
# trata isbs
imgThr_isbs = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
# deixa apenas os menores que thrSat
cv.Threshold(isbs, imgThr_isbs, thrSat, 255, cv.CV_THRESH_BINARY)
# trata isbs
imgThr_ihbh = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
# deixa apenas os menores que thrSat
cv.Threshold(ihbh, imgThr_ihbh, thrHue, 255, cv.CV_THRESH_BINARY_INV)
# onde é preto em todas as imagens, é sombra
imgSombra = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
cv.Not(imgThr_ivbv, imgThr_ivbv)
cv.Not(imgThr_isbs, imgThr_isbs)
cv.And(imgThr_ivbv, imgThr_isbs, imgSombra)
cv.Not(imgThr_ihbh, imgThr_ihbh)
cv.And(imgSombra, imgThr_ihbh, imgSombra)
for i in range(nErode):
cv.Erode(imgSombra, imgSombra)
for i in range(nDilate):
cv.Dilate(imgSombra, imgSombra)
if dbg:
print 'Tempo para detectar sombras: %.5f' % (time.time() - t1)
#exibe frames de saida
#destaca de verde a sombra sobre o frame
frameDestacado = cv.CloneImage(frame)
cv.Or(imgG, imgSombra, imgG)
cv.Merge(imgR, imgG, imgB, None, frameDestacado)
'''
cv.ShowImage('frameDestacado',frameDestacado)
cv.WaitKey()
'''
retorno = {}
retorno['sombra'] = imgSombra
retorno['sombraDestacada'] = frameDestacado
return retorno
cv.ShowImage('ivbv', ivbv)
cv.ShowImage('isbs', isbs)
cv.ShowImage('ihbh', ihbh)
cv.ShowImage('imgThr_isbs', imgThr_isbs)
cv.ShowImage('imgThr_ivbv', imgThr_ivbv)
cv.ShowImage('imgThr_ihbh', imgThr_ihbh)
cv.ShowImage('imgSombra', imgSombra)
cv.WaitKey()
sys.exit()
frameMerge = cv.CloneImage(frame)
cv.Merge(imgR, imgR, imgR, None, frameMerge)
cv.ShowImage('frame', frame)
cv.ShowImage('frameMerge', frameMerge)
cv.ShowImage('imgR', imgR)
cv.ShowImage('imgG', imgG)
cv.ShowImage('imgB', imgB)
cv.ShowImage('imgH', imgH)
cv.ShowImage('imgS', imgS)
cv.ShowImage('imgV', imgV)
cv.WaitKey()
return 0
def threshold(image,
bg_mode,
filter_pr2,
crop_rect=None,
cam_info=None,
listener=None,
hue_interval=(0, 180)):
image_hsv = cv.CloneImage(image)
cv.CvtColor(image, image_hsv, cv.CV_RGB2HSV) #TODO: THIS SHOULD BE BGR
image_hue = cv.CreateImage(cv.GetSize(image_hsv), 8, 1)
image_gray = cv.CreateImage(cv.GetSize(image_hsv), 8, 1)
cv.CvtColor(image, image_gray, cv.CV_RGB2GRAY)
cv.Split(image_hsv, image_hue, None, None, None)
image_thresh = cv.CloneImage(image_gray)
hue_low = hue_interval[0]
hue_up = hue_interval[1]
if bg_mode == GREEN_BG:
upper_thresh = cv.CloneImage(image_hue)
lower_thresh = cv.CloneImage(image_hue)
black_thresh = cv.CloneImage(image_hue)
cv.Threshold(
image_hue, upper_thresh, 80, 255,
cv.CV_THRESH_BINARY) #upper_thresh = white for all h>80, black o/w
cv.Threshold(image_hue, lower_thresh, 40, 255, cv.CV_THRESH_BINARY_INV
) #lower_thresh = white for all h<30, black o/w
cv.Threshold(image_gray, black_thresh, 1, 255, cv.CV_THRESH_BINARY
) #black_thresh = black for pure black, white o/w
#Filter out the green band of the hue
cv.Or(upper_thresh, lower_thresh,
image_thresh) #image_thresh = white for all h<30 OR h>80
#Filter out pure black, for boundaries in birdseye
cv.And(
image_thresh, black_thresh, image_thresh
) #image_thresh = white for all non-pure-black pixels and (h<30 or h>80)
elif bg_mode == WHITE_BG:
cv.Threshold(image_gray, image_thresh, 250, 255,
cv.CV_THRESH_BINARY_INV
) #image_gray = white for all non-super white, black o/w
elif bg_mode == YELLOW_BG:
upper_thresh = cv.CloneImage(image_hue)
lower_thresh = cv.CloneImage(image_hue)
black_thresh = cv.CloneImage(image_hue)
cv.Threshold(image_hue, upper_thresh, 98, 255, cv.CV_THRESH_BINARY)
cv.Threshold(image_hue, lower_thresh, 85, 255, cv.CV_THRESH_BINARY_INV)
cv.Threshold(image_gray, black_thresh, 1, 255, cv.CV_THRESH_BINARY)
#Filter out the yellow band of the hue
cv.Or(upper_thresh, lower_thresh,
image_thresh) #image_thresh = white for all h<85 OR h>98
#Filter out pure black, for boundaries in birdseye
cv.And(
image_thresh, black_thresh, image_thresh
) #image_thresh = white for all non-pure-black pixels and (h<30 or h>80)
elif bg_mode == CUSTOM:
upper_thresh = cv.CloneImage(image_hue)
lower_thresh = cv.CloneImage(image_hue)
black_thresh = cv.CloneImage(image_hue)
cv.Threshold(image_hue, upper_thresh, hue_up, 255, cv.CV_THRESH_BINARY)
cv.Threshold(image_hue, lower_thresh, hue_low, 255,
cv.CV_THRESH_BINARY_INV)
cv.Threshold(image_gray, black_thresh, 1, 255, cv.CV_THRESH_BINARY)
#Filter out the selected band of the hue
cv.Or(upper_thresh, lower_thresh,
image_thresh) #image_thresh = white for all h outside range
#Filter out pure black, for boundaries in birdseye
cv.And(
image_thresh, black_thresh, image_thresh
) #image_thresh = white for all non-pure-black pixels and h outside range)
cv.Erode(image_thresh, image_thresh) #Opening to remove noise
cv.Dilate(image_thresh, image_thresh)
#set all pixels outside the crop_rect to black
if crop_rect:
(x, y, width, height) = crop_rect
for j in range(image_thresh.height):
for i in range(x):
image_thresh[j, i] = 0
for i in range(x + width, image_thresh.width):
image_thresh[j, i] = 0
for i in range(image_thresh.width):
for j in range(y):
image_thresh[j, i] = 0
for j in range(y + height, image_thresh.height):
image_thresh[j, i] = 0
if filter_pr2:
#Filter out grippers
cam_frame = cam_info.header.frame_id
now = rospy.Time.now()
for link in ("l_gripper_l_finger_tip_link",
"r_gripper_l_finger_tip_link"):
listener.waitForTransform(cam_frame, link, now,
rospy.Duration(10.0))
l_grip_origin = PointStamped()
l_grip_origin.header.frame_id = link
l_grip_in_camera = listener.transformPoint(cam_frame,
l_grip_origin)
camera_model = image_geometry.PinholeCameraModel()
camera_model.fromCameraInfo(cam_info)
(u, v) = camera_model.project3dToPixel(
(l_grip_in_camera.point.x, l_grip_in_camera.point.y,
l_grip_in_camera.point.z))
if link[0] == "l":
x_range = range(0, u)
else:
x_range = range(u, image_thresh.width)
if 0 < u < image_thresh.width and 0 < v < image_thresh.height:
for x in x_range:
for y in range(0, image_thresh.height):
image_thresh[y, x] = 0.0
save_num = 0
cv.SaveImage("/tmp/thresholded_%d.png" % save_num, image_thresh)
save_num = save_num + 1
return image_thresh
def show(self):
""" Process and show the current frame """
source = cv.LoadImage(self.files[self.index])
width, height = cv.GetSize(source)
center = (width / 2) + self.offset
cv.Line(source, (center, 0), (center, height), (0, 255, 0), 1)
if self.roi:
x, y, a, b = self.roi
print self.roi
width, height = ((a - x), (b - y))
mask = cv.CreateImage((width, height), cv.IPL_DEPTH_8U, 1)
cv.SetImageROI(source, (x, y, width, height))
cv.Split(source, None, None, mask, None)
gray = cv.CloneImage(mask)
cv.InRangeS(mask, self.thresholdMin, self.thresholdMax, mask)
cv.And(mask, gray, gray)
line = []
points = []
for i in range(0, height - 1):
row = cv.GetRow(gray, i)
minVal, minLoc, maxLoc, maxVal = cv.MinMaxLoc(row)
y = i
x = maxVal[0]
point = (0, 0, height - i)
if x > 0:
line.append((x, y))
s = x / sin(radians(self.camAngle))
x = s * cos(self.angles[self.index])
z = height - y
y = s * sin(self.angles[self.index])
point = (round(x, 2), round(y, 2), z)
points.append(point)
cv.PolyLine(source, [line], False, (255, 0, 0), 2, 8)
cv.ResetImageROI(source)
x, y, a, b = self.roi
cv.Rectangle(source, (int(x), int(y)), (int(a), int(b)),
(255.0, 255, 255, 0))
if self.roi:
x, y, a, b = self.roi
width, height = ((a - x), (b - y))
mask = cv.CreateImage((width, height), cv.IPL_DEPTH_8U, 1)
cv.SetImageROI(
source, (x - width, y, width, height)) # moves roi to the left
cv.Split(source, None, None, mask, None)
gray = cv.CloneImage(mask)
cv.InRangeS(mask, self.thresholdMin, self.thresholdMax, mask)
cv.And(mask, gray, gray)
line = []
points2 = []
for i in range(0, height - 1):
row = cv.GetRow(gray, i)
minVal, minLoc, maxLoc, maxVal = cv.MinMaxLoc(row)
y = i
x = maxVal[0]
point = (0, 0, height - i)
if x > 0:
line.append((x, y))
x = width - x
# left to the x-axis
s = x / sin(radians(self.camAngle))
x = s * cos(self.angles[self.index])
z = height - y # 500 higher then the other.
y = s * sin(self.angles[self.index])
a = radians(300)
nx = (cos(a) * x) - (sin(a) * y)
ny = (sin(a) * x) + (cos(a) * y)
point = (nx, ny, z)
points2.append(point)
cv.PolyLine(source, [line], False, (255, 0, 0), 2, 8)
cv.ResetImageROI(source)
x, y, a, b = self.roi
cv.Rectangle(source, (int(x), int(y)), (int(a), int(b)),
(255.0, 255, 255, 0))
if self.mode == 'mask':
cv.ShowImage('preview', mask)
return
if self.mode == 'record' and self.roi:
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 0.5, 0.5, 1)
cv.PutText(source, "recording %d" % self.index, (20, 20), font,
(0, 0, 255))
self.points.extend(points)
self.points2.extend(points2)
#self.colors.extend(colors);
cv.ShowImage('preview', source)
def main():
# create windows
create_and_position_window('Thresholded_HSV_Image', 10, 10)
create_and_position_window('RGB_VideoFrame', 10 + cam_width, 10)
create_and_position_window('Hue', 10, 10 + cam_height)
create_and_position_window('Saturation', 210, 10 + cam_height)
create_and_position_window('Value', 410, 10 + cam_height)
create_and_position_window('LaserPointer', 0, 0)
capture = setup_camera_capture()
# create images for the different channels
h_img = cv.CreateImage((cam_width, cam_height), 8, 1)
s_img = cv.CreateImage((cam_width, cam_height), 8, 1)
v_img = cv.CreateImage((cam_width, cam_height), 8, 1)
laser_img = cv.CreateImage((cam_width, cam_height), 8, 1)
cv.SetZero(h_img)
cv.SetZero(s_img)
cv.SetZero(v_img)
cv.SetZero(laser_img)
while True:
# 1. capture the current image
frame = cv.QueryFrame(capture)
if frame is None:
# no image captured... end the processing
break
hsv_image = cv.CloneImage(frame) # temporary copy of the frame
cv.CvtColor(frame, hsv_image, cv.CV_BGR2HSV) # convert to HSV
# split the video frame into color channels
cv.Split(hsv_image, h_img, s_img, v_img, None)
# Threshold ranges of HSV components.
cv.InRangeS(h_img, hmin, hmax, h_img)
cv.InRangeS(s_img, smin, smax, s_img)
cv.InRangeS(v_img, vmin, vmax, v_img)
# Perform an AND on HSV components to identify the laser!
cv.And(h_img, v_img, laser_img)
# This actually Worked OK for me without using Saturation.
#cv.cvAnd(laser_img, s_img,laser_img)
# Merge the HSV components back together.
cv.Merge(h_img, s_img, v_img, None, hsv_image)
#-----------------------------------------------------
# NOTE: default color space in OpenCV is BGR!!
# we can now display the images
cv.ShowImage('Thresholded_HSV_Image', hsv_image)
cv.ShowImage('RGB_VideoFrame', frame)
cv.ShowImage('Hue', h_img)
cv.ShowImage('Saturation', s_img)
cv.ShowImage('Value', v_img)
cv.ShowImage('LaserPointer', laser_img)
# handle events
k = cv.WaitKey(10)
if k == '\x1b' or k == 'q':
# user has press the ESC key, so exit
break
for i in range(len(hist)-1):
cur_value = hist[i]
next_value = hist[i + 1]
# still walking up the hill
if cur_value > hist[end]:
end = i
# arrived in a valley
if ((cur_value < perc * hist[end]) & (1.1 * cur_value < next_value)):
# cut out a certain depth layer
cv.Threshold(for_thresh, min_thresh, bins[start], 255, cv.CV_THRESH_BINARY)
cv.Threshold(for_thresh, max_thresh, bins[i], 255, cv.CV_THRESH_BINARY_INV)
cv.And(min_thresh, max_thresh, and_thresh)
# erode the layer and find contours
if erode:
cv.Erode(and_thresh, and_thresh, elem)
conts = cv.FindContours(and_thresh, storage, cv.CV_RETR_EXTERNAL, cv.CV_CHAIN_APPROX_SIMPLE)
# collect all interesting contours in a list
while conts:
if draw_cluster:
cv.FillPoly(contours, [conts], color_tab[c])
if len(conts) > cont_length and min_cont_area < cv.ContourArea(conts) < max_cont_area:
conts_list.append(list(conts))
conts = conts.h_next()
circles = np.asarray(storage)
print len(circles), 'circles found'
for circle in circles:
Radius, x, y = int(circle[0][2]), int(circle[0][0]), int(circle[0][1])
cv.Circle(output, (x, y), 1, cv.CV_RGB(0, 255, 0), -1, 8, 0)
cv.Circle(output, (x, y), Radius, cv.CV_RGB(255, 0, 0), 3, 8, 0)
#split image into RGB components
cv.Split(orig, rrr, ggg, bbb, None)
#process each component
channel_processing(rrr)
channel_processing(ggg)
channel_processing(bbb)
#combine images using logical 'And' to avoid saturation
cv.And(rrr, ggg, rrr)
cv.And(rrr, bbb, processed)
cv.ShowImage('before canny', processed)
# cv.SaveImage('case3_processed.jpg',processed)
#use canny, as HoughCircles seems to prefer ring like circles to filled ones.
cv.Canny(processed, processed, 5, 70, 3)
#smooth to reduce noise a bit more
cv.Smooth(processed, processed, cv.CV_GAUSSIAN, 7, 7)
cv.ShowImage('processed', processed)
#find circles, with parameter search
storage = find_circles(processed, storage, 100)
draw_circles(storage, output)
# show images
cv.ShowImage("original with circles", output)
cv.SaveImage('case1.jpg', output)
def and_planes(planes):
assert len(planes) > 0
res = planes[0]
for plane in planes[1:]:
cv.And(plane, res, res)
return res
