def roiMask(image, boundaries):
scale = max([1.0, np.average(np.array(image.shape)[0:2] / 400.0)])
shape = (int(round(image.shape[1] / scale)), int(round(image.shape[0] / scale)))
small_color = cv2.resize(image, shape, interpolation=cv2.INTER_LINEAR)
# reduce details and remove noise for better edge detection
small_color = cv2.bilateralFilter(small_color, 8, 64, 64)
small_color = cv2.pyrMeanShiftFiltering(small_color, 8, 64, maxLevel=1)
small = cv2.cvtColor(small_color, cv2.COLOR_BGR2HSV)
hue = small[::, ::, 0]
intensity = cv2.cvtColor(small_color, cv2.COLOR_BGR2GRAY)
edges = extractEdges(hue, intensity)
roi = roiFromEdges(edges)
weight_map = weightMap(hue, intensity, edges, roi)
_, final_mask = cv2.threshold(roi, 5, 255, cv2.THRESH_BINARY)
small = cv2.bitwise_and(small, small, mask=final_mask)
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (4, 4))
for (lower, upper) in boundaries:
lower = np.array([lower, 80, 50], dtype="uint8")
upper = np.array([upper, 255, 255], dtype="uint8")
# find the colors within the specified boundaries and apply
# the mask
mask = cv2.inRange(small, lower, upper)
mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel, iterations=3)
mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel, iterations=1)
final_mask = cv2.bitwise_and(final_mask, mask)
# blur the mask for better contour extraction
final_mask = cv2.GaussianBlur(final_mask, (5, 5), 0)
return (final_mask, weight_map, scale)
python类MORPH_CLOSE的实例源码
def getClosingImage(img):
kernel = np.ones((35,35),np.uint8)
closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)
return closing
def check_if_good_boundary(self, boundary, norm_height, norm_width, color_img):
preprocess_bg_mask = PreprocessBackgroundMask(boundary)
char_w = norm_width / 20
remove_noise = PreprocessRemoveNonCharNoise(char_w)
id_card_img_mask = preprocess_bg_mask.do(color_img)
id_card_img_mask[0:int(norm_height*0.05),:] = 0
id_card_img_mask[int(norm_height*0.95): ,:] = 0
id_card_img_mask[:, 0:int(norm_width*0.05)] = 0
id_card_img_mask[:, int(norm_width*0.95):] = 0
remove_noise.do(id_card_img_mask)
# se1 = cv2.getStructuringElement(cv2.MORPH_RECT, (5,5))
# se2 = cv2.getStructuringElement(cv2.MORPH_RECT, (2,2))
# mask = cv2.morphologyEx(id_card_img_mask, cv2.MORPH_CLOSE, se1)
# id_card_img_mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, se2)
#
## remove right head profile
left_half_id_card_img_mask = np.copy(id_card_img_mask)
left_half_id_card_img_mask[:, norm_width/2:] = 0
## Try to find text lines and chars
horizontal_sum = np.sum(left_half_id_card_img_mask, axis=1)
line_ranges = extract_peek_ranges_from_array(horizontal_sum)
return len(line_ranges) >= 5 and len(line_ranges) <= 7
def preprocess(self):
self.resizeCaptcha()
# ???
img_thresh = self.th1(self.img)
if self.m_debug:
cv2.imshow("thres", img_thresh)
cv2.imwrite("debug/threshold.png", img_thresh)
# ????? ???
kernel = np.ones((2,2),np.uint8)
closing = cv2.morphologyEx(img_thresh , cv2.MORPH_CLOSE, kernel)
if self.m_debug:
cv2.imshow("close", closing)
cv2.imwrite("debug/closing.png",closing)
# ????
constant = cv2.copyMakeBorder(closing ,50,50,50,50,cv2.BORDER_CONSTANT,value=255)
# ??????? 0 ? 255??
# inverse binary image
# constant = self.inverseColor(constant)
# ??
constantSrc = cv2.merge((constant,constant,constant))
if self.m_debug:
cv2.imwrite("debug/broader.png",constantSrc)
self.imgPreprocess = constantSrc.copy()
def closing(binary_img=None, k_size=2, iterations=1):
kernel = np.ones((k_size, k_size), np.uint8)
return cv2.morphologyEx(binary_img, cv2.MORPH_CLOSE, kernel, iterations=iterations) # iteration = loop
def find_fairy_ring(self):
run = 1
while run:
play_screen = Screenshot.shoot(6,59,510,355,'hsv')
# finding white on fairy ring inner circle
low = np.array([107,92,93])
high = np.array([113,255,129])
mask = cv2.inRange(play_screen, low, high)
kernel = np.ones((10,10), np.uint8)
dilation = cv2.dilate(mask, kernel, iterations = 1)
#closing = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
#_,contours,_ = cv2,findContours(closing.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
_,contours,_ = cv2.findContours(dilation, cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
for con in contours:
print("Area: {}".format(cv2.contourArea(con)))
if cv2.contourArea(con) > 1.0:
(x, y, w, h) = cv2.boundingRect(con)
x += self.rs_x
y += self.rs_y
x1 = x
y1 = y
x2 = x + w
y2 = y + h
print("x1:{} y1:{} x2:{} y2:{}".format(x1,y1,x2,y2))
#print(cv2.contourArea(con))
#M = cv2.moments(con)
# finds centroid
#x,y = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
Mouse.randMove(x1,y1,x2,y2,3)
time.sleep(5)
if RS.findOptionClick(x1,y1,'cis'):
run = 0
time.sleep(2)
break
#cv2.imshow('img', mask)
#cv2.waitKey(000)
def morph_close(image, kernel_x=5, kernel_y=1):
# Attempt to connect adjacent contours by dilating and then eroding
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (kernel_x, kernel_y))
image = cv2.morphologyEx(image, cv2.MORPH_CLOSE, kernel)
return image
def close(self, **kwargs):
if 'shape' not in kwargs:
kwargs['shape'] = cv2.MORPH_ELLIPSE
if 'size' not in kwargs:
kwargs['size'] = 3
if kwargs['size'] > 0:
kernel = cv2.getStructuringElement(kwargs['shape'], (kwargs['size'], kwargs['size']))
self._ndarray = cv2.morphologyEx(self.ndarray, cv2.MORPH_CLOSE, kernel)
self._contours = None
# AND this frame with another frame
def detect_contours(self):
blurred = cv2.GaussianBlur(self.src, (self.kernel_size, self.kernel_size), self.sigma)
# apply canny detector
detected_edges = cv2.Canny(blurred, self.threshold, self.threshold * self.ratio, apertureSize=self.apertureSize, L2gradient=True)
if self.use_dilate:
kernel = np.ones((3, 3), np.uint8)
detected_edges = cv2.morphologyEx(detected_edges, cv2.MORPH_CLOSE, kernel)
self.contours_img, self.simple_contours, self.hierarchy = cv2.findContours(detected_edges.copy(), cv2.RETR_CCOMP, cv2.CHAIN_APPROX_TC89_KCOS)
# pdb.gimp_message(self.hierarchy)
_, self.full_contours, _ = cv2.findContours(detected_edges, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)
def hasBird(spec, threshold=16):
#working copy
img = spec.copy()
#STEP 1: Median blur
img = cv2.medianBlur(img,5)
#STEP 2: Median threshold
col_median = np.median(img, axis=0, keepdims=True)
row_median = np.median(img, axis=1, keepdims=True)
img[img < row_median * 3] = 0
img[img < col_median * 4] = 0
img[img > 0] = 1
#STEP 3: Remove singles
img = filter_isolated_cells(img, struct=np.ones((3,3)))
#STEP 4: Morph Closing
img = cv2.morphologyEx(img, cv2.MORPH_CLOSE, np.ones((5,5), np.float32))
#STEP 5: Frequency crop
img = img[128:-16, :]
#STEP 6: Count columns and rows with signal
#(Note: We only use rows with signal as threshold, but columns might come in handy in other scenarios)
#column has signal?
col_max = np.max(img, axis=0)
col_max = ndimage.morphology.binary_dilation(col_max, iterations=2).astype(col_max.dtype)
cthresh = col_max.sum()
#row has signal?
row_max = np.max(img, axis=1)
row_max = ndimage.morphology.binary_dilation(row_max, iterations=2).astype(row_max.dtype)
rthresh = row_max.sum()
#final threshold
thresh = rthresh
#DBUGB: show?
#print thresh
#cv2.imshow('BIRD?', img)
#cv2.waitKey(-1)
#STEP 7: Apply threshold (Default = 16)
bird = True
if thresh < threshold:
bird = False
return bird, thresh
######################################################
#elist all bird species
def find_contours(img):
'''
:param img: (numpy array)
:return: all possible rectangles (contours)
'''
img_blurred = cv2.GaussianBlur(img, (5, 5), 1) # remove noise
img_gray = cv2.cvtColor(img_blurred, cv2.COLOR_BGR2GRAY) # greyscale image
# cv2.imshow('', img_gray)
# cv2.waitKey(0)
# Apply Sobel filter to find the vertical edges
# Find vertical lines. Car plates have high density of vertical lines
img_sobel_x = cv2.Sobel(img_gray, cv2.CV_8UC1, dx=1, dy=0, ksize=3, scale=1, delta=0, borderType=cv2.BORDER_DEFAULT)
# cv2.imshow('img_sobel', img_sobel_x)
# Apply optimal threshold by using Oslu algorithm
retval, img_threshold = cv2.threshold(img_sobel_x, 0, 255, cv2.THRESH_OTSU + cv2.THRESH_BINARY)
# cv2.imshow('s', img_threshold)
# cv2.waitKey(0)
# TODO: Try to apply AdaptiveThresh
# Size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, and so on.
# gaus_threshold = cv2.adaptiveThreshold(img_gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 115, 1)
# cv2.imshow('or', img)
# cv2.imshow('gaus', gaus_threshold)
# cv2.waitKey(0)
# Define a stuctural element as rectangular of size 17x3 (we'll use it during the morphological cleaning)
element = cv2.getStructuringElement(shape=cv2.MORPH_RECT, ksize=(17, 3))
# And use this structural element in a close morphological operation
morph_img_threshold = deepcopy(img_threshold)
cv2.morphologyEx(src=img_threshold, op=cv2.MORPH_CLOSE, kernel=element, dst=morph_img_threshold)
# cv2.dilate(img_threshold, kernel=np.ones((1,1), np.uint8), dst=img_threshold, iterations=1)
# cv2.imshow('Normal Threshold', img_threshold)
# cv2.imshow('Morphological Threshold based on rect. mask', morph_img_threshold)
# cv2.waitKey(0)
# Find contours that contain possible plates (in hierarchical relationship)
contours, hierarchy = cv2.findContours(morph_img_threshold,
mode=cv2.RETR_EXTERNAL, # retrieve the external contours
method=cv2.CHAIN_APPROX_NONE) # all pixels of each contour
plot_intermediate_steps = False
if plot_intermediate_steps:
plot(plt, 321, img, "Original image")
plot(plt, 322, img_blurred, "Blurred image")
plot(plt, 323, img_gray, "Grayscale image", cmap='gray')
plot(plt, 324, img_sobel_x, "Sobel")
plot(plt, 325, img_threshold, "Threshold image")
# plot(plt, 326, morph_img_threshold, "After Morphological filter")
plt.tight_layout()
plt.show()
return contours
def img_tesseract_detect(c_rect, im):
# ????minAreaRect??????-90~0??????????????????
# ???????????????????????????????????????
pts = c_rect.reshape(4, 2)
rect = np.zeros((4, 2), dtype = "float32")
# the top-left point has the smallest sum whereas the
# bottom-right has the largest sum
s = pts.sum(axis = 1)
rect[0] = pts[np.argmin(s)]
rect[3] = pts[np.argmax(s)]
# compute the difference between the points -- the top-right
# will have the minumum difference and the bottom-left will
# have the maximum difference
diff = np.diff(pts, axis = 1)
rect[2] = pts[np.argmin(diff)]
rect[1] = pts[np.argmax(diff)]
dst = np.float32([[0,0],[0,100],[200,0],[200,100]])
M = cv2.getPerspectiveTransform(rect, dst)
warp = cv2.warpPerspective(im, M, (200, 100))
img_show_hook("??????", warp)
warp = np.array(warp, dtype=np.uint8)
radius = 10
selem = disk(radius)
#????????OTSU????
local_otsu = rank.otsu(warp, selem)
l_otsu = np.uint8(warp >= local_otsu)
l_otsu *= 255
kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(4, 4))
l_otsu = cv2.morphologyEx(l_otsu, cv2.MORPH_CLOSE, kernel)
img_show_hook("?????OTSU??", l_otsu)
print("?????")
print(pytesseract.image_to_string(Image.fromarray(l_otsu)))
cv2.waitKey(0)
return
def img_tesseract_detect(c_rect, im):
# ????minAreaRect??????-90~0??????????????????
# ???????????????????????????????????????
pts = c_rect.reshape(4, 2)
rect = np.zeros((4, 2), dtype = "float32")
# the top-left point has the smallest sum whereas the
# bottom-right has the largest sum
s = pts.sum(axis = 1)
rect[0] = pts[np.argmin(s)]
rect[3] = pts[np.argmax(s)]
# compute the difference between the points -- the top-right
# will have the minumum difference and the bottom-left will
# have the maximum difference
diff = np.diff(pts, axis = 1)
rect[2] = pts[np.argmin(diff)]
rect[1] = pts[np.argmax(diff)]
width = rect[3][0] - rect[0][0]
height = rect[3][1] - rect[0][1]
width = (int)((50.0 / height) * width)
height = 50
dst = np.float32([[0,0],[0,height],[width,0],[width,height]])
M = cv2.getPerspectiveTransform(rect, dst)
warp = cv2.warpPerspective(im, M, (width, height))
img_show_hook("??????", warp)
warp = np.array(warp, dtype=np.uint8)
radius = 13
selem = disk(radius)
#????????OTSU????
local_otsu = rank.otsu(warp, selem)
l_otsu = np.uint8(warp >= local_otsu)
l_otsu *= 255
kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(2,2))
l_otsu = cv2.morphologyEx(l_otsu, cv2.MORPH_CLOSE, kernel)
img_show_hook("?????OTSU??", l_otsu)
print("?????")
print(pytesseract.image_to_string(Image.fromarray(l_otsu), lang="chi-sim"))
cv2.waitKey(0)
return
def image_callback(self, msg):
# convert ROS image to OpenCV image
try:
image = self.bridge.imgmsg_to_cv2(msg, desired_encoding='bgr8')
except CvBridgeError as e:
print(e)
# create hsv image of scene
hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
# find pink objects in the image
lower_pink = numpy.array([139, 0, 240], numpy.uint8)
upper_pink = numpy.array([159, 121, 255], numpy.uint8)
mask = cv2.inRange(hsv, lower_pink, upper_pink)
# dilate and erode with kernel size 11x11
cv2.morphologyEx(mask, cv2.MORPH_CLOSE, numpy.ones((11,11)))
# find all of the contours in the mask image
contours, heirarchy = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
self.contourLength = len(contours)
# Check for at least one target found
if self.contourLength < 1:
print "No target found"
else: # target found
## Loop through all of the contours, and get their areas
area = [0.0]*len(contours)
for i in range(self.contourLength):
area[i] = cv2.contourArea(contours[i])
#### Target #### the largest "pink" object
target_image = contours[area.index(max(area))]
# Using moments find the center of the object and draw a red outline around the object
target_m = cv2.moments(target_image)
self.target_u = int(target_m['m10']/target_m['m00'])
self.target_v = int(target_m['m01']/target_m['m00'])
points = cv2.minAreaRect(target_image)
box = cv2.cv.BoxPoints(points)
box = numpy.int0(box)
cv2.drawContours(image, [box], 0, (0, 0, 255), 2)
rospy.loginfo("Center of target is x at %d and y at %d", int(self.target_u), int(self.target_v))
self.target_found = True # set flag for depth_callback processing
# show image with target outlined with a red rectangle
cv2.imshow ("Target", image)
cv2.waitKey(3)
# This callback function handles processing Kinect depth image, looking for the depth value
# at the location of the center of the pink target.
detect_crazyflie.py 文件源码
项目：ROS-Robotics-By-Example
作者: PacktPublishing
项目源码
文件源码
阅读 23
收藏 0
点赞 0
评论 0
def image_callback(self, msg):
# convert ROS image to OpenCV image
try:
image = self.bridge.imgmsg_to_cv2(msg, desired_encoding='bgr8')
except CvBridgeError as e:
print(e)
# create hsv image of scene
hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
# find green objects in the image
lower_green = numpy.array([50, 50, 177], numpy.uint8) # fluffy green ball
upper_green = numpy.array([84, 150, 255], numpy.uint8)
mask = cv2.inRange(hsv, lower_green, upper_green)
# dilate and erode with kernel size 11x11
cv2.morphologyEx(mask, cv2.MORPH_CLOSE, numpy.ones((11,11)))
# find all of the contours in the mask image
contours, heirarchy = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
self.contourLength = len(contours)
# Check for at least one ball found
if self.contourLength < 1:
print "No objects found"
sys.exit("No objects found") # if no Crazyflie in image, exit process
## Loop through all of the contours, and get their areas
area = [0.0]*len(contours)
for i in range(self.contourLength):
area[i] = cv2.contourArea(contours[i])
#### Ball #### the largest "green" object
ball_image = contours[area.index(max(area))]
# Find the circumcircle of the green ball and draw a blue outline around it
(self.cf_u,self.cf_v),radius = cv2.minEnclosingCircle(ball_image)
ball_center = (int(self.cf_u),int(self.cf_v))
ball_radius = int(radius)
cv2.circle(image, ball_center, ball_radius, (255,0,0), 2)
# show image with green ball outlined with a blue circle
cv2.imshow ("KinectV2", image)
cv2.waitKey(3)
# This callback function handles processing Kinect depth image, looking for the depth value
# at the location of the center of the green ball on top of Crazyflie.
def find_bank_booth():
"""Finds bank booth and clicks it. Returns True if found, else False"""
bank_booth_glass_window = ([0,72,149],[179,82,163])
# take screenshot of playing area
play_area_screen,psx,psy = getPlayingScreen()
# find glasswindow for bankbooth
mask = cv2.inRange(play_area_screen, np.array(bank_booth_glass_window[0]), np.array(bank_booth_glass_window[1]))
# gets RS window's position
rsx,rsy = position()
psx += rsx
psy += rsy
kernel = np.ones((3,3), np.uint8)
closing = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
#cv2.imshow('img', closing)
#cv2.waitKey(0)
# Finds contours
_,contours,_ = cv2.findContours(closing.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
try:
for con in contours:
if cv2.contourArea(con) > 10:
#print(cv2.contourArea(con))
M = cv2.moments(con)
# finds centroid
cx,cy = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
psx += cx
psy += cy
# adds randomness to coords
psx += random.randint(-7,7)
psy += random.randint(-7,7)
#move click
Mouse.moveClick(psx,psy,1)
RandTime.randTime(0,0,0,0,9,9)
return 1
except Exception as e:
print("Bank NOT found!\nMove camera around!")
# returns False if bank not found
return 0
def find_motherload_mine():
"""Returns mine's location x, and y coords"""
play_img,psx,psy = RS.getPlayingScreen()
mines = {
0: (np.array([0,0,153]), np.array([8,25,209])),
1: (np.array([0,0,72]), np.array([2,25,144]))
}
for mine_key in mines.keys():
#print("Mine: {}".format(mine_key))
lower = mines[mine_key][0]
upper = mines[mine_key][1]
mask = cv2.inRange(play_img, lower, upper)
kernel = np.ones((10,10), np.uint8)
closing = cv2.morphologyEx(mask.copy(), cv2.MORPH_CLOSE, kernel)
#cv2.imshow('mask', mask)
#cv2.imshow('closing', closing)
#cv2.waitKey(0)
_, contours, _ = cv2.findContours(mask.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
if contours[0].any():
pass
else:
print('didnt find contours')
break
for con in contours[::-1]:
M = cv2.moments(con)
if cv2.contourArea(con) > 20:
# Shows the mask
#centroid from img moments
cx = int(M['m10']/M['m00'])
cy = int(M['m01']/M['m00'])
#combine psx,psy coords with centroid coords from above
cx += psx
cy += psy
#print("Area:",cv2.contourArea(con))
#print(con[0][0][0],con[0][0][1])
Mouse.moveClick(cx,cy, 1)
return cx,cy
else:
continue
def image_callback(self, msg):
# convert ROS image to OpenCV image
try:
image = self.bridge.imgmsg_to_cv2(msg, desired_encoding='bgr8')
except CvBridgeError as e:
print(e)
# create hsv image of scene
hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
# find pink objects in the image
lower_pink = numpy.array([139, 0, 240], numpy.uint8)
upper_pink = numpy.array([159, 121, 255], numpy.uint8)
mask = cv2.inRange(hsv, lower_pink, upper_pink)
# dilate and erode with kernel size 11x11
cv2.morphologyEx(mask, cv2.MORPH_CLOSE, numpy.ones((11,11)))
# find all of the contours in the mask image
contours, heirarchy = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
self.contourLength = len(contours)
# Check for at least one target found
if self.contourLength < 1:
print "No target found"
else: # target found
## Loop through all of the contours, and get their areas
area = [0.0]*len(contours)
for i in range(self.contourLength):
area[i] = cv2.contourArea(contours[i])
#### Target #### the largest "pink" object
target_image = contours[area.index(max(area))]
# Using moments find the center of the object and draw a red outline around the object
target_m = cv2.moments(target_image)
self.target_u = int(target_m['m10']/target_m['m00'])
self.target_v = int(target_m['m01']/target_m['m00'])
points = cv2.minAreaRect(target_image)
box = cv2.cv.BoxPoints(points)
box = numpy.int0(box)
cv2.drawContours(image, [box], 0, (0, 0, 255), 2)
rospy.loginfo("Center of target is x at %d and y at %d", int(self.target_u), int(self.target_v))
self.target_found = True # set flag for depth_callback processing
# show image with target outlined with a red rectangle
cv2.imshow ("Target", image)
cv2.waitKey(3)
# This callback function handles processing Kinect depth image, looking for the depth value
# at the location of the center of the pink target.
def image_callback(self, msg):
# convert ROS image to OpenCV image
try:
image = self.bridge.imgmsg_to_cv2(msg, desired_encoding='bgr8')
except CvBridgeError as e:
print(e)
# create hsv image of scene
hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
# find green objects in the image
lower_green = numpy.array([50, 50, 177], numpy.uint8) # fluffy green ball
upper_green = numpy.array([84, 150, 255], numpy.uint8)
mask = cv2.inRange(hsv, lower_green, upper_green)
# dilate and erode with kernel size 11x11
cv2.morphologyEx(mask, cv2.MORPH_CLOSE, numpy.ones((11,11)))
# find all of the contours in the mask image
contours, heirarchy = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
self.contourLength = len(contours)
# Check for at least one ball found
if self.contourLength < 1:
print "No objects found"
sys.exit("No objects found") # if no Crazyflie in image, exit process
## Loop through all of the contours, and get their areas
area = [0.0]*len(contours)
for i in range(self.contourLength):
area[i] = cv2.contourArea(contours[i])
#### Ball #### the largest "green" object
ball_image = contours[area.index(max(area))]
# Find the circumcircle of the green ball and draw a blue outline around it
(self.cf_u,self.cf_v),radius = cv2.minEnclosingCircle(ball_image)
ball_center = (int(self.cf_u),int(self.cf_v))
ball_radius = int(radius)
cv2.circle(image, ball_center, ball_radius, (255,0,0), 2)
# show image with green ball outlined with a blue circle
cv2.imshow ("KinectV2", image)
cv2.waitKey(3)
# This callback function handles processing Kinect depth image, looking for the depth value
# at the location of the center of the green ball on top of Crazyflie.
def detect_barcode(imageval):
# load the image and convert it to grayscale
file_bytes = np.asarray(bytearray(imageval), dtype=np.uint8)
img_data_ndarray = cv2.imdecode(file_bytes, cv2.CV_LOAD_IMAGE_UNCHANGED)
gray = cv2.cvtColor(img_data_ndarray, cv2.COLOR_BGR2GRAY)
# compute the Scharr gradient magnitude representation of the images
# in both the x and y direction
gradX = cv2.Sobel(gray, ddepth = cv2.cv.CV_32F, dx = 1, dy = 0, ksize = -1)
gradY = cv2.Sobel(gray, ddepth = cv2.cv.CV_32F, dx = 0, dy = 1, ksize = -1)
# subtract the y-gradient from the x-gradient
gradient = cv2.subtract(gradX, gradY)
gradient = cv2.convertScaleAbs(gradient)
# blur and threshold the image
blurred = cv2.blur(gradient, (9, 9))
(_, thresh) = cv2.threshold(blurred, 225, 255, cv2.THRESH_BINARY)
# construct a closing kernel and apply it to the thresholded image
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (21, 7))
closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)
# perform a series of erosions and dilations
closed = cv2.erode(closed, None, iterations = 4)
closed = cv2.dilate(closed, None, iterations = 4)
# find the contours in the thresholded image, then sort the contours
# by their area, keeping only the largest one
(cnts, _) = cv2.findContours(closed.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
c = sorted(cnts, key = cv2.contourArea, reverse = True)[0]
# compute the rotated bounding box of the largest contour
rect = cv2.minAreaRect(c)
box = np.int0(cv2.cv.BoxPoints(rect))
# draw a bounding box arounded the detected barcode and display the
# image
cv2.drawContours(img_data_ndarray, [box], -1, (0, 255, 0), 3)
# cv2.imshow("Image", image)
#cv2.imwrite("uploads/output-"+ datetime.datetime.now().strftime("%Y-%m-%d-%H:%M:%S") +".jpg",image)
# cv2.waitKey(0)
#outputfile = "uploads/output-" + time.strftime("%H:%M:%S") + ".jpg"
outputfile = "uploads/output.jpg"
cv2.imwrite(outputfile,img_data_ndarray)
