def avgstd_image_list(images):
mean = None
std = None
if len(images) > 0:
scale = 1. / len(images)
mean = cv.CreateImage(cv.GetSize(images[0]), cv.IPL_DEPTH_32F,
images[0].channels)
std = cv.CreateImage(cv.GetSize(images[0]), cv.IPL_DEPTH_32F,
images[0].channels)
buf = cv.CreateImage(cv.GetSize(images[0]), cv.IPL_DEPTH_32F,
images[0].channels)
for image in images:
cv.Add(image, mean, mean)
cv.Mul(image, image, buf)
cv.Add(buf, std, std)
cv.ConvertScale(mean, mean, scale)
cv.ConvertScale(std, std, scale)
cv.Mul(mean, mean, buf)
cv.Sub(std, buf, std)
cv.Pow(std, std, 0.5)
meanresult = cv.CreateImage(cv.GetSize(images[0]), images[0].depth,
images[0].channels)
stdresult = cv.CreateImage(cv.GetSize(images[0]), images[0].depth,
images[0].channels)
cv.ConvertScale(mean, meanresult)
cv.ConvertScale(std, stdresult)
del buf
del std
del mean
return (meanresult, stdresult)
def anaglyph(left_color, right_color, correction):
#create oversized image
#result = cv.CreateImage(cv.GetSize(right_color), cv.IPL_DEPTH_8U, 4)
w, h = cv.GetSize(left_color)
bgra = cv.CreateImage((w * 2, h), cv.IPL_DEPTH_8U, 4)
cv.Set(bgra, 0)
right_bgra = add_alpha_channel(right_color,
round(255 / 2.)) #cyan (remove red?)
left_bgra = add_alpha_channel(left_color,
round(255 / 2.)) #red (remove blue?, green?)
#remove blue & green from left => red
left_red = remove_channels(left_bgra, [0, 1])
#remove red from right_bgra => cyan
right_cyan = remove_channels(right_bgra, [2])
if correction < 0:
left_area = cv.GetSubRect(bgra, (-correction, 0, w, h))
right_area = cv.GetSubRect(bgra, (0, 0, w, h))
valid_area = cv.GetSubRect(bgra, (-correction, 0, w + correction, h))
else:
#copy left & right onto bgra
left_area = cv.GetSubRect(bgra, (0, 0, w, h))
right_area = cv.GetSubRect(bgra, (correction, 0, w, h))
valid_area = cv.GetSubRect(bgra, (correction, 0, w - correction, h))
cv.Add(left_red, left_area, left_area)
cv.Add(right_cyan, right_area, right_area)
#return right_cyan
#return left_red
#return left_bgra
#return bgra
return valid_area
def get_normalized_rgb_planes(r, g, b):
size = cv.GetSize(r)
# r,g,b = get_three_planes(img)
nr_plane = cv.CreateImage(size, 8, 1)
ng_plane = cv.CreateImage(size, 8, 1)
nb_plane = cv.CreateImage(size, 8, 1)
r32 = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
g32 = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
b32 = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
sum = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
cv.Zero(sum)
cv.Convert(r, r32)
cv.Convert(g, g32)
cv.Convert(b, b32)
cv.Add(r32, g32, sum)
cv.Add(b32, sum, sum)
tmp = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
cv.Div(r32, sum, tmp)
cv.ConvertScale(tmp, nr_plane, scale=255)
cv.Div(g32, sum, tmp)
cv.ConvertScale(tmp, ng_plane, scale=255)
cv.Div(b32, sum, tmp)
cv.ConvertScale(tmp, nb_plane, scale=255)
# res = image_empty_clone(img)
# cv.Merge(nr_plane,ng_plane,nb_plane,None,res)
return nr_plane, ng_plane, nb_plane
def concat_images(a, b):
img_height = max(a.height, b.height)
c = cv.CreateImage((a.width+b.width, img_height), a.depth, a.channels)
a_area = cv.GetSubRect(c, (0,0, a.width, a.height))
b_area = cv.GetSubRect(c, (a.width, 0, b.width, b.height))
cv.Add(a, a_area, a_area)
cv.Add(b, b_area, b_area)
return c
def getthresholdedimgRGeneric(R, imhsv): # A little change here. Creates images for blue and yellow (or whatever color you like). imgRed =cv.CreateImage(cv.GetSize(imhsv),8,1) imgBlue=cv.CreateImage(cv.GetSize(imhsv),8,1) imgGreen=cv.CreateImage(cv.GetSize(imhsv),8,1) imgthreshold=cv.CreateImage(cv.GetSize(imhsv),8,1) cv.InRangeS(imghsv,cv.Scalar(R["minRed"][0], R["minRed"][1], R["minRed"][2]),cv.Scalar(R["maxRed"][0], R["maxRed"][1], R["maxRed"][2]),imgRed) # Select a range of yellow color cv.InRangeS(imghsv,cv.Scalar(R["minBlue"][0], R["minBlue"][1], R["minBlue"][2]),cv.Scalar(R["maxBlue"][0], R["maxBlue"][1], R["maxBlue"][2]),imgBlue) # Select a range of blue color cv.InRangeS(imghsv,cv.Scalar(R["minGreen"][0], R["minGreen"][1], R["minGreen"][2]),cv.Scalar(R["maxGreen"][0], R["maxGreen"][1], R["maxGreen"][2]),imgGreen) # Select a range of blue color cv.Add(imgRed,imgBlue,imgthreshold) cv.Add(imgGreen, imgGreen, imgthreshold) return imgthreshold
def getthresholdedimgR4(imhsv): # A little change here. Creates images for blue and yellow (or whatever color you like). imgRed =cv.CreateImage(cv.GetSize(imhsv),8,1) imgBlue=cv.CreateImage(cv.GetSize(imhsv),8,1) imgGreen=cv.CreateImage(cv.GetSize(imhsv),8,1) imgthreshold=cv.CreateImage(cv.GetSize(imhsv),8,1) cv.InRangeS(imghsv,cv.Scalar(169, 168, 115),cv.Scalar(180, 243, 200),imgRed) # Select a range of yellow color cv.InRangeS(imghsv,cv.Scalar(100,100,100),cv.Scalar(120,255,255),imgBlue) # Select a range of blue color cv.InRangeS(imghsv,cv.Scalar(67, 103, 46),cv.Scalar(100, 209, 184),imgGreen) # Select a range of blue color cv.Add(imgRed,imgBlue,imgthreshold) cv.Add(imgGreen, imgGreen, imgthreshold) return imgthreshold
def findRectPoints(self, oldRectPoints):
hueRange = self.hueRange
satRange = self.satRange
valRange = self.valRange
clone = cv.CloneImage(self.frame)
hsv = cv.CloneImage(self.channels3)
threshold = cv.CloneImage(self.channels1)
threshold2 = cv.CloneImage(self.channels1)
cv.Smooth(clone, clone, cv.CV_GAUSSIAN, 7, 7)
cv.CvtColor(clone, hsv, cv.CV_BGR2HSV)
cv.InRangeS(hsv, (hueRange[0], satRange[0], valRange[0]),
(hueRange[1], satRange[1], satRange[1]), threshold)
cv.InRangeS(hsv, (hueRange[2], satRange[0], satRange[0]),
(hueRange[3], satRange[1], valRange[1]), threshold2)
cv.Add(threshold, threshold2, threshold)
cv.Erode(threshold, threshold, iterations=5)
cv.Dilate(threshold, threshold, iterations=5)
# cv.ShowImage(self.color, threshold)
memory = cv.CreateMemStorage(0)
clone2 = cv.CloneImage(threshold)
contours = cv.FindContours(clone2, memory, cv.CV_RETR_LIST,
cv.CV_CHAIN_APPROX_SIMPLE, (0, 0))
if not contours:
rectPoints = oldRectPoints
else:
rectPoints = cv.BoundingRect(list(contours))
return rectPoints
def CountPinkPixels(self,cv_img):
cv.Smooth(cv_img, cv_img, cv.CV_BLUR, 3);
hsv_img = cv.CreateImage(cv.GetSize(cv_img), 8, 3)
cv.CvtColor(cv_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, (120, 80, 80), (180, 255, 255), thresholded_img)
#print type(thresholded_img)
mat = cv.GetMat(thresholded_img)
#mat = hsv_img.getNumpy()
(width,height) = cv.GetSize(thresholded_img)
aveW = 0
aveH = 0
count = 0
for j in range(0,height):
for i in range(0,width):
if (mat[j,i] == 255.0):
count += 1
aveH += j
aveW += i
print i,j, mat[j,i]
aveH = aveH/count
aveW = aveW/count
overlay = cv.CreateImage(cv.GetSize(cv_img),8,3)
cv.Circle(overlay, (int(aveW), int(aveH)), 2, (255,255,255),20)
cv.Add(cv_img,overlay,cv_img)
return cv_img
def main():
root = "/Users/soswow/Documents/Face Detection/test/negative"
# root = "/Users/soswow/Documents/Face Detection/test/sets/negative"
# root = "/Users/soswow/Documents/Face Detection/test/edge_view/positive"
# root = "/Users/soswow/Documents/Face Detection/test/sobel/positive"
# root = "/Users/soswow/Documents/Face Detection/test/sets/positive"
# root = "/Users/soswow/Documents/Face Detection/test/falses"
for folder in os.listdir(root):
path = p.join(root, folder)
if p.isdir(path):
sum = cv.CreateMat(32, 32, cv.CV_32F)
cv.Zero(sum)
k = 0
for path, _ in directory_files(path):
try:
img = cv.LoadImage(path, iscolor=False)
except IOError:
continue
mat = cv.CreateMat(32, 32, cv.CV_32F)
cv.Zero(mat)
cv.Convert(cv.GetMat(img), mat)
cv.Add(mat, sum, sum)
k += 1
avg = cv.CreateMat(32, 32, cv.CV_32F)
cv.Zero(avg)
count = cv.CreateMat(32, 32, cv.CV_32F)
cv.Zero(count)
cv.Set(count, k)
cv.Div(sum, count, avg)
new_img = cv.CreateImage((32, 32), 8, 0)
cv.Zero(new_img)
cv.Convert(avg, new_img)
cv.SaveImage(p.join(root, "%s-avg.png" % folder), new_img)
def draw(self, img, pixmapper):
'''draw the icon on the image'''
if self.trail is not None:
self.trail.draw(img, pixmapper)
icon = self.img()
(px, py) = pixmapper(self.latlon)
# find top left
px -= icon.width / 2
py -= icon.height / 2
w = icon.width
h = icon.height
(px, py, sx, sy, w, h) = self.clip(px, py, w, h, img)
cv.SetImageROI(icon, (sx, sy, w, h))
cv.SetImageROI(img, (px, py, w, h))
cv.Add(icon, img, img)
cv.ResetImageROI(img)
cv.ResetImageROI(icon)
# remember where we placed it for clicked()
self.posx = px + w / 2
self.posy = py + h / 2
def 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 findRectPoints(self, oldRectPoints):
hueRange = self.hueRange
clone = cv.CloneImage(self.frame)
hsv = cv.CloneImage(self.channels3)
threshold = cv.CloneImage(self.channels1)
threshold2 = cv.CloneImage(self.channels1)
cv.CvtColor(clone, hsv, cv.CV_RGB2HSV)
cv.InRangeS(hsv, (165, 100, 100), (180, 255, 255), threshold)
cv.InRangeS(hsv, (0, 100, 100), (15, 255, 255), threshold2)
cv.Add(threshold, threshold2, threshold)
self.hue += 1
print self.hue
cv.Erode(threshold, threshold, iterations=5)
cv.Dilate(threshold, threshold, iterations=5)
cv.ShowImage(self.color, threshold)
memory = cv.CreateMemStorage(0)
clone2 = cv.CloneImage(threshold)
contours = cv.FindContours(clone2, memory, cv.CV_RETR_LIST,
cv.CV_CHAIN_APPROX_SIMPLE, (0, 0))
if not contours:
rectPoints = oldRectPoints
else:
rectPoints = cv.BoundingRect(contours)
return rectPoints
def getAverageValues2(self, images):
""" get the average values over all the images
for every two images, divides the images by 2
then adds them together
"""
if len(images) == 0:
return None
if len(images) == 1:
return images[0]
width = images[0].width
height = images[0].height
# create image with only 2's
# this will be used for division
divisionImage = cv.CreateImage((width, height), cv.IPL_DEPTH_8U, 1)
cv.Set(divisionImage, 2)
image1 = cv.CreateImage((width, height), cv.IPL_DEPTH_8U, 1)
image2 = cv.CreateImage((width, height), cv.IPL_DEPTH_8U, 1)
avgImage = cv.CloneImage(images[0])
for image in images:
# divide images by 2
cv.Div(avgImage, divisionImage, image1)
cv.Div(image, divisionImage, image2)
# add them to get result
cv.Add(image1, image2, avgImage)
return avgImage
def locateMarker(self, frame):
self.frameReal = cv.CloneImage(frame)
self.frameImag = cv.CloneImage(frame)
self.frameRealThirdHarmonics = cv.CloneImage(frame)
self.frameImagThirdHarmonics = cv.CloneImage(frame)
# Calculate convolution and determine response strength.
cv.Filter2D(self.frameReal, self.frameReal, self.matReal)
cv.Filter2D(self.frameImag, self.frameImag, self.matImag)
cv.Mul(self.frameReal, self.frameReal, self.frameRealSq)
cv.Mul(self.frameImag, self.frameImag, self.frameImagSq)
cv.Add(self.frameRealSq, self.frameImagSq, self.frameSumSq)
# Calculate convolution of third harmonics for quality estimation.
cv.Filter2D(self.frameRealThirdHarmonics, self.frameRealThirdHarmonics,
self.matRealThirdHarmonics)
cv.Filter2D(self.frameImagThirdHarmonics, self.frameImagThirdHarmonics,
self.matImagThirdHarmonics)
min_val, max_val, min_loc, max_loc = cv.MinMaxLoc(self.frameSumSq)
self.lastMarkerLocation = max_loc
(xm, ym) = max_loc
self.determineMarkerOrientation(frame)
self.determineMarkerQuality()
return max_loc
def detect_and_draw(img):
t1 = time.time()
# allocate temporary images
gray = cv.CreateImage((img.width, img.height), 8, 1)
small_img = cv.CreateImage((cv.Round(
img.width / image_scale), cv.Round(img.height / image_scale)), 8, 1)
# blur the source image to reduce color noise
cv.Smooth(img, img, cv.CV_BLUR, 3)
hsv_img = cv.CreateImage(cv.GetSize(img), 8, 3)
cv.CvtColor(img, hsv_img, cv.CV_BGR2HSV)
thresholded_img = cv.CreateImage(cv.GetSize(hsv_img), 8, 1)
#cv.InRangeS(hsv_img, (120, 80, 80), (140, 255, 255), thresholded_img)
# White
sensitivity = 15
cv.InRangeS(hsv_img, (0, 0, 255 - sensitivity), (255, sensitivity, 255),
thresholded_img)
# Red
#cv.InRangeS(hsv_img, (0, 150, 0), (5, 255, 255), thresholded_img)
# Blue
#cv.InRangeS(hsv_img, (100, 50, 50), (140, 255, 255), thresholded_img)
# Green
#cv.InRangeS(hsv_img, (40, 50, 50), (80, 255, 255), thresholded_img)
mat = cv.GetMat(thresholded_img)
moments = cv.Moments(mat, 0)
area = cv.GetCentralMoment(moments, 0, 0)
# scale input image for faster processing
cv.Resize(gray, small_img, cv.CV_INTER_LINEAR)
cv.EqualizeHist(small_img, small_img)
if (area > 5000):
#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
x = int(round(x))
y = int(round(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, (0, 0, 0), 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)
t2 = time.time()
message = "Color tracked!"
print "detection time = %gs x=%d,y=%d" % (round(t2 - t1, 3), x, y)
cv.ShowImage("Color detection", img)
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 __add__(self, addend):
"""Add two images together -> cvImg
"""
bmp = self.empty()
if isinstance(addend, Img):
cv.Add(self.cv_rep(), addend.cv_rep(), bmp)
else:
cv.AddS(self.cv_rep(), cv.Scalar(addend, addend, addend), bmp)
return bmp
def getthresholdedimg(im):
'''this function take RGB image.Then convert it into HSV for easy colour detection and threshold it with yellow part as white and all other regions as black.Then return that image'''
imghsv=cv.CreateImage(cv.GetSize(im),8,3)
cv.CvtColor(im,imghsv,cv.CV_BGR2HSV)#CV_BGR2HSV# Convert image from RGB to HSV
# A little change here. Creates images for green,blue and yellow (or whatever color you like).
imgyellow=cv.CreateImage(cv.GetSize(im),8,1)
imgblue=cv.CreateImage(cv.GetSize(im),8,1)
imggreen=cv.CreateImage(cv.GetSize(im),8,1)
imgthreshold=cv.CreateImage(cv.GetSize(im),8,1)
cv.InRangeS(imghsv,cv.Scalar(85,100,100),cv.Scalar(95,255,255),imggreen)
cv.InRangeS(imghsv,cv.Scalar(20,100,100),cv.Scalar(30,255,255),imgyellow)#imgyellow# Select a range of yellow color
cv.InRangeS(imghsv,cv.Scalar(100,100,100),cv.Scalar(120,255,255),imgblue)#imgblue# Select a range of blue color
# Add everything
cv.Add(imgyellow,imgblue,imgthreshold)
cv.Add(imgthreshold,imggreen,imgthreshold)
return imgthreshold
def getthresholdedimg(imhsv): #Get component colors imgyellow=cv.CreateImage(cv.GetSize(imhsv),8,1) imgblue=cv.CreateImage(cv.GetSize(imhsv),8,1) imgthreshold=cv.CreateImage(cv.GetSize(imhsv),8,1) cv.InRangeS(imghsv,cv.Scalar(20,100,100),cv.Scalar(30,255,255),imgyellow) # Select a range of yellow color cv.InRangeS(imghsv,cv.Scalar(100,100,100),cv.Scalar(120,255,255),imgblue) # Select a range of blue color cv.Add(imgyellow,imgblue,imgthreshold) return imgthreshold
def drawPointOnImage(self,img,object_position):
try:
object_indicator = cv.CreateImage(cv.GetSize(img), img.depth, 3)
cv.Circle(object_indicator, object_position, 12, (0,0,255), 4)
cv.Add(img, object_indicator, img)
except:
pass
# object_indicator = cv.CreateImage(cv.GetSize(img), img.depth, 1)
# cv.Circle(object_indicator, object_position, 12, (0), 4)
# cv.Add(img, object_indicator, img)
return img
def main():
color_tracker_window = "output"
thresh_window = "thresh"
capture = cv.CaptureFromCAM(-1)
cv.NamedWindow(color_tracker_window, 1)
cv.NamedWindow(thresh_window, 1)
imgScrible = None
global posX
global posY
fido.init_servos()
while True:
frame = cv.QueryFrame(capture)
cv.Smooth(frame, frame, cv.CV_BLUR, 3)
if (imgScrible is None):
imgScrible = cv.CreateImage(cv.GetSize(frame), 8, 3)
imgThresh = GetThresholdedImage(frame)
mat = cv.GetMat(imgThresh)
#Calculating the moments
moments = cv.Moments(mat, 0)
area = cv.GetCentralMoment(moments, 0, 0)
moment10 = cv.GetSpatialMoment(moments, 1, 0)
moment01 = cv.GetSpatialMoment(moments, 0, 1)
#lastX and lastY stores the previous positions
lastX = posX
lastY = posY
#Finding a big enough blob
if (area > 100000):
#Calculating the coordinate postition of the centroid
posX = int(moment10 / area)
posY = int(moment01 / area)
print 'x: ' + str(posX) + ' y: ' + str(posY) + ' area: ' + str(
area)
#drawing lines to track the movement of the blob
if (lastX > 0 and lastY > 0 and posX > 0 and posY > 0):
cv.Line(imgScrible, (posX, posY), (lastX, lastY),
cv.Scalar(0, 255, 255), 5)
#Adds the three layers and stores it in the frame
#frame -> it has the camera stream
#imgScrible -> it has the line tracking the movement of the blob
cv.Add(frame, imgScrible, frame)
cv.ShowImage(thresh_window, imgThresh)
cv.ShowImage(color_tracker_window, frame)
c = cv.WaitKey(10)
if (c != -1):
break
def addGaussianNoise(image_path, save_path):
img = cv.LoadImage(image_path)
noise = cv.CreateImage(cv.GetSize(img), img.depth, img.nChannels)
cv.SetZero(noise)
rng = cv.RNG(-1)
cv.RandArr(rng, noise, cv.CV_RAND_NORMAL, cv.ScalarAll(0),
cv.ScalarAll(25))
cv.Add(img, noise, img)
tempName = os.path.splitext(
os.path.basename(image_path))[0] + "_noised.jpg"
save_image = os.path.join(save_path, tempName)
cv.SaveImage(save_image, img)
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 cam_measurebulk(nframes=100,
interactive=True,
show=True,
norm=False,
verb=0):
"""
Take **nframes** frames and average these. If **norm** is set, set the
average of the summed frame to unity, otherwise it is divided by the
number of frames.
This routine is intended to measure flat and dark frames. Flat frames
might be normalized such that dividing by these does not affect the
average intensity of the input frame. Dark frames should never be
normalized.
The flatfield is stored in CAM_CFG['flat'] and is used automatically
from then on.
@param [in] nframes Number of frames to average
@param [in] show Show flat field + one correct image when done
@param [in] verb Verbosity
@return Summed and scaled frame.
"""
if (verb & VERB_M > L_INFO):
print "Measuring bulk (n=%d)..." % (nframes)
if (interactive):
print "Will measure bulk now, press c to continue..."
while (True):
cam_getimage(show=True, waitkey=0)
if (chr(cv.WaitKey(1) & 255) == "c"):
print "ok!"
break
bulkimg = cam_getimage(show=False, dfcorr=False, raw=True)
for dummy in xrange(nframes - 1):
cv.Add(bulkimg, cam_getimage(show=False, dfcorr=False, raw=True),
bulkimg)
if (norm):
cv.ConvertScale(bulkimg, bulkimg, scale=1.0 / cv.Avg(bulkimg)[0])
else:
cv.ConvertScale(bulkimg, bulkimg, scale=1.0 / nframes)
if (show):
cv.NamedWindow("cam_bulkimg", cv.CV_WINDOW_AUTOSIZE)
cv.ShowImage('cam_bulkimg', bulkimg)
c = cv.WaitKey(20)
return bulkimg
def max_contrast(image):
"""Maximise the contrast of an image using top and bottom hat filters."""
size = cv.GetSize(image)
bh = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1)
th = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1)
s1 = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1)
s2 = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1)
el = cv.CreateStructuringElementEx(3, 3, 1, 1, cv.CV_SHAPE_ELLIPSE)
cv.MorphologyEx(image, th, None, el, cv.CV_MOP_TOPHAT, 1)
cv.MorphologyEx(image, bh, None, el, cv.CV_MOP_BLACKHAT, 1)
cv.Add(image, th, s1)
cv.Sub(s1, bh, s2)
return s2
def crunch(): size = cv.GetSize(band3) assert size == cv.GetSize(band4) numerator = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) cv.Sub(band4, band3, numerator) denominator = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) cv.Add(band4, band3, denominator) ndvi_img = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1) cv.Div(numerator, denominator, ndvi_img) # (NDVI + 1) cv.AddS(ndvi_img, 1, ndvi_img) return ndvi_img
def average_image_list(images):
result = None
if len(images) > 0:
scale = 1. / len(images)
mean = cv.CreateImage(cv.GetSize(images[0]), cv.IPL_DEPTH_32F,
images[0].channels)
result = cv.CreateImage(cv.GetSize(images[0]), images[0].depth,
images[0].channels)
for image in images:
cv.Add(image, mean, mean)
cv.ConvertScale(mean, mean, scale)
cv.ConvertScale(mean, result)
del mean
return result
def image_processor():
cv.Smooth(gray_image, gray_image, cv.CV_GAUSSIAN, 3,
3) #Blurring to remove some noise
cv.AbsDiff(prev_image, gray_image,
accumulator) #Getting the difference image
cv.InRangeS(accumulator, threshold_limit1_lower, threshold_limit1_upper,
accumulator) #Thresholding the difference image
cv.Dilate(accumulator, accumulator, None,
2) #Dilating the thresholded difference image
cv.Add(accumulator, sum_image, sum_image,
accumulator) #Adding the image to a register to use fading
cv.SubS(sum_image, fading_factor, sum_image) #Fading
cv.InRangeS(sum_image, threshold_limit2_lower, threshold_limit2_upper,
accumulator) #Thresholding the fading image
cv.Copy(gray_image, prev_image)
cv.Copy(accumulator, temp_image)
def edge_magnitude(image):
magnitude32f = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_32F, 1)
horizontal = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_16S, 1)
vertical = cv.CloneImage(horizontal)
magnitude = cv.CloneImage(horizontal)
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)
return mag
def getthresholdedimg(im):
'''this function take RGB image.Then convert it into HSV for easy colour detection and threshold it with yellow and blue part as white and all other regions as black.Then return that image'''
global imghsv
imghsv = cv.CreateImage(cv.GetSize(im), 8, 3)
cv.CvtColor(im, imghsv, cv.CV_BGR2HSV)
imgyellow = cv.CreateImage(cv.GetSize(im), 8, 1)
imgblue = cv.CreateImage(cv.GetSize(im), 8, 1)
imgthreshold = cv.CreateImage(cv.GetSize(im), 8, 1)
cv.InRangeS(imghsv, cv.Scalar(20, 100, 100), cv.Scalar(30, 255, 255),
imgyellow) # Select a range of yellow color
cv.InRangeS(imghsv, cv.Scalar(100, 100, 100), cv.Scalar(120, 255, 255),
imgblue) # Select a range of blue color
cv.Add(imgyellow, imgblue, imgthreshold)
return imgthreshold
