def diff(img1, img2, result):
im1 = cv.LoadImage(img1, 1)
im2 = cv.LoadImage(img2, 1)
mat1 = cv.GetMat(im1)
mat2 = cv.GetMat(im2)
a = numpy.asarray(mat1)
diff = cv.CloneMat(mat1)
cv.AbsDiff(mat1, mat2, diff)
c = numpy.asarray(diff)
difference = c.sum(axis=2)
differenceNonZeroes = difference.nonzero()
res = float(differenceNonZeroes[0].size) / difference.size
diffNonZeroes = c.nonzero()
positions = []
for pos in range(len(diffNonZeroes[0])):
for dim in range(len(diffNonZeroes)):
positions.append(diffNonZeroes[dim][pos])
a[positions[0]][positions[1]] = [0, 0, 255]
positions = []
cv.SaveImage(result, cv.fromarray(a))
return res
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 detect_card(grey_image, grey_base, thresh=100):
diff = cv.CloneImage(grey_image)
cv.AbsDiff(grey_image, grey_base, diff)
edges = cv.CloneImage(grey_image)
cv.Canny(diff, edges, thresh, thresh)
contours = cv.FindContours(edges, cv.CreateMemStorage(0))
edge_pts = []
c = contours
while c is not None:
if len(c) > 10:
edge_pts += list(c)
if len(c) == 0: #'cus opencv is buggy and dumb
break
c = c.h_next()
if len(edge_pts) == 0:
return None
hull = cv.ConvexHull2(edge_pts, cv.CreateMemStorage(0), cv.CV_CLOCKWISE, 1)
lines = longest_lines(hull)
perim = sum(l['len'] for l in lines)
#print perim
#likely to be a card. . .
#if abs(perim - 1200) < 160:
if perim > 700:
#extrapolate the rectangle from the hull.
#if our 4 longest lines make up 80% of our perimiter
l = sum(l['len'] for l in lines[0:4])
#print "l = ",l
if l / perim > 0.7:
#we probably have a high-quality rectangle. extrapolate!
sides = sorted(lines[0:4], key=lambda x: x['angle'])
#sides are in _some_ clockwise order.
corners = [None] * 4
# TODO: figure out why we can get an IndexError on xrange(4)
try:
for n in xrange(4):
corners[n] = line_intersect(sides[n], sides[(n + 1) % 4])
if not all(corners):
return None
except IndexError:
print >> sys.stderr, "detect_card() IndexError(), we should track down why this happens exactly"
return None
#rotate corners so top-left corner is first.
#that way we're clockwise from top-left
sorted_x = sorted(c[0] for c in corners)
sorted_y = sorted(c[1] for c in corners)
top_left = None
for index, (x, y) in enumerate(corners):
if sorted_x.index(x) < 2 and sorted_y.index(y) < 2:
top_left = index
if top_left is None:
return None
#return rotated list
return corners[top_left:] + corners[:top_left]
return None
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 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 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 accumulateBackground(self, img):
cv.CvtScale(img, self.Iscratch, 1, 0)
if (not self.first):
cv.Acc(self.Iscratch, self.IavgF)
cv.AbsDiff(self.Iscratch, self.IprevF, self.Iscratch2)
cv.Acc(self.Iscratch2, self.IdiffF)
self.Icount += 1.0
self.first = 0
cv.Copy(self.Iscratch, self.IprevF)
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 accumulateBackground(img):
global first, Icount
cv.CvtScale(img, Iscratch, 1, 0)
if (not first):
cv.Acc(Iscratch, IavgF)
cv.AbsDiff(Iscratch, IprevF, Iscratch2)
cv.Acc(Iscratch2, IdiffF)
Icount += 1.0
first = 0
cv.Copy(Iscratch, IprevF)
def estimaBG(frames):
npixels = cv.GetSize(frames[0])[1] * cv.GetSize(frames[0])[0]
gray = cv.CreateImage(cv.GetSize(frames[0]), cv.IPL_DEPTH_8U, 1)
frAbsDif = cv.CloneImage(gray)
frThrDif = cv.CloneImage(gray)
frAnt = cv.CloneImage(gray)
# converte cada quadro para cinza
cinzas = []
for fr in frames:
gray = cv.CreateImage(cv.GetSize(frames[0]), cv.IPL_DEPTH_8U, 1)
cv.CvtColor(fr, gray, cv.CV_RGB2GRAY)
cinzas.append(gray)
iframe = 1
fundos = []
for fr in cinzas[1:]:
frAnt = cinzas[iframe - 1]
cv.AbsDiff(frAnt, fr, frAbsDif)
pixelsDiferentesAbs = cv.CountNonZero(frAbsDif)
# limiariza para evitar diferencas muito pequenas.
cv.Threshold(frAbsDif, frThrDif, 120, 255, cv.CV_THRESH_TOZERO)
# se a direrença for zero, considera a imagem para a mediana dos fundos
pixelsDiferentesThr = cv.CountNonZero(frThrDif)
print("Pixels diferentes do threeshold: " + str(pixelsDiferentesThr))
if pixelsDiferentesThr < 30:
#print 'Imagem adicionada para determinacao do background...'
fundos.append((frames[iframe], cv.CloneImage(frThrDif),
cv.CloneImage(frThrDif), pixelsDiferentesAbs,
pixelsDiferentesThr))
iframe += 1
if not fundos:
print 'Não foi possivel determinar o fundo usando os primeiros %d frames da imagem' % len(
frames)
sys.exit(1)
# pega o menor threshold absoluto, ordenando e pegando o primeiro.
def porThr(a, b):
return cmp(a[3], b[3])
fundos.sort(porThr)
# retorna o que apresentou melhor diferença com relação ao anterior
return fundos[0][0]
return fr
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 test_crop_oriented_boxes(self):
box_num = 0
for cropped_image in oriented_bounding_boxes.cropped_oriented_boxes(
"test/test_case_bbox.xml", "test/test_case.png"):
box_num += 1
gold_standard = cv.LoadImage("test/test_case_%03d.png" % box_num)
self.assertEquals(cv.GetElemType(cropped_image),
cv.GetElemType(gold_standard))
self.assertEquals(cv.GetSize(cropped_image),
cv.GetSize(gold_standard))
diff = cv.CloneImage(gold_standard)
cv.AbsDiff(cropped_image, gold_standard, diff)
self.assertEquals(cv.Sum(diff), (0, 0, 0, 0))
def tryToDetect(self):
if time.time() - self.lastTime >= 0.5:
self.current = self.getGrayImage(cv.GetSize(self.previous))
diffImg = cv.CloneImage(self.previous)
cv.AbsDiff(self.previous, self.current, diffImg)
avg = cv.Avg(diffImg)
self.previous = cv.CloneImage(self.current)
self.lastTime = time.time()
self.motionFactor = self.getMotionFactor(avg[0])
self.actualAvgDiff = avg[0]
else:
self.getFrame()
def getDiff(self, frame):
diffImg = cv.CloneImage(self.referencedImage)
cv.Smooth(frame, frame, cv.CV_GAUSSIAN, 9, 0)
cv.AbsDiff(self.referencedImage, frame, diffImg)
greyImg = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
cv.CvtColor(diffImg, greyImg, cv.CV_RGB2GRAY)
cv.Threshold(greyImg, greyImg, 30, 255, cv.CV_THRESH_BINARY)
cv.Dilate(greyImg, greyImg, None, 9)
cv.Erode(greyImg, greyImg, None, 5)
# return greyImg
return greyImg
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 detecta(imagem):
cv.Smooth(imagem, imagem, cv.CV_GAUSSIAN, 3)
maiorArea = 0
listaContornos = []
listaVertices = []
cv.AbsDiff(imagem, fundo, mascara)
cv.CvtColor(mascara, cinza, cv.CV_BGR2GRAY)
cv.Threshold(cinza, cinza, 50, 255, cv.CV_THRESH_BINARY)
cv.Dilate(cinza, cinza, None, 18)
cv.Erode(cinza, cinza, None, 18)
armazenamento = cv.CreateMemStorage(0)
contorno = cv.FindContours(cinza, armazenamento, cv.CV_RETR_LIST,
cv.CV_LINK_RUNS)
while contorno:
vertices_do_retangulo = cv.BoundingRect(list(contorno))
listaVertices.append(vertices_do_retangulo)
listaContornos.append(cv.ContourArea(contorno))
maiorArea = max(listaContornos)
maiorArea_index = listaContornos.index(maiorArea)
retangulo_de_interesse = listaVertices[maiorArea_index]
contorno = contorno.h_next()
ponto1 = (retangulo_de_interesse[0], retangulo_de_interesse[1])
ponto2 = (retangulo_de_interesse[0] + retangulo_de_interesse[2],
retangulo_de_interesse[1] + retangulo_de_interesse[3])
cv.Rectangle(imagem, ponto1, ponto2, cv.CV_RGB(0, 0, 0), 2)
cv.Rectangle(cinza, ponto1, ponto2, cv.CV_RGB(255, 255, 255), 1)
largura = ponto2[0] - ponto1[0]
altura = ponto2[1] - ponto1[1]
cv.Line(cinza, (ponto1[0] + largura / 2, ponto1[1]),
(ponto1[0] + largura / 2, ponto2[1]), cv.CV_RGB(255, 255,
255), 1)
cv.Line(cinza, (ponto1[0], ponto1[1] + altura / 2),
(ponto2[0], ponto1[1] + altura / 2), cv.CV_RGB(255, 255,
255), 1)
global x
x = ((640 / 2 - (ponto1[0] + (largura / 2))) * -1) / 5
cv.ShowImage("Webcam", imagem)
cv.ShowImage("Mascara", mascara)
cv.ShowImage("Cinza", cinza)
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 detectMotion(self, curr):
assert (curr.nChannels == 1)
if len(self.history_frames) < self.nHistory:
self.history_frames.append(curr)
return curr
else:
oldest_frame = self.history_frames.pop(0)
self.history_frames.append(curr)
size = (curr.width, curr.height)
motion_frame = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1)
cv.AbsDiff(oldest_frame, curr, motion_frame)
cv.CmpS(motion_frame, self.threshold, motion_frame, cv.CV_CMP_GT)
# Eliminate disperse pixels, which occur because of
# the noise of the camera
img_temp = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1)
cv.Erode(motion_frame, img_temp)
cv.Dilate(img_temp, motion_frame)
return motion_frame
def difference(il,tol):
if(len(list(il))<2):
return True
i1=list(il)[0]
i2=list(il)[1]
temp = cv.CreateImage((i1.width,i1.height),i1.depth,i1.nChannels)
cv.AbsDiff(i1,i2,temp)
#cv.ConvertScale(temp,temp,20)
#cv.ShowImage("difference",temp)
mean = cv.Avg(temp)
#cv.SetImageCOI(temp,2)
#mmlvec = cv.MinMaxLoc(temp)
#print mean,mmlvec
mean = (mean[0]+mean[1]+mean[2])/3
if(mean > tol):
return True
return False
def run(self):
while True:
if time.time() - self.lastTime >= 0.5:
self.current = self.getGrayImage(cv.GetSize(self.previous))
diffImg = cv.CloneImage(self.previous)
cv.AbsDiff(self.previous, self.current, diffImg)
avg = cv.Avg(diffImg)
#print "\t" + str(avg[0] > 5)
print "\t" + str(avg[0])
self.previous = cv.CloneImage(self.current)
self.lastTime = time.time()
else:
self.getFrame()
if time.time() - self.startTime > 20:
break
print "\n>> END <<\n"
def evaluatePolygonLabelRaw(polygons, gtImage, maskImage, foundZeros, image):
#splat the results to an image
labelImage = getBlankLabelImage(image)
visualizePolygons(labelImage, polygons)
#get the label image and rescale it to the correct size, if necessary
labelImageRescale = cv.CreateImage(cv.GetSize(gtImage), cv.IPL_DEPTH_8U, 1)
cv.Resize(labelImage, labelImageRescale)
labelImage = labelImageRescale
#compute the difference -- this is 0 if correct
cv.AbsDiff(labelImage, gtImage, labelImage)
w, h = cv.GetSize(gtImage)
#mask out unknown values
cv.Set(labelImage, 1, maskImage)
#return (Total Pixels - incorrect) / (total pixels)
nPixValid = w * h - foundZeros
return float(w * h - cv.CountNonZero(labelImage)) / nPixValid
def doloop():
global depth, rgb
for i in range(1,10):
(depth,_), (rgb,_) = get_depth(), get_video()
bg=cv.CloneMat(cv.fromarray(depth.astype(numpy.uint8)))
scratch = cv.CreateImage((640,480),8,1)
scratch2 = cv.CreateImage((640,480),8,1)
cv.SaveImage('bg.png',bg)xz
while True:
# Get a fresh frame
(depth,_), (rgb,_) = get_depth(), get_video()
depth=cv.fromarray(depth.astype(numpy.uint8))
cv.AbsDiff(bg,depth,scratch)
cv.Sub(scratch,2,10,scratch2)
# cv.ConvertScale(scratch,scratch2,50)
cv.Add(depth,scratch2,scratch2)
# Simple Downsample
cv.ShowImage('both',scratch2)
cv.WaitKey(10)
def motiondetect(self, img):
gray = cv.CreateImage(self.size, 8, 1)
cv.CvtColor(img, gray, cv.CV_BGR2GRAY)
if not self.oldimg or (time.time() - self.lasttime) > 1:
self.oldimg = cv.CreateImage(self.size, 8, 1)
cv.Copy(gray, self.oldimg)
self.lasttime = time.time()
return 0
self.lasttime = time.time()
diff = cv.CreateImage(self.size, 8, 1)
cv.AbsDiff(gray, self.oldimg, diff)
thr = cv.CreateImage(self.size, 8, 1)
movement = cv.CreateImage(self.size, 8, 1)
cv.SetZero(movement)
cv.Threshold(diff, thr, 30, 1, cv.CV_THRESH_BINARY)
movecount = cv.CountNonZero(thr)
color = cv.CreateImage(self.size, 8, 3)
cv.Set(color, (255, 0, 0))
cv.Copy(color, img, thr)
cv.Copy(diff, movement, thr)
cv.ShowImage("movement" + str(self.channel), movement)
writetext(
img, 'c' + str(self.channel) + ' a' +
str(int(self.core.bucket.value)) + ' m' + str(movecount))
cv.ShowImage("camera" + str(self.channel), img)
cv.Copy(gray, self.oldimg)
self.lasttime = time.time()
return movecount
def init_track_window(self, frame):
win_name = 'Tracks'
cv.NamedWindow(win_name, cv.CV_WINDOW_NORMAL)
frame_size = cv.GetSize(frame)
# Sample Grayscale Image
gray = cv.CreateImage(frame_size, cv.IPL_DEPTH_8U, 1)
'''Edge Detection for giving background reference to the tracks'''
canny_thres = 300 if self.opt == 'file' else 150
# Plain White Image for inverting purposes
white_image = cv.CloneImage(gray)
cv.Set(white_image, 255)
# Detecting edge, inverting colors and creating a colored image
gray_frame = cv.CloneImage(gray)
cv.CvtColor(frame, gray_frame, cv.CV_RGB2GRAY)
cv.Smooth(gray_frame, gray_frame, cv.CV_GAUSSIAN, 3, 0)
cv.Canny(gray_frame, gray_frame, canny_thres, 0, 3)
cv.Threshold(gray_frame, gray_frame, 70, 70, cv.CV_THRESH_BINARY)
cv.AbsDiff(gray_frame, white_image, gray_frame)
track_image = cv.CreateImage(frame_size, 8, 3)
cv.CvtColor(gray_frame, track_image, cv.CV_GRAY2RGB)
return track_image, win_name
def get_motion_mask(first_frame, second_frame):
cv.Smooth(first_frame, first_frame, cv.CV_GAUSSIAN, GAUSSIAN_BLUR_FACTOR_1,
0) #smooth/blur inicial para eliminar ruido
cv.Smooth(second_frame, first_frame, cv.CV_GAUSSIAN,
GAUSSIAN_BLUR_FACTOR_1,
0) #smooth/blur inicial para eliminar ruido
#cv.RunningAvg( color_image, running_average_image, 0.320, None )#obtencion de un promedio de frames
#cv.ConvertScale( running_average_image, running_average_in_display_color_depth, 1.0, 0.0 ) #conversion de escala
cv.AbsDiff(first_frame, second_frame,
difference) #diferencia entre la imagen promedio y la original
cv.CvtColor(difference, grey_image,
cv.CV_RGB2GRAY) #conversion de la imagen a escala de grises
cv.Threshold(grey_image, grey_image, BINARY_THRESHOLD_1, 255,
cv.CV_THRESH_BINARY) #binarizacion de la imagen
#dilatacion y afinamiento de las manchas para crear blobs mas definidos
cv.Dilate(grey_image, grey_image, None, 4)
cv.Erode(grey_image, grey_image, None, 4)
cv.Smooth(grey_image, grey_image, cv.CV_GAUSSIAN, GAUSSIAN_BLUR_FACTOR_2,
0) #otro smooth aplicado para eliminar pequenas manchas
cv.Threshold(
grey_image, grey_image, BINARY_THRESHOLD_2, 255,
cv.CV_THRESH_BINARY) #rebinarizacion para eliminar pequenas manchas
return grey_image
# FPS calc
if DISPLAY:
framecnt = framecnt + 1
ctime = time()
if ctime - stime >= 1:
print '%ifps' % (framecnt)
framecnt = 0
stime = ctime
# Get original image
img = cv.QueryFrame(cam)
# Adaptive diff
#cv.Smooth(img, col, cv.CV_GAUSSIAN, 3, 0)
cv.AddWeighted(img, 1 - ADAPT, avg, ADAPT, 0, avg)
cv.AbsDiff(img, avg, col)
cv.CvtColor(col, col, cv.CV_RGB2HSV)
cv.Split(col, None, None, val, None)
cv.CmpS(val, TH, val, cv.CV_CMP_GE)
#cv.Dilate(val, val, None, 18)
#cv.Erode(val, val, None, 10)
dif = cv.CountNonZero(val)
# Show image if it's radically new
if (dif < PIXCOUNT):
if act < 0:
act = ACTLOW
else:
act -= 1
else:
if act > 0:
frameT0 = time.time()
displayImage = cv.CloneImage(cameraImage)
colourImage = cv.CloneImage(displayImage)
cv.Smooth(colourImage, colourImage, cv.CV_GAUSSIAN, 19, 0)
# Use the Running Average as the static background
# a = 0.020 leaves artifacts lingering way too long.
# a = 0.320 works well at 320x240, 15fps. (1/a is roughly num frames.)
cv.RunningAvg(colourImage, runningAverageImage, 0.64, None)
cv.ConvertScale(runningAverageImage, runningAverageInDisplayColourDepth,
1.0, 0)
#Get the difference between the content and the running average
cv.AbsDiff(colourImage, runningAverageInDisplayColourDepth, difference)
#Convert the difference image to grayscale
cv.CvtColor(difference, greyImage, cv.CV_RGB2GRAY)
# Threshold to difference image to a black and whit motion mask
cv.Threshold(greyImage, greyImage, 2, 255, cv.CV_THRESH_BINARY)
# Smooth and Threshold again to eliminate artifacts
cv.Smooth(greyImage, greyImage, cv.CV_GAUSSIAN, 19, 0)
cv.Threshold(greyImage, greyImage, 240, 255, cv.CV_THRESH_BINARY)
# Turn the greay image into an array
greyImageAsArray = numpy.asarray(cv.GetMat(greyImage))
nonBlackCoordinatesArray = numpy.where(greyImageAsArray > 3)
nonBlackCoordinatesArray = zip(nonBlackCoordinatesArray[1],
nonBlackCoordinatesArray[0])
def absdiff(self, input1, input2):
output = cv.CloneImage(input1)
cv.AbsDiff(input1, input2, output)
return output
def run(self):
# Capture first frame to get size
frame = cv.QueryFrame(self.capture)
frame_size = cv.GetSize(frame)
new_size = ( frame_size[0] / 2, frame_size[1] / 2)
color_image = cv.CreateImage(new_size, 8, 3)
grey_image = cv.CreateImage(new_size, cv.IPL_DEPTH_8U, 1)
moving_average = cv.CreateImage(new_size, cv.IPL_DEPTH_32F, 3)
font = cv.InitFont(cv.CV_FONT_HERSHEY_COMPLEX_SMALL, 1, 1, 0, 1, 1)
first = True
k = 0
while True:
k+=1
captured_image = cv.QueryFrame(self.capture)
color_image = cv.CreateImage(new_size, captured_image.depth, captured_image.nChannels)
cv.Resize(captured_image, color_image)
# Smooth to get rid of false positives
cv.Smooth(color_image, color_image, cv.CV_GAUSSIAN, 3, 0)
if first:
difference = cv.CloneImage(color_image)
temp = cv.CloneImage(color_image)
cv.ConvertScale(color_image, moving_average, 1.0, 0.0)
first = False
else:
cv.RunningAvg(color_image, moving_average, 0.020, None)
# Convert the scale of the moving average.
cv.ConvertScale(moving_average, temp, 1.0, 0.0)
# Minus the current frame from the moving average.
cv.AbsDiff(color_image, temp, difference)
# Convert the image to grayscale.
cv.CvtColor(difference, grey_image, cv.CV_RGB2GRAY)
# Convert the image to black and white.
cv.Threshold(grey_image, grey_image, 70, 255, cv.CV_THRESH_BINARY)
# Dilate and erode to get people blobs
cv.Dilate(grey_image, grey_image, None, 18)
cv.Erode(grey_image, grey_image, None, 10)
storage = cv.CreateMemStorage(0)
contour = cv.FindContours(grey_image, storage, cv.CV_RETR_CCOMP, cv.CV_CHAIN_APPROX_TC89_KCOS)
points = []
#cv.DrawContours(color_image, contour, cv.CV_RGB(255,0,0), cv.CV_RGB(255,0,255), 2, 1, 8, (0, 0))
i = 0
while contour:
self.observed_occupancy = True
bound_rect = cv.BoundingRect(list(contour))
center_x = bound_rect[0] + (bound_rect[2]/2)
center_y = bound_rect[1] + (bound_rect[3]/2)
#if center_y < 200:
# continue
i+=1
closest_distance = 10000
closest_object = None
for to in self.tracked_objects:
current_distance = math.hypot(to.latest_position[0] - center_x, to.latest_position[1] - center_y)
closest_distance = min(closest_distance, current_distance)
#print "DISTANCES: ", str(closest_distance), str(current_distance)
if current_distance == closest_distance:
closest_object = to
if closest_object is None:
#print "OBJECT IS NEW"
self.tracked_objects.append(TrackedObject((center_x, center_y), [(center_x, center_y)], "new"))
else:
#print "CLOSEST OBJECT: ", closest_object.latest_position
closest_object.movement_vector.append((center_x, center_y))
closest_object.latest_position = (center_x, center_y)
#print "AMOUNT OF OBJECTS: ", str(len(self.tracked_objects))
if closest_object is not None:
cv.Line(color_image, closest_object.latest_position, (center_x, center_y), cv.CV_RGB(0,255,0))
#closest_x = min(closest_x, to.latest_position[0])
#closest_y = min(closest_y, to.latest_position[0])
contour = contour.h_next()
pt1 = (bound_rect[0], bound_rect[1])
pt2 = (bound_rect[0] + bound_rect[2], bound_rect[1] + bound_rect[3])
points.append(pt1)
points.append(pt2)
cv.Rectangle(color_image, pt1, pt2, cv.CV_RGB(0,0,255), 1)
cv.PutText(color_image, str(i), pt1, font, cv.CV_RGB(255,0,255))
cv.Circle(color_image, (center_x, center_y), 2, cv.CV_RGB(255,0,255), 2, 8, 0)
#print "LEN ", len(self.tracked_objects)
#if len(self.tracked_objects) > 0 and self.tracked_objects[0] is not None:
# #print "ENTRE"
# obj_vector = self.tracked_objects[0].movement_vector
# print "MVV LEN ", len(obj_vector)
# for index in range(0, len(obj_vector)-2):
# try:
# print "Index ", index, "len(obj_vector) ", len(obj_vector)
# cv.Line(color_image, obj_vector[index], obj_vector[index+1], cv.CV_RGB(0,255,0))
#
# except: print "oops"
#print "Iteration ", k, " Vector: ", vectors["1"]
cv.ShowImage("Target", color_image)
time_passed = time.time() - self.last_request
request_threshold = 60
if time_passed > request_threshold:
self.send_occupancy()
self.send_image(color_image)
#Listen for ESC key
c = cv.WaitKey(10)
#c = cv.WaitKey(7) % 0x100
if c == 27:
break
def measure(im, debug=False):
gray = image.rgb2gray(im)
size = cv.GetSize(im)
total = float(size[0] * size[1])
l = image.sub(gray, image.gaussian(gray, 5))
l2 = image.sub(gray, image.gaussian(gray, 9))
edges = image.dilate(image.auto_edges(im, percentage=0.2))
if debug:
image.show(image.threshold(l, threshold=1),
"Before Edge Removal (kernel=5)")
image.show(image.threshold(l2, threshold=1),
"Before Edge Removal (kernel=9)")
cv.Set(l, 0, image.threshold(edges, threshold=1))
cv.Set(l2, 0, image.threshold(edges, threshold=1))
l = image.threshold(l, threshold=1)
l2 = image.threshold(l2, threshold=1)
if debug:
image.show(image.threshold(edges, threshold=1), "Edges")
image.show(l, "After Edge Removal (kernel=5)")
image.show(l2, "After Edge Removal (kernel=9)")
noise2 = image.new_from(gray)
cv.EqualizeHist(gray, noise2)
cv.AbsDiff(noise2, gray, noise2)
cv.Set(noise2, 0,
image.threshold(image.sobel(im, xorder=2, yorder=2), threshold=4))
diff = image.cv2array(noise2)
if debug:
image.show(noise2, "DIFF")
print "M", diff.mean(), "S", diff.std()
diff_stat = (diff.mean(), diff.std())
percent_noise = cv.CountNonZero(noise2) / total
if debug:
image.show(noise2, "NOISE2")
# magical, I don't understand how this works
_, sat, _ = image.split(image.rgb2hsv(im))
edges = image.auto_edges(im)
l, u, v = tuple(map(image.equalize_hist, image.split(image.rgb2luv(im))))
u, v = tuple(map(image.gaussian, (u, v)))
if debug:
image.show(l, "1. L")
image.show(u, "1. U")
image.show(v, "1. V")
la, ua, va, uva = tuple(map(image.cv2array, (l, u, v, image.And(l, u, v))))
test = image.new_from(gray)
test2 = image.new_from(gray)
cv.Xor(u, v, test)
if debug:
image.show(test, "2. U Xor V")
cv.Set(test, 0, image.dilate(edges))
#cv.Set(test, 0, image.invert(image.threshold(sat, threshold=8)))
uv_score = cv.CountNonZero(test) / total
if debug:
image.show(
test, "3. U Xor V - dilate(Edges) - invert(threshold(Saturation))")
g = Grid(size)
images = map(image.cv2array, g.split_into(test, 6))
arr = image.cv2array(test)
avg_mean, avg_std = arr.mean(), arr.std()
#ms = [(a.mean(), a.std()) for a in images]
#min_mean = min_std = 255
#max_mean = max_std = 0
#for m,s in ms:
# min_mean = min(min_mean, m)
# min_std = min(min_std, s)
# max_mean = max(max_mean, m)
# max_std = max(max_std, s)
#if debug:
# print min_mean, min_std
# print avg_mean, avg_std
# print max_mean, max_std
#
#score = uv_score, min_mean, avg_mean, avg_std, max_mean
uv_score = uv_score, avg_std
score = cv.CountNonZero(l) / total, cv.CountNonZero(l2) / total, \
diff_stat[0], diff_stat[1], uv_score
return l, score
