# Python numpy.int0() 使用实例

The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.

Example 1

```def img_contour_select(ctrs, im):
# ????????????
cand_rect = []
for item in ctrs:
epsilon = 0.02*cv2.arcLength(item, True)
approx = cv2.approxPolyDP(item, epsilon, True)
if len(approx) <= 8:
rect = cv2.minAreaRect(item)
if rect[1][0] < 20 or rect[1][1] < 20:
continue
if rect[1][0] > 150 or rect[1][1] > 150:
continue
#ratio = (rect[1][1]+0.00001) / rect[1][0]
#if ratio > 1 or ratio < 0.9:
#    continue
box = cv2.boxPoints(rect)
box_d = np.int0(box)
cv2.drawContours(im, [box_d], 0, (0,255,0), 3)
cand_rect.append(box)
img_show_hook("????", im)
return cand_rect ```

Example 2

```def img_contour_select(ctrs, im):
# ????????????
cand_rect = []
for item in ctrs:
epsilon = 0.02*cv2.arcLength(item, True)
approx = cv2.approxPolyDP(item, epsilon, True)
if len(approx) <= 8:
rect = cv2.minAreaRect(item)
#????????
if rect[2] < -10 and rect[2] > -80:
continue
if rect[1][0] < 10 or rect[1][1] < 10:
continue
#ratio = (rect[1][1]+0.00001) / rect[1][0]
#if ratio > 1 or ratio < 0.9:
#    continue
box = cv2.boxPoints(rect)
box_d = np.int0(box)
cv2.drawContours(im, [box_d], 0, (0,255,0), 3)
cand_rect.append(box)
img_show_hook("????", im)
return cand_rect ```

Example 3

```def findCorners(contour):
"""blank_image = np.zeros((img.shape[0],img.shape[1],3), np.uint8)
cv2.drawContours(blank_image, contour, -1, (255, 255, 255))
rows,cols = img.shape[0], img.shape[1]
M = cv2.getRotationMatrix2D((cols/2,rows/2),-45,0.5)
dst = cv2.warpAffine(blank_image,M,(cols,rows))
cv2.imshow("rotatio", dst)
cv2.waitKey()"""
rect = cv2.minAreaRect(contour)
box = cv2.boxPoints(rect)
box = np.int0(box)
height_px_1 = box[0][1] - box[3][1]
height_px_2 = box[1][1] - box[2][1]
print height_px_1, height_px_2
if height_px_1 < height_px_2:
close_height_px = height_px_2
far_height_px = height_px_1
else:
close_height_px = height_px_1
far_height_px = height_px_2

return close_height_px, far_height_px ```

Example 4

```def remove_border(contour, ary):
"""Remove everything outside a border contour."""
# Use a rotated rectangle (should be a good approximation of a border).
# If it's far from a right angle, it's probably two sides of a border and
# we should use the bounding box instead.
c_im = np.zeros(ary.shape)
r = cv2.minAreaRect(contour)
degs = r[2]
if angle_from_right(degs) <= 10.0:
box = cv2.boxPoints(r)
box = np.int0(box)
cv2.drawContours(c_im, [box], 0, 255, -1)
cv2.drawContours(c_im, [box], 0, 0, 4)
else:
x1, y1, x2, y2 = cv2.boundingRect(contour)
cv2.rectangle(c_im, (x1, y1), (x2, y2), 255, -1)
cv2.rectangle(c_im, (x1, y1), (x2, y2), 0, 4)

return np.minimum(c_im, ary) ```

Example 5

```def getMask(self, shape):

p=self.state['pos']
s=self.state['size']
center=p + s / 2
a=self.state['angle']
# opencv convention:
shape = (shape[1], shape[0])
arr1 = np.zeros(shape, dtype=np.uint8)
arr2 = np.zeros(shape, dtype=np.uint8)

# draw rotated rectangle:
vertices = np.int0(cv2.boxPoints((center, s, a)))
cv2.drawContours(arr1, [vertices], 0, color=1, thickness=-1)
# draw ellipse:
cv2.ellipse(arr2, (int(center[0]), int(center[1])), (int(s[0] / 2 * self._ratioEllispeRectangle),
int(s[1] / 2 * self._ratioEllispeRectangle)), int(a),
startAngle=0, endAngle=360, color=1, thickness=-1)
# bring both together:
return np.logical_and(arr1, arr2).T ```

Example 6

```def getMask(self, shape):

p = self.state['pos']
s = self.state['size']
center = p + s / 2
a = self.state['angle']
# opencv convention:
shape = (shape[1], shape[0])
arr = np.zeros(shape, dtype=np.uint8)
# draw rotated rectangle:
vertices = np.int0(cv2.boxPoints((center, s, a)))
cv2.drawContours(arr, [vertices],
0,
color=1,
thickness=-1)
return arr.astype(bool).T ```

Example 7

```def deal(self,frame):
frame=frame.copy()
track_window=self.track_window
term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1 )
roi_hist=self.roi_hist
dst = cv2.calcBackProject([frame],[0],roi_hist,[0,180],1)
if self.m=='m':
ret, track_window_r = cv2.meanShift(dst, track_window, term_crit)
x,y,w,h = track_window_r
img2 = cv2.rectangle(frame, (x,y), (x+w,y+h), 255,2)
elif self.m=='c':
ret, track_window_r = cv2.CamShift(dst, track_window, term_crit)

pts = cv2.boxPoints(ret)
pts = np.int0(pts)
img2 = cv2.polylines(frame,[pts],True, 255,2)
rectsNew=[]

center1=(track_window[0]+track_window[2]//2,track_window[1]+track_window[3]//2)
center2=(track_window_r[0]+track_window_r[2]//2,track_window_r[1]+track_window_r[3]//2)
img2 = cv2.line(img2,center1,center2,color=0)
rectsNew=track_window_r
#        x,y,w,h = track_window
#        img2 = cv2.rectangle(frame, (x,y), (x+w,y+h), 255,2)
cv2.imshow('img2',img2)
cv2.waitKey(0)
cv2.destroyAllWindows()
return rectsNew ```

Example 8

```def remove_border(contour, ary):
"""Remove everything outside a border contour."""
# Use a rotated rectangle (should be a good approximation of a border).
# If it's far from a right angle, it's probably two sides of a border and
# we should use the bounding box instead.
c_im = np.zeros(ary.shape)
r = cv2.minAreaRect(contour)
degs = r[2]
if angle_from_right(degs) <= 10.0:
box = cv2.cv.BoxPoints(r)
box = np.int0(box)
cv2.drawContours(c_im, [box], 0, 255, -1)
cv2.drawContours(c_im, [box], 0, 0, 4)
else:
x1, y1, x2, y2 = cv2.boundingRect(contour)
cv2.rectangle(c_im, (x1, y1), (x2, y2), 255, -1)
cv2.rectangle(c_im, (x1, y1), (x2, y2), 0, 4)

return np.minimum(c_im, ary) ```

Example 9

```def density_slice(rast, rel=np.less_equal, threshold=1000, nodata=-9999):
'''
Returns a density slice from a given raster. Arguments:
rast        A gdal.Dataset or a NumPy array
rel         A NumPy logic function; defaults to np.less_equal
threshold   An integer number
'''
# Can accept either a gdal.Dataset or numpy.array instance
if not isinstance(rast, np.ndarray):

else:
rastr = rast.copy()

if (len(rastr.shape) > 2 and min(rastr.shape) > 1):
raise ValueError('Expected a single-band raster array')

return np.logical_and(
rel(rastr, np.ones(rast.shape) * threshold),
np.not_equal(rastr, np.ones(rast.shape) * nodata)).astype(np.int0) ```

Example 10

```def shapeFiltering(img):
contours = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[0]
if len(contours) == 0:
return "yoopsie"
#else:
#print contours
"""blank_image = np.zeros((img.shape[0],img.shape[1],3), np.uint8)
cv2.drawContours(blank_image, contours, -1, (255, 255, 255))
cv2.imshow("imagiae", blank_image)
cv2.waitKey()"""
good_shape = []
for c in contours:
x,y,w,h = cv2.boundingRect(c)
"""rect = cv2.minAreaRect(contour)
box = cv2.boxPoints(rect)
box = np.int0(box)
w = """
#if h == 0:
#    continue
ratio = w / h
ratio_grade = ratio / (TMw / TMh)
if 0.2 < ratio_grade < 1.8:
good_shape.append(c)
"""blank_image = np.zeros((img.shape[0],img.shape[1],3), np.uint8)
cv2.drawContours(blank_image, good_shape, -1, (255, 255, 255))
cv2.imshow("imagia", blank_image)
cv2.waitKey()"""
return good_shape ```

Example 11

```def findCorners(contour):
rect = cv2.minAreaRect(contour)
box = cv2.boxPoints(rect)
box = numpy.int0(box)
height_px_1 = box[0][1] - box[3][1]
height_px_2 = box[1][1] - box[2][1]
print height_px_1, height_px_2
if height_px_1 < height_px_2:
close_height_px = height_px_2
far_height_px = height_px_1
else:
close_height_px = height_px_1
far_height_px = height_px_2

return close_height_px, far_height_px ```

Example 12

```def update(roi):
img1b.setImage(roi.getArrayRegion(arr, img1a), levels=(0, arr.max()))

# cell.sigRegionChanged.connect(update)
# update(cell) ```

Example 13

```def get_bounding_rect(contour):
rect = cv2.minAreaRect(contour)
box = cv2.boxPoints(rect)
return np.int0(box) ```

Example 14

```def shi_tomasi(gray):
# image????
# maxCorners???????
# qualityLevel?????????????????????
# minDistance??????????
corners = cv2.goodFeaturesToTrack(gray,25,0.01,10)
cv2.computeCorrespondEpilines()
# ?????? [[ 311., 250.]] ????????
corners = np.int0(corners)
return corners ```

Example 15

```def calculateFrame(self,cap):
data = self.getDataPoints()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
lower_bound = np.array([float(data['HMIN']),float(data["SMIN"]),float(data['VMIN'])])
upper_bound = np.array([float(data['HMAX']),float(data["SMAX"]),float(data['VMAX'])])

hsv = cv2.cvtColor(frame,cv2.COLOR_BGR2HSV)

largest_area = 0
xCenter = -1
yCenter = -1
targetRect = None

contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)

if len(contours) > 1:
areas = [cv2.contourArea(c) for c in contours]
max_index = np.argmax(areas)
cnt = contours[max_index]
rect = cv2.minAreaRect(cnt)
box = cv2.cv.BoxPoints(rect)
box = np.int0(box)

xCenter = (box[0][0] + box[1][0] + box[2][0] + box[3][0]) /4
yCenter = (box[0][1] + box[1][1] + box[2][1] + box[3][1]) /4
cv2.drawContours(frame,[box],0,(0,255,0),2)

output = {}
distance = 0.0025396523 * yCenter**2 + 0.1000098497 *yCenter + 46.8824851568
theta = math.atan2(xCenter-160, distance)
output_dict = {"xCenter": xCenter, "yCenter": yCenter,"theta": theta, "distance":distance}
output = json.dumps(output_dict)

return frame ,output , True, mask ```

Example 16

```def cfmask(mask, mask_values=(1,2,3,4,255), nodata=-9999):
'''
Returns a binary mask according to the CFMask algorithm results for the
image; mask has True for water, cloud, shadow, and snow (if any) and False
everywhere else. More information can be found:
https://landsat.usgs.gov/landsat-surface-reflectance-quality-assessment

Landsat 4-7 Pre-Collection pixel_qa values to be masked:
mask_values = (1, 2, 3, 4)

Landsat 4-7 Collection 1 pixel_qa values to be masked (for "Medium" confidence):
mask_values = (1, 68, 72, 80, 112, 132, 136, 144, 160, 176, 224)

Landsat 8 Collection 1 pixel_qa values to be masked (for "Medium" confidence):
mask_values = (1, 324, 328, 386, 388, 392, 400, 416, 432, 480, 832, 836, 840, 848, 864, 880, 900, 904, 912, 928, 944, 992, 1024)

Arguments:
mask        A gdal.Dataset or a NumPy array
mask_path   The path to an EOS HDF4 CFMask raster
mask_values The values in the mask that correspond to NoData pixels
nodata      The NoData value; defaults to -9999.
'''
if not isinstance(mask, np.ndarray):

else:

# Mask according to bit-packing described here:
# https://landsat.usgs.gov/landsat-surface-reflectance-quality-assessment

Example 17

```def getTargetBox(target):
minRect = cv2.minAreaRect(target)
box = cv2.cv.BoxPoints(minRect)
#box = np.int0(box) # convert points to ints
return box ```

Example 18

```def validate_contour(contour, img, aspect_ratio_range, area_range):
rect = cv2.minAreaRect(contour)
img_width = img.shape[1]
img_height = img.shape[0]
box = cv2.boxPoints(rect)
box = np.int0(box)

X = rect[0][0]
Y = rect[0][1]
angle = rect[2]
width = rect[1][0]
height = rect[1][1]

angle = (angle + 180) if width < height else (angle + 90)

output=False

if (width > 0 and height > 0) and ((width < img_width/2.0) and (height < img_width/2.0)):
aspect_ratio = float(width)/height if width > height else float(height)/width
if (aspect_ratio >= aspect_ratio_range[0] and aspect_ratio <= aspect_ratio_range[1]):
if((height*width > area_range[0]) and (height*width < area_range[1])):

box_copy = list(box)
point = box_copy[0]
del(box_copy[0])
dists = [((p[0]-point[0])**2 + (p[1]-point[1])**2) for p in box_copy]
sorted_dists = sorted(dists)
opposite_point = box_copy[dists.index(sorted_dists[1])]
tmp_angle = 90

if abs(point[0]-opposite_point[0]) > 0:
tmp_angle = abs(float(point[1]-opposite_point[1]))/abs(point[0]-opposite_point[0])

if tmp_angle <= 45:
output = True
return output ```

Example 19

```def bboxes_to_xys(bboxes, image_shape):
"""Convert Seglink bboxes to xys, i.e., eight points
The `image_shape` is used to to make sure all points return are valid, i.e., within image area
"""
if len(bboxes) == 0:
return []

assert np.ndim(bboxes) == 2 and np.shape(bboxes)[-1] == 5, 'invalid `bboxes` param with shape =  ' + str(np.shape(bboxes))

h, w = image_shape[0:2]
def get_valid_x(x):
if x < 0:
return 0
if x >= w:
return w - 1
return x

def get_valid_y(y):
if y < 0:
return 0
if y >= h:
return h - 1
return y

xys = np.zeros((len(bboxes), 8))
for bbox_idx, bbox in enumerate(bboxes):
bbox = ((bbox[0], bbox[1]), (bbox[2], bbox[3]), bbox[4])
points = cv2.cv.BoxPoints(bbox)
points = np.int0(points)
for i_xy, (x, y) in enumerate(points):
x = get_valid_x(x)
y = get_valid_y(y)
points[i_xy, :] = [x, y]
points = np.reshape(points, -1)
xys[bbox_idx, :] = points
return xys ```

Example 20

```def draw_markers(img,markers):
for m in markers:
centroid = np.array(m['centroid'],dtype=np.float32)
origin = np.array(m['verts'][0],dtype=np.float32)
hat = np.array([[[0,0],[0,1],[.5,1.25],[1,1],[1,0]]],dtype=np.float32)
hat = cv2.perspectiveTransform(hat,m_marker_to_screen(m))
if m['id_confidence']>.9:
cv2.polylines(img,np.int0(hat),color = (0,0,255),isClosed=True)
else:
cv2.polylines(img,np.int0(hat),color = (0,255,0),isClosed=True)
# cv2.polylines(img,np.int0(centroid),color = (255,255,int(255*m['id_confidence'])),isClosed=True,thickness=2)
m_str = 'id: {:d}'.format(m['id'])
org = origin.copy()
# cv2.rectangle(img, tuple(np.int0(org+(-5,-13))[0,:]), tuple(np.int0(org+(100,30))[0,:]),color=(0,0,0),thickness=-1)
cv2.putText(img,m_str,tuple(np.int0(org)[0,:]),fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.4, color=(0,0,255))
if 'id_confidence' in m:
m_str = 'idc: {:.3f}'.format(m['id_confidence'])
org += (0, 12)
cv2.putText(img,m_str,tuple(np.int0(org)[0,:]),fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.4, color=(0,0,255))
if 'loc_confidence' in m:
m_str = 'locc: {:.3f}'.format(m['loc_confidence'])
org += (0, 12 )
cv2.putText(img,m_str,tuple(np.int0(org)[0,:]),fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.4, color=(0,0,255))
if 'frames_since_true_detection' in m:
m_str = 'otf: {}'.format(m['frames_since_true_detection'])
org += (0, 12 )
cv2.putText(img,m_str,tuple(np.int0(org)[0,:]),fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.4, color=(0,0,255))
if 'opf_vel' in m:
m_str = 'otf: {}'.format(m['opf_vel'])
org += (0, 12 )
cv2.putText(img,m_str,tuple(np.int0(org)[0,:]),fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.4, color=(0,0,255)) ```

Example 21

```def __init__(self, fname=None, include_orth=True, include_pols=True):
if fname is None:
# fname is the name of the file to read in the design matrix
self.design = np.zeros([0, 0])
self.n_col = 0
# number of columns (conditions) in the design matrix
self.column_types = np.ones(0)
self.n_basis = 0
self.n_stim = 0
self.n_orth = 0
self.StimLabels = []
else:
# isAFNI = re.match(r'.+[.](1D|1d|txt)\$', fname)
filename, ext = os.path.splitext(fname)
# We assume all AFNI 1D files have extension of 1D or 1d or txt
if ext in ['.1D', '.1d', '.txt']:

self.include_orth = include_orth
self.include_pols = include_pols
# The two flags above dictates whether columns corresponding to
# baseline drift modeled by polynomial functions of time and
# columns corresponding to other orthogonal signals (usually motion)
# are included in nuisance regressors.
self.cols_task = np.where(self.column_types == 1)[0]
if np.ndim(self.design_task) == 1:
# part of the design matrix related to task conditions.
self.n_TR = np.size(self.design_task, axis=0)
self.cols_nuisance = np.array([])
if self.include_orth:
self.cols_nuisance = np.int0(
np.sort(np.append(self.cols_nuisance,
np.where(self.column_types == 0)[0])))
if self.include_pols:
self.cols_nuisance = np.int0(
np.sort(np.append(self.cols_nuisance,
np.where(self.column_types == -1)[0])))
if np.size(self.cols_nuisance) > 0:
self.reg_nuisance = self.design[:, self.cols_nuisance]
if np.ndim(self.reg_nuisance) == 1:
self.reg_nuisance = self.reg_nuisance[:, None]
else:
self.reg_nuisance = None
# Nuisance regressors for motion, baseline, etc. ```

Example 22

```def _find_array_button_thing(self):
""" Find the array button on the solar array box """

""" This uses color to determine if we have a choke """
lower = np.array([0, 0, 60], dtype = "uint8")
upper = np.array([20, 20, 255], dtype = "uint8")
mask = cv2.inRange(self.img, lower, upper)

blurred = cv2.GaussianBlur(mask, (5, 5), 0)
thresh = cv2.threshold(blurred, 60, 255, cv2.THRESH_BINARY)[1]

contours = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
contours = contours[0] if is_cv2() else contours[1]

debug_img = None
if self.debug:
debug_img = self.img.copy()

button_box = None
for c in contours:
box = cv2.boundingRect(c)

if button_box is None:
button_box = box
else:
button_box = self._union_box(deepcopy(button_box), box)

if button_box is None:
return

top,bottom,left,right,center = self.find_dimensions(np.int0(np.array(self._bound_to_boxpoints(button_box))))
if top is None or left is None or center is None:
return None

height = self.find_distance(top, bottom)
width = self.find_distance(left, right)

if self.debug:
for c in contours:
cv2.drawContours(debug_img, [c], -1, (0, 255, 0), 2)

cv2.circle(debug_img, top, 5, (255, 255, 0))
cv2.circle(debug_img, bottom, 5, (255, 255, 0))
cv2.circle(debug_img, left, 5, (255, 255, 0))
cv2.circle(debug_img, right, 5, (255, 255, 0))
cv2.rectangle(debug_img, (button_box[0], button_box[1]),
(button_box[0] + button_box[2], button_box[1] + button_box[3]), (128, 0, 128), 2)
#cv2.circle(debug_img, center, 5, (255, 255, 0))

cv2.imshow("button picture", debug_img)
cv2.setMouseCallback("button picture", self.handle_mouse)
cv2.waitKey(0)
cv2.destroyAllWindows()

self.array_button = Thing(height, width, center, None)
self.array_button.set_array_button()
self.array_button.computed_center = self.compute_center(left, right, top, bottom)
self.things.append(self.array_button) ```

Example 23

```def _find_a_thing(self, c, min_height, max_height, min_width, max_width, max_distance, debug_img=None):
rect = cv2.minAreaRect(c)
box = cv2.cv.BoxPoints(rect) if is_cv2() else cv2.boxPoints(rect)

top,bottom,left,right,center = self.find_dimensions(np.int0(np.array(box)))

if top is None or left is None or center is None:
return None

vertical = self.find_distance(top, bottom)
horizontal = self.find_distance(left, right)
away = self.find_distance(center, None)

if vertical > horizontal:
height = vertical
width = horizontal
flipped = False
else:
height = horizontal
width = vertical
flipped = True

if height < min_height or height > max_height:
return None

if width < min_width or width > max_height:
return None

if away > max_distance:
return None

# https://namkeenman.wordpress.com/2015/12/18/open-cv-determine-angle-of-rotatedrect-minarearect/
angle = rect[2]
if rect[1][0] < rect[1][1]:
angle -= 90.0

if debug_img is not None:
x,y,w,h = cv2.boundingRect(c)
cv2.drawContours(debug_img, [c], -1, (0, 255, 0), 2)
cv2.drawContours(debug_img, [np.int0(np.array(box))], -1, (0, 0, 255), 2)
cv2.rectangle(debug_img,(x,y),(x+w,y+h),(255,0,0),2)

cv2.circle(debug_img, top, 5, (255, 255, 0))
cv2.circle(debug_img, bottom, 5, (255, 255, 0))
cv2.circle(debug_img, left, 5, (255, 255, 0))
cv2.circle(debug_img, right, 5, (255, 255, 0))
cv2.circle(debug_img, center, 5, (255, 255, 0))

return Thing(height, width, center, angle) ```

Example 24

```def get_contours(orig_image):
"""
Get edge points (hopefully corners) from the given opencv image (called
contours in opencv)

Parameters:
:param: `orig_image` - the thresholded image from which to find contours
"""
new_image = numpy.copy(orig_image)
# cv2.imshow("Vision", new_image)
# cv2.waitKey(1000)
new_image, contours, hierarchy = cv2.findContours(new_image,
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
# print(len(contours))
# print(len(contours[0]))
# print(len(contours[0][0]))
# print(len(contours[0][0][0]))
largest_contour = 0
most_matching = 0
min_score = 0
max_area = 0
if len(contours) > 1:
print("Length of contours:", len(contours))
max_area = cv2.contourArea(contours[0])
min_score = average_goal_matching(contours[0])
for i in range(1, len(contours)):
# print(contours[i])
current_score = average_goal_matching(contours[i])
current_area = cv2.contourArea(contours[i])
if current_area > max_area:
max_area = current_area
largest_contour = i
if current_score < min_score and current_score != 0 and current_area > 300 and current_area < 1500:
min_score = current_score
most_matching = i
elif len(contours) == 0:
if min_score >= 9999999999999999:
print("largest_contour:", largest_contour)
print("Area:", max_area)
# print("largest_contour:", largest_contour)
print("Most matching:", most_matching)
print("Score:", min_score)
print("Area of most matching:", cv2.contourArea(contours[most_matching]))

rect = cv2.minAreaRect(contours[most_matching])
box = cv2.boxPoints(rect)
box = numpy.int0(box)
# print(box)
return numpy.array(contours[most_matching]), box ```

Example 25

```def detectAllVertices(self, testImg):
# Detecting vertices on the newly constructed board
self.gray = cv2.cvtColor(testImg, cv2.COLOR_BGR2GRAY)

tempVertices = cv2.goodFeaturesToTrack(self.gray, int(self.FINAL_VERTICES_COUNT), 0.01, 10)
tempVertices = np.int0(tempVertices)

newVertices = []

for i in tempVertices:
x, y = i.ravel()
newVertices.append((x, y))

# Matrix to store coordinates of vertices on the board
self.ALL_VERTICES = [[(0, 0) for x in range(self.FACTOR + 2)] for x in range(self.FACTOR + 2)]

# Filling the matrix
self.ALL_VERTICES[0][0] = (self.CORNERS[1])

for i in range(0, self.FACTOR):
for j in range(0, self.FACTOR):
predicted_x = self.ALL_VERTICES[i][j][0] + int(
(self.OUTER_VERTICES[2][self.FACTOR - i][0] - self.OUTER_VERTICES[0][i][0]) / 8)
predicted_y = self.ALL_VERTICES[i][j][1] + int(
(self.OUTER_VERTICES[3][self.FACTOR - i][1] - self.OUTER_VERTICES[1][i][1]) / 8)

minn_dist = self.INT_MAX

for point in newVertices:
this_dist = Geometry.getPointsDistance(point, (predicted_x, self.ALL_VERTICES[i][j][1]))
if this_dist < minn_dist:
self.ALL_VERTICES[i][j + 1] = point
minn_dist = this_dist

minn_dist = self.INT_MAX

for point in newVertices:
this_dist = Geometry.getPointsDistance(point, (self.ALL_VERTICES[i][j][0], predicted_y))
if this_dist < minn_dist:
self.ALL_VERTICES[i + 1][j] = point;
minn_dist = this_dist

self.ALL_VERTICES[self.FACTOR][self.FACTOR] = (self.CORNERS[3]) ```

Example 26

```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

# 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. ```

Example 27

```def binary_mask(rast, mask, nodata=-9999, invert=False):
'''
Applies an arbitrary, binary mask (data in [0,1]) where pixels with
a value of 1 are pixels to be masked out. Arguments:
rast    A gdal.Dataset or a NumPy array
mask    A gdal.Dataset or a NumPy array
nodata  The NoData value; defaults to -9999.
invert  Invert the mask? (tranpose meaning of 0 and 1); defaults to False.
'''
# Can accept either a gdal.Dataset or numpy.array instance
if not isinstance(rast, np.ndarray):

else:
rastr = rast.copy()

if not isinstance(mask, np.ndarray):

else:

if not np.alltrue(np.equal(rastr.shape[-2:], maskr.shape[-2:])):
raise ValueError('Raster and mask do not have the same shape')

# Convert Boolean arrays to ones and zeros
if maskr.dtype == bool:

# Transform into a "1-band" array and apply the mask
if maskr.shape != rastr.shape:
.repeat(rastr.shape[0], axis=0) # Copy the mask across the "bands"

# TODO Compare to place(), e.g.,
# np.place(rastr, mask.repeat(rastr.shape[0], axis=0), (nodata,))
# Mask out areas that match the mask (==1)
if invert:
rastr[maskr < 1] = nodata

else:
rastr[maskr > 0] = nodata

return rastr ```

Example 28

```def filterContoursFancy(contours, image=None):
if len(contours) == 0:
return []

numContours = len(contours)
areas = np.array([cv2.contourArea(contour) for contour in contours])

boundingRects = [cv2.boundingRect(contour) for contour in contours]
widths, heights, positions = boundingInfo(boundingRects)

rotatedRects = [cv2.minAreaRect(contour) for contour in contours]
if config.withOpenCV3:
rotatedBoxes = [np.int0(cv2.boxPoints(rect)) for rect in rotatedRects]
else:
rotatedBoxes = [np.int0(cv2.cv.BoxPoints(rect)) for rect in rotatedRects]
rotatedAreas = [cv2.contourArea(box) for box in rotatedBoxes]

sizeScores = [size(area)for area in areas]
ratioScores = ratios(widths, heights)
rotationScores = [rotation(rect) for rect in rotatedRects]
rectangularScores = [distToPolygon(contour, poly) for contour,poly in zip(contours, rotatedBoxes)]
areaScores = polygonAreaDiff(areas, rotatedAreas)
quadScores = [Quadrify(contour) for contour in contours]

rectangularScores = np.divide(rectangularScores, widths)

scores = np.array([sizeScores, ratioScores, rotationScores, rectangularScores, areaScores, quadScores])
contourScores = np.dot(weights, scores)

correctInds, incorrectInds = sortedInds(contourScores)
correctContours = np.array(contours)[correctInds]

if config.extra_debug:
print "size, ratio, rotation, rectangular, area, quad"
print "Weights:", weights
print "Scores: ", contourScores
print np.average(scores, axis=1)
if len(incorrectInds) != 0:
print "AVG, WORST", test(scores, correctInds, incorrectInds)
for i in range(numContours):
print "CONTOUR " + str(i)
print np.multiply(scores[:, i], weights) #newWeights
print contourScores[i]
if image:
img = copy.deepcopy(image)
Printing.drawImage(img, contours[:i] + contours[i+1:], contours[i], False)
Printing.display(img, "contour " + str(i), doResize=True)
cv2.waitKey(0)
cv2.destroyAllWindows()
return correctContours ```

Example 29

```def filterContoursAutocalibrate(contours, image=None):
if len(contours) == 0:
return []

numContours = len(contours)
areas = np.array([cv2.contourArea(contour) for contour in contours])

boundingRects = [cv2.boundingRect(contour) for contour in contours]
widths, heights, positions = boundingInfo(boundingRects)

rotatedRects = [cv2.minAreaRect(contour) for contour in contours]
if config.withOpenCV3:
rotatedBoxes = [np.int0(cv2.boxPoints(rect)) for rect in rotatedRects]
else:
rotatedBoxes = [np.int0(cv2.cv.BoxPoints(rect)) for rect in rotatedRects]
rotatedAreas = [cv2.contourArea(box) for box in rotatedBoxes]

sizeScores = [size(area)for area in areas]
ratioScores = ratios(widths, heights)
rotationScores = [rotation(rect) for rect in rotatedRects]
rectangularScores = [distToPolygon(contour, poly) for contour,poly in zip(contours, rotatedBoxes)]
areaScores = polygonAreaDiff(areas, rotatedAreas)
quadScores = [Quadrify(contour) for contour in contours]

rectangularScores = np.divide(rectangularScores, widths)

scores = np.array([sizeScores, ratioScores, rotationScores, rectangularScores, areaScores, quadScores])
contourScores = np.dot(weights, scores)

correctInds, incorrectInds = sortedInds(contourScores)
correctContours = np.array(contours)[correctInds]

averageScore = 0
for i in range(numContours):
averageScore += sizeScores[i]
averageScore +=  ratioScores[i]
averageScore +=  rotationScores[i]
averageScore +=  rectangularScores[i]
averageScore +=  areaScores[i]
averageScore /= numContours
return averageScore ```

Example 30

```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

# 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. ```

Example 31

```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

# 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)