def getWatershedMask(self):
'''
Uses the watershed algorithm to refine the foreground mask.
Currently, this doesn't work well on real video...maybe grabcut would be better.
'''
cvMarkerImg = cv.CreateImage(self._fgMask.size, cv.IPL_DEPTH_32S, 1)
cv.SetZero(cvMarkerImg)
#fill each contour with a different gray level to label connected components
seq = self._contours
c = 50
while not (seq == None) and len(seq) != 0:
if cv.ContourArea(seq) > self._minArea:
c += 10
moments = cv.Moments(seq)
m00 = cv.GetSpatialMoment(moments, 0, 0)
m01 = cv.GetSpatialMoment(moments, 0, 1)
m10 = cv.GetSpatialMoment(moments, 1, 0)
centroid = (int(m10 / m00), int(m01 / m00))
cv.Circle(cvMarkerImg, centroid, 3, cv.RGB(c, c, c),
cv.CV_FILLED)
seq = seq.h_next()
if (c > 0):
img = self._annotateImg.asOpenCV()
cv.Watershed(img, cvMarkerImg)
tmp = cv.CreateImage(cv.GetSize(cvMarkerImg), cv.IPL_DEPTH_8U, 1)
cv.CvtScale(cvMarkerImg, tmp)
return pv.Image(tmp)
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 saveImage(dcim, filename):
w, h, l, r, d = dcim
cv_l = None
cv_r = None
cv_d = None
if l != None:
channels = len(l) / (w * h)
cv_l = cv.CreateImageHeader((w, h), cv.IPL_DEPTH_8U, channels)
cv.SetData(cv_l, str(l), w * channels)
if channels == 3:
cv.CvtColor(cv_l, cv_l, cv.CV_BGR2RGB)
if r != None:
channels = len(r) / (w * h)
cv_r = cv.CreateImageHeader((w, h), cv.IPL_DEPTH_8U, channels)
cv.SetData(cv_r, str(r), w * channels)
if channels == 3:
cv.CvtColor(cv_r, cv_r, cv.CV_BGR2RGB)
if d != None:
(dimg, dpp, numDisp) = d
max_disparity = (dpp * numDisp) - 1
d16 = cv.CreateImageHeader((w, h), cv.IPL_DEPTH_16U, 1)
cv.SetData(d16, str(dimg), w * 2)
cv_d = cv.CreateImage((w, h), cv.IPL_DEPTH_8U, 1)
cv.CvtScale(d16, cv_d, 255.0 / max_disparity)
cv.SaveImage(filename, compose(cv_l, cv_r, cv_d))
def backgroundDiff(self, img, Imask):
#cv.Zero(self.Imaskt)
cv.Zero(Imask)
cv.CvtScale(img, self.Iscratch, 1, 0)
cv.InRange(self.Iscratch, self.IlowF, self.IhiF, Imask)
cv.SubRS(Imask, 255, Imask)
cv.MorphologyEx(Imask, Imask, None, None, cv.CV_MOP_OPEN, 1)
cv.MorphologyEx(Imask, Imask, None, None, cv.CV_MOP_CLOSE, 2)
#######This stuff was for when it was 3 channel model, now only 1
#######for backprojection
#cv.Split(self.Iscratch, self.Igray1, self.Igray2, self.Igray3, None)
#cv.InRange(self.Igray1, self.Ilow1, self.Ihi1, Imask)
# cv.InRange(self.Igray2, self.Ilow2, self.Ihi2, self.Imaskt)
# cv.Or(Imask, self.Imaskt, Imask)
# cv.InRange(self.Igray3, self.Ilow3, self.Ihi3, self.Imaskt)
# cv.Or(Imask, self.Imaskt, Imask)
# cv.SubRS(Imask, 255, Imask)
#cv.SaveImage('/home/mkillpack/Desktop/mask.png', Imask)
#cv.Erode(Imask, Imask)
return Imask
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 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 subtract(self, thres_chan):
cv.RunningAvg(thres_chan, self.accumulator, self.adaptation_rate)
cv.CvtScale(thres_chan, self.green32_img)
cv.Sub(self.green32_img, self.accumulator, self.difference_img)
cv.Threshold(self.difference_img, self.thresholded_img, self.threshold,
1, cv.CV_THRESH_BINARY)
cv.Dilate(self.thresholded_img, self.thresholded_img, iterations=1)
blob.remove_large_blobs(self.thresholded_img, max_area=self.max_area)
return self.thresholded_img
def 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 backgroundDiff(img, Imask):
cv.CvtScale(img, Iscratch, 1, 0)
cv.Split(Iscratch, Igray1, Igray2, Igray3, None)
cv.InRange(Igray1, Ilow1, Ihi1, Imask)
cv.InRange(Igray2, Ilow2, Ihi2, Imaskt)
cv.Or(Imask, Imaskt, Imask)
cv.InRange(Igray3, Ilow3, Ihi3, Imaskt)
cv.Or(Imask, Imaskt, Imask)
cv.SubRS(Imask, 255, Imask)
cv.SaveImage('/home/mkillpack/Desktop/mask.png', Imask)
#cv.Erode(Imask, Imask)
print "here is the sum of the non-zero pixels", cv.Sum(Imask)
return Imask
def backgroundDiff(self, img, Imask):
print "got into backgroundDiff"
cv.CvtScale(img, self.Iscratch, 1, 0)
#cv.Split(self.Iscratch, self.Igray1, self.Igray2, self.Igray3, None)
#cv.InRange(self.Igray1, self.Ilow1, self.Ihi1, Imask)
cv.InRange(self.Iscratch, self.IlowF, self.IhiF, Imask)
# cv.InRange(self.Igray2, self.Ilow2, self.Ihi2, self.Imaskt)
# cv.Or(Imask, self.Imaskt, Imask)
# cv.InRange(self.Igray3, self.Ilow3, self.Ihi3, self.Imaskt)
# cv.Or(Imask, self.Imaskt, Imask)
cv.SubRS(Imask, 255, Imask)
#cv.SaveImage('/home/mkillpack/Desktop/mask.png', Imask)
#cv.Erode(Imask, Imask)
return Imask
def get_average(self, imagesArray):
bitDepth = imagesArray[0].depth
if bitDepth > 8:
print 'ERROR: Image bit depth too large. Adjust get_average method parameters.'
sys.exit()
imageSize = cv.GetSize(imagesArray[0])
averageImage = cv.CreateImage(imageSize, cv.IPL_DEPTH_16U, 3)
cv.Set(averageImage,0)
for image in imagesArray:
imageExpansion = cv.CreateImage(imageSize, cv.IPL_DEPTH_16U, 3)
cv.Convert(image, imageExpansion)
cv.Add(averageImage, imageExpansion, averageImage)
nImages = 1/float(len(imagesArray))
imageReduction = cv.CreateImage(imageSize, cv.IPL_DEPTH_8U, 3)
cv.CvtScale(averageImage,imageReduction,nImages)
return imageReduction
def getAverageValues(self, images):
""" get the average values over all the images
adds them all together and then divides them with the numb. images
"""
if len(images) == 0:
return None
if len(images) == 1:
return images[0]
imageSize = (images[0].width, images[0].height)
sumImage = cv.CreateImage(imageSize, cv.IPL_DEPTH_32S, 1)
cv.Set(sumImage, 0)
for image in images:
tempImage = cv.CreateImage(imageSize, cv.IPL_DEPTH_32S, 1)
cv.Convert(image, tempImage)
cv.Add(sumImage, tempImage, sumImage)
nImages = 1 / float(len(images))
meanImage = cv.CreateImage(imageSize, cv.IPL_DEPTH_8U, 1)
cv.CvtScale(sumImage, meanImage, nImages)
return meanImage
if 0:
cv.ShowImage('value', val)
cv.WaitKey()
cv.ShowImage('hue', hue)
cv.WaitKey()
cv.ShowImage('saturation', sat)
cv.WaitKey()
cv.ShowImage('HSV', Ihsv)
cv.WaitKey()
cv.Threshold(sat, sat, 128, 255, cv.CV_THRESH_BINARY)
cv.CvtColor(sat, frameSaida, cv.CV_GRAY2RGB)
cv.CvtScale(frameDiff, frameDiff)
ProcessaImagem = True
if ProcessaImagem:
# filtro gaussiano para tirar o ruido
cv.Smooth(gray, gray, cv.CV_GAUSSIAN, 5, 3)
colunasIniciais = []
colunasFinais = []
pixelsIniciais = []
pixelsFinais = []
# faz a diferenca com o frame anterior
if iframe != frameInicial:
