def find_tree_contour(gray, param, min_frac=0.5):
_,thresh = cv2.threshold(gray, 200, 255, cv2.THRESH_BINARY_INV) # threshold
kernel = cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))
dilated = cv2.dilate(thresh,kernel,iterations = param) # dilate
im2, contours, hierarchy = cv2.findContours(dilated, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
out = np.zeros(gray.shape, dtype=np.uint8) + 255
for i, contour in enumerate(contours):
[x,y,w,h] = cv2.boundingRect(contour)
if gray.shape[-1] > gray.shape[-2]:
if w < gray.shape[-1] * min_frac:
continue
elif gray.shape[-1] < gray.shape[-2]:
if h < gray.shape[-2] * min_frac:
continue
else:
if h < gray.shape[-2] * min_frac or w < gray.shape[-1] * min_frac:
continue
#cv2.rectangle(img, (x,y), (x+w,y+h), (255,0,255), 1)
cv2.drawContours(out, contours, i, 0, -1)
out2 = np.zeros(gray.shape, dtype=np.uint8) + 255
out2[out == 0] = gray[out == 0]
return out2
def captureImage(self):
position = [0, 0]
velocity = [0, 0]
frame = self.cap.read()[1]
if frame != None:
frame = cv2.flip(frame, 1)
self.frame_hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
threshold_mask = self.createMultipleThresholds(self.frame_hsv)
contour = self.getLargestContour(threshold_mask)
if type(contour) != int:
cv2.drawContours(frame, contour, -1, (0, 255, 255), 2)
position = self.getContourMoment(contour)
cv2.circle(frame, (position[0], position[1]), 5, (0,0,255), -1)
# calculate velocity
velocity = [position[0] - self.oldPosition[0], position[1] - self.oldPosition[1]]
# print velocity
cv2.imshow("Frame", frame)
cv2.waitKey(10)
self.oldPosition = position
return [position, velocity]
def track2(bs,img_copy,img, avg): x = -1 y = -1 img_copy = cv2.GaussianBlur(img_copy,(5,5),0) cv2.accumulateWeighted(img_copy,avg,0.4) res = cv2.convertScaleAbs(avg) res = cv2.absdiff(img, res) _,processed_img = cv2.threshold( res, 7, 255, cv2.THRESH_BINARY ) processed_img = cv2.GaussianBlur(processed_img,(5,5),0) _,processed_img = cv2.threshold( processed_img, 240, 255, cv2.THRESH_BINARY ) processed_img = bs.bg_subtractor.apply(processed_img, None, 0.05) # img_thresh = cv2.morphologyEx(img_thresh, cv2.MORPH_OPEN, kernel) if np.count_nonzero(processed_img) > 5: # Get the largest contour contours, hierarchy = cv2.findContours(processed_img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) areas = [cv2.contourArea(c) for c in contours] max_index = np.argmax(areas) # Make sure it's big enough if cv2.contourArea(contours[max_index]) >= MIN_BLOB_SIZE: cv2.drawContours(img, contours, max_index, (255, 255, 255), -1) x, y = getCentroid(contours[max_index]) return x, y
def detect_possible_buttons(image, source_image):
contours, hierarchy = cv2.findContours(image, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
buttons = []
for cnt in contours:
if 850 < cv2.contourArea(cnt) < 3000: # remove small and large areas like noise etc
hull = cv2.convexHull(cnt) # find the convex hull of contour
hull = cv2.approxPolyDP(hull, 0.1 * cv2.arcLength(hull, True), True)
min = [10000.0, 10000.0]
max = [0.0, 0.0]
#print '%d,%d' % (point[0][0], point[0][1])
if len(hull) == 4:
margin = 2
for point in hull:
x = point[0][0]
y = point[0][1]
if x < min[0]:
min[0] = x - margin
if y < min[1]:
min[1] = y - margin
if x > max[0]:
max[0] = x + margin
if y > max[1]:
max[1] = y + margin
points = [[min[0], min[1]], [max[0], min[1]], [max[0], max[1]], [min[0], max[1]]]
points = np.array(points,np.int0)
button = {'image': source_image[min[0]:max[0], min[1]:max[1]],
'x': 0.5*(max[0]+min[0]), 'y': 0.5*(max[1]+min[1]),
'w': max[0]-min[0], 'h': max[1]-min[1]}
buttons.append(button)
cv2.polylines(source_image, [points], True, (255, 0, 0), 2)
cv2.drawContours(source_image, [hull], 0, (0, 255, 0), 1)
return buttons
def make_boundaries(image):
temp = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
ret,thresh = cv2.threshold(temp,5,255,cv2.THRESH_BINARY_INV)
contors,hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
for i in range(1,len(contors),1):
if 10000 > cv2.contourArea(contors[i]) > 540:
cv2.drawContours(image,contors,i,(0,255,0),2)
def object_detection(self, depth_array):
"""
Function to detect objects from the depth image given
:return:
"""
self.detect_arm()
# Perform thresholding on the image to remove all objects behind a plain
ret, bin_img = cv2.threshold(depth_array, 0.3, 1, cv2.THRESH_BINARY_INV)
# Erode the image a few times in order to separate close objects
element = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))
err_img = cv2.erode(bin_img, element, iterations=20)
# Create a new array of type uint8 for the findContours function
con_img = np.array(err_img, dtype=np.uint8)
# Find the contours of the image and then draw them on
contours, hierarchy = cv2.findContours(con_img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(con_img, contours, -1, (128, 255, 0), 3)
for x in range(0, len(contours)):
x, y, w, h = cv2.boundingRect(contours[x])
cv2.rectangle(con_img, (x, y), ((x+w), (y+h)), (255, 0, 127), thickness=5, lineType=8, shift=0)
# Show the colour images of the objects
# self.show_colour(contours)
# Show the Depth image and objects images
cv2.imshow('Contours', con_img)
cv2.imshow("Depth", bin_img)
cv2.waitKey(3)
def track(bs,img_copy,img, avg): x = -1 y = -1 img_copy = cv2.GaussianBlur(img_copy,(5,5),0) cv2.accumulateWeighted(img_copy,avg,0.4) res = cv2.convertScaleAbs(avg) res = bs.bg_subtractor.apply(res, None, 0.05) gradient = cv2.morphologyEx(res, cv2.MORPH_GRADIENT, kernel) processed_img = cv2.GaussianBlur(gradient,(5,5),0) _,threshold_img = cv2.threshold( processed_img, 20, 255, cv2.THRESH_BINARY ) if np.count_nonzero(threshold_img) > 5: contours, hierarchy = cv2.findContours(threshold_img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) # totally not from stack overflow areas = [cv2.contourArea(c) for c in contours] # max_index = np.argmax(areas) max_index = np.argmin(areas) # Make sure it's big enough if cv2.contourArea(contours[max_index]) >= MIN_BLOB_SIZE_ROBOT: # img_out = np.zeros(img_thresh.shape).astype(np.uint8) cv2.drawContours(img, contours, max_index, (255, 255, 255), -1) x, y = getCentroid(contours[max_index]) return x, y
def rectangle_mask(img, p1, p2, device, debug, color="black"):
# takes an input image and returns a binary image masked by a rectangular area denoted by p1 and p2
# note that p1 = (0,0) is the top left hand corner bottom right hand corner is p2 = (max-value(x), max-value(y))
# device = device number. Used to count steps in the pipeline
# debug = True/False. If True; print output image
# get the dimensions of the input image
ix, iy = np.shape(img)
size = ix,iy
# create a blank image of same size
bnk = np.zeros(size, dtype=np.uint8)
# draw a rectangle denoted by pt1 and pt2 on the blank image
if color=="black":
cv2.rectangle(img = bnk, pt1 = p1, pt2 = p2, color = (255,255,255))
ret, bnk = cv2.threshold(bnk,127,255,0)
contour,hierarchy = cv2.findContours(bnk,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
# make sure entire rectangle is within (visable within) plotting region or else it will not fill with thickness = -1
# note that you should only print the first contour (contour[0]) if you want to fill with thickness = -1
# otherwise two rectangles will be drawn and the space between them will get filled
cv2.drawContours(bnk, contour, 0 ,(255,255,255), -1)
device +=1
if color=="gray":
cv2.rectangle(img = bnk, pt1 = p1, pt2 = p2, color = (192,192,192))
ret, bnk = cv2.threshold(bnk,127,255,0)
contour,hierarchy = cv2.findContours(bnk,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
# make sure entire rectangle is within (visable within) plotting region or else it will not fill with thickness = -1
# note that you should only print the first contour (contour[0]) if you want to fill with thickness = -1
# otherwise two rectangles will be drawn and the space between them will get filled
cv2.drawContours(bnk, contour, 0 ,(192,192,192), -1)
if debug:
print_image(bnk, (str(device) + '_roi.png'))
return device, bnk, contour, hierarchy
def border_mask(img, p1, p2, device, debug, color="black"):
# by using rectangle_mask to mask the edge of plotting regions you end up missing the border of the images by 1 pixel
# This function fills this region in
# note that p1 = (0,0) is the top left hand corner bottom right hand corner is p2 = (max-value(x), max-value(y))
# device = device number. Used to count steps in the pipeline
# debug = True/False. If True; print output image
if color=="black":
ix, iy = np.shape(img)
size = ix,iy
bnk = np.zeros(size, dtype=np.uint8)
cv2.rectangle(img = bnk, pt1 = p1, pt2 = p2, color = (255,255,255))
ret, bnk = cv2.threshold(bnk,127,255,0)
contour,hierarchy = cv2.findContours(bnk,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
cv2.drawContours(bnk, contour, -1 ,(255,255,255), 5)
device +=1
if color=="gray":
ix, iy = np.shape(img)
size = ix,iy
bnk = np.zeros(size, dtype=np.uint8)
cv2.rectangle(img = bnk, pt1 = p1, pt2 = p2, color = (192,192,192))
ret, bnk = cv2.threshold(bnk,127,255,0)
contour,hierarchy = cv2.findContours(bnk,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
cv2.drawContours(bnk, contour, -1 ,(192,192,192), 5)
device +=1
if debug:
print_image(bnk, (str(device) + '_brd_mskd_' + '.png'))
return device, bnk, contour, hierarchy
def main():
global red
global white
global coloured
global pots
img=cv2.imread('C:\\ASK\\Major\\image\\5.jpg')
copy1=img
start=timeit.default_timer()
cv2.imshow('Image',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
hsv=cv2.cvtColor(img,cv2.cv.CV_BGR2HSV)
lower_bound=np.array([38,150,40])
upper_bound=np.array([75,255,200])
masked=cv2.inRange(hsv,lower_bound,upper_bound)
contour=structures.detect_table(masked)
pots=structures.detect_pots(img,contour)
cv2.drawContours(img,contour,contourIdx=-1,color=[0,0,255])
cv2.imshow('Detected table',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
detect_balls(hsv)
draw_balls(img,coloured)
draw_balls(img,red)
draw_balls(img,white)
cv2.imshow('Detected balls and table',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
return (white,pots,coloured,red)
def detect_screen(self, blur_pars=(21, 17, 17), draw_contours=True):
gray = cv2.cvtColor(self.frame, cv2.COLOR_BGR2GRAY)
gray = cv2.bilateralFilter(gray, *blur_pars)
edged = cv2.Canny(gray, 30, 200)
(_, contours, _) = cv2.findContours(edged.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
contours = sorted(contours, key=cv2.contourArea, reverse=True)[:5]
screen_contour = []
for c in contours:
# approximate the contour
peri = cv2.arcLength(c, True)
approx = cv2.approxPolyDP(c, 0.02 * peri, True)
if len(approx) == 4:
screen_contour = approx
break
if len(screen_contour):
global global_rect
coords = np.array([[i[0][0], i[0][1]] for i in screen_contour])
if draw_contours:
cv2.drawContours(self.frame, [screen_contour], -1, (0, 0, 255), 3)
global_rect = self.order_points(coords)
def remove_blobs(image, max_area=1000, min_height=5):
"""
Remove blobs with thresholed size from the image.
Parameters
------------
image : Numpy array
max_area : float
Area threshold
min_height : float
Height threshold
Returns
-------
newimage : Numpy array
The image with blobs removed
"""
ret, img2 = cv2.threshold(image, 250, 255, 1)
contours, hier = cv2.findContours(np.array(img2),
cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
mask = np.zeros(img2.shape, np.uint8)
for cnt in contours:
area = cv2.contourArea(cnt)
x, y, width, height = cv2.boundingRect(cnt)
if cv2.contourArea(cnt) > max_area or height < min_height:
cv2.drawContours(mask,[cnt],0, 255, -1)
return cv2.bitwise_and(img2, cv2.bitwise_not(mask))
def run(self):
started = time.time()
print "started"
print started
while True:
ret, frame = self.cap.read()
currentframe = frame.copy()
# cv2.imshow("Image", currentframe)
instant = time.time()
# print instant
self.processImage (currentframe)
if not self.isRecording:
if self.somethingHasMoved():
self.speedEstimation()
cv2.drawContours(currentframe, self.currentcontours,-1,(0, 0, 255),2)
if self.show:
for dist in self.tracks_dist:
if dist[2] > 0:
font = cv2.FONT_HERSHEY_SIMPLEX
# cv2.putText(currentframe,'OpenCV',(10,500), font, 4,(255,255,255),2,cv2.LINE_AA)
# cv2.putText(currentframe, str(dist[2]/(9*5/30)), (60, 60), font, 4,(255,255,255),2,cv2.CV_AA)
draw_str(currentframe,(dist[0],dist[1]), str(dist[2]/(9*5/30)))
cv2.imshow("Image", currentframe)
self.prev_gray = self.gray_frame
self.frame_idx += 1
c = cv2.waitKey(1) % 0x100
if c==27 or c == 10: #Break if user enters 'Esc'.
break
def MomentDescriptor(name, thres):
img1=cv2.imread(name)
# img=img1
img=cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
# edges=cv2.Canny(img, thres, thres*2)
#Image to draw the contours
drawing=np.zeros(img.shape[:2], np.uint8)
ret,thresh = cv2.threshold(img,thres,255,0)
contours, hierarchy=cv2.findContours(thresh,cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
MomentVector=[]
for cnt in contours:
M=cv2.moments(cnt) #Calculate moments
if M['m00']!=0:
Cx=int(M['m10']/M['m00'])
Cy=int(M['m01']/M['m00'])
Moments_Area=M['m00'] # Contour area moment
Contours_Area=cv2.contourArea(cnt) # Contour area using in_built function
#Draw moment
rect = cv2.minAreaRect(cnt)
box = cv2.cv.BoxPoints(rect)
box = np.int0(box)
# cv2.drawContours(img1,contours, 0, (0,255,0),3) #draw contours in green color
cv2.drawContours(img1,[box],0,(0,0,255),1)
cv2.circle(img1, (Cx,Cy), 3,(0,255,0), -1)#draw centroids in red color
MomentVector.append([M['m00'],Cx,Cy])
cv2.imshow('winname',img1)
cv2.waitKey(5000)
print MomentVector
def draw_walls(self):
left_wall_points = np.array([self.transform(point) for point in self.left_wall_points])
right_wall_points = np.array([self.transform(point) for point in self.right_wall_points])
rect = cv2.minAreaRect(left_wall_points[:,:2].astype(np.float32))
box = cv2.cv.BoxPoints(rect)
box = np.int0(box)
cv2.drawContours(self.grid, [box], 0, 128, -1)
rect = cv2.minAreaRect(right_wall_points[:,:2].astype(np.float32))
box = cv2.cv.BoxPoints(rect)
box = np.int0(box)
cv2.drawContours(self.grid, [box], 0, 128, -1)
# So I dont have to comment abunch of stuff out for debugging
dont_display = True
if dont_display:
return
# Bob Ross it up (just for display)
left_f, right_f = self.transform(self.left_f), self.transform(self.right_f)
left_b, right_b = self.transform(self.left_b), self.transform(self.right_b)
boat = self.transform(self.boat_pos)
target = self.transform(self.target)
cv2.circle(self.grid, tuple(boat[:2].astype(np.int32)), 8, 255)
cv2.circle(self.grid, tuple(target[:2].astype(np.int32)), 15, 255)
cv2.circle(self.grid, tuple(self.transform(self.mid_point)[:2].astype(np.int32)), 5, 255)
cv2.circle(self.grid, tuple(left_f[:2].astype(np.int32)), 10, 255)
cv2.circle(self.grid, tuple(right_f[:2].astype(np.int32)), 10, 255)
cv2.circle(self.grid, tuple(left_b[:2].astype(np.int32)), 3, 125)
cv2.circle(self.grid, tuple(right_b[:2].astype(np.int32)), 3, 128)
cv2.imshow("test", self.grid)
cv2.waitKey(0)
def save_image_as(pix, add, name):
import cv2, time
from PIL import ImageGrab, Image, ImageDraw, ImageOps
pix2 = pix.copy() ## We make a copy of the background image
cv2.drawContours(pix2,add,-1,(0,255,0),3)
im = Image.fromarray(pix2)
im.save("Images/" + name + ".png")
def thresh_callback(thresh):
p = cv2.getTrackbarPos('perim','input')
print thresh, p
edges = cv2.Canny(blur,thresh,thresh*2)
drawing = np.zeros(img.shape,np.uint8) # Image to draw the contours
contours,hierarchy = cv2.findContours(edges,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
block = False
for i,cnt in enumerate(contours):
color = np.random.randint(0,255,(3)).tolist() # Select a random color
perim = cv2.arcLength(cnt, True)
#print perim
if perim > p and not block:
x,y,w,h = cv2.boundingRect(cnt)
print x,y, w, h
cv2.drawContours(drawing,[cnt],0,color,2)
cv2.imshow('output',drawing)
#with open('im_rect.jpg', 'w'):
# plt.imshow(img)
block = True
subpic = img[y:y+h,x:x+w]
# fgbg = cv2.BackgroundSubstractorMOG()
#fgmask = fgbg.apply(subpic)
#cv2.bitwise_and(subpic, subpic, mask=fgmask)
print subpic[10,10]
img[img==subpic[10,10]]=255
cv2.imwrite('rect_bottom.png', subpic)
cv2.imshow('input',img)
def run(self):
while True:
f, orig_img = self.capture.read()
orig_img = cv2.flip(orig_img, 1)
img = cv2.GaussianBlur(orig_img, (5,5), 0)
img = cv2.cvtColor(orig_img, cv2.COLOR_BGR2HSV)
img = cv2.resize(img, (len(orig_img[0]) / self.scale_down, len(orig_img) / self.scale_down))
red_lower = np.array([0, 150, 0],np.uint8)
red_upper = np.array([5, 255, 255],np.uint8)
red_binary = cv2.inRange(img, red_lower, red_upper)
dilation = np.ones((15, 15), "uint8")
red_binary = cv2.dilate(red_binary, dilation)
contours, hierarchy = cv2.findContours(red_binary, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
max_area = 0
largest_contour = None
for idx, contour in enumerate(contours):
area = cv2.contourArea(contour)
if area > max_area:
max_area = area
largest_contour = contour
if not largest_contour == None:
moment = cv2.moments(largest_contour)
if moment["m00"] > 1000 / self.scale_down:
rect = cv2.minAreaRect(largest_contour)
rect = ((rect[0][0] * self.scale_down, rect[0][1] * self.scale_down), (rect[1][0] * self.scale_down, rect[1][1] * self.scale_down), rect[2])
box = cv2.cv.BoxPoints(rect)
box = np.int0(box)
cv2.drawContours(orig_img,[box], 0, (0, 0, 255), 2)
cv2.imshow("ColourTrackerWindow", orig_img)
if cv2.waitKey(20) == 27:
cv2.destroyWindow("ColourTrackerWindow")
self.capture.release()
break
def cartonify_image(image):
"""
convert an inpuy image to a cartoon-like image
Args:
image: input PIL image
Returns:
out (numpy.ndarray): A grasycale or color image of dtype uint8, with
the shape of image
"""
output = np.array(image)
x, y, c = output.shape
# noise removal while keeping edges sharp
for i in xrange(c):
output[:, :, i] = cv2.bilateralFilter(output[:, :, i], 5, 50, 50)
#edges in an image using the Canny algorithm
edge = cv2.Canny(output, 100, 200)
#convert image into RGB color space
output = cv2.cvtColor(output, cv2.COLOR_RGB2HSV)
#historygram array
hists = []
#Compute the histogram of a set of data.
#H
hist, _ = np.histogram(output[:, :, 0], bins=np.arange(180+1))
hists.append(hist)
#S
hist, _ = np.histogram(output[:, :, 1], bins=np.arange(256+1))
hists.append(hist)
#V
hist, _ = np.histogram(output[:, :, 2], bins=np.arange(256+1))
hists.append(hist)
centroids = []
for h in hists:
centroids.append(kmeans_histogram(h))
print("centroids: {0}".format(centroids))
output = output.reshape((-1, c))
for i in xrange(c):
channel = output[:, i]
index = np.argmin(np.abs(channel[:, np.newaxis] - centroids[i]), axis=1)
output[:, i] = centroids[i][index]
output = output.reshape((x, y, c))
output = cv2.cvtColor(output, cv2.COLOR_HSV2RGB)
# Retrieves contours from the binary image
# RETR_EXTERNAL: retrieves only the extreme outer contours
# CHAIN_APPROX_NONE= stores absolutely all the contour points
contours, _ = cv2.findContours(edge,
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
# Draws contours outlines
cv2.drawContours(output, contours, -1, 0, thickness=1)
return output
def maskcolor(path,_hsv_mask):
if path=='0':
path=0;
cap = cv2.VideoCapture(path)
while(cap.isOpened()):
_, frame = cap.read()
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# Threshold the HSV image to get only blue colors
mask = cv2.inRange(hsv,_hsv_mask[0],_hsv_mask[1]);
# Bitwise-AND mask and original image
_res = cv2.bitwise_and(frame,frame, mask= mask)
_gray = cv2.cvtColor(_res,cv2.COLOR_RGB2GRAY)
_edge = cv2.adaptiveThreshold(_gray,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,11,2)
cnt,hchy = cv2.findContours(_edge,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
print hchy
cv2.drawContours(frame, cnt, -1, (0,255,0), 3)
#x,y,w,h = cv2.boundingRect(np.vstack(cnt))
#cv2.rectangle(frame,(x,y),(x+w,y+h),(0,0,255),2)
#rect = cv2.minAreaRect(np.vstack(cnt))
#box = cv2.cv.BoxPoints(rect)
#box = np.int0(box)
#cv2.drawContours(frame,[box],0,(0,0,255),2)
cv2.imshow('a',frame)
#cv2.imshow('b',_edge)
#cv2.imshow('c',res)
#plt.show()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
def fill_ratio(self, mat, contour, threshed):
fill_mask = np.zeros(mat.shape[:2], dtype=np.uint8)
cv2.drawContours(fill_mask, [contour], -1, 255, thickness=-1)
fill_masked = cv2.bitwise_and(threshed, threshed, mask=fill_mask)
hull_area = cv2.contourArea(cv2.convexHull(contour))
fill = np.sum(fill_masked) / 255 / hull_area
return fill
def updateContours(self, frame, contours):
self.movingObjects = []
self.histograms = []
height, width = frame.shape[:2]
i=0
for contour in contours:
c,r,w,h = cv2.boundingRect(contour)
if w*h < 20:
continue
# set up the ROI for tracking
roi = frame[r:r+h, c:c+w]
hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
mask2 = cv2.inRange(hsv_roi, np.array((0., 30.,30.)), np.array((180.,250.,250.)))
mask = np.zeros((height,width), np.uint8)
cv2.drawContours(mask, [contour], 0, 255, -1)
maskArea = mask[r:r+h,c:c+w]
maskArea = cv2.bitwise_and(maskArea, mask2)
img = cv2.bitwise_and(roi,roi,mask=maskArea)
#cv2.imshow('maskarea', mask2)
roi_hist = cv2.calcHist([hsv_roi],[0,1],maskArea,[180,256],[0,180,0,256])
#roi_hist = cv2.calcHist([hsv_roi],[0],maskArea,[180],[0,180])
cv2.normalize(roi_hist,roi_hist,0,255,cv2.NORM_MINMAX)
#print i
i+=1
self.movingObjects.append((c,r,w,h))
self.histograms.append(roi_hist)
def get_centroids (contours, frame): centres = [] if contours: for i in range(len(contours)): moments = cv2.moments(contours[i]) centres.append((int(moments['m10']/moments['m00']), int(moments['m01']/moments['m00']))) if i>0: dist = calculateDistance(centres[i-1][0],centres[i-1][1],centres[i][0],centres[i][1]) area=cv2.contourArea(contours[i]) prevarea=cv2.contourArea(contours[i-1]) if dist < 120: if area > prevarea: rect = cv2.minAreaRect(contours[i]) box = cv2.boxPoints(rect) box = np.int0(box) print(box) frame = cv2.drawContours(frame,[box],0,(0,0,255),2) else : rect = cv2.minAreaRect(contours[i-1]) box = cv2.boxPoints(rect) box = np.int0(box) print(box) frame = cv2.drawContours(frame,[box],0,(0,0,255),2) else: rect = cv2.minAreaRect(contours[i]) box = cv2.boxPoints(rect) box = np.int0(box) frame = cv2.drawContours(frame,[box],0,(0,0,255),2) print(box) return centres, frame
def getLetter(self): if self.thresh is None: print "no thresh for getLetter" return 0 contours, hierarchy = cv2.findContours( self.thresh.copy() ,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE) # sort contours by cnt area / img area ratio from max to min contours = sorted(contours, key = lambda x: cv2.contourArea(x)/self.thresh.size, reverse = False) for cnt in contours: area = cv2.contourArea(cnt) # area calculation (x,y),radius = cv2.minEnclosingCircle(cnt) radius = int(radius) minArea = 3.14159*radius*radius*0.6 maxArea = 3.14159*radius*radius*1.4 # if actual area is close enough to 2*pi*r area && area > 10% of pic if area >= minArea and area <= maxArea and area > self.thresh.size*0.1: # copy thresh = cv2.bitwise_not(self.thresh) mask = np.zeros_like(thresh) # Create mask where white is what we want, black otherwise cv2.drawContours(mask, [cnt], 0, 255, -1) # Draw filled contour in mask self.letter = np.zeros_like(thresh) # Extract out the object and place into output image self.letter[mask == 255] = thresh[mask == 255]
def imclearborder(imgBW, radius):
# Given a black and white image, first find all of its contours
imgBWcopy = imgBW.copy()
contours = cv2.findContours(imgBWcopy.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)[-2]
# Get dimensions of image
imgRows = imgBW.shape[0]
imgCols = imgBW.shape[1]
contourList = [] # ID list of contours that touch the border
# For each contour...
for idx in np.arange(len(contours)):
# Get the i'th contour
cnt = contours[idx]
# Look at each point in the contour
for pt in cnt:
rowCnt = pt[0][1]
colCnt = pt[0][0]
check1 = (rowCnt >= 0 and rowCnt < radius) or (rowCnt >= imgRows - 1 - radius and rowCnt < imgRows)
check2 = (colCnt >= 0 and colCnt < radius) or (colCnt >= imgCols - 1 - radius and colCnt < imgCols)
if check1 or check2:
contourList.append(idx)
break
for idx in contourList:
cv2.drawContours(imgBWcopy, contours, idx, (0, 0, 0), -1)
print "deleted ROI"
return imgBWcopy
def contourMidpoint(self, imageIn):
contours, hierarchy = cv2.findContours(imageIn, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
bestContour = None
bestArea = 0
result = None
for contour in contours:
area = cv2.contourArea(contour)
if area > bestArea:
bestContour = contour
bestArea = area
if bestContour != None:
# print bestArea
l = bestContour[bestContour[:,:,0].argmin()][0][0]
r = bestContour[bestContour[:,:,0].argmax()][0][0]
t = bestContour[bestContour[:,:,1].argmin()][0][1]
b = bestContour[bestContour[:,:,1].argmax()][0][1]
# print l, r, t, b
cx = (l + r) / 2
cy = (t + b) / 2
if self.debug:
imageContour = np.zeros(self.imageHSV.shape, np.uint8)
cv2.drawContours(imageContour, [bestContour], 0, (0, 255, 0), 1)
cv2.circle(imageContour, (cx, cy), 1, (0, 0, 255), -1)
cv2.imshow(self.windowContour, imageContour)
result = (cx, cy, bestArea)
return result
def get_motions(f, fMask, thickness=1, color=(170, 170, 170)):
'''
Iterates over the contours in a mask and draws a bounding box
around the ones that encompas an area greater than a threshold.
This will return an image of just the draw bock (black bg), and
also an array of the box points.
'''
rects_mot = []
f_rects = np.zeros(f.shape, np.uint8)
# get contours
if imutils.is_cv3():
_, cnts, hierarchy = cv2.findContours(
fMask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
elif imutils.is_cv2():
cnts, hierarchy = cv2.findContours(
fMask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# loop over the contours
for c in cnts:
# if the contour is too small, ignore it
if cv2.contourArea(c) < contourThresh:
continue
if imutils.is_cv3():
box = cv2.boxPoints(cv2.minAreaRect(c))
elif imutils.is_cv2():
box = cv2.cv.BoxPoints(cv2.minAreaRect(c))
box = np.int0(box)
cv2.drawContours(f_rects, [box], 0, color, thickness)
rects_mot.append(cv2.boundingRect(c))
return f_rects, rects_mot
def convexhull(self, gray):
mask = np.zeros(gray.shape, dtype=np.uint8)
cnt, _ = cv2.findContours(gray, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
for c in cnt:
hull = cv2.convexHull(c)
cv2.drawContours(mask, [hull], -1, 255, -1)
return mask
def contours(img): #img = blurred(img) #img = cv2.erode(hsvthreshold(img), cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))) img = hsvthreshold(img) ret = cv2.merge([img, img, img]) cons, hier = cv2.findContours(img, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE) targets = [] #cv2.drawContours(ret, np.array(cons), -1, np.array([255.0, 255.0, 0.0]), -1) for i in range(len(cons)): if cv2.contourArea(cons[i]) >= 1000: #print len(cons[i]) #print len(cv2.convexHull(cons[i])) #cons[i] = cv2.convexHull(cons[i]) cv2.drawContours(ret, np.array(cons), i, np.array([255.0, 0.0, 0.0]), 1) pts = [] for pt in cons[i]: pts.append(pt[0]) #ret[pt[0][1]][pt[0][0]] = np.array([255.0, 0.0, 0.0]) corn = corners(pts, ret) if len(corn) == 4: rvec, tvec = cv2.solvePnP(target,np.array(corn[:]),cam,dis) print np.linalg.norm(tvec) #target = pts[:,1].astype(np.double).sum() / len(pts) for x, y in corn: cv2.circle(ret, (int(x), int(y)), 5, np.array([0.0, 0.0, 255.0]), -1) return ret
def updateBiggestObjectContour(self, frame, contour):
if contour == None:
return
height, width = frame.shape[:2]
c,r,w,h = cv2.boundingRect(contour)
if w*h < 20:
return
# set up the ROI for tracking
roi = frame[r:r+h, c:c+w]
hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
mask2 = cv2.inRange(hsv_roi, np.array((0., 60.,32.)), np.array((180.,255.,255.)))
mask = np.zeros((height,width), np.uint8)
cv2.drawContours(mask, [contour], 0, 255, -1)
maskArea = mask[r:r+h,c:c+w]
maskArea = cv2.bitwise_and(maskArea, mask2)
img = cv2.bitwise_and(roi,roi,mask=maskArea)
#cv2.imshow('maskarea', mask2)
#roi_hist = cv2.calcHist([hsv_roi],[0,1,2],maskArea,[180,256,256],[0,180,0,256,0,256])
roi_hist = cv2.calcHist([hsv_roi],[0,1],maskArea,[180,256],[0,180,0,256])
#roi_hist = cv2.calcHist([hsv_roi],[0],maskArea,[180],[0,180])
cv2.normalize(roi_hist,roi_hist,0,255,cv2.NORM_MINMAX)
#print i
self.biggestObject = (c,r,w,h)
self.biggestObjectHistogram = roi_hist
thresh = cv2.threshold(gray, 225, 255, cv2.THRESH_BINARY_INV)[1]
print("STEP 3: 灰度图像求阈值")
cv2.imshow("Thresh", thresh)
cv2.waitKey(0)
#4.检测、计数和绘制轮廓
# 在图像中找到前景物体的轮廓
cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours(cnts)
output = image.copy()
# 循环绘制轮廓
for c in cnts:
# 以紫色线条绘制轮廓
# 一次显示一个物体的轮廓
cv2.drawContours(output, [c], -1, (240, 0, 159), 3)
print("STEP 4: 绘制轮廓")
cv2.imshow("Contours", output)
cv2.waitKey(0)
# 注明紫色轮廓的个数
text = "I found {} objects!".format(len(cnts))
cv2.putText(output, text, (10, 25), cv2.FONT_HERSHEY_SIMPLEX, 0.7,
(240, 0, 159), 2)
print("STEP 4: 标注轮廓数目")
cv2.imshow("Contours", output)
cv2.waitKey(0)
#5、腐蚀和膨胀
#通过腐蚀减小前景物体的尺寸，利用cv2.erode将轮廓尺寸减小5
mask = thresh.copy()
mask = cv2.erode(mask, None, iterations=5)
line -- corner
fit an poly wrong
x+y??
shape matching ??
"""
rect=cv2.minAreaRect(cnt)
box=cv2.boxPoints(rect)
box=np.int0(box)
box_img=np.copy(img)
cv2.drawContours(box_img,[box],0,(0,0,255),3)
cv2.imwrite('box.jpg',box_img)
cnt_img=np.copy(img)
cv2.drawContours(cnt_img,contours,chosen_index,(0,255,0),3)
cv2.imwrite('cnt.jpg',cnt_img)
"""
cam=PiCamera()
for i in range(5):
cam.start_preview()
time.sleep(2)
cam.capture('test'+str(i)+'.jpg')
cam.stop_preview()
time.sleep(2)
"""
def processPoints(im, debug):
# Convert to Grayscale
imgray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
# Threshold the image with adaptative thresholding
thresh = cv2.adaptiveThreshold(imgray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
cv2.THRESH_BINARY, 15, 2)
# Find image contours
(_, cnts, _) = cv2.findContours(thresh.copy(), cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
# Output of "good" contours
allcnts = []
# Auxiliarry variables to help understand what is being processed (total points)
totalP = 0
# loop over our contours
for c in cnts:
# approximate the contour
peri = cv2.arcLength(c, True)
# If perimeter is too low, discart contour
if peri < 100:
continue
# Try approximating poligon to simplify number of points
approx = cv2.approxPolyDP(c, 6, True)
# Sum total points processed
totalP = totalP + len(approx)
# Append contour to "good contours"
allcnts.append(approx)
# Debug total points
print("Frame total points: " + str(totalP))
# Debug: Show image contours
if debug:
if onlyLines:
out = im.copy() * 0
cv2.drawContours(out, allcnts, -1, (0, 255, 0), 1)
else:
out = im
# Debug: Show image
cv2.imshow("thres", thresh)
cv2.imshow("output", out)
# Stored list of x y points in series
points = []
# Loop over selected contours and append everything to a single array of x, y, x, y, x, y... coordinates
# points.append(1)
# points.append(1)
# points.append(1)
# points.append(255)
# points.append(255)
# points.append(255)
# points.append(255)
# points.append(1)
# points.append(1)
# points.append(1)
for contour in allcnts:
for p in contour:
x = p[0][0] * 1.0
y = p[0][1] * 1.0
xOut = int(math.floor(x / im.shape[0] * 255))
yOut = int(math.floor(y / im.shape[1] * 255))
points.append(xOut)
points.append(yOut)
points.append(0)
points.append(0)
points.append(0)
points.append(0)
# Return points
return points
def draw_contours_on_image_like(contours, img_orig):
img_blank = np.ones_like(img_orig) * 255
cv2.drawContours(img_blank, contours, -1, (0, 255, 0), 1)
return img_blank
cv2.imshow(window_name, binary_pokemon_image)
cv2.waitKey()
# initialize the outline image
outline_image = np.zeros(pokemon_resized_image.shape, dtype="uint8")
# find the outermost contours (the outline) of the pokemone
contours = cv2.findContours(binary_pokemon_image.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# parsing the contours for various versions of OpenCV.
contours = imutils.grab_contours(contours)
contours = sorted(contours, key=cv2.contourArea, reverse=True)[0]
print(contours.shape)
# sort the contours based on their area (in descending order) and keeping only the largest contour and discard the others.
# draw contours
cv2.drawContours(outline_image, [contours], -1, 255, -1)
# show outline image
window_name = 'Outline Image'
cv2.imshow(window_name, outline_image)
cv2.waitKey()
# compute Zernike moments to characterize the shape of pokemon outline
zernikeMoments = ZernikeMoments(21)
pokemonFeatures = zernikeMoments.describe(outline_image)
# perform the search to identify the pokemon
searcher = Searcher(index)
pokemon_name = searcher.search(pokemonFeatures)
print("That pokemon is: %s" % pokemon_name[0][1].upper())
# show image Comparing
fore = fgbg.apply(frame, learningRate=0)
if backgroundFrame == 1:
print startTime
back = fgbg.getBackgroundImage()
kernel = np.ones((3, 3), np.uint8)
fore = cv2.erode(fore, kernel, iterations=1)
fore = cv2.dilate(fore, kernel, iterations=5)
_, contours, _ = cv2.findContours(fore, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
for contour in contours:
if cv2.contourArea(contour) > 8500:
tcontours = []
hull = []
tcontours.append(contour)
cv2.drawContours(frame, contour, -1, (0, 0, 255), 2)
hull.insert(0, cv2.convexHull(tcontours[0], clockwise=False))
cv2.drawContours(frame, hull, -1, (0, 255, 0), 2)
x, y, w, h = cv2.boundingRect(tcontours[0])
#x1, y1, w1, h1 = cv2.boundingRect(hull[0])
cv2.rectangle(frame, (x, y - 20), (x + 213, y + 193), (0, 255, 0),
2, 8, 0)
#cv2.rectangle(frame,(x1,y1),(x1+w1,y1+h1), (255, 255, 0), 2, 8, 0)
if backgroundFrame > 0:
cv2.putText(fore, "Recording Background", (30, 30),
cv2.FONT_HERSHEY_COMPLEX_SMALL, 0.8, (200, 200, 250), 1,
cv2.LINE_AA)
else:
diff = time.time() - startTime
int_diff = int(diff)
cv2.putText(fore, "Time:" + str(int_diff), (30, 30),
def doloop():
global min_distance, num_im, dx, dy, dpx, dpy
while True:
# Get a fresh frame
rgb = get_video()
depth = measure_depth()
depthimage = np.dstack((depth, depth, depth)).astype(np.uint8)
# remove the background
if not os.path.exists("floor.npy"):
measure_background()
floor = np.load("floor.npy")
depth = remove_background(depth, floor)
cutimage = np.dstack((depth, depth, depth)).astype(np.uint8)
#Find contour
gray = cv2.cvtColor(cutimage, cv2.COLOR_BGR2GRAY)
_, thresholded = cv2.threshold(gray, min_distance, 255,
cv2.THRESH_BINARY_INV)
try:
contours, hierarchies = cv2.findContours(thresholded,
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
contour = max(contours, key=cv2.contourArea)
cv2.drawContours(depthimage, contour, -1, (0, 0, 255), 2)
outline = np.copy(contour[:, 0, :])
tck, u = interpolate.splprep(outline.transpose(), s=0)
du = 1 / (num_points - 1)
unew = np.arange(0, 1.0, du)
out = interpolate.splev(unew, tck)
outline[1, :] = outline[1, :] * dpy
outline[1, :] = outline[1, :] + dy
outline[0, :] = outline[0, :] * dpx
outline[0, :] = outline[0, :] + dx
outline = outline.transpose().reshape((-1, 1, 2))
cv2.drawContours(rgb, [outline.astype(int)], -1, (0, 0, 255), 2)
mask = np.zeros_like(rgb)
cv2.drawContours(mask, [outline.astype(int)], -1, (255, 255, 255),
-1)
cropped = np.zeros_like(rgb)
cropped[mask == 255] = rgb[mask == 255]
da = np.hstack((depthimage, rgb))
db = np.hstack((mask, cropped))
da = np.vstack((da, db))
except Exception as error:
#raise error
da = np.hstack((depthimage, rgb))
# Simple Downsample
cv2.imshow('both', np.array(da))
#cv2.imshow('both',np.array(da[::2,::2,::-1]))
key = cv2.waitKey(5)
if chr(key & 255) == ' ': #space
print('Writing contour')
outline = outline.reshape((-1, 2))
outline[:, 1:] = 480 - outline[:, 1:]
#outline[:,0] = 640-outline[:,0]
np.savetxt("scf{}-outline-coords.dat".format(num_im),
outline,
fmt='%i %i')
cv2.imwrite("scf{}-depthimage.png".format(num_im), depthimage)
cv2.imwrite("scf{}-colorimage.png".format(num_im),
cv2.cvtColor(cropped, cv2.COLOR_RGB2BGR))
cv2.imwrite("scf{}-fullcolorimage.png".format(num_im),
cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR))
cv2.imwrite("scf{}-blackandwhiteimage.png".format(num_im),
cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY))
num_im += 1
elif chr(key & 255) == 'b':
measure_background()
elif chr(key & 255) == 'w':
dy -= 5
elif chr(key & 255) == 's':
dy += 5
elif chr(key & 255) == 'a':
dx -= 5
elif chr(key & 255) == 'd':
dx += 5
elif chr(key & 255) == 'r':
dpy *= 1.02
elif chr(key & 255) == 'f':
dpy /= 1.02
elif chr(key & 255) == 't':
dpx *= 1.02
elif chr(key & 255) == 'g':
dpx /= 1.02
elif key == 65362: #up on linux
min_distance += 10
print("threshold ", min_distance)
elif key == 65364: #down on linux
min_distance -= 10
print("threshold ", min_distance)
elif key == -1: #none
continue
else:
print(key)
print(dx, dy, dpx, dpy)
def rysowanie(frame,x,y,contour_max,color,yy):
cv2.putText(frame,'B: x = {0} y = {1}'.format(x,y),(20,yy), cv2.FONT_HERSHEY_SIMPLEX, 1,color,2)
cv2.circle(frame,(x,y), 3, (255,0,255), -1)
cv2.drawContours(frame,[contour_max], 0, (255,0,255), 2)
def main(table):
camSrv = CameraServer.getInstance()
camSrv.enableLogging()
cam = UsbCamera("logitech", 0)
camSrv.addCamera(cam)
#cam = cs.startAutomaticCapture()
cam.setResolution(CAM_WIDTH, CAM_HEIGHT)
# Get a CvSink. This will capture images from the camera
cvSink = camSrv.getVideo() #camera=cam)
# (optional) Setup a CvSource. This will send images back to the Dashboard
outputStream = camSrv.putVideo("Rectangle", CAM_WIDTH, CAM_HEIGHT)
# Allocating new images is very expensive, always try to preallocate
rawimg = np.zeros(shape=(CAM_HEIGHT, CAM_WIDTH, 3), dtype=np.uint8)
# OpenCV ranges
# Hue: 0 - 180
# Saturation: 0 - 255
# Vibrancy: 0 - 255
lower = np.array([0, 0, 200])
upper = np.array([10, 100, 255])
while True:
# Tell the CvSink to grab a frame from the camera and put it
# in the source image. If there is an error notify the output.
#print('grab a frame...')
time, rawimg = cvSink.grabFrame(rawimg,0.5)
if time == 0:
# Send the output the error.
print(cvSink.getError())
#outputStream.notifyError(cvSink.getError())
# skip the rest of the current iteration
continue
# convert RGB to HSV
hsv = cv2.cvtColor(rawimg, cv2.COLOR_RGB2HSV)
# Threshold the HSV image to get only the selected colors
mask = cv2.inRange(hsv, lower, upper)
mask, contours, hierarchy = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
if len(contours) == 0:
print('no contours')
continue
try:
contours.sort(key=lambda x: cv2.contourArea(x))
target = max(contours, key=cv2.contourArea)
boundingBox = cv2.minAreaRect(target)
except:
print('no bounding box')
continue
angle = boundingBox[2]
if angle < -45:
angle = angle + 90
table.putNumber('cameraAngle', angle)
# draw a red outline on the output image
# so that the user can see what is targeted
boxPoints = cv2.boxPoints(boundingBox)
boxPoints = np.int0(boxPoints)
rawimg = cv2.drawContours(rawimg, [boxPoints], 0, (0,0,255), 2)
# Give the output stream a new image to display
outputStream.putFrame(rawimg)
image = imstack[:,:,1]
gray = cv2.GaussianBlur(image, (3, 3), 0)
edged = cv2.Canny(gray, 20, 100)
im_shape = images_d.shape
# find contours in the edge map
cnts = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours(cnts)
# ensure at least one contour was found
if len(cnts) > 0:
# grab the largest contour, then draw a mask for the well
c = max(cnts, key=cv2.contourArea)
mask = np.zeros(gray.shape, dtype="uint8")
cv2.drawContours(mask, [c], -1, 255, -1)
# compute its bounding box of well, then extract the ROI,
# and apply the mask
(x, y, w, h) = cv2.boundingRect(c)
# rect_mask = np.zeros(image.shape)
# rect_mask[y:y + h, x:x + w]=1
imageROI = image[y:y + h, x:x + w]
# maskROI = mask[y:y + h, x:x + w]
# imageROI1= cv2.bitwise_and(imageROI, imageROI, mask=maskROI)
image_rotated = image.copy()
for angle in angles:
rotated = ndimage.rotate(imageROI , angle, reshape=False, cval=255)
image_rotated[y:y + h, x:x + w] = rotated
# 2 形态学闭操作: 先膨胀再腐蚀
kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))
img_bgr_morph = cv.morphologyEx(img_bgr_copy, cv.MORPH_CLOSE, kernel)
img_gray = cv.cvtColor(img_bgr_morph, cv.COLOR_BGR2GRAY) # 转为 灰度图
# cv.namedWindow("track_bar")
# cv.createTrackbar("threshold", "track_bar", 0, 255, on_change)
ret, img_bi = cv.threshold(img_gray, 10, 255, cv.THRESH_BINARY)
cv.imshow("img_bi", img_bi)
# 3 查找轮廓
_, contours, hierarchy = cv.findContours(img_bi, cv.RETR_EXTERNAL,
cv.CHAIN_APPROX_SIMPLE)
print "找到轮廓的个数: ", len(contours)
cv.drawContours(img_bgr_copy, contours, -1, (0, 0, 255))
cv.imshow("img_bgr_copy3", img_bgr_copy)
# 4 多边形逼 近
for i, contour in enumerate(contours):
# 获取矩形区域
x, y, w, h = cv.boundingRect(contour)
# 计算面积
area = cv.contourArea(contour)
print area
# 计算周长
arc = cv.arcLength(contour, True)
epsilon = arc * 0.02 # 逼近程度 阈值
# STEP 2: FINDING CONTOURS
# assumption - largest contour in the image with exactly four points is the piece of paper to be scanned
cnts = cv2.findContours(edged.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours(cnts)
cnts = sorted(cnts, key=cv2.contourArea, reverse=True)[:5]
for c in cnts:
# approximate the contour
p = cv2.arcLength(c, True) #contour perimeter
approx = cv2.approxPolyDP(c, 0.02*p, True)
if len(approx) == 4:
screenContour = approx
break
# show the outline
print("Finding Contours")
cv2.drawContours(image, [screenContour], -1, (0,255,0), 2) # pass -1 to draw all the contours
cv2.imshow("outline", image)
cv2.waitKey(0)
cv2.destroyAllWindows()
# STEP # - APPLY PERSPECTIVE TRANSFORM AND THRESHOLD
# apply 4 point transform to obtain top-down view of the orginal Image
warped = four_point_transform(orig, screenContour.reshape(4,2)*ratio)
# convert warped image to grayscale and then threshold it to give it 'black and white paper' look
warped = cv2.cvtColor(warped, cv2.COLOR_BGR2GRAY)
T = threshold_local(warped, 11, offset=10, method = "gaussian")
warped = (warped > T).astype("uint8")*255
print("Apply PERSPECTIVE TRANSFORM")
cv2.imshow("Original", imutils.resize(orig, height=650))
cv2.imshow("Scanned",imutils.resize(warped,height=650))
segmentation = [[int(x) for x in cnt.ravel().tolist()]]
x,y,w,h = cv2.boundingRect(cnt)
annotations.append({
'segmentation': segmentation,
'area': area,
'bbox': [int(x), int(y), int(w), int(h)],
'iscrowd': 0,
'id': len(annotations)+1,
'image_id': 1,
'category_id': category_id
})
for ann in annotations:
color = tuple ([int(x*255) for x in np.random.rand(3)])
cv2.drawContours(bg,[np.array(ann['segmentation']).reshape(-1,1,2)],0,color,-1)
name = str(uuid.uuid1()).split('-')[0]
all_coco = {'info': {'year': 2021,
'version': '1.0',
'description': 'build with dataset_builder',
'contributor': 'MiXaiLL76',
'url': 'https://t.me/mixaill76',
'date_created': '2021-01-06 16:22:20'},
'images': [{
"id": 1,
"width": W,
"height": H,
"file_name": f"{name}.png",
"license": 1,
"date_captured": "",
largest_area = cv2.contourArea(contours[i])
largest_area_index = i
M = cv2.moments(contours[largest_area_index])
cX = int(M["m10"] / M["m00"])
cY = int(M["m01"] / M["m00"])
# print(cX,cY)
# print(asli.shape)
sample = np.zeros((20, 20, 3), dtype=np.uint8)
x = 0
for i in range(20):
for n in range(20):
sample[i, n] = (asli[cY - 10 + n, cX - 10 + i])
cv2.drawContours(image, contours[largest_area_index], -1, 255, 3)
cv2.rectangle(image, (cX - 11, cY - 11), (cX + 11, cY + 11), (255, 255, 255),
1)
cv2.circle(image, (cX, cY), 1, (255, 255, 255), -1)
cv2.putText(image, "Titik Sample", (cX - 20, cY - 20),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)
gray_sample = cv2.cvtColor(sample, cv2.COLOR_BGR2GRAY)
# sample = cv2.GaussianBlur(sample,(3,3),cv2.BORDER_DEFAULT)
print(gray_sample)
print("Avg of red : ", np.average(sample[:, :, 2]))
print("Avg of green : ", np.average(sample[:, :, 1]))
print("Avg of blue : ", np.average(sample[:, :, 0]))
print("Avg Gray value = ", np.average(sample))
hsv_sample = cv2.cvtColor(sample, cv2.COLOR_BGR2HSV)
# print(sample)
def data(self,noised_maps,ref_map,mask,rotate_angle,mode):
# Lboxes are the large boxes around doorways for classfication
# Sboxes are the small boxes around doorways for determination of the number of doors involved in a window
# divided_masks are the masks of each doorway separately
Lboxes=[]
Sboxes=[]
divided_masks=[]
_,contours,_ = cv2.findContours(mask,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
for cnt in contours:
# separate the masks based on their contours
canvas = np.zeros_like(mask)
cv2.drawContours(canvas,[cnt], 0, 255, -1)
divided_masks.append(canvas)
rect = cv2.minAreaRect(cnt)
box = cv2.boxPoints(rect)
box = np.int0(np.round(box))
# adjust the large box according to the rotated angle
tuned_x_gap = round(self.x_gap/self.resolution*(1-utils.normfun(rotate_angle%90,24)*33)).astype(np.int)
large_box = utils.calc_box(box,tuned_x_gap,int(self.y_gap/self.resolution),rotate_angle,self.center)
Lboxes.append(large_box)
small_box = utils.calc_box(box,1,1,rotate_angle,self.center)
Sboxes.append(small_box)
Lboxes = np.array(Lboxes)
Sboxes = np.array(Sboxes)
# rotate the divided masks with the given angle
rotate_kernel = cv2.getRotationMatrix2D(tuple(self.center),rotate_angle,1)
rotate_masks=[]
for mask in divided_masks:
rotate_mask = cv2.warpAffine(mask,rotate_kernel,self.img_size,borderValue=0)
rotate_masks.append(rotate_mask)
for x in range(0,self.img_size[0],self.stride):
if (x+self.window_size)<=self.img_size[0]:
for y in range(0,self.img_size[1],self.stride):
if (y+self.window_size)<=self.img_size[1]:
window = np.array([x,y,x+self.window_size-1,y+self.window_size-1])
# reious is regarded as the threshold for classification
reious = utils.overlapp(window,Lboxes)
if mode ==0:
# extract samples of background
if (reious<=self.thres_bg).all():
bk = ref_map[x:x+self.window_size,y:y+self.window_size]
if np.sum(bk==self.colors['gray'])<3600:
# calculate the selection rate according to the variance and the proportion of gray pixels
var = np.var(bk)
denominator = 40-utils.sigmoid(var/3200)*12+30*np.sum((bk>120)*(bk<130))/(self.window_size**2)
if np.random.randint(denominator)==0:
# save the extracted samples
for n,nmaps in enumerate(noised_maps):
for l, lmap in enumerate(nmaps):
background = lmap[x:x+self.window_size,y:y+self.window_size]
# background region for cnn
path = self.dir_path[0]+'_'+str(n)+str(l)+'/0/'
utils.mkdir(path)
cv2.imwrite(path+str(self.cnn_count)+'.png',background)
self.cnn_count +=1
# set the upper limit
if self.cnn_count==self.cnn_num:
sys.exit()
if mode == 1:
# extract samples of doorways
if(reious>=self.thres_door).any():
# calculate the number of doors involved in this window
if (rotate_angle%90)<10:
thres =0
elif (rotate_angle%90)>80:
thres =0
elif (rotate_angle%90)<=45:
thres = (rotate_angle%90)/45*0.5
else :
thres = (90-rotate_angle%90)/45*0.5
num_door = np.where(utils.overlapp(window,Sboxes)>thres)[0].shape[0]
ref = np.where(reious>=self.thres_door)[0].shape[0]
# ensure that all the doors involved in this window are completely covered
if num_door ==ref:
if np.random.randint(10)==0:
indices = np.where(reious>=self.thres_door)[0]
# save the extracted samples
for n,nmaps in enumerate(noised_maps):
for l, lmap in enumerate(nmaps):
proxi_area = lmap[x:x+self.window_size,y:y+self.window_size]
mask_area = np.zeros((self.window_size,self.window_size),np.uint8)
for index in indices:
mask_area = mask_area+rotate_masks[index][x:x+self.window_size,y:y+self.window_size]
# doorway region for u-net
path = self.dir_path[1]+'_'+str(n)+str(l)+'/imgs/'
utils.mkdir(path)
cv2.imwrite(path+str(self.unet_count)+'.png',proxi_area)
# mask of doorway for u-net
path = self.dir_path[1]+'_'+str(n)+str(l)+'/masks/'
utils.mkdir(path)
cv2.imwrite(path+str(self.unet_count)+'.png',mask_area)
# doorway region for cnn
path = self.dir_path[0]+'_'+str(n)+str(l)+'/1/'
utils.mkdir(path)
if self.cnn_count<self.cnn_num:
cv2.imwrite(path+str(self.cnn_count)+'.png',proxi_area)
self.cnn_count+=1
self.unet_count+=1
# set the upper limit
if self.unet_count==self.unet_num:
sys.exit()
# crop1 = img1[y1:y1+h1,x1:x1+w1]
# cv2.imwrite('image2.png',crop)
# cv2.imwrite('image1.png',crop1)
###CONTOURS FOR IMAGE SEGMENTAITON####
ret, thresh = cv2.threshold(img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
im2, contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
###First argument img is the source of image
###Second is the countours which should be passed as python list
###Third is index of contours (to draw all contours pass -1)
####remaining are color and thickness
mask2 = cv2.drawContours(thresh, contours, 0, (255, 0, 0), -1)
masked_data = cv2.bitwise_and(img, img, mask=mask2)
b, g, r = cv2.split(img2)
rgba = [b, g, r, thresh]
dst = cv2.merge(rgba, 4)
#idx=1
#print(contours)
#print(type(contours))
# x,y,w,h = cv2.boundingRect(dst)
# roi=dst[y:y+h,x:x+w]
#cv2.imwrite(str(idx) + '.jpg', dst)
cv2.imwrite('image2sfdsf.png', dst)
import numpy as np
import cv2
image = cv2.imread('images/hand.jpg')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imshow('Original Image', image)
cv2.waitKey(0)
ret, thresh = cv2.threshold(gray, 176, 255, 0)
contours, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)
n = len(contours) - 1
contours = sorted(contours, key=cv2.contourArea, reverse=False)[:n]
for c in contours:
hull = cv2.convexHull(c)
cv2.drawContours(image, [hull], 0, (0, 255, 0), 2)
cv2.imshow('Convex Hull', image)
cv2.waitKey(0)
cv2.destroyAllWindows()
# In[11]:
#Get largest Contour
contours = cv2.findContours(morph, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
contours = contours[0] if len(contours) == 2 else contours[1]
area_thresh = 0
for c in contours:
area = cv2.contourArea(c)
if area > area_thresh:
area_thresh = area
big_contour = c
#Draw
page = np.zeros_like(img)
cv2.drawContours(page, [big_contour], 0, (255,255,255), -1)
#Get perimeter and ~polygon
peri = cv2.arcLength(big_contour, True)
corners = cv2.approxPolyDP(big_contour, 0.04 * peri, True)
#Draw polygon on input img from detedcted corner
polygon = img.copy()
cv2.polylines(polygon, [corners], True, (0,0,255), 1, cv2.LINE_AA)
print(len(corners))
print(corners)
width = 0.5 * ((corners[0][0][0] - corners[1][0][0]) + (corners[3][0][0] - corners[2][0][0]))
height = 0.5 * ((corners[2][0][1] - corners[1][0][1]) + (corners[3][0][1] - corners[0][0][1]))
def geometry():
#extraction info from json
json_obj = request.get_json(force=True)
shape_sides = json_obj['shape']
surface = json_obj['surface']
color = json_obj['color']
#getting original image
big_img = cv2.imread(app.root_path + '/static/pictures/original.jpg', 1)
#convert from RGB to HSV
org_img_hsv = cv2.cvtColor(big_img, cv2.COLOR_BGR2HSV)
#defining color boundaries in HSV
if color == "G":
lower_color = np.array([35, 30, 0])
upper_color = np.array([104, 255, 255])
if color == "R":
lower_color = np.array([0, 30, 0])
upper_color = np.array([30, 255, 255])
lower_color1 = np.array([150, 30, 0])
upper_color1 = np.array([180, 255, 255])
if color == "B":
lower_color = np.array([109, 30, 0])
upper_color = np.array([169, 255, 255])
#creating mask according to specific color boundaries
mask = cv2.inRange(org_img_hsv, lower_color, upper_color)
#
contours, hierarchy = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
#spacial case if color is red because of red's non-continues nature
if color == "R":
mask1 = cv2.inRange(org_img_hsv, lower_color1, upper_color1)
contours1, hierarchy = cv2.findContours(mask1.copy(),
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
for cnt in contours1:
if cv2.isContourConvex(cnt):
area = cv2.contourArea(cnt)
peri = cv2.arcLength(cnt, True)
approx = cv2.approxPolyDP(cnt, 0.04 * peri, True)
if (area > float(surface) and len(approx) == int(shape_sides)):
cv2.drawContours(big_img, [cnt], -1, (0, 0, 0), 4)
for cnt in contours:
if cv2.isContourConvex(cnt):
area = cv2.contourArea(cnt)
peri = cv2.arcLength(cnt, True)
approx = cv2.approxPolyDP(cnt, 0.04 * peri, True)
if (area > float(surface) and len(approx) == int(shape_sides)):
cv2.drawContours(big_img, [cnt], -1, (0, 0, 0), 2)
randon_hex = secrets.token_hex(8)
f_ext = '.jpg'
picture_fn = randon_hex + f_ext
path = os.path.join(app.root_path, 'static/pictures', picture_fn)
cv2.imwrite(path, big_img)
rel_path = '/static/pictures/' + picture_fn
return jsonify({'result': 'success', 'image_path': rel_path})
blueLower = np.array([75, 67, 0], dtype="uint8")
blueUpper = np.array([255, 180, 80], dtype="uint8")
camera = cv2.VideoCapture(args['video'])
while True:
(grabbed, frame) = camera.read()
if not grabbed:
break
blue = cv2.inRange(frame, blueLower, blueUpper)
blue = cv2.GaussianBlur(blue, (3, 3), 0)
(cnts, _) = cv2.findContours(blue.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
if len(cnts) > 0:
cnt = sorted(cnts, key=cv2.contourArea, reverse=True)[0]
rect = np.int32(cv2.boxPoints(cv2.minAreaRect(cnt)))
cv2.drawContours(frame, [rect], -1, (0, 255, 0), 2)
cv2.imshow("Tracking", frame)
cv2.imshow("Binary", blue)
time.sleep(0.025)
if cv2.waitKey(1) & 0xFF == ord("q"):
break
camera.release()
cv2.destroyAllWindows()
frame = imutils.resize(frame, width=550)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
subjects = detect(gray, 0)
for subject in subjects:
shape = predict(gray, subject)
shape = face_utils.shape_to_np(shape)
leftEye = shape[lStart:lEnd]
rightEye = shape[rStart:rEnd]
leftEAR = eye_aspect_ratio(leftEye)
rightEAR = eye_aspect_ratio(rightEye)
ear = (leftEAR + rightEAR) / 2.0
leftEyeHull = cv2.convexHull(leftEye)
rightEyeHull = cv2.convexHull(rightEye)
cv2.drawContours(frame, [leftEyeHull], -1, (0, 255, 0), 1)
cv2.drawContours(frame, [rightEyeHull], -1, (0, 255, 0), 1)
cv2.putText(frame, "Visuals: {:.2f}".format(ear), (0, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 0, 0), 2)
if ear < thresh:
flag += 1
#print (flag)
cv2.putText(frame, "B L I N K", (430, 20),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (100, 155, 0), 2)
if flag >= frame_check:
cv2.putText(frame, "********* WAKE UP SIR ********", (10, 70),
cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2)
# image, "TEXT", (x,y), fontFamily-eg. SIMPLEX / PLAIN, frontScale, (B,G,R), thickness
def detect_parking(self,
img,
distanceBetween2Lines=45,
distanceFromTop=175,
minLineLength=140,
binaryThreshold=230):
height = img.shape[0]
width = img.shape[1]
# img = bird_view(img, False)
# left cover
cv2.drawContours(
img, [np.array([(width // 2, 0), (0, 0),
(0, height * 2 // 3)])], 0, (0, 0, 0), -1)
# right cover
cv2.drawContours(img, [
np.array([(width // 2, 0), (width, 0), (width, height * 2 // 3)])
], 0, (0, 0, 0), -1)
# bottom cover
cv2.drawContours(img, [
np.array([(0, height * 10 // 11), (width, height * 10 // 11),
(width, height), (0, height)])
], 0, (0, 0, 0), -1)
# top cover
cv2.drawContours(img, [
np.array([(0, 0), (width, 0), (width, int(height * 0.6)),
(0, int(height * 0.6))])
], 0, (0, 0, 0), -1)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
_, thres = cv2.threshold(gray, binaryThreshold, 255, cv2.THRESH_BINARY)
try:
rho, theta = self.findLine(thres, minLineLength)
if rho < 0:
raise Exception
except:
return False, (0, 0), (0, 0)
a = np.cos(theta)
b = np.sin(theta)
x0 = a * rho
y0 = b * rho
x1 = int(x0 + 1000 * (-b))
y1 = int(y0 + 1000 * (a))
x2 = int(x0 - 1000 * (-b))
y2 = int(y0 - 1000 * (a))
pt1 = (x1, y1)
pt2 = (x2, y2)
if (not self.isFirstDetection) and (np.abs(rho - self.lastRho) >
distanceBetween2Lines):
self.isSecondLine = True
else:
self.isFirstDetection = False
self.lastRho = rho
if self.isSecondLine and rho > distanceFromTop:
return True, pt1, pt2
else:
return False, pt1, pt2
mc[i] = (mu[i]['m10'] / (mu[i]['m00'] + 1e-5),
mu[i]['m01'] / (mu[i]['m00'] + 1e-5)
) #-- add 1e-5 to avoid division by zero
if (flag):
points3d[i] = list(
getXYZfromUVD(int(mc[i][0]), int(mc[i][1]), mid_depth[i]))
points3d[i][0] = .001 - points3d[i][0]
points3d[i][1] = 1.0 - points3d[i][1]
points3d[i][2] = -.45 - points3d[i][2]
print(points3d[i])
cv2.circle(RGB_image, (int(mc[i][0]), int(mc[i][1])),
int(radius[i]), color, 2)
cv2.drawContours(RGB_image, contours, i, color, 2)
cv2.circle(RGB_image, (int(mc[i][0]), int(mc[i][1])), 4, color,
-1)
#depth_message = bridge.cv2_to_imgmsg(Depth_image, encoding="passthrough")
try:
None
except:
#print("Not Published")
None
if cv2.waitKey(1) == 27:
break # esc to quit
cv2.destroyAllWindows()
def drumbackend(self):
pygame.mixer.music.pause()
lower_red = numpy.array([-10, 100, 100])
upper_red = numpy.array([10, 255, 255])
lower_blue = numpy.array([80, 100, 100])
upper_blue = numpy.array([100, 255, 255])
frequencybeep = 2500 # Set Frequency To 2500 Hertz
durationbeep = 50 # Set Duration To 1000 ms == 1 second
kernelOpen = numpy.ones((10, 10))
kernelClose = numpy.ones((20, 20))
cap = cv2.VideoCapture(0)
cap.set(3, 1920)
cap.set(4, 1080)
retval, frame = cap.read()
runningcam = True
while runningcam:
cv2.flip(frame, 1, frame) #mirror the image
self.screen.fill(0)
retval, frame = cap.read()
frame = numpy.rot90(frame)
frame = numpy.ascontiguousarray(frame, dtype=numpy.uint8)
cv2.rectangle(frame, (450, 200), (550, 300), (0, 255, 0), 2)
cv2.rectangle(frame, (450, 600), (550, 700), (0, 255, 0), 2)
cv2.rectangle(frame, (450, 1000), (550, 1100), (0, 255, 0), 2)
cv2.rectangle(frame, (250, 400), (350, 500), (0, 255, 0), 2)
cv2.rectangle(frame, (250, 800), (350, 900), (0, 255, 0), 2)
frameHSV = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
mask1 = cv2.inRange(frameHSV, lower_red, upper_red)
mask2 = cv2.inRange(frameHSV, lower_blue, upper_blue)
#res = cv2.bitwise_and(frame,frame, mask= mask1)
maskOpen1 = cv2.morphologyEx(mask1, cv2.MORPH_OPEN, kernelOpen)
maskClose1 = cv2.morphologyEx(maskOpen1, cv2.MORPH_CLOSE,
kernelClose)
maskOpen2 = cv2.morphologyEx(mask2, cv2.MORPH_OPEN, kernelOpen)
maskClose2 = cv2.morphologyEx(maskOpen2, cv2.MORPH_CLOSE,
kernelClose)
maskClose = maskClose1 + maskClose2
maskFinal = maskClose
img, contours, h = cv2.findContours(maskFinal.copy(),
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
for contour in contours:
area = cv2.contourArea(contour)
if area > 1000:
cv2.drawContours(frame, contour, -1, (0, 255, 255), 3)
for i in range(len(contours)):
from playsound import playsound
x, y, w, h = cv2.boundingRect(contour[i])
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 3)
#print(x,y)
if x > 450 and y > 200 and x + w < 550 and y + h < 300:
cv2.rectangle(frame, (450, 200), (550, 300), (0, 255, 255),
3)
# from playsound import playsound
playsound(
"F:\\openCV-jay\\raunak files\\drum\\sound\\sound\\New folder\\New folder\\sound 1-[AudioTrimmer.com].wav"
)
elif x > 450 and y > 600 and x + w < 550 and y + h < 700:
cv2.rectangle(frame, (450, 600), (550, 700), (0, 255, 255),
3)
# from playsound import playsound
playsound(
"F:\\openCV-jay\\raunak files\\drum\\sound\\sound\\New folder\\New folder\\sound 2-[AudioTrimmer.com].wav"
)
elif x > 450 and y > 1000 and x + w < 550 and y + h < 1100:
cv2.rectangle(frame, (450, 1000), (550, 1100),
(0, 255, 255), 3)
playsound(
"F:\\openCV-jay\\raunak files\\drum\\sound\\sound\\New folder\\New folder\\sound 3-[AudioTrimmer.com].wav"
)
elif x > 250 and y > 400 and x + w < 350 and y + h < 500:
cv2.rectangle(frame, (250, 400), (350, 500), (0, 255, 255),
3)
#from playsound import playsound
playsound(
"F:\\openCV-jay\\raunak files\\drum\\sound\\sound\\New folder\\New folder\\sound 4-[AudioTrimmer.com].wav"
)
elif x > 250 and y > 800 and x + w < 350 and y + h < 900:
cv2.rectangle(frame, (250, 800), (350, 900), (0, 255, 255),
3)
#from playsound import playsound
playsound(
"F:\\openCV-jay\\raunak files\\drum\\sound\\sound\\New folder\\New folder\\sound 5-[AudioTrimmer.com].wav"
)
framepygame = frame
framepygame = cv2.cvtColor(framepygame, cv2.COLOR_BGR2RGB)
framepygame = pygame.surfarray.make_surface(framepygame)
framepygame = pygame.transform.scale(framepygame, (1920, 1080))
self.screen.blit(framepygame, (0, 0))
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
runningcam = False
cap.release()
pygame.quit()
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
pygame.mixer.music.unpause()
runningcam = False
self.draw()
if event.key == pygame.K_q:
runningcam = False
cap.release()
pygame.quit()
sys.exit()
cv.imwrite('{}/GrayscaleBef.png'.format(pathForToday), gray)
weiSize,serSize,filStr = 7,7,12
gray = cv.fastNlMeansDenoising(gray, gray, weiSize, serSize, filStr)
cv.imwrite('{}/GrayscaleAftS{}F{}.png'.format(pathForToday, weiSize, filStr), gray)
lowThresh,highThresh = 100,300
note = open("{}/data.txt".format(pathForToday), "w")
note.write("Low thresh:{}\nHigh thresh:{}\n".format(lowThresh,highThresh))
note.close()
thresh = cv.Canny(gray, lowThresh, highThresh)
grad = gray
contours, hierarchy = cv.findContours(thresh, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE) # Изменить коэфициенты
cv.drawContours(grad, contours, -1, (0,255,0), 3) # Поиграться с коэфициентами
for cnt in contours:
rect = cv.minAreaRect(cnt) # пытаемся вписать прямоугольник
box = cv.boxPoints(rect) # поиск четырех вершин прямоугольника
box = np.int0(box) # округление координат
cv.drawContours(grad,[box],0,(255,0,0),2) # Поиграться с коэфициентами
cv.imwrite('{}/Countours_TestB{}.png'.format(pathForToday, BLUR_C), grad)
f = open("Ready_Images/iteration.txt", "w")
iterationNumber += 1
f.write(str(iterationNumber))
f.close()
cv.waitKey()
cv.destroyAllWindows()
def detect (self, image, threshold = 0.7):
match_method = cv2.TM_CCOEFF_NORMED
detected = {}
num_objects = 0
with Timer('detection'):
# Compare squares against patterns, and if not recognized, take the sample as new pattern
for i, cnt in enumerate(self.squares):
max_found = threshold
max_item = None
max_location = (-1,-1)
max_angle = -1
bounds = cv2.boundingRect(cnt)
location_abs, size, phi = cv2.minAreaRect(cnt)
cropped = cv2.getRectSubPix(self.processed, bounds[2:], location_abs)
location = (location_abs[0]-bounds[0], location_abs[1]-bounds[1])
w, h = tuple(int(c) for c in size)
rot = cv2.getRotationMatrix2D(location, phi, 1)
rotated = cv2.warpAffine(cropped, rot, dsize = cropped.shape[:2], flags=cv2.INTER_CUBIC)
sample = cv2.getRectSubPix(rotated, (w-4, h-4), location)
#sample = cv2.cvtColor(sample, cv2.COLOR_BGR2GRAY)
sample = cv2.resize(sample, (90, 90))
#ret, sample = cv2.threshold(sample, 230, 255, cv2.THRESH_BINARY)
#sample = cv2.equalizeHist(sample)
#cv2.circle(self.original, tuple(int(l) for l in location_abs), 20, (0,0,255))
#cv2.imshow('crop'+str(i),self.processed)
for tag, pattern in self.patterns.items():
match = cv2.matchTemplate(sample, pattern, match_method)
result, _, _, _ = cv2.minMaxLoc(match)
if result > max_found:
#print "Best candidate for %s is %s with %s" % (str(i),tag, str(result))
max_found = result
max_item = tag
max_location = (int(location_abs[0]), int(location_abs[1]))
max_angle = phi
if result > threshold * 1.5:
break
else:
#print "Discarted", str(i)
if self.training:
#print "Store new pattern",i
cv2.imwrite('patterns/tag-%s.pgm' % str(i), sample)
if max_item:
cv2.drawContours(self.original, self.squares, i, (0, 255, 0), 5)
tag_id = max_item.replace("patterns/tag-", "").replace(".pgm", "")
max_angle = (360 - max_angle) % 360
try:
name, angle = tag_id.split("-", 1)
#if name=='arrow':
# print "Orig angle", max_angle, "using", angle
if angle=='t1':
max_angle += 90
elif angle=='t2':
max_angle += 180
elif angle=='t3':
max_angle += 270
except:
name = tag_id
cv2.putText(self.original, "%s" % name,
(max_location[0]-20, max_location[1]-20), cv2.FONT_HERSHEY_PLAIN, 1, (0,0,255), 1)
#vmod = 10
#p2 = (int(max_location[0] + vmod * np.cos(max_angle + np.pi/4)),
# int(max_location[1] + vmod * np.sin(max_angle + np.pi/4)))
#cv2.line(self.original, max_location, p2, (0,255,255), 3)
#print "Chosen %s to be %s" % (str(i), max_item)
if not name in detected:
detected[name] = []
detected[name].append({'angle': int(100 * max_angle)/100.0, 'pos': max_location})
num_objects +=1
return num_objects, detected
clone = frame.copy()
for c in cnts:
# calculate contour properties
area = cv2.contourArea(c)
peri = cv2.arcLength(c, True)
# select desired contours
if area > 0:
box = cv2.minAreaRect(c)
((x, y), (w, h), theta) = box
if (theta < -7.0 and theta >- 11.0) and w < 15 and w > 2 and h > 10:
# draw in the minimum rectangles
box = np.int0(cv2.cv.BoxPoints(box))
cv2.drawContours(clone, [box], -1, (0, 255, 0), 2)
if debug > 0:
cv2.putText(clone, '%0.1f' % theta, (int(x), int(y-15)), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 200, 100), 1)
# identify center of rectangle
cx = int(x+(w/2))
cy = int(y+(h/2))
cv2.circle(clone, (int(x), int(y)), 3, (0, 0, 255), -1)
if debug > 0:
cv2.putText(clone, ' (%d,%d)' % (int(x), int(y)), (int(x), int(y)), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)
if debug > 1:
print x, y, w, h, theta
if debug > 0:
fnum = '%d %d %d' % (fcnt, param1, param2)
def sleep_detect():
global outputFrame, lock, COUNTER, active, is_sleep, ALARM_ON
while True:
# grab the frame from the threaded video file stream, resize
# it, and convert it to grayscale
# channels)
frame = vs.read()
frame = imutils.resize(frame, width=450)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# detect faces in the grayscale frame
rects = detector.detectMultiScale(gray,
scaleFactor=1.1,
minNeighbors=5,
minSize=(30, 30),
flags=cv2.CASCADE_SCALE_IMAGE)
# loop over the face detections
for (x, y, w, h) in rects:
# construct a dlib rectangle object from the Haar cascade
# bounding box
rect = dlib.rectangle(int(x), int(y), int(x + w), int(y + h))
# determine the facial landmarks for the face region, then
# convert the facial landmark (x, y)-coordinates to a NumPy
# array
shape = predictor(gray, rect)
shape = face_utils.shape_to_np(shape)
# extract the left and right eye coordinates, then use the
# coordinates to compute the eye aspect ratio for both eyes
leftEye = shape[lStart:lEnd]
rightEye = shape[rStart:rEnd]
leftEAR = eye_aspect_ratio(leftEye)
rightEAR = eye_aspect_ratio(rightEye)
# average the eye aspect ratio together for both eyes
ear = (leftEAR + rightEAR) / 2.0
# compute the convex hull for the left and right eye, then
# visualize each of the eyes
leftEyeHull = cv2.convexHull(leftEye)
rightEyeHull = cv2.convexHull(rightEye)
cv2.drawContours(frame, [leftEyeHull], -1, (0, 255, 0), 1)
cv2.drawContours(frame, [rightEyeHull], -1, (0, 255, 0), 1)
# check to see if the eye aspect ratio is below the blink
# threshold, and if so, increment the blink frame counter
if ear < EYE_AR_THRESH:
COUNTER += 1
# if the eyes were closed for a sufficient number of
# frames, then sound the alarm
if COUNTER >= EYE_AR_CONSEC_FRAMES:
# if the alarm is not on, turn it on
if not ALARM_ON:
ALARM_ON = True
# check to see if the TrafficHat buzzer should
# be sounded
if args["alarm"] > 0 and active == True:
th.buzzer.blink(0.1, 0.1, 10, background=True)
# is_sleep on
is_sleep = True
# draw an alarm on the frame
cv2.putText(frame, "DROWSINESS ALERT!", (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
# otherwise, the eye aspect ratio is not below the blink
# threshold, so reset the counter and alarm
else:
COUNTER = 0
ALARM_ON = False
is_sleep = False
# draw the computed eye aspect ratio on the frame to help
# with debugging and setting the correct eye aspect ratio
# thresholds and frame counters
cv2.putText(frame, "EAR: {:.3f}".format(ear), (300, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
# acquire the lock, set the output frame, and release the lock
with lock:
outputFrame = frame.copy()
def get():
if request.method == 'POST':
url = request.args.get(key='imagelink')
req = urlopen(url)
arr = np.asarray(bytearray(req.read()), dtype=np.uint8)
img = cv2.imdecode(arr, -1) # 'Load it as it is'
# Load image
original = img.copy() # Original Image copy
# Image Processing
gamma = 0.8
invGamma = 1 / gamma
table = np.array([((i / 255.0)**invGamma) * 255
for i in np.arange(0, 256)]).astype("uint8")
cv2.LUT(img, table, img)
img = cv2.fastNlMeansDenoisingColored(img, None, 10, 10, 7, 21)
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #To grayscale
img = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_MEAN_C,
cv2.THRESH_BINARY, 11, 12) #To binary
img = np.invert(img) #Invert
img = cv2.morphologyEx(img, cv2.MORPH_CLOSE,
cv2.getStructuringElement(
cv2.MORPH_RECT, (3, 3))) #Closing
contours, hier = cv2.findContours(
img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) #Find all contours
biggest_area = 0
biggest_contour = None
for i in contours:
area = cv2.contourArea(i)
if area > biggest_area:
biggest_area = area
biggest_contour = i
if biggest_contour is None:
sys.exit(1)
mask = np.zeros((img.shape), np.uint8)
cv2.drawContours(mask, [biggest_contour], 0, (255, 255, 255), -1)
img = cv2.bitwise_and(img, mask)
grid = original.copy()
cv2.drawContours(grid, [biggest_contour], 0, (255, 0, 255), 3)
contours, hier = cv2.findContours(
img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) #Find all contours
c = 0
grid = original.copy()
average_cell_size = biggest_area / 81
bound_range = 4
lower_bound = average_cell_size - average_cell_size / bound_range
upper_bound = biggest_area / 81 + average_cell_size / bound_range
cells = []
x, y, w, h = cv2.boundingRect(biggest_contour)
epsilon = 0.1 * cv2.arcLength(biggest_contour, True)
approx = cv2.approxPolyDP(biggest_contour, epsilon, True)
cv2.drawContours(grid, [approx], 0, (255, 255, 0), 3)
for i in contours:
area = cv2.contourArea(i)
if area >= lower_bound and area <= upper_bound:
cv2.drawContours(grid, contours, c, (0, 255, 0), 3)
cells.append(i)
c += 1
bx, by, bw, bh = cv2.boundingRect(biggest_contour)
aw = int(bw / 9)
ah = int(bh / 9)
awb = int(aw / 4)
ahb = int(aw / 4)
tabla = np.zeros((9, 9))
dataList = []
if len(cells) == 81:
for i in range(9):
for j in range(9):
x = [0, int(bx - awb + j * aw), int(bx + bw)]
y = [0, int(by - ahb + i * ah), int(by + bh)]
x.sort()
y.sort()
x = x[1]
y = y[1]
crop = img[y:by + ah + ahb + i * ah,
x:bx + aw + awb + j * aw]
cont, hier = cv2.findContours(crop, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
bsize = 0
bcont = None
bindex = None
for c in range(len(cont)):
area = cv2.contourArea(cont[c])
if area > bsize:
bsize = area
bcont = cont[c]
bindex = c
if bcont is None:
sys.exit(1)
else:
secondbsize = 0
secondbcont = None
for c in range(len(cont)):
if hier[0][c][3] == bindex:
area = cv2.contourArea(cont[c])
if area > secondbsize:
secondbsize = area
secondbcont = cont[c]
if secondbcont is None:
sys.exit(2)
mask = np.zeros((crop.shape), np.uint8)
cv2.drawContours(mask, [secondbcont], 0,
(255, 255, 255), -1)
finetune = cv2.bitwise_and(crop, mask)
x, y, w, h = cv2.boundingRect(secondbcont)
finetune = finetune[y + 3:y + h - 3, x + 3:x + w - 3]
finetune = cv2.morphologyEx(
finetune, cv2.MORPH_CLOSE,
cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3)))
finetune = np.invert(finetune)
kernel = np.array([[-1, -1, -1], [-1, 9, -1],
[-1, -1, -1]])
finetune = cv2.filter2D(finetune, -1, kernel)
finetune = cv2.resize(finetune, (0, 0), fx=3, fy=3)
finetune = cv2.GaussianBlur(finetune, (11, 11), 0)
finetune = cv2.medianBlur(finetune, 9)
data = pytesseract.image_to_string(
finetune,
lang='eng',
config=
'--psm 10 --oem 3 -c tessedit_char_whitelist=123456789'
)
dataList = dataList + re.split(r',|\.|\n| ', data)
number = re.findall('\d+', data)
if not re.findall('\d+', data):
tabla[i, j] = 0
else:
tabla[i, j] = number[0]
else:
sys.exit(1)
numpyData = {"array": tabla}
encodedNumpyData = json.dumps(numpyData, cls=NumpyArrayEncoder)
return encodedNumpyData
return contours
src = cv.imread("D:/images/abc.png")
cv.namedWindow("input1", cv.WINDOW_AUTOSIZE)
cv.imshow("input1", src)
src2 = cv.imread("D:/images/a5.png")
cv.imshow("input2", src2)
# 轮廓发现
contours1 = contours_info(src)
contours2 = contours_info(src2)
# 几何矩计算与hu矩计算
mm2 = cv.moments(contours2[0])
hum2 = cv.HuMoments(mm2)
# 轮廓匹配
for c in range(len(contours1)):
mm = cv.moments(contours1[c])
hum = cv.HuMoments(mm)
dist = cv.matchShapes(hum, hum2, cv.CONTOURS_MATCH_I1, 0)
if dist < 1:
cv.drawContours(src, contours1, c, (0, 0, 255), 2, 8)
print("dist %f" % (dist))
# 显示
cv.imshow("contours_analysis", src)
cv.imwrite("D:/contours_analysis.png", src)
cv.waitKey(0)
cv.destroyAllWindows()