def _fitImg(self, img):
'''
fit perspective and size of the input image to the reference image
'''
img = imread(img, 'gray')
if self.bg is not None:
img = cv2.subtract(img, self.bg)
if self.lens is not None:
img = self.lens.correct(img, keepSize=True)
(H, _, _, _, _, _, _, n_matches) = self.findHomography(img)
H_inv = self.invertHomography(H)
s = self.obj_shape
fit = cv2.warpPerspective(img, H_inv, (s[1], s[0]))
return fit, img, H, H_inv, n_matches
python类subtract()的实例源码
def composite(img1, img2, mask0):
if mask0.shape[2] == 3:
mask2 = cv2.cvtColor(mask0, cv2.COLOR_BGR2GRAY)
else:
mask2 = mask0[:]
mask1 = np.ones((img1.shape[0], img1.shape[1], 3), np.uint8)
mask1[..., 0] = mask2
mask1[..., 1] = mask2
mask1[..., 2] = mask2
white = np.ones((img1.shape[0], img1.shape[1], 3), np.uint8)
white[:] = (0, 0, 0)
invmask = np.zeros((img1.shape[0], img1.shape[1], 3), np.uint8)
invmask = cv2.absdiff(white, mask1)
invmask = cv2.bitwise_not(invmask)
output = np.zeros((img1.shape[0], img1.shape[1], 3), np.uint8)
cv2.subtract(img2, invmask, dst=output)
return output
def detectCellVal(img_rgb,grid_map):
zero = cv2.imread('digits/0.jpg')
one = cv2.imread('digits/1.jpg')
for i in range(14):
for j in range(14):
px = img_rgb[((50*i)+5):((50*i)+45),((50*j)+5):((50*j)+45)]
d1 = cv2.subtract(px,zero[5:45,5:45])
gray = cv2.cvtColor(d1,cv2.COLOR_BGR2GRAY)
ret, mask = cv2.threshold(gray, 220,255,cv2.THRESH_BINARY)
r = not np.any(mask)
if r == True:
grid_map[i][j]=1
d1 = cv2.subtract(px,one[5:45,5:45])
gray = cv2.cvtColor(d1,cv2.COLOR_BGR2GRAY)
ret, mask = cv2.threshold(gray, 220,255,cv2.THRESH_BINARY)
r = not np.any(mask)
if r == True:
grid_map[i][j]=0
return grid_map
############################################################################################
# solveGrid finds the shortest path,
# between valid grid cell in the start row
# and valid grid cell in the destination row
# solveGrid(grid_map)
# Return the route_path and route_length
def animpingpong(self):
obj=self.Object
res=None
for t in obj.OutList:
print t.Label
img=t.ViewObject.Proxy.img.copy()
if res==None:
res=img.copy()
else:
#rr=cv2.subtract(res,img)
#rr=cv2.add(res,img)
aw=0.0+float(obj.aWeight)/100
bw=0.0+float(obj.bWeight)/100
print aw
print bw
if obj.aInverse:
# b umsetzen
ret, mask = cv2.threshold(img, 50, 255, cv2.THRESH_BINARY)
img=cv2.bitwise_not(mask)
rr=cv2.addWeighted(res,aw,img,bw,0)
res=rr
#b,g,r = cv2.split(res)
cv2.imshow(obj.Label,res)
#cv2.imshow(obj.Label +" b",b)
#cv2.imshow(obj.Label + " g",g)
#cv2.imshow(obj.Label + " r",r)
res=img
if not obj.matplotlib:
cv2.imshow(obj.Label,img)
else:
from matplotlib import pyplot as plt
# plt.subplot(121),
plt.imshow(img,cmap = 'gray')
plt.title(obj.Label), plt.xticks([]), plt.yticks([])
plt.show()
self.img=img
def extract_bv(image):
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
contrast_enhanced_green_fundus = clahe.apply(image)
# applying alternate sequential filtering (3 times closing opening)
r1 = cv2.morphologyEx(contrast_enhanced_green_fundus, cv2.MORPH_OPEN, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5)), iterations = 1)
R1 = cv2.morphologyEx(r1, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5)), iterations = 1)
r2 = cv2.morphologyEx(R1, cv2.MORPH_OPEN, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(11,11)), iterations = 1)
R2 = cv2.morphologyEx(r2, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(11,11)), iterations = 1)
r3 = cv2.morphologyEx(R2, cv2.MORPH_OPEN, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(23,23)), iterations = 1)
R3 = cv2.morphologyEx(r3, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(23,23)), iterations = 1)
f4 = cv2.subtract(R3,contrast_enhanced_green_fundus)
f5 = clahe.apply(f4)
# removing very small contours through area parameter noise removal
ret,f6 = cv2.threshold(f5,15,255,cv2.THRESH_BINARY)
mask = np.ones(f5.shape[:2], dtype="uint8") * 255
im2, contours, hierarchy = cv2.findContours(f6.copy(),cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
for cnt in contours:
if cv2.contourArea(cnt) <= 200:
cv2.drawContours(mask, [cnt], -1, 0, -1)
im = cv2.bitwise_and(f5, f5, mask=mask)
ret,fin = cv2.threshold(im,15,255,cv2.THRESH_BINARY_INV)
newfin = cv2.erode(fin, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(3,3)), iterations=1)
# removing blobs of microaneurysm & unwanted bigger chunks taking in consideration they are not straight lines like blood
# vessels and also in an interval of area
fundus_eroded = cv2.bitwise_not(newfin)
xmask = np.ones(image.shape[:2], dtype="uint8") * 255
x1, xcontours, xhierarchy = cv2.findContours(fundus_eroded.copy(),cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
for cnt in xcontours:
shape = "unidentified"
peri = cv2.arcLength(cnt, True)
approx = cv2.approxPolyDP(cnt, 0.04 * peri, False)
if len(approx) > 4 and cv2.contourArea(cnt) <= 3000 and cv2.contourArea(cnt) >= 100:
shape = "circle"
else:
shape = "veins"
if(shape=="circle"):
cv2.drawContours(xmask, [cnt], -1, 0, -1)
finimage = cv2.bitwise_and(fundus_eroded,fundus_eroded,mask=xmask)
blood_vessels = cv2.bitwise_not(finimage)
dilated = cv2.erode(blood_vessels, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(7,7)), iterations=1)
#dilated1 = cv2.dilate(blood_vessels, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(3,3)), iterations=1)
blood_vessels_1 = cv2.bitwise_not(dilated)
return blood_vessels_1
def extract_bv(image):
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
contrast_enhanced_green_fundus = clahe.apply(image)
# applying alternate sequential filtering (3 times closing opening)
r1 = cv2.morphologyEx(contrast_enhanced_green_fundus, cv2.MORPH_OPEN, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5)), iterations = 1)
R1 = cv2.morphologyEx(r1, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5)), iterations = 1)
r2 = cv2.morphologyEx(R1, cv2.MORPH_OPEN, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(11,11)), iterations = 1)
R2 = cv2.morphologyEx(r2, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(11,11)), iterations = 1)
r3 = cv2.morphologyEx(R2, cv2.MORPH_OPEN, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(23,23)), iterations = 1)
R3 = cv2.morphologyEx(r3, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(23,23)), iterations = 1)
f4 = cv2.subtract(R3,contrast_enhanced_green_fundus)
f5 = clahe.apply(f4)
# removing very small contours through area parameter noise removal
ret,f6 = cv2.threshold(f5,15,255,cv2.THRESH_BINARY)
mask = np.ones(f5.shape[:2], dtype="uint8") * 255
im2, contours, hierarchy = cv2.findContours(f6.copy(),cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
for cnt in contours:
if cv2.contourArea(cnt) <= 200:
cv2.drawContours(mask, [cnt], -1, 0, -1)
im = cv2.bitwise_and(f5, f5, mask=mask)
ret,fin = cv2.threshold(im,15,255,cv2.THRESH_BINARY_INV)
newfin = cv2.erode(fin, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(3,3)), iterations=1)
# removing blobs of microaneurysm & unwanted bigger chunks taking in consideration they are not straight lines like blood
# vessels and also in an interval of area
fundus_eroded = cv2.bitwise_not(newfin)
xmask = np.ones(image.shape[:2], dtype="uint8") * 255
x1, xcontours, xhierarchy = cv2.findContours(fundus_eroded.copy(),cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
for cnt in xcontours:
shape = "unidentified"
peri = cv2.arcLength(cnt, True)
approx = cv2.approxPolyDP(cnt, 0.04 * peri, False)
if len(approx) > 4 and cv2.contourArea(cnt) <= 3000 and cv2.contourArea(cnt) >= 100:
shape = "circle"
else:
shape = "veins"
if(shape=="circle"):
cv2.drawContours(xmask, [cnt], -1, 0, -1)
finimage = cv2.bitwise_and(fundus_eroded,fundus_eroded,mask=xmask)
blood_vessels = cv2.bitwise_not(finimage)
dilated = cv2.erode(blood_vessels, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(7,7)), iterations=1)
#dilated1 = cv2.dilate(blood_vessels, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(3,3)), iterations=1)
blood_vessels_1 = cv2.bitwise_not(dilated)
return blood_vessels_1
def detect(self, image, mask = None):
b,g,r = cv2.split(image)
difference = cv2.subtract(np.float32(r), np.float32(b))
_, result = cv2.threshold(difference, Configuration.rb_difference_threshold, 1, cv2.THRESH_BINARY)
return np.uint8(result)
def detect(self, image, mask = None):
b,g,r = cv2.split(image)
difference = cv2.subtract(r, b)
difference = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# ADAPTIVE_THRESH_GAUSSIAN_C or ADAPTIVE_THRESH_MEAN_C
return cv2.adaptiveThreshold(difference, 1, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, Configuration.adaptive_block_size, Configuration.adaptive_threshold)
def subract_test(self):
tmp_frame= self.cap.grab()
_, tmp_frame= self.cap.retrieve()
plastic_golden= cv2.imread('Data/Para/background.png')
test= cv2.subtract(tmp_frame, plastic_golden)
return test
def skeletonize(image, size, structuring=cv2.MORPH_RECT):
# determine the area (i.e. total number of pixels in the image),
# initialize the output skeletonized image, and construct the
# morphological structuring element
area = image.shape[0] * image.shape[1]
skeleton = np.zeros(image.shape, dtype="uint8")
elem = cv2.getStructuringElement(structuring, size)
# keep looping until the erosions remove all pixels from the
# image
while True:
# erode and dilate the image using the structuring element
eroded = cv2.erode(image, elem)
temp = cv2.dilate(eroded, elem)
# subtract the temporary image from the original, eroded
# image, then take the bitwise 'or' between the skeleton
# and the temporary image
temp = cv2.subtract(image, temp)
skeleton = cv2.bitwise_or(skeleton, temp)
image = eroded.copy()
# if there are no more 'white' pixels in the image, then
# break from the loop
if area == area - cv2.countNonZero(image):
break
# return the skeletonized image
return skeleton
def __init__(self, img, bg=None, maxDev=1e-4, maxIter=10, remove_border_size=0,
# feature_size=5,
cameraMatrix=None, distortionCoeffs=None): # 20
"""
Args:
img (path or array): Reference image
Kwargs:
bg (path or array): background image - same for all given images
maxDev (float): Relative deviation between the last two iteration steps
Stop iterative refinement, if deviation is smaller
maxIter (int): Stop iterative refinement after maxIter steps
"""
self.lens = None
if cameraMatrix is not None:
self.lens = LensDistortion()
self.lens._coeffs['distortionCoeffs'] = distortionCoeffs
self.lens._coeffs['cameraMatrix'] = cameraMatrix
self.maxDev = maxDev
self.maxIter = maxIter
self.remove_border_size = remove_border_size
#self.feature_size = feature_size
img = imread(img, 'gray')
self.bg = bg
if bg is not None:
self.bg = getBackground(bg)
if not isinstance(self.bg, np.ndarray):
self.bg = np.full_like(img, self.bg, dtype=img.dtype)
else:
self.bg = self.bg.astype(img.dtype)
img = cv2.subtract(img, self.bg)
if self.lens is not None:
img = self.lens.correct(img, keepSize=True)
# CREATE TEMPLATE FOR PATTERN COMPARISON:
pos = self._findObject(img)
self.obj_shape = img[pos].shape
PatternRecognition.__init__(self, img[pos])
self._ff_mma = MaskedMovingAverage(shape=img.shape,
dtype=np.float64)
self.object = None
self.Hs = [] # Homography matrices of all fitted images
self.Hinvs = [] # same, but inverse
self.fits = [] # all imaged, fitted to reference
self._fit_masks = []
self._refined = False
# TODO: remove that property?
def find_black_center(cv_img, msk):
"""
Given an opencv image containing a dark object on a light background
and a mask of objects to ignore (a gripper, for instance),
return the coordinates of the centroid of the largest object
(excluding those touching edges) and its simplified contour.
If none detected or problem with centroid, return [(-1, -1), False].
"""
# Convert to black and white
(rows, cols, _) = cv_img.shape
grey_img = cv2.cvtColor(cv_img, cv2.COLOR_BGR2GRAY)
grey_img = cv2.bilateralFilter(grey_img, 11, 17, 17)
_, outlines = cv2.threshold(
grey_img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Subtract gripper
msk_out = cv2.subtract(cv2.bitwise_not(outlines), msk)
# Remove objects touching edges
flood_fill_edges(msk_out, 30)
# Find contours
_, contours, _ = cv2.findContours(
msk_out, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
if len(contours) == 0:
return [(-1, -1), False]
# Find largest contour
max_area = 0
for cnt in contours:
area = cv2.contourArea(cnt)
if area > max_area:
contour = cnt
max_area = area
# Approximate contour
epsilon = 0.025 * cv2.arcLength(contour, True)
approx = cv2.approxPolyDP(contour, epsilon, True)
# Find centroid
try:
M = cv2.moments(approx)
cx = int(M['m10']/M['m00'])
cy = int(M['m01']/M['m00'])
return [(cx, cy), approx]
except ZeroDivisionError:
return [(-1, -1), False]
def __findLine(self):
self.__grabImage();
if(self.currentImage is None):
#grabbing image failed
return -2.0
#Convert to Grayscale
img = cv2.cvtColor(self.currentImage, cv2.COLOR_BGR2GRAY)
#Blur to reduce noise
img = cv2.medianBlur(img,25)
#Do Thresholding
h,img = cv2.threshold(img, self.thresh, self.maxValue, cv2.THRESH_BINARY_INV)
img = cv2.blur(img,(2,2))
#Make image smaller
img = cv2.resize(img, (self.horizontalRes, self.verticalRes))
#org_img = cv2.resize(org_img, (self.horizontalRes, self.verticalRes))
#Create skeleton
size = np.size(img)
skel = np.zeros(img.shape,np.uint8)
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
#Do Line Detection
lines = cv2.HoughLinesP(skel,1,np.pi/180,2,
self.hough_minLineLength,self.hough_maxLineGap)
#get minimum and maximum x-coordinate from lines
x_min = self.horizontalRes+1.0
x_max = -1.0;
if(lines != None and len(lines[0]) > 0):
for x1,y1,x2,y2 in lines[0]:
x_min = min(x_min, x1, x2)
x_max = max(x_max, x1, x2)
#cv2.line(org_img,(x1,y1),(x2,y2),(0,255,0),2)
#write output visualization
#cv2.imwrite("output-img.png",org_img);
#find the middle point x of the line and return
#return -1.0 if no lines found
if(x_max == -1.0 or x_min == (self.horizontalRes+1.0) ):
return -1.0 #no line found
else:
return (x_min + x_max) / 2.0
def detect_barcode(imageval):
# load the image and convert it to grayscale
file_bytes = np.asarray(bytearray(imageval), dtype=np.uint8)
img_data_ndarray = cv2.imdecode(file_bytes, cv2.CV_LOAD_IMAGE_UNCHANGED)
gray = cv2.cvtColor(img_data_ndarray, cv2.COLOR_BGR2GRAY)
# compute the Scharr gradient magnitude representation of the images
# in both the x and y direction
gradX = cv2.Sobel(gray, ddepth = cv2.cv.CV_32F, dx = 1, dy = 0, ksize = -1)
gradY = cv2.Sobel(gray, ddepth = cv2.cv.CV_32F, dx = 0, dy = 1, ksize = -1)
# subtract the y-gradient from the x-gradient
gradient = cv2.subtract(gradX, gradY)
gradient = cv2.convertScaleAbs(gradient)
# blur and threshold the image
blurred = cv2.blur(gradient, (9, 9))
(_, thresh) = cv2.threshold(blurred, 225, 255, cv2.THRESH_BINARY)
# construct a closing kernel and apply it to the thresholded image
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (21, 7))
closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)
# perform a series of erosions and dilations
closed = cv2.erode(closed, None, iterations = 4)
closed = cv2.dilate(closed, None, iterations = 4)
# find the contours in the thresholded image, then sort the contours
# by their area, keeping only the largest one
(cnts, _) = cv2.findContours(closed.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
c = sorted(cnts, key = cv2.contourArea, reverse = True)[0]
# compute the rotated bounding box of the largest contour
rect = cv2.minAreaRect(c)
box = np.int0(cv2.cv.BoxPoints(rect))
# draw a bounding box arounded the detected barcode and display the
# image
cv2.drawContours(img_data_ndarray, [box], -1, (0, 255, 0), 3)
# cv2.imshow("Image", image)
#cv2.imwrite("uploads/output-"+ datetime.datetime.now().strftime("%Y-%m-%d-%H:%M:%S") +".jpg",image)
# cv2.waitKey(0)
#outputfile = "uploads/output-" + time.strftime("%H:%M:%S") + ".jpg"
outputfile = "uploads/output.jpg"
cv2.imwrite(outputfile,img_data_ndarray)
