def processImage(self, frame):
cv.CvtColor(frame, self.frame2gray, cv.CV_RGB2GRAY)
#Absdiff to get the difference between to the frames
cv.AbsDiff(self.frame1gray, self.frame2gray, self.res)
#Remove the noise and do the threshold
cv.Smooth(self.res, self.res, cv.CV_BLUR, 5, 5)
cv.MorphologyEx(self.res, self.res, None, None, cv.CV_MOP_OPEN)
cv.MorphologyEx(self.res, self.res, None, None, cv.CV_MOP_CLOSE)
cv.Threshold(self.res, self.res, 10, 255, cv.CV_THRESH_BINARY_INV)
def observe(self):
'''Grab the latest image, detect the table on it, and write the observation to memory'''
temp = self.get_last_observation()
if temp == None or not temp.nChannels == 1:
return
img = cv.CreateImage(cv.GetSize(temp), temp.depth, temp.nChannels)
SE = cv.CreateStructuringElementEx(50, 50, 25, 25, cv.CV_SHAPE_RECT)
cv.MorphologyEx(temp, img, temp, SE, cv.CV_MOP_CLOSE, iterations=1)
# only look at the pixels that are interesting, just cut off the Nao and stuff.
cv.SetImageROI(img, config["roi"])
# remove tilt
self.filter.filter(img)
# cut the image into layers of interest
layers = self.segmentizer.segmentize(img)
# the HistogramSegmentizer can fail when no peaks are ever found
if not layers:
return
# find arms and objects in the table layer of the image
observation = self.detector.detect(layers['table'])
if observation:
# write the observation to memory
self.emit(observation)
def blackhat():
display(src_image,"source_image")
struc=cv.CreateStructuringElementEx(5,5,3,3,cv.CV_SHAPE_RECT)
dst=cv.CreateImage((src_image.width,src_image.height),8,src_image.channels)
temp=cv.CreateImage((src_image.width,src_image.height),8,src_image.channels)
cv.MorphologyEx(src_image,dst,temp,struc,cv2.MORPH_BLACKHAT,1)
display(dst,"destination image")
cv.WaitKey(0)
cv.DestroyAllWindows()
import cv2.cv as cv
image = cv.LoadImage('../img/build.png', cv.CV_LOAD_IMAGE_GRAYSCALE)
#Get edges
morphed = cv.CloneImage(image)
cv.MorphologyEx(image, morphed, None, None,
cv.CV_MOP_GRADIENT) # Apply a dilate - Erode
cv.Threshold(morphed, morphed, 30, 255, cv.CV_THRESH_BINARY_INV)
cv.ShowImage("Image", image)
cv.ShowImage("Morphed", morphed)
cv.WaitKey(0)
w = frame2gray.width
h = frame2gray.height
nb_pixels = frame2gray.width * frame2gray.height
while True:
frame2 = cv.QueryFrame(capture)
cv.CvtColor(frame2, frame2gray, cv.CV_RGB2GRAY)
cv.AbsDiff(frame1gray, frame2gray, res)
cv.ShowImage("After AbsDiff", res)
cv.Smooth(res, res, cv.CV_BLUR, 5, 5)
element = cv.CreateStructuringElementEx(5 * 2 + 1, 5 * 2 + 1, 5, 5,
cv.CV_SHAPE_RECT)
cv.MorphologyEx(res, res, None, None, cv.CV_MOP_OPEN)
cv.MorphologyEx(res, res, None, None, cv.CV_MOP_CLOSE)
cv.Threshold(res, res, 10, 255, cv.CV_THRESH_BINARY_INV)
cv.ShowImage("Image", frame2)
cv.ShowImage("Res", res)
# -----------
nb = 0
for y in range(h):
for x in range(w):
if res[y, x] == 0.0:
nb += 1
avg = (nb * 100.0) / nb_pixels
# print "Average: ",avg, "%\r",
if avg >= 5:
def openCloseImage(im, nbiter=0):
for i in range(nbiter):
cv.MorphologyEx(
im, im, None, None,
cv.CV_MOP_OPEN) #Open and close to make appear contours
cv.MorphologyEx(im, im, None, None, cv.CV_MOP_CLOSE)
import cv2.cv as cv
orig = cv.LoadImage('meinv.jpg', cv.CV_LOAD_IMAGE_COLOR)
im = cv.CreateImage(cv.GetSize(orig), 8, 1)
cv.CvtColor(orig, im, cv.CV_BGR2GRAY)
#Keep the original in colour to draw contours in the end
cv.Threshold(im, im, 128, 255, cv.CV_THRESH_BINARY)
cv.ShowImage("Threshold 1", im)
element = cv.CreateStructuringElementEx(5*2+1, 5*2+1, 5, 5, cv.CV_SHAPE_RECT)
cv.MorphologyEx(im, im, None, element, cv.CV_MOP_OPEN) #Open and close to make appear contours
cv.MorphologyEx(im, im, None, element, cv.CV_MOP_CLOSE)
cv.Threshold(im, im, 128, 255, cv.CV_THRESH_BINARY_INV)
cv.ShowImage("After MorphologyEx", im)
# --------------------------------
vals = cv.CloneImage(im) #Make a clone because FindContours can modify the image
contours=cv.FindContours(vals, cv.CreateMemStorage(0), cv.CV_RETR_LIST, cv.CV_CHAIN_APPROX_SIMPLE, (0,0))
_red = (0, 0, 255); #Red for external contours
_green = (0, 255, 0);# Gren internal contours
levels=2 #1 contours drawn, 2 internal contours as well, 3 ...
cv.DrawContours (orig, contours, _red, _green, levels, 2, cv.CV_FILLED) #Draw contours on the colour image
cv.ShowImage("Image", orig)
cv.WaitKey(0)
# res = cv2.absdiff(frame1gray, frame2gray) # 此为cv2新版api
cv.ShowImage("After AbsDiff", res)
# 4. 保存res作为前景目标foreground
# cv.Convert(res, gray)
# out_foreground.write(np.uint8(res)) # 保存为前景目标
# out_foreground.write(np.asarray(cv.GetMat(res)))
cv.WriteFrame(out_foreground, cv.GetImage(res)) # res格式为cvmat格式，转化为iplimage格式
# 5. 平滑处理
# cv.Smooth(res, res, cv.CV_BLUR, 5, 5) # 光滑一下res
# 6. 形态学变换，开闭操作
element = cv.CreateStructuringElementEx(5*2+1, 5*2+1, 5, 5, cv.CV_SHAPE_RECT) # CreateStructuringElementEx(cols, rows, anchorX, anchorY, shape, values=None)
cv.MorphologyEx(res, res, None, None, cv.CV_MOP_OPEN) # cv2.morphologyEx(src, op, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]]]])
cv.MorphologyEx(res, res, None, None, cv.CV_MOP_CLOSE) # 形态学变换相应的开 闭操作
# 7. 二值化阈值处理：对得到的前景进行阈值选择，去掉伪前景
cv.Threshold(res, res, 10, 255, cv.CV_THRESH_BINARY) # 二值化 cv.Threshold(src, dst, threshold, maxValue, thresholdType)
# 8. blob提取电梯区域 ------------- 未完
# print(type(res))
# # Set up the detector with default parameters.
# detector = cv2.SimpleBlobDetector()
# # Detect blobs.
# keypoints = detector.detect(np.array(res))
# # Draw detected blobs as red circles.
# # cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS ensures the size of the circle corresponds to the size of blob
# im_with_keypoints = cv2.drawKeypoints(np.array(res), keypoints, np.array([]), (0, 0, 255),
cv.Abs(sobx, sobx)
cv.Abs(soby, soby)
result = cv.CloneImage(g)
cv.Add(sobx, soby, result) #Add the two results together.
cv.Threshold(result, result, 100, 255, cv.CV_THRESH_BINARY_INV)
cv.ShowImage('green edge Sobel', result)
cv.SaveImage("green edge Sobel.png", dst)
cv.WaitKey(0)
enter = raw_input("Mostrar Morphed")
#morphel
#imagen en gris
morphed = cv.CloneImage(img)
cv.MorphologyEx(img, morphed, None, None,
cv.CV_MOP_GRADIENT) # Apply a dilate - Erode
cv.Threshold(morphed, morphed, 30, 255, cv.CV_THRESH_BINARY_INV)
cv.ShowImage("Morphed Grayscale edge", morphed)
cv.SaveImage("Grayscale edge Morphed.png", dst)
cv.WaitKey(0)
#blue
morphed = cv.CloneImage(b)
cv.MorphologyEx(b, morphed, None, None,
cv.CV_MOP_GRADIENT) # Apply a dilate - Erode
cv.Threshold(morphed, morphed, 30, 255, cv.CV_THRESH_BINARY_INV)
cv.ShowImage("Morphed blue edge", morphed)
cv.SaveImage("blue edge Morphed.png", dst)
cv.WaitKey(0)
def detectObject(filename):
img=cv.LoadImage(filename)
'''
#get color histogram
'''
# im32f=np.zeros((img.shape[:2]),np.uint32)
hist_range=[[0,256],[0,256],[0,256]]
im32f=cv.CreateImage(cv.GetSize(img), cv2.IPL_DEPTH_32F, 3)
cv.ConvertScale(img, im32f)
hist=cv.CreateHist([32,32,32],cv.CV_HIST_ARRAY,hist_range,3)
'''
#create three histogram'''
b=cv.CreateImage(cv.GetSize(im32f), cv2.IPL_DEPTH_32F, 1)
g=cv.CreateImage(cv.GetSize(im32f), cv2.IPL_DEPTH_32F, 1)
r=cv.CreateImage(cv.GetSize(im32f), cv2.IPL_DEPTH_32F, 1)
'''
#create image backproject 32f, 8u
'''
backproject32f=cv.CreateImage(cv.GetSize(img),cv2.IPL_DEPTH_32F,1)
backproject8u=cv.CreateImage(cv.GetSize(img),cv2.IPL_DEPTH_8U,1)
'''
#create binary
'''
bw=cv.CreateImage(cv.GetSize(img),cv2.IPL_DEPTH_8U,1)
'''
#create kernel image
'''
kernel=cv.CreateStructuringElementEx(3, 3, 1, 1, cv2.MORPH_ELLIPSE)
cv.Split(im32f, b, g, r,None)
planes=[b,g,r]
cv.CalcHist(planes, hist)
'''
#find min and max histogram bin.
'''
minval=maxval=0.0
min_idx=max_idx=0
minval, maxval, min_idx, max_idx=cv.GetMinMaxHistValue(hist)
'''
# threshold histogram. this sets the bin values that are below the threshold
to zero
'''
cv.ThreshHist(hist, maxval/32.0)
'''
#backproject the thresholded histogram, backprojection should contian higher values for
#background and lower values for the foreground
'''
cv.CalcBackProject(planes, backproject32f, hist)
'''
#convert to 8u type
'''
val_min=val_max=0.0
idx_min=idx_max=0
val_min,val_max,idx_min,idx_max=cv.MinMaxLoc(backproject32f)
cv.ConvertScale(backproject32f, backproject8u,255.0/maxval)
'''
#threshold backprojected image. this gives us the background
'''
cv.Threshold(backproject8u, bw, 10, 255, cv2.THRESH_BINARY)
'''
#some morphology on background
'''
cv.Dilate(bw, bw,kernel,1)
cv.MorphologyEx(bw, bw, None,kernel, cv2.MORPH_CLOSE, 2)
'''
#get the foreground
'''
cv.SubRS(bw,cv.Scalar(255,255,255),bw)
cv.MorphologyEx(bw, bw, None, kernel,cv2.MORPH_OPEN,2)
cv.Erode(bw, bw, kernel, 1)
'''
#find contours of foreground
#Grabcut
'''
size=cv.GetSize(bw)
color=np.asarray(img[:,:])
fg=np.asarray(bw[:,:])
# mask=cv.CreateMat(size[1], size[0], cv2.CV_8UC1)
'''
#Make anywhere black in the grey_image (output from MOG) as likely background
#Make anywhere white in the grey_image (output from MOG) as definite foreground
'''
rect = (0,0,0,0)
mat_mask=np.zeros((size[1],size[0]),dtype='uint8')
mat_mask[:,:]=fg
mat_mask[mat_mask[:,:] == 0] = 2
mat_mask[mat_mask[:,:] == 255] = 1
'''
#Make containers
'''
bgdModel = np.zeros((1, 13 * 5))
fgdModel = np.zeros((1, 13 * 5))
cv2.grabCut(color, mat_mask, rect, bgdModel, fgdModel,cv2.GC_INIT_WITH_MASK)
'''
#Multiple new mask by original image to get cut
'''
mask2 = np.where((mat_mask==0)|(mat_mask==2),0,1).astype('uint8')
gcfg=np.zeros((size[1],size[0]),np.uint8)
gcfg=mask2
img_cut = color*mask2[:,:,np.newaxis]
contours, hierarchy=cv2.findContours(gcfg ,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
for cnt in contours:
print cnt
rect_box = cv2.minAreaRect(cnt)
box = cv2.cv.BoxPoints(rect_box)
box = np.int0(box)
cv2.drawContours(color,[box], 0,(0,0,255),2)
cv2.imshow('demo', color)
cv2.waitKey(0)
