def test_imageSWT():
filename = 'test/rab_butler.jpg'
img = cv2.imread(filename,0)
B,G,R = cv2.split(cv2.imread(filename,1))
img_color = cv2.merge((R,G,B))
swt_pos = swt.strokeWidthTransform(img, 1)
swt_pos_dilated = 255 - cv2.dilate(255 - swt_pos, kernel = np.ones((2,2),np.uint8), iterations = 2)
swt_neg = swt.strokeWidthTransform(img, -1)
swt_neg_dilated = 255 - cv2.dilate(255 - swt_neg, kernel = np.ones((2,2),np.uint8), iterations = 2)
plt.subplot(3,2,1)
plt.imshow(img_color, interpolation="none")
plt.title('original image')
plt.subplot(3,2,3)
plt.imshow(swt_pos, cmap="gray", interpolation="none")
plt.title('positive swt of image')
plt.subplot(3,2,4)
plt.imshow(swt_pos_dilated, cmap="gray", interpolation="none")
plt.title('dilated positive swt of image')
plt.subplot(3,2,5)
plt.title('negative swt of image')
plt.imshow(swt_neg, cmap="gray", interpolation="none")
plt.subplot(3,2,6)
plt.title('dilated negative swt of image')
plt.imshow(swt_neg_dilated, cmap="gray", interpolation="none")
plt.show()
def drawCorners(img):
min_dilations = 0
max_dilations = 7
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
for k in range(0, 6):
for dilations in range(min_dilations, max_dilations):
#cv2.adaptiveThreshold(img, thresh_img, 255,
# cv2.CV_ADAPTIVE_THRESH_MEAN_C, CV_THRESH_BINARY, block_size, (k/2)*5)
#if dilations > 0:
# thresh_img = cv2.dilate(thresh_img, 0, dilations - 1)
mean = cv2.mean(gray)[0]
thresh_level = int(mean - 10)
thresh_level = max(thresh_level, 10)
retval, thresh_img = cv2.threshold(gray, thresh_level, 255, cv2.THRESH_BINARY)
cv2.dilate(thresh_img, None, thresh_img, (-1,-1), dilations)
rows = len(thresh_img)
cols = len(thresh_img[0])
cv2.rectangle(thresh_img, (0, 0), (cols-1, rows-1), (255, 255, 255), 3, 8)
cv2.imshow("drawCorners: thresh_img " + str(k*0) + str(dilations), thresh_img)
cv2.waitKey(1)
def dilate(self, size=(5, 5), iterations=1, binary_in=False):
"""
morphological dilate
Parameters
----------
size : 'tuple'
kernel size
iterations : 'int'
number of times to run kernel
binary_in : 'boole'
run on binary
Returns
-------
self.img_b : 'array'
new binary array
self.img : 'array'
new img array
"""
kernel = np.ones(size, np.uint8)
if binary_in:
dilation = cv2.dilate(self.img_b, kernel, iterations=iterations)
self.img_b = dilation
else:
dilation = cv2.dilate(self.img, kernel, iterations=iterations)
self.img = dilation
def get_contours(self, frame, crop, adjustments, o_type=None):
"""
Adjust the given frame based on 'min', 'max', 'contrast' and 'blur'
keys in adjustments dictionary.
"""
try:
if o_type == 'BALL':
frame = frame[crop[2]:crop[3], crop[0]:crop[1]]
if frame is None:
return None
if adjustments['blur'] >= 1:
blur = self.oddify(adjustments['blur'])
# print adjustments['blur']
frame = cv2.GaussianBlur(frame, (blur, blur), 0)
# plt.imshow(frame)
# plt.show()
if adjustments['contrast'] >= 1.0:
frame = cv2.add(frame,
np.array([float(adjustments['contrast'])]))
# Convert frame to HSV
frame_hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# Create a mask
frame_mask = cv2.inRange(frame_hsv,
adjustments['min'],
adjustments['max'])
# Find contours
if adjustments['open'] >= 1:
kernel = np.ones((2,2),np.uint8)
frame_mask = cv2.morphologyEx(frame_mask,
cv2.MORPH_OPEN,
kernel,
iterations=adjustments['open'])
if adjustments['close'] >= 1:
kernel = np.ones((2,2),np.uint8)
frame_mask = cv2.dilate(frame_mask,
kernel,
iterations=adjustments['close'])
if adjustments['erode'] >= 1:
kernel = np.ones((2,2),np.uint8)
frame_mask = cv2.dilate(frame_mask,
kernel,
iterations=adjustments['erode'])
contours, hierarchy = cv2.findContours(
frame_mask,
cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE
)
return (contours, hierarchy, frame_mask)
except:
# bbbbb
raise
def classifyFrame(self):
if not self.depthRosImg or not self.rgbRosImg:
return None
origImg = or_util.toCvImg(self.rgbRosImg, 'bgr8')
depthImg = or_util.toCvImg(self.depthRosImg, 'passthrough')
denoised = cv2.GaussianBlur(origImg, (2*self.blurSize+1, 2*self.blurSize+1), self.sigmaX / 10.)
structuringElement = img_manip.getStructuringElement(cv2.MORPH_ELLIPSE, self.morphSize)
morphed = denoised
morphed = cv2.dilate(morphed, structuringElement)
morphed = cv2.erode(morphed, structuringElement)
morphed = cv2.erode(morphed, structuringElement)
morphed = cv2.dilate(morphed, structuringElement)
hsvImg = cv2.cvtColor(morphed, cv2.COLOR_BGR2HSV)
detector = cv2.SimpleBlobDetector(self.blobParams)
keypoints = detector.detect(hsvImg)
objects = []
for kp in keypoints:
classes = self.classifyOne(depthImg, origImg, hsvImg, kp)
objects.append(classes)
self.tracker.feed(keypoints, map(lambda obj: OBJECTS_DICT[obj], objects))
trackerKeypoints, trackerVotes = self.tracker.voteAll()
trackerObjects = map(lambda vote: OBJECTS_LIST[vote], trackerVotes)
out = drawStuff(morphed, trackerKeypoints, trackerObjects)
if self.show:
cv2.imshow(WINDOW_NAME, out)
cv2.waitKey(1)
return trackerObjects, out
def select_lines(self):
image_gray = img_fun.image_gray(self.image)
image_bin = cv2.adaptiveThreshold(image_gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY_INV, 33, 5)
horizontalsize = 50
horizontalStructure = cv2.getStructuringElement(cv2.MORPH_RECT, (horizontalsize, 1))
image_bin = cv2.erode(image_bin, horizontalStructure, iterations=1)
image_bin = cv2.dilate(image_bin,horizontalStructure, iterations=1)
# image_bin = cv2.dilate(image_bin,np.ones((2,500)), iterations=1)
image_bin = cv2.dilate(image_bin,np.ones((2,200)), iterations=1)
img,reg,pos = self.select_horizontal_lines(self.image.copy(),image_bin)
lines,groups = npt.add_additional_lines(pos)
self.lines = lines
self.groups = groups
# cv2.imshow('lines',cv2.resize(image_bin, (1000, 750), interpolation=cv2.INTER_NEAREST))
# cv2.waitKey(0)
# cv2.imshow('aaaaaaaaaa',img)
img_fun.show_image('bin',image_bin)
img_fun.show_image('img' ,img)
def colorImage(originalImage, imageOne, imageTwo):
#Dilate the first image
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (11, 11))
imageOneDilated= cv2.dilate(imageOne, kernel)
imageOne = imageOneDilated - imageOne
#Dilate the second Image
imageTwoDilated = cv2.dilate(imageTwo, kernel)
imageTwo = imageTwoDilated - imageTwo
#Get all the borders in both images by getting the white points
imageOneBorders = np.where(imageOne != 0)
imageOneBorders = zip(imageOneBorders[0], imageOneBorders[1])
imageTwoBorders = np.where(imageTwo != 0)
imageTwoBorders = zip(imageTwoBorders[0], imageTwoBorders[1])
originalImage = cv2.cvtColor(originalImage, cv2.COLOR_GRAY2RGB)
#Color the borders of small coins red
for i in imageOneBorders:
originalImage.itemset((i[0], i[1], 0), 0)
originalImage.itemset((i[0], i[1], 1), 0)
originalImage.itemset((i[0], i[1], 2), 255)
#Color the borders of the large coins blue
for i in imageTwoBorders:
originalImage.itemset((i[0], i[1], 0), 255)
originalImage.itemset((i[0], i[1], 1), 0)
originalImage.itemset((i[0], i[1], 2), 0)
return originalImage
def mouseDoubleClickEvent(self, event):
frame = self.bridge.imgmsg_to_cv(self.image, 'bgr8')
cv_image = np.array(frame, dtype=np.uint8)
unclosed_gray = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY)
kernel = np.array([[1, 1, 1],[1, 1, 1],[1, 1, 1]], 'uint8')
kernel7 = np.ones((7,7),'uint8')
gray = cv2.dilate(cv2.erode(unclosed_gray, kernel7), kernel7)
edges = cv2.Canny(gray,50,150,apertureSize = 3)
# kernel = np.ones((3,3),'uint8')
dilated_edges = cv2.dilate(edges, kernel)
minLineLength = 140
maxLineGap = 10
lines = cv2.HoughLinesP(dilated_edges,1,np.pi/180,300,minLineLength,maxLineGap)
if lines is not None:
for x1,y1,x2,y2 in lines[0]:
cv2.line(cv_image,(x1,y1),(x2,y2),(0,255,0),2)
frame = cv.fromarray(cv_image)
edges = cv.fromarray(edges)
dilated_edges = cv.fromarray(dilated_edges)
cv.ShowImage("im window", frame)
cv.ShowImage("im window2", edges)
cv.ShowImage("im window3", dilated_edges)
cv.MoveWindow("im window2", 820, 60)
cv.MoveWindow("im window3", 820, 660)
print "Yoda"
def find_position ( self, frame ):
pos_x = self.last_x
pos_y = self.last_y
hsv_img = cv2.cvtColor( frame, cv2.COLOR_BGR2HSV )
mask1 = cv2.inRange( hsv_img, self.lower_red_l, self.lower_red_h )
mask2 = cv2.inRange( hsv_img, self.upper_red_l, self.upper_red_h )
mask = mask1 + mask2
mask = cv2.erode( mask, self.kernel )
mask = cv2.dilate( mask, self.kernel )
mask = cv2.dilate( mask, self.kernel )
mask = cv2.erode( mask, self.kernel )
o_moments = cv2.moments( mask )
d_m01 = o_moments['m01']
d_m10 = o_moments['m10']
d_area = o_moments['m00']
print "MOMENTS " + str(d_m01) + " " + str(d_m10) + " " + str(d_area)
if d_area > 10000:
pos_x = int(d_m10 / d_area)
pos_y = int(d_m01 / d_area)
print "[" + str(pos_x) + " , " + str(pos_y) + "]"
return pos_x, pos_y
def process(self, image):
foreground = getfg(image)
element = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
cv2.erode(foreground, element, foreground, iterations=1)
cv2.dilate(foreground, element, foreground, iterations=1)
return foreground
def find_boxes(img):
"""
Detects box(square) shapes in the input image.
:param img: input image.
:return: image with outlines of boxes from the original image.
"""
kernel_length = np.array(img).shape[1] // 75
verticle_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, kernel_length))
hori_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (kernel_length, 1))
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
# Detect vertical and horizontal lines in the image
img_temp1 = cv2.erode(img, verticle_kernel, iterations=2)
verticle_lines_img = cv2.dilate(img_temp1, verticle_kernel, iterations=2)
img_temp2 = cv2.erode(img, hori_kernel, iterations=2)
horizontal_lines_img = cv2.dilate(img_temp2, hori_kernel, iterations=2)
# Weighting parameters, this will decide the quantity of an image to be added to make a new image.
alpha = 0.5
beta = 1.0 - alpha
# Add the vertical and horizontal lines images to get a third image as summation.
img_final_bin = cv2.addWeighted(verticle_lines_img, alpha, horizontal_lines_img, beta, 0.0)
img_final_bin = cv2.erode(~img_final_bin, kernel, iterations=2)
(_, img_final_bin) = cv2.threshold(img_final_bin, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
return img_final_bin
def get_corners(self, img):
""" img: np.array, -> np.array
This function will find corners. It does:
dilate with cross
erode with diamond
dilate with X
erode with square
Corners are obtained by differentiating the two closed images
"""
img_1 = cv2.dilate(img, self._kernel_cross)
print('cross dilate')
# ava.cv.utl.show_image_wait_2(img_1) # ------------------
img_1 = cv2.erode(img_1, self._kernel_diamond)
print('erode diamond')
# ava.cv.utl.show_image_wait_2(img_1) # ------------------
img_2 = cv2.dilate(img, self._kernel_x)
print('x dilate')
# ava.cv.utl.show_image_wait_2(img_2) # ------------------
img_2 = cv2.erode(img_2, self._kernel_5x5)
print('erode square')
# ava.cv.utl.show_image_wait_2(img_2) # ------------------
img_1 = cv2.absdiff(img_2,img_1)
#threshold
img_1 = self.apply_threshold(img_1)
return img_1
def calibrate_hsv(self, img):
element = self.element
result = np.zeros((img.shape[0], img.shape[1]), np.uint8)
img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
h,s,v = cv2.split(img_hsv)
d = cv2.inRange(h, np.array([self.current_conf[0]],np.uint8),
np.array([self.current_conf[1]],np.uint8))
d2 = cv2.inRange(h, np.array([self.current_conf[2]],np.uint8),
np.array([self.current_conf[3]],np.uint8))
d = cv2.bitwise_or(d, d2)
d = cv2.erode(d, element)
d = cv2.dilate(d, element)
d = cv2.dilate(d, element)
d = cv2.dilate(d, element)
d = cv2.dilate(d, element)
result = d
res = result.copy()
contours, hier = cv2.findContours(res, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
self.current_rect_count = len(contours)
self.rects = self.choose_contour(contours)
if len(self.rects) > 0:
self.current_biggest_rect_area = area(self.rects[0])
else:
self.current_biggest_rect_area = 0
middle_roi = get_roi(result, self.middle_rect)
self.current_middle_non_zero = cv2.countNonZero(middle_roi)
self.feedback()
def motionDetected(self, new_frame):
frame = self.preprocessInputFrame(new_frame)
gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
gray = cv.GaussianBlur(gray, (11, 11), 0)
if self.prevPrevFrame is None:
self.prevPrevFrame = gray
return False
if self.prevFrame is None:
self.prevFrame = gray
return False
cv.normalize(gray, gray, 0, 255, cv.NORM_MINMAX)
frameDiff = self.diffImg(self.prevPrevFrame, self.prevFrame, gray)
ret1, th1 = cv.threshold(frameDiff, 10, 255, cv.THRESH_BINARY)
cv.dilate(th1, None, iterations=15)
cv.erode(th1, None, iterations=1)
delta_count = cv.countNonZero(th1)
cv.imshow("frame_th1", th1)
self.prevPrevFrame = self.prevFrame
self.prevFrame = gray
ret = delta_count > self.threshold
if ret:
self.updateMotionDetectionDts()
return ret
def hsv_to_im_mask(im_hsv, hsv_lows, hsv_highs, is_bucket=False, is_arm=False):
if is_bucket:
# mask by threshold
im_mask = cv2.inRange(im_hsv, hsv_lows, hsv_highs)
im_mask = cv2.medianBlur(im_mask, 7)
# erode
im_mask = cv2.erode(im_mask, None, iterations=2)
# dilate
im_mask = cv2.dilate(im_mask, None, iterations=3)
elif is_arm:
# mask by threshold
im_mask = cv2.inRange(im_hsv, hsv_lows, hsv_highs)
im_mask = cv2.medianBlur(im_mask, 9)
# erode
# im_mask = cv2.erode(im_mask, None, iterations=2)
# dilate
im_mask = cv2.dilate(im_mask, None, iterations=3)
else:
# mask by threshold
im_mask = cv2.inRange(im_hsv, hsv_lows, hsv_highs)
im_mask = cv2.medianBlur(im_mask, 5)
# erode
# im_mask = cv2.erode(im_mask, None, iterations=2)
# dilate
im_mask = cv2.dilate(im_mask, None, iterations=3)
return im_mask
def skin_blobs(self, img, det_face_hsv, face_rect, masked_img):
"""
Do blob morphology stuff on faces. Perform a mask,
Then dilate and erode to make them into more coherent blobs.
:param img: BGR image from webcam
:param det_face_hsv: hsv image of the face from the previous detection
:param face_rect: non-normalized dimensions of face rectangle (left, top, cols, rows)
:return: 2D array, black and white image of skin blobs
"""
#open and close
# kernel size and shape are more art than science
# using a small kernel to erode noise and a large on to
# to dilate since I have more false negatives with skin
# detection than I do false positives.
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (4, 4))
kernel_small = kernel & np.transpose(kernel) #symmetry
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (6, 6))
kernel_big = kernel & np.transpose(kernel) #symmetry
blob_img = cv2.erode(masked_img, kernel_small)
blob_img = cv2.dilate(blob_img, kernel_big)
blob_img = cv2.erode(blob_img, kernel_small)
blob_img = cv2.dilate(blob_img, kernel_big)
return blob_img
def getPoly(self):
self.image = self.image[0:][300:]
imgray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)
ret,thresh = cv2.threshold(imgray,0,255,0)
#cv2.bitwise_not(thresh)
height = thresh.shape[0]
width = thresh.shape[1]
tempImage = np.copy(thresh)
fillPoint = None
for x in range(height - 1, 0, -1):
currPixel = thresh[x][width / 2]
if currPixel.all() != 0:
fillPoint = ((width/ 2), x)
print fillPoint
break
dim = (height + 2, width + 2)
mask = np.zeros(dim, dtype=np.uint8)
#Produces nothing if the fill point is used
#If (0, 0) is used it fills in noise
cv2.floodFill(thresh, mask, (0, 0), 255)
cv2.imshow("filledImage", thresh)
#removes most noise from the thresholded image
noiseRemoved = cv2.bitwise_xor(thresh, tempImage)
#Dilates in order to remove more noise
cv2.dilate(noiseRemoved, np.ones((4,4), dtype=np.uint8), noiseRemoved, (-1, -1), 1)
cv2.imshow("f", noiseRemoved)
def get_mask_YCbCr(im, mask_YCbCr):
minH = 80; maxH = 220
minS = 65; maxS = 220
minV = 65; maxV = 220
tmp = cv2.cvtColor(im, cv.CV_BGR2YCrCb) # RGB → YCrCb
p_src = cv2.split(tmp) # 元画像RGBのimを。HVSの場合はtmpとする。修正HSVとする場合はimでよい。
p_dst = cv2.split(tmp) # マスク用に変更する画像
# 修正HSVではなく普通のHSVで使うやつ
H = p_src[0] # 0から180
S = p_src[1]
V = p_src[2]
p_dst[0] = 255*(minH <= H)*(H <= maxH)*(minS <= S)*(S <= maxS)*(minV <= V)*(V <= maxV)
p_dst[1] = 255*(minH <= H)*(H <= maxH)*(minS <= S)*(S <= maxS)*(minV <= V)*(V <= maxV)
p_dst[2] = 255*(minH <= H)*(H <= maxH)*(minS <= S)*(S <= maxS)*(minV <= V)*(V <= maxV)
mask_YCbCr[:,:,0] = p_dst[0]; mask_YCbCr[:,:,1] = p_dst[1]; mask_YCbCr[:,:,2] = p_dst[2];
# 細かいノイズを取り除く
element = cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))
cv2.dilate( np.uint8(mask_YCbCr), element )
cv2.erode(np.uint8(mask_YCbCr), element)
def detectRover(self, argFrame):
frame = self.frame
hsvFrame = self.frame
thresh = self.frame[:,:,0]
rGreen = (38,67,155,198,0,255)
rPink = (165,182,155,192,0,255)
hsvFrame = cv2.cvtColor(self.frame.copy(), cv2.COLOR_BGR2HSV)
thresh = cv2.inRange(hsvFrame.copy(),np.array([rGreen[0],rGreen[2],rGreen[4]]),np.array([rGreen[1],rGreen[3],rGreen[5]]))
thresh = cv2.medianBlur(thresh.copy(),5)
thresh = cv2.erode(thresh.copy(), erodeElem)
#thresh = cv2.erode(thresh.copy(), erodeElem)
thresh = cv2.dilate(thresh.copy(), dilateElem)
thresh = cv2.dilate(thresh.copy(), dilateElem)
_, contours, _ = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
if len(contours) != 1:
return -1
(x,y,w,h) = cv2.boundingRect(contours[0])
greenPt = (int((x+x+w)/2),int((y+y+h)/2))
thresh = cv2.inRange(hsvFrame.copy(),np.array([rPink[0],rPink[2],rPink[4]]),np.array([rPink[1],rPink[3],rPink[5]]))
thresh = cv2.medianBlur(thresh.copy(),5)
thresh = cv2.erode(thresh.copy(), erodeElem)
#thresh = cv2.erode(thresh.copy(), erodeElem)
thresh = cv2.dilate(thresh.copy(), dilateElem)
thresh = cv2.dilate(thresh.copy(), dilateElem)
_, contours, _ = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
if len(contours) != 1:
return -1
(x,y,w,h) = cv2.boundingRect(contours[0])
pinkPt = (int((x+x+w)/2),int((y+y+h)/2))
self.roverPos = (int((greenPt[0]+pinkPt[0])/2),int((greenPt[1]+pinkPt[1])/2))
angle = getAngle(pinkPt[0],pinkPt[1],greenPt[0],greenPt[1])
self.roverHeading = 360+angle[2]*-1
return greenPt, pinkPt
def _findCorner(self):
"""
Find the corners by using some morphological operator and then use
the connectedComponents in order to isolate them.
"""
# a few morphological operator in order to find corners
self.img_corner = cv2.dilate(self.img, CheckboxConstant.cross)
self.img_corner = cv2.erode(self.img_corner, CheckboxConstant.diamond)
temp = cv2.dilate(self.img, CheckboxConstant.xelem)
temp = cv2.erode(temp, CheckboxConstant.rect)
self.img_corner = cv2.absdiff(temp, self.img_corner)
# threshold
ret, self.img_corner = cv2.threshold(255-self.img_corner, 190, 255, 0)
# find the different area
temp = connectedComponents(self.img_corner, connectivity=8)
N = np.max(temp)
# loop over each region except background
for n in range(1, N):
# average position of the corner
index = np.array((0, 0), int)
count = 0
for i in range(temp.shape[0]):
for j in range(temp.shape[1]):
if temp[i, j] == n:
index += (i, j)
count += 1
if count != 0:
index /= count
self.corners.append((index[0], index[1]))
def segment_on_dt(img):
#http://stackoverflow.com/questions/11294859/how-to-define-the-markers-for-watershed-in-opencv
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
_, img_bin = cv2.threshold(img_gray, 0, 255,cv2.THRESH_OTSU)
img_bin = cv2.morphologyEx(img_bin, cv2.MORPH_OPEN,numpy.ones((3, 3), dtype=int))
border = cv2.dilate(img_bin, None, iterations=5)
border = border - cv2.erode(border, None)
dt = cv2.distanceTransform(img_bin, 2, 3)
dt = ((dt - dt.min()) / (dt.max() - dt.min()) * 255).astype(numpy.uint8)
_, dt = cv2.threshold(dt, 180, 255, cv2.THRESH_BINARY)
lbl, ncc = label(dt)
lbl = lbl * (255/ncc)
# Completing the markers now.
lbl[border == 255] = 255
lbl = lbl.astype(numpy.int32)
cv2.watershed(img, lbl)
lbl[lbl == -1] = 0
lbl = lbl.astype(numpy.uint8)
result = 255 - lbl
result[result != 255] = 0
result = cv2.dilate(result, None)
img[result == 255] = (0, 0, 255)
return img
def ErodeTrick(im):
cv2.erode(im, im, None, 3)
cv2.dilate(im, im, None, 3)
cv2.dilate(im, im, None, 3)
cv2.erode(im, im, None, 3)
return im
def Harris_Corner(self):
self.threshold = 0.999999999999
temp_i = self.image_i.copy()
temp1_i = self.image_i.copy()
gray_i = cv2.cvtColor(temp_i, cv2.COLOR_BGR2GRAY)
gray_i = numpy.float32(gray_i)
dst_i = cv2.cornerHarris(gray_i, 2, 3, 0.025)
dst_i = cv2.dilate(dst_i, None)
# Threshold for an optimal value, it may vary depending on the image.
temp_i[dst_i < 0.01 * dst_i.max()] = [0, 0, 0]
temp1_i[dst_i > 0.01 * dst_i.max()] = [0, 0, 255]
hist_i = cv2.calcHist([temp_i], [0], None, [256], [0, 256])
temp_j = self.image_j.copy()
temp1_j = self.image_j.copy()
gray_j = cv2.cvtColor(temp_j, cv2.COLOR_BGR2GRAY)
gray_j = numpy.float32(gray_j)
dst_j = cv2.cornerHarris(gray_j, 2, 3, 0.025)
dst_j = cv2.dilate(dst_j, None)
# Threshold for an optimal value, it may vary depending on the image.
temp_j[dst_j < 0.01 * dst_j.max()] = [0, 0, 0]
temp1_j[dst_j > 0.01 * dst_j.max()] = [0, 0, 255]
hist_j = cv2.calcHist([temp_j], [0], None, [256], [0, 256])
self.measure = cv2.compareHist(hist_i, hist_j, cv.CV_COMP_CORREL)
self.assertGreater(self.measure, self.threshold)
print self.measure
def foreground(bg_img, raw_img):
#take the background and subtract somehow from the foreground
img = raw_img*1
raw_hsv = cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
bg_hsv = cv2.cvtColor(bg_img,cv2.COLOR_BGR2HSV)
hmask = cv2.absdiff(raw_hsv[:,:,0], bg_hsv[:,:,0])
smask = cv2.absdiff(raw_hsv[:,:,1], bg_hsv[:,:,1])
vmask = cv2.absdiff(raw_hsv[:,:,2], bg_hsv[:,:,2])
ret,hmask_thresh = cv2.threshold(hmask,1.,1.,cv2.THRESH_BINARY)
ret,smask_thresh = cv2.threshold(smask,1.,1.,cv2.THRESH_BINARY)
ret, vmask_thresh = cv2.threshold(vmask,1.,1.,cv2.THRESH_BINARY)
hsv_mask = np.multiply(hmask_thresh, smask_thresh)
hsv_mask = np.multiply(hsv_mask, vmask_thresh)
hsv_mask = cv2.dilate(hsv_mask,(100,100) )
###Filter out colors with extreme values and no red for skin###
# ret, rmask = cv2.threshold(img[:,:,2],40,1., cv2.THRESH_BINARY)
# ret, r2mask = cv2.threshold(img[:,:,2],235.,1., cv2.THRESH_BINARY_INV)
# rb_mask = np.multiply(rmask, r2mask)
# img[:,:,0 ]= np.multiply(img[:,:,0], rb_mask)
# img[:,:,1 ]= np.multiply(img[:,:,1], rb_mask)
# img[:,:,2 ]= np.multiply(img[:,:,2], rb_mask)
# bmask = cv2.absdiff(img[:,:,0], bg_img[:,:,0])
# gmask = cv2.absdiff(img[:,:,1], bg_img[:,:,1])
rmask = cv2.absdiff(img[:,:,2], bg_img[:,:,2])
ret,rmask_thresh = cv2.threshold(rmask,20.,1.,cv2.THRESH_BINARY)
##Greyscale mask that kinda worked except for bright lighting
raw_gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
#raw_gray = cv2.GaussianBlur(raw_gray, (5,5), 2)
bg_gray = cv2.cvtColor(bg_img,cv2.COLOR_BGR2GRAY)
#bg_gray = cv2.GaussianBlur(bg_gray, (5,5), 5)
mask =cv2.absdiff(raw_gray, bg_gray)
ret,mask = cv2.threshold(mask,15.,1.,cv2.THRESH_BINARY)
###
###make changes here
mask = mask*1.0
mask = np.multiply(rmask_thresh, mask)
mask = np.multiply(hsv_mask, mask)
mask = cv2.dilate(mask,(100,100))
for i in range(4):
mask = cv2.erode(mask*255, (50,50))/255.
for i in range(5):
mask = cv2.dilate(mask*255., (50,50))/255.
fg_img = img*1.0
fg_img[:,:,0 ]= np.multiply(img[:,:,0], mask)
fg_img[:,:,1 ]= np.multiply(img[:,:,1], mask)
fg_img[:,:,2 ]= np.multiply(img[:,:,2], mask)
cv2.imshow("fg_img", np.array(fg_img, dtype= "uint8"))
return np.array(mask, dtype = "uint8")
def GenericFilter(self,infile,outfile):
#print infile,":",outfile
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
kernel1 = np.ones((5,5),np.uint8)
kernel2 = np.ones((3,3),np.uint8)
img = cv2.imread(str(infile),0)
cv2.imshow("img",img)
blur=cv2.medianBlur(img,5)
cl1 = clahe.apply(blur)
circles_mask = cv2.dilate(cl1,kernel1,iterations = 6)
circles_mask = (255-circles_mask)
circles_mask = cv2.threshold(circles_mask, 0, 255, cv2.THRESH_BINARY)[1]
edges = cv2.Canny(cl1,100,200)
dilation = cv2.dilate(edges,kernel1,iterations = 1)
display = cv2.bitwise_and(img,img,mask=dilation)
cl2 = clahe.apply(display)
cl2 = clahe.apply(cl2)
ret,th = cv2.threshold(cl2,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
th = 255 - th
thg = cv2.adaptiveThreshold(display,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,\
cv2.THRESH_BINARY,11,2)
saveimgfile=outfile.split(".")
print saveimgfile[1]
final = cv2.bitwise_and(dilation,dilation,mask=th)
cv2.imwrite("Filtered-images/"+str(saveimgfile[0])+"1."+str(saveimgfile[1]),final)
finalg = cv2.bitwise_and(dilation,dilation,mask=thg)
cv2.imwrite("Filtered-images/"+str(saveimgfile[0])+"2."+str(saveimgfile[1]),finalg)
finalg = 255 - finalg
abso = cv2.bitwise_and(dilation,dilation,mask=finalg)
cv2.imwrite("Filtered-images/"+str(saveimgfile[0])+"orig."+str(saveimgfile[1]),abso)
cv2.waitKey(0)
def find_red_position ( frame ):
pos_x = last_x
pos_y = last_y
hsv_img = cv2.cvtColor( frame, cv2.COLOR_BGR2HSV )
red_mask1 = cv2.inRange( hsv_img, lower_red_l, lower_red_h )
red_mask2 = cv2.inRange( hsv_img, upper_red_l, upper_red_h )
red_mask = red_mask1 + red_mask2
red_mask = cv2.erode( red_mask, kernel )
red_mask = cv2.dilate( red_mask, kernel )
red_mask = cv2.dilate( red_mask, kernel )
red_mask = cv2.erode( red_mask, kernel )
o_moments = cv2.moments( red_mask )
d_m01 = o_moments['m01']
d_m10 = o_moments['m10']
d_area = o_moments['m00']
#print "MOMENTS " + str(d_m01) + " " + str(d_m10) + " " + str(d_area)
if d_area > 10000:
pos_x = int(d_m10 / d_area)
pos_y = int(d_m01 / d_area)
#print "[" + str(pos_x) + " , " + str(pos_y) + "]"
return pos_x, pos_y, red_mask
def sameCardShape(shape1, shape2):
#val = cv2.matchShapes(shape1, shape2, 1, 0.0)
#print val
(maxX1, maxY1) = (max(shape1[:,0,0]), max(shape1[:,0,1]))
(minX1, minY1) = (min(shape1[:,0,0]), min(shape1[:,0,1]))
(maxX2, maxY2) = (max(shape2[:,0,0]), max(shape2[:,0,1]))
(minX2, minY2) = (min(shape2[:,0,0]), min(shape2[:,0,1]))
maxXDiff = max(maxX1 - minX1, maxX2 - minX2)
maxYDiff = max(maxY1 - minY1, maxY2 - minY2)
image1 = np.zeros((maxYDiff,maxXDiff), np.uint8)
cv2.drawContours(image1, [shape1], 0, 255, offset=(-minX1, -minY1))
image1 = cv2.dilate(image1, np.ones((17,17), np.uint8))
if DEBUGSHAPES:
showImage(image1, 'contour1', wait=False)
image2 = np.zeros((maxYDiff,maxXDiff), np.uint8)
cv2.drawContours(image2, [shape2], 0, 255, offset=(-minX2, -minY2))
image2 = cv2.dilate(image2, np.ones((17,17), np.uint8))
if DEBUGSHAPES:
showImage(image2, 'contour2', wait=False)
intersectImage = cv2.bitwise_and(image1, image2)
intersectCount = float(cv2.countNonZero(intersectImage))
count1 = cv2.countNonZero(image1)
count2 = cv2.countNonZero(image2)
if DEBUGSHAPES:
print str(intersectCount / count1 > shape_similarity_threshold or \
intersectCount / count2 > shape_similarity_threshold) + \
' intersect ratio = ' + str(intersectCount/count1) + ', ' + str(intersectCount/count2)
showImage(intersectImage, 'and')
return intersectCount / min(count1, count2) > shape_similarity_threshold
def find_yellow_contours(self, split_image):
lab_bthreshed_board = cv2.adaptiveThreshold(split_image.lab[2], 255,
cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY,
self.options["board_blocksize"], self.options["board_C_b"])
yuv_uthreshed_board = cv2.adaptiveThreshold(split_image.yuv[2], 255,
cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY,
self.options["board_blocksize"], self.options["board_C_u"])
yuv_uthreshed_board = cv2.bitwise_not(yuv_uthreshed_board)
finalThreshed = lab_bthreshed_board & yuv_uthreshed_board
# Erode and dilate thresholded images
morph_size = self.options["board_morph_size"]
erode_element = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (morph_size * 2 + 1, morph_size * 2 + 1),
(morph_size, morph_size))
dilate_element = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (morph_size * 2 + 1, morph_size * 2 + 1),
(morph_size, morph_size))
eroded = cv2.erode(finalThreshed,erode_element, iterations = self.options["board_morph_iter"])
finalThreshed = cv2.dilate(eroded, dilate_element, iterations = self.options["board_morph_iter"])
finalThreshed = cv2.dilate(finalThreshed, dilate_element, iterations = self.options["board_morph_iter"])
finalThreshed = cv2.erode(finalThreshed, erode_element, iterations = self.options["board_morph_iter"])
self.post_if_enabled('yellow_lab_bthreshed', lab_bthreshed_board)
self.post_if_enabled('yellow_yuv_uthreshed', yuv_uthreshed_board)
self.post_if_enabled('yellow_binary_image', finalThreshed)
_, contours, hierarchy = cv2.findContours(np.copy(finalThreshed),
cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
return contours, hierarchy
def marcarRectas(img) :
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
flag,b = cv2.threshold(gray,100,255,cv2.THRESH_BINARY)
element = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(7,7))
cv2.dilate(b,element)
edges = cv2.Canny(b,100,255)
lines90 = cv2.HoughLinesP(edges,1, np.pi/180, 100)
lines180 = cv2.HoughLinesP(edges,1, np.pi, 100)
if(lines90!=None):
l = lines90.tolist()
for x1,y1,x2,y2 in l[0]:
cv2.line(img, (x1,y1), (x2,y2), (0,255,0), 5)
#if(lines180!=None):
# l = lines180.tolist()
# for x1,y1,x2,y2 in l[0]:
# cv2.line(img, (x1,y1), (x2,y2), (0,255,0), 3)
return img
def preprocess(gray):
# 1. Sobel算子，x方向求梯度
sobel = cv2.Sobel(gray, cv2.CV_8U, 1, 0, ksize = 3)
# 2. 二值化
ret, binary = cv2.threshold(sobel, 0, 255, cv2.THRESH_OTSU+cv2.THRESH_BINARY)
# 3. 膨胀和腐蚀操作的核函数
element1 = cv2.getStructuringElement(cv2.MORPH_RECT, (30, 9))
element2 = cv2.getStructuringElement(cv2.MORPH_RECT, (24, 6))
# 4. 膨胀一次，让轮廓突出
dilation = cv2.dilate(binary, element2, iterations = 1)
# 5. 腐蚀一次，去掉细节，如表格线等。注意这里去掉的是竖直的线
erosion = cv2.erode(dilation, element1, iterations = 1)
# 6. 再次膨胀，让轮廓明显一些
dilation2 = cv2.dilate(erosion, element2, iterations = 3)
# dilation2 = cv2.dilate(erosion, element1, iterations = 1)
# 7. 存储中间图片
cv2.imwrite("temp/gray.png", gray)
cv2.imwrite("temp/binary.png", binary)
cv2.imwrite("temp/dilation.png", dilation)
cv2.imwrite("temp/erosion.png", erosion)
cv2.imwrite("temp/dilation2.png", dilation2)
return dilation2
frame_out = frame.copy()
# Hiển thị số frame trên góc trái video
if dict['text_overlay']:
str_on_frame = "%d/%d" % (video_cur_frame, video_info['num_of_frames'])
cv2.putText(frame_out, str_on_frame, (5, 30), cv2.FONT_HERSHEY_SIMPLEX,
0.8, (0, 255, 255), 2, cv2.LINE_AA)
cv2.putText(frame_out, global_str + str(round(change_pos, 2)) + 'sec', (5, 60), cv2.FONT_HERSHEY_SIMPLEX,
0.8, (255, 0, 0), 2, cv2.LINE_AA)
# motion detection cho mọi objects
if dict['motion_detection']:
fgmask = fgbg.apply(frame_blur)
bw = np.uint8(fgmask == 255) * 255
bw = cv2.erode(bw, kernel_erode, iterations=1)
bw = cv2.dilate(bw, kernel_dilate, iterations=1)
(_, cnts, _) = cv2.findContours(bw.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# Áp loop cho contours
for c in cnts:
# Nếu contours quá nhỏ thì bỏ qua
if cv2.contourArea(c) < dict['min_area_motion_contour']:
continue
(x, y, w, h) = cv2.boundingRect(c)
cv2.rectangle(frame_out, (x, y), (x + w, y + h), (255, 0, 0), 1)
# Detect xe và chỗ trống
if dict['parking_detection']:
for ind, park in enumerate(parking_data):
points = np.array(park['points'])
rect = parking_bounding_rects[ind]
roi_gray = frame_gray[rect[1]:(rect[1] + rect[3]),
def camera_callback(self, data):
start_time = time.time()
self.recieved_image = True
try:
# We select bgr8 because its the OpenCV encoding by default
cv_image = self.bridge_object.imgmsg_to_cv2(
data, desired_encoding="bgr8")
#resize
#height, width, channels = cv_image.shape
#cv_image = cv2.resize(cv_image, (width/10, height/10), interpolation = cv2.INTER_AREA)
#crop
height, width, channels = cv_image.shape
descentre = -140
rows_to_watch = 200
#crop_image = cv_image[(height)/2+descentre:(height)/2+(descentre+rows_to_watch)][1:width]
crop_image = cv_image
#blur
#blur = cv2.GaussianBlur(crop_image, (15,15), 0)
#blur = cv2.bilateralFilter( crop_image, 5, 75 ,75)
blur = crop_image
#hsv
hsv = cv2.cvtColor(blur, cv2.COLOR_BGR2HSV)
#mask
par = self.myHSV
lower = np.array([par[0], par[1], par[2]])
upper = np.array([par[3], par[4], par[5]])
mask = cv2.inRange(hsv, lower, upper)
#filters
mask = cv2.erode(mask, None, iterations=2)
mask = cv2.dilate(mask, None, iterations=2)
# find contours
cnts = cv2.findContours(mask, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = cnts[1]
if len(cnts) > 0:
c = max(cnts, key=cv2.contourArea)
((x, y), radius) = cv2.minEnclosingCircle(c)
if radius > 5:
m = cv2.moments(c)
cx, cy = m['m10'] / m['m00'], m['m01'] / m['m00']
self.target_found = True
cv2.circle(crop_image, (int(cx), int(cy)), int(radius),
(0, 255, 255), 2)
self.object_location = cx - width / 2
else:
self.target_found = False
#print 'target too small', radius
else:
self.target_found = False
#cv2.circle(res, (int(cx), int(cy)), 10, (255,0,0), -1)
except CvBridgeError as e:
print(e)
#print(cv2)
#cv2.imshow("Image window", cv_image)
#cv2.imshow("Cropped", crop_image)
#cv2.imshow("HSV", hsv)
#cv2.imshow("Masked", res)
cv2.waitKey(1)
elapsed_time = time.time() - start_time
model.load_state_dict(torch.load("path_to_model.pt"))
model.to(torch.device('cuda'))
# cv.namedWindow("Img", cv.WINDOW_AUTOSIZE)
# outVid = cv.VideoWriter('output.avi',cv.VideoWriter_fourcc('M','J','P','G'), 1, (1920,1080))
# Read Image
img = cv.imread("path_to_image")
imgGray = cv.cvtColor(img, cv.COLOR_BGR2GRAY);
__, imgGray = cv.threshold(imgGray, 150, 255, cv.THRESH_BINARY_INV);
# Find Rectangular Region in Image
vSE = cv.getStructuringElement(cv.MORPH_RECT, (1, 20));
vErodeImg = cv.erode(imgGray, vSE)
vDilateImg = cv.dilate(vErodeImg, vSE)
hSE = cv.getStructuringElement(cv.MORPH_RECT, (20, 1));
hErodeImg = cv.erode(imgGray, hSE);
hDilateImg = cv.dilate(hErodeImg, hSE)
binaryImg = vDilateImg + hDilateImg;
imgContours = cv.findContours(binaryImg, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
for cnt in reversed(imgContours[0]):
x,y,w,h = cv.boundingRect(cnt)
area = cv.contourArea(cnt)
imgDisp = cp.deepcopy(img)
#!/usr/bin/env python
# -*- coding=utf8 -*-
"""
# Author: xiao
# Created Time : 2019-05-22
# File Name: erode_dilate.py
# Description:
"""
import cv2
import numpy as np
if __name__=='__main__':
imgfn = 'test.jpg'
img = cv2.imread(imgfn)
for k in range(3,8):
kernel = np.ones((k,k),np.uint8)
erosion = cv2.erode(img,kernel,iterations = 1)
dilation = cv2.dilate(img,kernel,iterations = 1)
closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)
opening = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)
new_img = np.vstack([erosion, dilation, closing, opening])
cv2.imshow('newimg_k_{}'.format(k), new_img)
cv2.waitKey()
ret, frame = video_capture.read()
#Flip the frame to avoid mirroring effect
frame = cv2.flip(frame,1)
#Resize the given frame to a 600*600 window
frame = imutils.resize(frame, width = 600)
#Blur the frame using Gaussian Filter of kernel size 5, to remove excessivve noise
blurred_frame = cv2.GaussianBlur(frame, (5,5), 0)
#Convert the frame to HSV, as HSV allow better segmentation.
hsv_converted_frame = cv2.cvtColor(blurred_frame, cv2.COLOR_BGR2HSV)
#Create a mask for the frame, showing green values
mask = cv2.inRange(hsv_converted_frame, greenLower, greenUpper)
#Erode the masked output to delete small white dots present in the masked image
mask = cv2.erode(mask, None, iterations = 2)
#Dilate the resultant image to restore our target
mask = cv2.dilate(mask, None, iterations = 2)
#Find all contours in the masked image
cnts,_ = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
#Define center of the ball to be detected as None
center = None
#If any object is detected, then only proceed
if(len(cnts) > 0):
#Find the contour with maximum area
c = max(cnts, key = cv2.contourArea)
#Find the center of the circle, and its radius of the largest detected contour.
((x, y), radius) = cv2.minEnclosingCircle(c)
#Calculate the centroid of the ball, as we need to draw a circle around it.
M = cv2.moments(c)
files = sorted(glob.glob(os.path.join(faces_folder_path, "*")))
x_coord = []
y_coord = []
for filename in files:
img = cv2.imread(filename)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gray = np.float32(gray)
dst = cv2.cornerHarris(gray, 2, 3, 0.04)
a = np.zeros(shape=(240, 352))
for i in range(0, 240):
for j in range(0, 352):
if dst[i][j] > 0.01 * dst.max():
x_coord.append(i)
y_coord.append(j)
#
# print "count = ",count
#result is dilated for marking the corners, not important
dst = cv2.dilate(dst, None)
# print dst.max(),dst.min()
cluster(x_coord, y_coord)
# Threshold for an optimal value, it may vary depending on the image.
img[dst > 0.01 * dst.max()] = [0, 0, 255]
cv2.imshow('dst', img)
if cv2.waitKey(0) & 0xff == 27:
cv2.destroyAllWindows()
if frame is None:
break
# Display camera input
image = frame
#define the processing reagion
crop_img = frame[450:700, 450:780]
# convert to grayscale, gaussian blur, and threshold
gray = cv.cvtColor(crop_img, cv.COLOR_BGR2GRAY)
blur = cv.GaussianBlur(gray, (5, 5), 0)
ret, th = cv.threshold(blur, 60, 255, cv.THRESH_BINARY_INV)
edged = cv.Canny(blur, 85, 85)
# Erode to eliminate noise, Dilate to restore eroded parts of image
mask1 = cv.erode(th, None, iterations=2)
mask = cv.dilate(mask1, None, iterations=2)
# Find all contours in frame
contours, hierarchy = cv.findContours(th.copy(), 1,
cv.CHAIN_APPROX_NONE)
# Find x-axis centroid of largest contour and cut power to appropriate motor
# to recenter camera on centroid.
if len(contours) > 0:
c = max(contours, key=cv.contourArea)
M = cv.moments(c)
if M["m00"] != 0:
cx = int(M['m10'] / M['m00'])
cy = int(M['m01'] / M['m00'])
print(cx, "value")
import numpy as np
import cv2
img = cv2.imread('/home/pi/Desktop/myFile', 0)
img = cv2.resize(img, (400, 400))
size = np.size(img)
skel = np.zeros(img.shape, np.uint8)
ret, img = cv2.threshold(img, 127, 255, 0)
element = cv2.getStructuringElement(cv2.MORPH_CROSS, (3,3))
done = False;
while( not done):
eroded = cv2.erode(img, element)
temp = cv2.dilate(eroded, element)
temp = cv2.subtract(img, temp)
skel = cv2.bitwise_or(skel, temp)
img = eroded.copy()
zeros = size - cv2.countNonZero(img)
if zeros == size:
done = True
cv2.imshow("skel", skel)
cv2.waitKey(0)
cv2.destroyAllWindows()
low = 90
up = 255
while (1):
_, image = cam.read()
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
gaussian1 = cv2.GaussianBlur(gray, (7, 7), 0)
#gaussian2 = cv2.medianBlur(gray,5)
kernal = cv2.getStructuringElement(cv2.MORPH_RECT, (10, 10))
_, thresh = cv2.threshold(gray, low, up,
cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)
#_,thresh = cv2.threshold(gaussian,low,up,cv2.THRESH_BINARY_INV)
#kernal = cv2.getStructuringElement(cv2.MORPH_RECT,(10,10))
#kernal = np.ones((5, 5), np.uint8)
erosion = cv2.erode(thresh, kernal, iterations=1)
dilate = cv2.dilate(thresh, kernal, iterations=1)
contours, _ = cv2.findContours(thresh, cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
for cnt in contours:
area = cv2.contourArea(cnt)
approx = cv2.approxPolyDP(cnt, 0.03 * cv2.arcLength(cnt, True), True)
x = approx.ravel()[0]
y = approx.ravel()[1]
if area > 5000:
cv2.drawContours(image, [approx], -1, (0, 255, 0), 2)
if (len(approx) == 4):
x, y, width, height = cv2.boundingRect(approx)
aspectRatio = width / float(height)
print(aspectRatio)
def detectObstacles(hsv_frame, frame, draw):
A1 = None
d1 = None
x = None
high_black = np.array([85, 70, 40])
low_black = np.array([0, 0, 0])
img_binary1 = cv2.inRange(hsv_frame.copy(), low_black, high_black)
img_binary1 = cv2.dilate(img_binary1, None, iterations=1)
# Finding Center
img_contours1 = img_binary1.copy()
contours1 = cv2.findContours(img_contours1, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)[-2]
# Finding largest contour and locating x,y values and width
obstacle1_d = None
obstacle1_A = None
obstacle2_d = None
obstacle2_A = None
obstacle3_d = None
obstacle3_A = None
w_min = 10
if len(contours1) > 0:
obstacles = []
Contour_size = []
count = 1
for i, c in enumerate(contours1):
area = cv2.contourArea(c)
obstacles.append(area)
# Sort area by largest to smallest
Contour_size = sorted(zip(obstacles, contours1),
key=lambda x: x[0],
reverse=True)
if len(Contour_size) > 2:
obstacle3 = Contour_size[2][1]
obstacle3_area = cv2.minAreaRect(obstacle3)
obstacle3_box = cv2.boxPoints(obstacle3_area)
obstacle3_box = np.int0(obstacle3_box)
obstacle3_w = abs(obstacle3_box[2] - obstacle3_box[0])
obstacle3_x, obstacle3_y = abs(obstacle3_box[0])
obstacle3_x2, obstacle3_y2 = obstacle3_w
if draw == True:
if obstacle3_x2 >= w_min:
drawobstacle3 = cv2.drawContours(frame, [obstacle3_box], 0,
(0, 255, 0), 2)
obstacle3_d = (15 * 300) / obstacle3_x2
obstacle3_A = (((obstacle3_x + (obstacle3_x2 / 2)) /
(320 / 108)) - 54)
cv2.putText(frame, "D: " + str(obstacle3_d), (4, 140),
cv2.FONT_HERSHEY_PLAIN, 1, (0, 255, 255))
cv2.putText(frame, "A: " + str(obstacle3_A), (4, 125),
cv2.FONT_HERSHEY_PLAIN, 1, (0, 255, 255))
cv2.putText(frame, "Obstacle3", (4, 110),
cv2.FONT_HERSHEY_PLAIN, 1, (0, 255, 255))
if len(Contour_size) > 1:
obstacle2 = Contour_size[1][1]
obstacle2_area = cv2.minAreaRect(obstacle2)
obstacle2_box = cv2.boxPoints(obstacle2_area)
obstacle2_box = np.int0(obstacle2_box)
obstacle2_w = abs(obstacle2_box[2] - obstacle2_box[0])
obstacle2_x, obstacle2_y = abs(obstacle2_box[0])
obstacle2_x2, obstacle2_y2 = obstacle2_w
if draw == True:
if obstacle2_x2 >= w_min:
drawobstacle2 = cv2.drawContours(frame, [obstacle2_box], 0,
(0, 255, 0), 2)
obstacle2_d = (15 * 300) / obstacle2_x2
obstacle2_A = (((obstacle2_x + (obstacle2_x2 / 2)) /
(320 / 108)) - 54)
cv2.putText(frame, "D: " + str(obstacle2_d), (4, 95),
cv2.FONT_HERSHEY_PLAIN, 1, (0, 255, 255))
cv2.putText(frame, "A: " + str(obstacle2_A), (4, 80),
cv2.FONT_HERSHEY_PLAIN, 1, (0, 255, 255))
cv2.putText(frame, "Obstacle2", (4, 65),
cv2.FONT_HERSHEY_PLAIN, 1, (0, 255, 255))
square = max(contours1, key=cv2.contourArea)
area = cv2.minAreaRect(square)
box = cv2.boxPoints(area)
box = np.int0(box)
w = abs(box[2] - box[0])
xyes, yyes = abs(box[0])
x, y = w
if draw == True:
if x >= w_min:
draw = cv2.drawContours(frame, [box], 0, (0, 255, 0), 2)
#Focal Length = (width@10cm * 10cm)/actual width = 255
obstacle1_d = (15 * 300) / x
obstacle1_A = (((xyes + (x / 2)) / (320 / 108)) - 54)
cv2.putText(frame, "D: " + str(obstacle1_d), (4, 50),
cv2.FONT_HERSHEY_PLAIN, 1, (0, 255, 255))
cv2.putText(frame, "A: " + str(obstacle1_A), (4, 35),
cv2.FONT_HERSHEY_PLAIN, 1, (0, 255, 255))
cv2.putText(frame, "Obstacle", (4, 20), cv2.FONT_HERSHEY_PLAIN,
1, (0, 255, 255))
return [[obstacle1_d, obstacle1_A], [obstacle2_d, obstacle2_A],
[obstacle3_d, obstacle3_A]]
for r, d, f in os.walk(path):
tamanhoImagem = len(f)
for filename in f:
imagem = cv2.imread(os.path.join(path, filename))
imagem = cv2.resize(imagem, dim, interpolation=cv2.INTER_AREA)
imagemBin = 255 - imagem[:,:,0]
novaImagem = np.zeros(np.shape(imagemBin))
kernel = np.ones((3,3), np.uint8)
novaImagem = normalizaImagem((imagemBin>100)*1)
imCopy = np.copy(novaImagem)
imPlot = np.zeros(np.shape(imagem))
imPlot[:,:,0] = imPlot[:,:,1] = imPlot[:,:,2] = imCopy
novaImagem = cv2.dilate(novaImagem, kernel, iterations=1) - novaImagem
novaImagem = cv2.resize(novaImagem, dim, interpolation=cv2.INTER_AREA)
max_xy = np.where(novaImagem == 255)
novaImagemRGB = np.zeros(np.shape(imagem))
novaImagemRGB[:,:,0] = novaImagemRGB[:,:,1] = novaImagemRGB[:,:,2] = novaImagem
cv2.circle(novaImagemRGB, (max_xy[1][0], max_xy[0][0]), int(3), (0,0,255), 2)
iniciarPonto = (max_xy[0][0], max_xy[1][0])
ponto = verifique(novaImagem, iniciarPonto, 4)
while(ponto!=iniciarPonto):
cv2.circle(imPlot, (ponto[1], ponto[0]), int(3), (0, 255, 255), 4)
ponto = verifique(novaImagem, ponto, 4)
print(ChainCode)
def find_banana(image, ruta='resultados'):
#Se invierte el esquema RGB a BGR, ya que las funciones son más compatibles
#teniendo el azul con más relevancia
# image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# cv2.imwrite('resultados/bgr.jpg', image)
#Un tamaño fijo
#con la dimension mas grande
max_dimension = max(image.shape)
#La escala de la imagen de salida no será mayor a 700px
scale = 700 / max_dimension
#Se redimenciona la imagen para que sea cuadrada.
image = cv2.resize(image, None, fx=scale, fy=scale)
#Reducimos el ruido de la imagen usando el filtro Gaussiano, con la escala
#maxima cuadrada.
# image_blur = cv2.bilateralFilter(image,9,75,75)
image_blur = cv2.GaussianBlur(image, (7, 7), 0)
cv2.imwrite(ruta + '/blur.jpg', image_blur)
#Tratamos de enfocarnos en el color, y por esta razón nos enfocamos en
#el esquema HSV, pues resalta el color y maneja solo saturacion y
#valor
image_blur_hsv = cv2.cvtColor(image_blur, cv2.COLOR_RGB2HSV)
cv2.imwrite(ruta + '/hsv.jpg', image_blur_hsv)
#kernel = np.ones((5,5),np.uint8)
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
erosion = cv2.erode(image_blur_hsv, kernel, iterations=1)
cv2.imwrite(ruta + '/erosionado.jpg', erosion)
dilation = cv2.dilate(image_blur_hsv, kernel, iterations=1)
cv2.imwrite(ruta + '/dilatado.jpg', dilation)
dilation_blur = cv2.morphologyEx(dilation, cv2.MORPH_CLOSE, kernel)
cv2.imwrite(ruta + '/dilatado_blur.jpg', dilation_blur)
# Filtro por color
# 20-30 hue
"""Aqui tenemos un problema, pues decidimos colocar un rango de amarillos
pero no lo reconoce en la imagen y tenemos dificultad al reconocer este
rango, ya que a veces toma colores que no debe. Según el tono es de
50 a 70 para amarillos"""
#hsv(15, 80, 50)
#hsv(105, 120, 255)
min_yellow = np.array([15, 100, 80])
max_yellow = np.array([105, 255, 255])
# min_yellow = np.array([20, 100, 80])
# max_yellow = np.array([30, 255, 255])
#layer
mask1 = cv2.inRange(dilation_blur, min_yellow, max_yellow)
#hsv(230, 0, 0)
#hsv(270, 255, 255)
black_min = np.array([130, 0, 0])
black_max = np.array([170, 255, 255])
black_mask = cv2.inRange(dilation_blur, black_min, black_max)
cv2.imwrite(ruta + '/mascara_negro.jpg', black_mask)
#Filtro por brillo
# 170-180 hue
#Tratamos de resaltar el brillo para tener un mejor reconocimiento de
#colores.
#hsv(170,100,80)
#hsv(180,255,255)
min_yellow2 = np.array([170, 100, 80])
max_yellow2 = np.array([180, 255, 255])
mask2 = cv2.inRange(dilation_blur, min_yellow2, max_yellow2)
cv2.imwrite(ruta + '/mascara1.jpg', mask1)
cv2.imwrite(ruta + '/mascara2.jpg', mask2)
#Combinamos las mascaras de colores.
mask = mask1 + mask2 + black_mask
cv2.imwrite(ruta + '/mask.jpg', mask)
# opening = cv2.morphologyEx(dilation, cv2.MORPH_OPEN, kernel)
# cv2.imwrite('resultados/opening.jpg', opening)
# Se limpia la imagen y se crea la elipse.
#Se erosiona la imagen para reducir espacios sin color. Y luego se dilata,
#Esto dentro de lo que buscamos encerrar.
mask_closed = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
mask_closed = cv2.dilate(mask_closed, kernel, iterations=3)
# mask_closed = cv2.dilate(mask_closed, kernel, iterations = 1)
# mask_closed = cv2.morphologyEx(mask_closed, cv2.MORPH_CLOSE, kernel)
cv2.imwrite(ruta + '/closed.jpg', mask_closed)
#Se dilata para reducr ruido afuera de lo que identificamos, y luego se erosiona.
mask_clean = cv2.morphologyEx(mask_closed, cv2.MORPH_OPEN, kernel)
cv2.imwrite(ruta + '/open.jpg', mask_clean)
# Se encuentra el mejor patron y se recibe el contorno
big_banana_contour, mask_bananas = find_biggest_contour(mask_clean)
# Se resalta la mascara limpia y se aclara en la imagen.
overlay = overlay_mask(mask_clean, image)
cv2.imwrite(ruta + '/overlay.jpg', overlay)
#Se circula el patron con mejor coincidencia.
circled, cropped = circle_contour(image, big_banana_contour, ruta)
#Y convertimos al esquema de original de colores.
cropped = cv2.cvtColor(cropped, cv2.COLOR_BGR2RGB)
return circled, cropped
def detectWord(img, toDetect):
processedImg = arabic_processing(img)
preparedImg = prepareImg(processedImg, 600)
if not os.path.exists('cropped'):
os.makedirs('cropped')
img1 = preparedImg
kernel = createKernel(kernelSize=15, sigma=11, theta=6)
imgFiltered = cv2.filter2D(preparedImg,
-1,
kernel,
borderType=cv2.BORDER_REPLICATE).astype(
np.uint8)
imgFiltered = cv2.dilate(imgFiltered, circle_kernel, iterations=5)
(_, imgThres) = cv2.threshold(imgFiltered, 0, 255,
cv2.THRESH_BINARY + cv2.THRESH_OTSU)
imgThres = 255 - imgThres
# Find the contours
contours, hierarchy = cv2.findContours(imgThres, cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
minArea = 250
res = []
for c in contours:
# skip small word candidates
if cv2.contourArea(c) < minArea:
continue
# append bounding box and image of word to result list
currBox = cv2.boundingRect(c) # returns (x, y, w, h)
(x, y, w, h) = currBox
currImg = preparedImg[y:y + h, x:x + w]
res.append((currBox, currImg))
res = sorted(res, key=lambda entry: entry[0][0])
i = 0
w, h = 5, len(res)
Matrix = [[0 for x in range(w)] for y in range(h)]
for (j, w) in enumerate(res):
(wordBox, wordImg) = w
(x, y, w, h) = wordBox
yr = range(y - 10, y + h + 10)
xr = range(x - 5, x + w + 2)
for k in range(img1.shape[0]):
for g in range(img1.shape[1]):
if not (g in xr and k in yr):
img1[k, g] = 255
Matrix[i][0] = y - 10
Matrix[i][1] = y + h + 10
Matrix[i][2] = x - 5
Matrix[i][3] = x + w + 2
Matrix[i][4] = 'cropped\pic000%d.png' % (i, )
cv2.imwrite('cropped/pic{:>05}.png'.format(i), img1)
imgx = arabic_processing(img)
img1 = prepareImg(imgx, 600)
i += 1
k = 0
y = toDetect
croppedImages = glob.glob("cropped/*.png")
for image in croppedImages:
with open(image, 'rb') as file:
text = pytesseract.image_to_string(Image.open(file),
lang='ara',
config=" --psm 10 ")
text = removeSpecial(text)
y = removeSpecial(y)
#text=removeHamza(text)
#y=removeHamza(y)
if text == y:
for t in range(len(res)):
if (str(image) == str(Matrix[t][4])):
cv2.rectangle(img1, (Matrix[t][2], Matrix[t][0]),
(Matrix[t][3], Matrix[t][1]), 0, 1)
k += 1
return img1
cy = y + y1
return cx, cy
detect = []
offset = 6 # allowable errorbetween pixel
counter = 0
while True:
ret, frame1 = cap.read()
grey = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
blur = cv2.GaussianBlur(grey, (3, 3), 5)
# applying on each frame
img_sub = algorithm.apply(blur)
dilat = cv2.dilate(img_sub, np.ones((5, 5)))
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
dilatada = cv2.morphologyEx(dilat, cv2.MORPH_CLOSE, kernel)
dilatada = cv2.morphologyEx(dilatada, cv2.MORPH_CLOSE, kernel)
dilatada = cv2.morphologyEx(dilatada, cv2.MORPH_CLOSE, kernel)
counterSahpe, h = cv2.findContours(dilatada, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
cv2.line(frame1, (25, count_line_position), (1200, count_line_position),
(255, 127, 0), 3)
for (i, c) in enumerate(counterSahpe):
(x, y, w, h) = cv2.boundingRect(c)
validate_counter = (w >= min_width_rect) and (h >= min_height_rect)
# if we are viewing a video and we did not grab a frame,
# then we have reached the end of the video
if args.get("video") and not grabbed:
break
# capture frames from the camera
#for frame in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True):
# resize the frame, blur it, and convert it to the HSV
# color space
# frame = imutils.resize(frame.array, width=600) # for picamera
frame = imutils.resize(frame, width=600) # for video
# blurred = cv2.GaussianBlur(frame, (11, 11), 0)
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# Threshold the HSV image to get only cyan colors
maskTable = cv2.inRange(hsv, lower_cyan, upper_cyan)
maskTable = cv2.dilate(maskTable, None, iterations=10)
maskTable = cv2.erode(maskTable, None, iterations=10)
# Threshold the HSV image for white color
maskWhite = cv2.inRange(hsv, lower_white, upper_white)
# maskWhite = cv2.dilate(maskWhite, None, iterations=2)
# maskWhite = cv2.erode(maskWhite, None, iterations=2)
#maskWhite = cv2.morphologyEx(maskWhite, cv2.MORPH_OPEN, kernel)
maskWhite = maskWhite & maskTable
# Threshold the HSV image for red color
maskRed1 = cv2.inRange(hsv, lower_red1, upper_red1)
maskRed2 = cv2.inRange(hsv, lower_red2, upper_red2)
maskRed = maskRed1 | maskRed2
maskRed = cv2.dilate(maskRed, None, iterations=1)
maskRed = cv2.erode(maskRed, None, iterations=2)
blur = cv2.blur(frame,(3,3))
#Convert to HSV color space
hsv = cv2.cvtColor(blur,cv2.COLOR_BGR2HSV)
#Create a binary image with where white will be skin colors and rest is black
mask2 = cv2.inRange(hsv,np.array([2,50,50]),np.array([15,255,255]))
#Kernel matrices for morphological transformation
kernel_square = np.ones((11,11),np.uint8)
kernel_ellipse= cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))
#Perform morphological transformations to filter out the background noise
#Dilation increase skin color area
#Erosion increase skin color area
dilation = cv2.dilate(mask2,kernel_ellipse,iterations = 1)
erosion = cv2.erode(dilation,kernel_square,iterations = 1)
dilation2 = cv2.dilate(erosion,kernel_ellipse,iterations = 1)
filtered = cv2.medianBlur(dilation2,5)
kernel_ellipse= cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(8,8))
dilation2 = cv2.dilate(filtered,kernel_ellipse,iterations = 1)
kernel_ellipse= cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))
dilation3 = cv2.dilate(filtered,kernel_ellipse,iterations = 1)
median = cv2.medianBlur(dilation2,5)
ret,thresh = cv2.threshold(median,127,255,0)
#Find contours of the filtered frame
#contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
_,contours,hierarchy=cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
#Draw Contours
#cv2.drawContours(frame, cnt, -1, (122,122,0), 3)
def make_mask(self):
mask_temp = cv2.inRange(self.image, self.lower_red, self.upper_red)
mask_eroded = cv2.erode(mask_temp, self.kernel_erode)
self.mask = cv2.dilate(mask_eroded, self.kernel_dilate, iterations=1)
def dilation(img, kernel_size=5):
kernel = np.ones((kernel_size, kernel_size), np.uint8)
return cv2.dilate(img, kernel, iterations=1)
# resize the frame, convert it to grayscale, and blur it
# frame = imutils.resize(frame, width=500,height=500)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (21, 21), 0)
# print firstFrame.shape,gray.shape
# if the first frame is None, initialize it
if firstFrame is None:
firstFrame = gray
continue
# compute the absolute difference between the current frame and
# first frame
frameDelta = cv2.absdiff(firstFrame, gray)
thresh = cv2.threshold(frameDelta, 25, 255, cv2.THRESH_BINARY)[1]
thresh = cv2.dilate(thresh, None, iterations=2)
(cnts, _) = cv2.findContours(thresh.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) < args["min_area"]:
continue
# compute the bounding box for the contour, draw it on the frame,
# and update the text
(x, y, w, h) = cv2.boundingRect(c)
crop_image = frame[y:y + h, x:x + w]
y = cv2.getTrackbarPos('Y','image')
u = cv2.getTrackbarPos('U','image')
v = cv2.getTrackbarPos('V','image')
img[:] = [y,u,v]
img= cv2.cvtColor(img, cv2.COLOR_BGR2YUV)
#cv2.imshow('image',img)
boln,f = cap.read()
img_yuv = cv2.cvtColor(f, cv2.COLOR_BGR2YUV)
#cv2.imshow("g1",img_yuv)
#img_yuv[:,:,2] = cv2.equalizeHist(img_yuv[:,:,2])
#cv2.imshow("g2",img_yuv
mask = cv2.inRange(img_yuv, (np.array([0,u-45,v-45])), (np.array([255,u+45,v+45])))
cv2.imshow("Masking",mask)
erode = cv2.erode(mask,None,iterations = 1)
dilate = cv2.dilate(erode,None,iterations = 1)
image,contours,hierarchy = cv2.findContours(dilate,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
for cnt in contours:
#if len(contours)>0:
#c = max(contours, key=cv2.contourArea)
x, y, w, h = cv2.boundingRect(cnt)
cv2.rectangle(f,(x,y),(x+w,y+h),[255,0,0],2)
#print x, y, w, h
#img_output = cv2.cvtColor(img_yuv, cv2.COLOR_YUV2BGR)
#cv2.imshow('Histogram equalized', f)
if cv2.waitKey(25)&0xff==27:
break
cap.release()
def back_end(image):
inimg1=image
inimg = cv2.blur(inimg1, (5,5))
hsv = cv2.cvtColor(inimg, cv2.COLOR_BGR2HSV)
lowerred = np.array([0, 70, 70], dtype=np.uint8) #hsv range for red
upperred = np.array([20, 255, 255], dtype=np.uint8)
lowerblue = np.array([98, 50, 50], dtype=np.uint8) #hsv range for blue
upperblue = np.array([170, 255, 255], dtype=np.uint8)
lowergreen = np.array([75, 50, 50], dtype=np.uint8) #hsv range for green
uppergreen = np.array([90, 255, 170], dtype=np.uint8)
p=0 #color maping 0 for green ,1 for red and 2 for blue
d=[]
shape= "no_CM" #initial values
contclr= "no_CM"
while(p<3):
if(p==0):
color="green"
lower=lowergreen
upper=uppergreen
elif (p==1):
color="red"
lower=lowerred
upper=upperred
elif (p==2):
color="blue"
lower=lowerblue
upper=upperblue
threshin = cv2.inRange(hsv, lower, upper)
#noise removal
median = cv2.medianBlur(threshin,5)
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(9,9))
dilated = cv2.dilate(median, kernel)
blur3 = cv2.bilateralFilter(dilated,9,75,75)
median3 = cv2.medianBlur(blur3,5)
incont, contours, hierarchy = cv2.findContours(median3,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
if (len(contours)>=1):
print len(contours)
cv2.drawContours(inimg1, contours, -1, (0,255,0), 3)
perimeter = cv2.arcLength(contours[0],True)
print "p=", perimeter
if (perimeter>=190): #classifying shapes based on perimeter
shape= "square"
#print "square"
elif(perimeter>=160 and perimeter<190):
#print "circle"
shape="circle"
elif(perimeter<160 and perimeter >120):
#print "triangle"
shape="triangle"
contclr = color
break
p=p+1
return shape,contclr,len(contours)
def dilate(self, img, size=(5, 5), iterations=1):
kernel = np.ones(tuple(size), np.uint8)
return cv2.dilate(img, kernel, iterations)
def extract(filename):
# filename = request.form['image']
# target = os.path.join(APP_ROOT, 'blob/')
# destination = "/".join([target, filename])
# image_path = os.path.join(app.config['static/'], filename)
#req = urllib.request.Request("{url_name}")
# image = StringIO.StringIO(urllib.request.urlopen(req).read())
image = test_image(filename)
import cv2
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib
matplotlib.use('Agg')
cv2.waitKey(1000)
cv2.destroyAllWindows()
import csv
import pytesseract
# read your file
# file = upload()
# file = send_image(file)
# image = cv2.imread(destination, 0)
# image.shape
# thresholding the image to a binary image
# thresh,img_binary = cv2.threshold(image,120,255,cv2.THRESH_BINARY |cv2.THRESH_OTSU)#inverting the image
img_binary = cv2.adaptiveThreshold(image, 255,
cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
cv2.THRESH_BINARY, 11, 2)
img_binary = 255 - img_binary # inverting the image
# cv2.imwrite('cv_inverted.png', img_binary) # Plotting the image to see the output
plotting = plt.imshow(img_binary, cmap='gray')
plt.show()
# In[3]:
# np.array(image).shape[0]
# In[4]:
# np.array(image).shape[1]
# In[5]:
Image_size = 2000
# length_x,width_y = image.size
length_x = np.array(image).shape[1]
width_y = np.array(image).shape[0]
factor = max(1, int(Image_size // length_x))
size = factor * length_x, factor * width_y
# In[6]:
# In[42]:
# Length of kernel as 100th of total width
kernel_length = 5
# ernel_length = factor
# Defining a vertical kernel to detect all vertical lines of image
vertical_kernel = cv2.getStructuringElement(cv2.MORPH_RECT,
(1, kernel_length))
# Defining a horizontal kernel to detect all horizontal lines of image
horizantal_kernel = cv2.getStructuringElement(cv2.MORPH_RECT,
(kernel_length, 1))
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2))
# In[43]:
image_1 = cv2.erode(img_binary, vertical_kernel, iterations=3)
vertical_lines = cv2.dilate(image_1, vertical_kernel, iterations=3)
# cv2.imwrite("testing-vertical.jpg", vertical_lines) # Plotting the generated image
plotting = plt.imshow(image_1, cmap='gray')
plt.show()
# In[44]:
# Use horizontal kernel to detect and save the horizontal lines in a jpg
image_2 = cv2.erode(img_binary, horizantal_kernel, iterations=3)
horizontal_lines = cv2.dilate(image_2, horizantal_kernel, iterations=3)
# cv2.imwrite("horizontal.jpg", horizontal_lines) # Plotting the generated image
plotting = plt.imshow(image_2, cmap='gray')
plt.show()
# In[45]:
# addweighted weighs horizantal and horizantal lines the same
# bitwise or and bitwise_not for exclusive or and not operations
# In[47]:
# Combine horizontal and vertical lines in a new third image, with both having same weight.
img_vh = cv2.addWeighted(vertical_lines, 0.5, horizontal_lines, 0.5,
0.0) # Eroding and thesholding the image
img_vh = cv2.erode(~img_vh, kernel, iterations=2)
thresh, img_vh = cv2.threshold(img_vh, 120, 255,
cv2.THRESH_BINARY | cv2.THRESH_OTSU)
# threshold binary or otsus binarization(mainly for bimodal)
# thresh is thresholded value used,next is the thresholded image
# cv2.imwrite("img_combined.jpg", img_vh)
bitxor = cv2.bitwise_xor(image, img_vh)
bitnot = cv2.bitwise_not(bitxor)
# cv2.imwrite("bitnot.jpg", bitnot)
# Plotting the generated image
plotting = plt.imshow(bitnot, cmap='gray')
plt.show()
# #
# The mode cv2.RETR_TREE finds all the promising contour lines and reconstruct
# s a full hierarchy of nested contours. The method cv2.CHAIN_APPROX_SIMPLE
# returns only the endpoints that are necessary for drawing the contour line.
# In[12]:
contours, hierarchy = cv2.findContours(img_vh, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
# In[13]:
import numpy as np
import argparse
import imutils
import cv2
# In[14]:
# get_ipython().system('pip install imutils')
# In[15]:
def sort_contours(cnts,
method="left-to-right"
): # initialize the reverse flag and sort index
reverse = False
i = 0 # handle if we need to sort in reverse
if method == "right-to-left" or method == "bottom-to-top":
reverse = True # handle if we are sorting against the y-coordinate rather than
# the x-coordinate of the bounding box
if method == "top-to-bottom" or method == "bottom-to-top":
i = 1 # construct the list of bounding boxes and sort them from top to
# bottom
boundingBoxes = [cv2.boundingRect(c) for c in cnts]
(cnts, boundingBoxes) = zip(
*sorted(zip(cnts, boundingBoxes),
key=lambda b: b[1][i],
reverse=reverse
)) # return the list of sorted contours and bounding boxes
return (cnts, boundingBoxes)
# ###following a top-down approach for sorting contours
# In[16]:
# Sort all the contours by top to bottom.
contours, boundingBoxes = sort_contours(contours, "top-to-bottom")
# In[17]:
# Creating a list of heights for all detected boxes
heights = [boundingBoxes[i][3]
for i in range(len(boundingBoxes))] # Get mean of heights
mean = np.mean(heights)
#
# In[51]:
box = [
] # Get position (x,y), width and height for every contour and show the contour on image
for c in contours:
x, y, w, h = cv2.boundingRect(c)
if (h < 1000 and w < 1000):
fimage = cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0),
2)
box.append([x, y, w, h])
plotting = plt.imshow(fimage, cmap='gray')
plt.show()
# In[19]:
# len(box)
# In[20]:
print(box)
# In[21]:
# len(box)
# In[22]:
# classifying into rows and columns
# In[23]:
row = []
column = []
j = 0
for i in range(len(box)):
if (i == 0):
column.append(box[i])
previous = box[i]
else:
if (box[i][1] <= previous[1] + mean / 2):
column.append(box[i])
previous = box[i]
if (i == len(box) - 1):
row.append(column)
else:
row.append(column)
column = []
previous = box[i]
column.append(box[i])
print(column)
print(row)
# In[24]:
countcol = 0
for i in range(len(row)):
countcol = len(row[i])
if countcol > countcol:
countcol = countcol
print(countcol)
# In[ ]:
# In[25]:
# row[0]
# In[ ]:
# In[26]:
count = 0
for i in range(len(row)):
count += 1
print(row[i])
print(count)
# In[27]:
# Retrieving the centers and sorting them
center = [
int(row[i][j][0] + row[i][j][2] / 2) for j in range(len(row[i]))
if row[0]
]
center = np.array(center)
center.sort()
# In[28]:
# print(center)
# In[29]:
# Regarding the distance to the columns center, the boxes are arranged in respective order
finalboxes = []
for i in range(len(row)):
lis = []
for k in range(countcol):
lis.append([])
for j in range(len(row[i])):
diff = abs(center - (row[i][j][0] + row[i][j][2] / 4))
minimum = min(diff)
indexing = list(diff).index(minimum)
lis[indexing].append(row[i][j])
finalboxes.append(lis)
# In[30]:
# finalboxes
#
# #psm:Set Tesseract to only run a subset of layout analysis and assume a certain form of imag
#
#
# 0 = Orientation and script detection (OSD) only.
# 1 = Automatic page segmentation with OSD.
# 2 = Automatic page segmentation, but no OSD, or OCR. (not implemented)
# 3 = Fully aut1matic page segmentation, but no OSD. (Default)
# 4 = Assume a single column of text of variable sizes.
# 5 = Assume a single uniform block of vertically aligned text.
# 6 = Assume a single uniform block of text.
# 7 = Treat the image as a single text line.
# 8 = Treat the image as a single word.
# 9 = Treat the image as a single word in a circle.
# 10 = Treat the image as a single character.
# 11 = Sparse text. Find as much text as possible in no particular order.
# 12 = Sparse text with OSD.
# 13 = Raw line. Treat the image as a single text line,
# bypassing hacks that are Tesseract-specific.
# #
# Specify OCR Engine mode. The options for N are:
#
# 0 = Original Tesseract only.
# 1 = Neural nets LSTM only.
# 2 = Tesseract + LSTM.
# 3 = Default, based on what is available.
#
#
# In[ ]:
# custom_config = r'--oem 3 --psm 6 outputbase digits'
# In[57]:
# from every single image-based cell/box the strings are extracted via pytesseract and stored in a list
outer = []
for i in range(len(finalboxes)):
for j in range(len(finalboxes[i])):
inner = ''
if (len(finalboxes[i][j]) == 0):
outer.append(' ')
else:
for k in range(len(finalboxes[i][j])):
y, x, w, h = finalboxes[i][j][k][0], finalboxes[i][j][k][1], finalboxes[i][j][k][2], \
finalboxes[i][j][k][3]
finalling = bitnot[x:x + h, y:y + w]
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (2, 1))
border = cv2.copyMakeBorder(finalling,
2,
2,
2,
2,
cv2.BORDER_CONSTANT,
value=[0, 255])
resizing = cv2.resize(border,
None,
fx=2,
fy=2,
interpolation=cv2.INTER_CUBIC)
dilation = cv2.dilate(
resizing, kernel,
iterations=1) ##size of foreground object increases
erosion = cv2.erode(
dilation, kernel, iterations=2
) # Thickness of foreground object decreases
out = pytesseract.image_to_string(finalling)
if (len(out) == 0):
out = pytesseract.image_to_string(
erosion,
config='--psm 3 --oem 3 -c '
'tessedit_char_whitelist=0123456789')
inner = inner + " " + out
outer.append(inner)
arr = np.array(outer)
dataframe = pd.DataFrame(arr.reshape(len(row), countcol))
print(dataframe)
data = dataframe.style.set_properties(align="left")
return Response(
dataframe.to_csv(),
mimetype="text/csv",
headers={"Content-disposition": "attachment; filename=filename.csv"})
def main():
frame_count = 0 #to skip few frames
zone_count =0 #to know the zone to overlay the seedling images
speed=50 #speed of the bot
skip=12 #how many frames to skip
count=0 #to knw the start of inverted plane
count2=0 #to know the end of inverted plane
for frameo in camera.capture_continuous(rawCapture,format='bgr',use_video_port=True,splitter_port=2,resize=(160,128)):
frame=frameo.array #fetching the frame
gray = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)
blur=apply_smoothing(gray)
ret,th1 = cv2.threshold(blur,5,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)#using threshold to get a binary image
ret1,th2 = cv2.threshold(th1,127,255,cv2.THRESH_BINARY_INV)# invert the pixels of the image
frame_count=frame_count+1
if(frame_count<10): #skiping few frames as soon as the bot has been turned on to allow the camera to heat up and stabilize
rawCapture.truncate(0)
continue
if(zone_count==5): #sending the noninverted thresholded frame for futher processing if inverted plane is detected
if(count2==1):
make=th1
count=1
skip=1000
speed=12 #decrease the speed in the inverted plane
print "inverted plane"
smooth1=cv2.erode(make,None,iterations=7)
dil=cv2.dilate(smooth1,None,iterations=11)
forward(speed)
selected_region=select_regionIP1(dil,frame)
selected_region2=select_regionIP2(dil,frame)
selected_region3=select_regionIP3(dil,frame)
cont= get_contour(selected_regionIP1)
cont2=get_contour(selected_regionIP2)
cont3=get_contour(selected_regionIP3)
else:
make=th2
else:
make=th2 #if it is black line detection send inverter thresholded frame for further processing
smooth1=cv2.erode(make,None,iterations=7) #erosion and dilation operation to remove the grid lines as they would interfere in proper line detection
dil=cv2.dilate(smooth1,None,iterations=11)
forward(speed) #no matter what move the bot forward at lower pwm
#the lower part of the input frame is divided into 3 regions
selected_region=select_region(dil,frame)
selected_region2=select_region2(dil,frame)
selected_region3=select_region3(dil,frame)
#contours are detected in each region
cont= get_contour(selected_region)
cont2=get_contour(selected_region2)
cont3=get_contour(selected_region3)
##########################################################################################################################################
#for every frame 3 contours are detected along the black line and its deviation from the centre of the frame is calculated and the pwm are upadted accordingly
##########################################################################################################################################
if len(cont)==1: #contour of region 1
Cx,Cy= get_centroid(cont) #centroid of the contour to find the devition from the centre of the frame
area= cv2.contourArea(cont[0]) #area of the contour to indentify whether zone has been encountered
draw_output(frame,cont,Cx,Cy)
frame_count +=1
if(frame_count>10):
compute_pwm(Cx,frame,0.0003,0.0018,0) #update the pwm of the motors proportional to its devition from the centroid
if len(cont2)==1: #contour of region 2
Cx2,Cy2=get_centroid(cont2)
draw_output(frame,cont2,Cx2,Cy2)
compute_pwm(Cx2,frame,0.0002,0.0015,0)
area2= cv2.contourArea(cont2[0])
if len(cont3)==1: #contour of region 3
Cx3,Cy3=get_centroid(cont3)
draw_output(frame,cont3,Cx3,Cy3)
area3= cv2.contourArea(cont3[0])
#identifying whether the zone has been encountered from the area of the detected contour
if(area>1100 and area2>1100 and area3>1000 and frame_count>skip and zone_count<5):
zone_count =zone_count+1
left.start(0) #stopiing at the zone
right.start(0)
shape,color,number=detect_shape() # detecting shapes
print shape,color,number
Region= "region"+str(zone_count)
#overlaying on the plantation image
if(zone_count==1 and number>0):
img=img0 #plantation image
skip=50
speed=20
numz1=number #storing number of CM to blink the Led at the end
colz1=color #storing color of CM to blink that particular color
image2=make_overlay(img,shape,color,number,Region) #overlay image
cv2.imshow("overlay",image2)
cv2.waitKey(1)
elif(zone_count==2 and number>0):
img=image2
skip=400
speed=25
numz2=number #storing number of CM to blink the Led at the end
colz2=color #storing color of CM to blink that particular color
image3=make_overlay(img,shape,color,number,Region)
cv2.imshow("overlay",image3)
cv2.waitKey(1)
elif(zone_count==3 and number>0):
img=image3
speed=12
skip=20
numz3=number #storing number of CM to blink the Led at the end
colz3=color #storing color of CM to blink that particular color
image4=make_overlay(img,shape,color,number,Region)
cv2.imshow("overlay",image4)
cv2.waitKey(1)
elif(zone_count==4 and number>0):
img=image4
speed=50
skip=50
numz4=number #storing number of CM to blink the Led at the end
colz4=color #storing color of CM to blink that particular color
image5=make_overlay(img,shape,color,number,Region)
cv2.imshow("overlay",image5)
cv2.waitKey(1)
if(number>0 or (zone_count>4 and number==0)):
forward(40)
time.sleep(0.1)
else:
zone_count=zone_count-1 #if no color markers are detected
left.start(0)
right.start(0)
rawCapture.truncate(0)
still.truncate(0)
frame_count=0
continue
#if all the centroid of the three contours detected on the line are in the centre of the frame move a bit faster
if (((Cx<(rowsp/2)+5) and (Cx>(rowsp/2)-5)) and ((Cx2<(rowsp/2)+5) and (Cx2>(rowsp/2)-5)) and ((Cx3<(rowsp/2)+5) and (Cx3>(rowsp/2)-5))):
compute_pwm(Cx3,frame,0.0001,0.002,1)
else:
compute_pwm(Cx3,frame,0.0001,0.002,0)
elif (len(cont)>1):
if(zone_count==5 and count==0): #if inverted plane is encountered there will be two contours detected
left.start(0)
right.start(0)
time.sleep(0.1)
count2=1
print "change count2"
forward(10)
time.sleep(0.8)
turn_softright(90)
time.sleep(0.1)
left.start(0)
right.start(0)
rawCapture.truncate(0)
continue
elif(zone_count==5 and count==1 and frame_count>skip): #when the inverted plane ends again two contours are detected
#which indicated shed has been reached
left.start(0)
right.start(0)
print "SHED reached"
forward(20)
print "zone1",colz1,numz1
print "zone2",colz2,numz2
print "zone3",colz3,numz3
print "zone4",colz4,numz4
time.sleep(2)
left.start(0)
right.start(0)
blink_end(colz1,1)
blink_end(colz2,1)
blink_end(colz3,1)
blink_end(colz4,1)
while(1):
left.start(0)
right.start(0) #stop at the shed permanently
elif(zone_count<5):
turn_softleft(10)
time.sleep((abs((rowsp/2)-50)*2)*0.0008)
print("more contour")
turn_softleft(10)
time.sleep((abs((rowsp/2)-50)*3)*0.0008)
print len(cont)
else: #some random case
if(zone_count==5): #might be due to reflection or shadows
forward(20)
time.sleep(0.1)
turn_softleft(20) #moving the bot slightly left and right insuch case worked for me
time.sleep(0.1)
left.start(0)
right.start(0)
rawCapture.truncate(0)
continue
turn_softright(10)
time.sleep((abs((rowsp/2)-50)*2)*0.0009)
print("in some random case")
rawCapture.truncate(0)
left.start(0)
right.start(0)
key=cv2.waitKey(1) & 0xFF
if key ==ord("q"):
rawCapture.truncate(0)
camera.stop_preview()
camera.close()
GPIO.cleanup()
break
cv2.destroyAllWindows()
import cv2
import numpy as np
class Segmenter(object):
def __init__(self):
self._mask_32S = None
self._waterImg = None
# 将掩膜转化为CV_32S
def setMark(self, mask):
self._mask_32S = np.int32(mask)
# 进行分水岭操作
def waterProcess(self, img):
self._waterImg = cv2.watershed(img, self._mask_32S)
# 获取分割后的8位图像
def getSegmentationImg(self):
segmentationImg = np.uint8(self._waterImg)
return segmentationImg
# 处理分割后图像的边界值
def getWaterSegmentationImg(self):
waterSegmentationImg = np.copy(self._waterImg)
waterSegmentationImg[self._waterImg == -1] = 1
waterSegmentationImg = np.uint8(waterSegmentationImg)
return waterSegmentationImg
# 将分水岭算法得到的图像与源图像合并 实现抠图效果
def mergeSegmentationImg(self, waterSegmentationImg, isWhite=False):
_, segmentMask = cv2.threshold(waterSegmentationImg, 250, 1,
cv2.THRESH_BINARY)
segmentMask = cv2.cvtColor(segmentMask, cv2.COLOR_GRAY2BGR)
mergeImg = cv2.multiply(img, segmentMask)
def process(self, inframe, outframe):
def tellRobot(bbox, out_center_x, out_center_y, serial_format="XY"):
if bbox is None:
jevois.sendSerial("stop")
else:
box_center_x, box_center_y = bbox[0]+bbox[2]/2, bbox[1]+bbox[3]/2
if serial_format == "XY":
if out_center_x < box_center_x:
move_x = box_center_x - out_center_x
elif box_center_x < out_center_x:
move_x = out_center_x - box_center_x
elif box_center_x == out_center_x:
move_x = 0
if out_center_y < box_center_y:
move_y = box_center_y - out_center_y
elif box_center_y < out_center_y:
move_y = out_center_y - box_center_y
elif box_center_y == out_center_y:
move_y = 0
if move_x < 100:
move_x = 100
if move_y < 100:
move_y = 100
jevois.sendSerial("smoothmove {} {}".format(int(move_x), int(move_y)))
else:
jevois.sendSerial("Invalid Serial Format")
img = inframe.getCvBGR()
frameHeight = img.shape[0]
frameWidth = img.shape[1]
out_center_x, out_center_y = frameWidth/2, frameHeight/2
# Set the frame rate
time.sleep(0.2)
# Set the serial output format
serial_format = "XY" #Options: "Belts", "XY"
# Preprocess the input
blurred = cv2.bilateralFilter(img,9,75,75)
# blurred = cv2.GaussianBlur(img, (21, 21), 0)
ret, thresh = cv2.threshold(blurred, 50, 255, cv2.THRESH_BINARY)
hsv = cv2.cvtColor(thresh, cv2.COLOR_BGR2HSV)
mask = np.zeros((thresh.shape[0], thresh.shape[1], 3), np.uint8)
# Setup the tracker
tracker = cv2.TrackerKCF_create()
bbox = None
# Filter the desired color range
greenLower = (29, 86, 6)
greenUpper = (64, 255, 255)
redLower = (0,10,70)
redUpper = (40,255,255)
image = cv2.inRange(hsv, redLower, redUpper)
image = cv2.erode(image, None, iterations=2)
image = cv2.dilate(image, None, iterations=2)
# Find the biggest contour
contours, hierarchy = cv2.findContours(image.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
contour_sizes = [(cv2.contourArea(contour), contour) for contour in contours]
if contours:
biggest_contour = max(contour_sizes, key=lambda x: x[0])[1]
x,y,w,h = cv2.boundingRect(biggest_contour)
box_center_x, box_center_y = x+w/2, y+h/2
cv2.drawContours(mask, [biggest_contour], -1, 255, -1)
# Track the biggest contour
if bbox is None:
bbox = (x, y, w, h)
ok = tracker.init(img, bbox)
cv2.rectangle(mask,(x,y), (x+w, y+h), (0,255,0), 2)
else:
ok, bbox = tracker.update(img)
if ok:
p1 = (int(bbox[0]), int(bbox[1]))
p2 = (int(bbox[0] + bbox[2]), int(bbox[1] + bbox[3]))
box_center_x, box_center_y = bbox[0]+bbox[2]/2, bbox[1]+bbox[3]/2
cv2.rectangle(mask,p1, p2, (0,255,0), 2)
else:
bbox = None
else:
bbox = None
cv2.putText(mask, "BBOX: " + str(bbox), (100,50), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (50,170,50), 2)
# Tell the robot what to do
tellRobot(bbox, out_center_x, out_center_y)
# Organize the visual output
toprow = np.hstack((img, blurred))
bottomrow = np.hstack((thresh, mask))
outimg = np.vstack((toprow, bottomrow))
outframe.sendCv(outimg)
maskname = "/home/pi/junk/mask" + str(imageCounter) + ".png"
flipped = cv2.flip(inimg, 0) # flip about the x axis
cv2.imwrite(savefilename, flipped)
#trim the image.
#cropped=flipped[imageHeight/2:imageHeight-1,0:imageWidth-1]
cropped = flipped
#try it without blurring first
#blurred=cv2.medianBlur(inimg,7)
imghls = cv2.cvtColor(cropped, cv2.COLOR_BGR2HLS)
mask = cv2.inRange(imghls, lowColor, highColor)
erosion = cv2.erode(mask, erosionKernel, iterations=1)
mask = cv2.dilate(erosion, erosionKernel, iterations=1)
cv2.imwrite(maskname, mask)
# Find contours
contours, hierarchy = cv2.findContours(mask, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
ballfound = False
ballTheta = -100
#filter the contours
# ratio of width<height<2
# ratio of height-width <2
# At least 1000 pixels
# High numbers of points
biggestContourArea = 0
biggestContour = None
def dilate_cv2(image, iterations=1):
kernel = np.ones((5, 5), np.uint8)
return cv2.dilate(image, kernel, iterations=iterations)
"""
##cutoff of pic ,get RGBvalues
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gradX = cv2.Sobel(gray, ddepth=cv2.CV_32F, dx=1, dy=0, ksize=-1)
gradY = cv2.Sobel(gray, ddepth=cv2.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, 90, 255, cv2.THRESH_BINARY)
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (25, 25))
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)
(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.boxPoints(rect))
# draw a bounding box arounded the detected barcode and display the image
cv2.drawContours(img, [box], -1, (0, 255, 0), 3)
cv2.imshow("Image", img)
cv2.imwrite("contoursImage2.jpg", img)
#cv2.waitKey(0)
Xs = [i[0] for i in box]
Ys = [i[1] for i in box]
x1 = min(Xs)
x2 = max(Xs)
upper_saturation = cv2.getTrackbarPos("upper_saturation", "bars")
upper_value = cv2.getTrackbarPos("upper_value", "bars")
lower_value = cv2.getTrackbarPos("lower_value", "bars")
lower_hue = cv2.getTrackbarPos("lower_hue", "bars")
lower_saturation = cv2.getTrackbarPos("lower_saturation", "bars")
# Kernel to be used for dilation
kernel = numpy.ones((3, 3), numpy.uint8)
upper_hsv = numpy.array([upper_hue, upper_saturation, upper_value])
lower_hsv = numpy.array([lower_hue, lower_saturation, lower_value])
mask = cv2.inRange(inspect, lower_hsv, upper_hsv)
mask = cv2.medianBlur(mask, 3)
mask_inv = 255 - mask
mask = cv2.dilate(mask, kernel, 5)
# The mixing of frames in a combination to achieve the required frame
b = frame[:, :, 0]
g = frame[:, :, 1]
r = frame[:, :, 2]
b = cv2.bitwise_and(mask_inv, b)
g = cv2.bitwise_and(mask_inv, g)
r = cv2.bitwise_and(mask_inv, r)
frame_inv = cv2.merge((b, g, r))
b = init_frame[:, :, 0]
g = init_frame[:, :, 1]
r = init_frame[:, :, 2]
b = cv2.bitwise_and(b, mask)
g = cv2.bitwise_and(g, mask)
