def getQuantizedDiff(fullPath,frameId,queryFrame,width,height,numOfBits):
queryDiffFrames=[]
#queryFrame=getVideoFrameById(fullPath,QueryFrameId)
prevFrame=getVideoFrameById(fullPath,frameId)
nextFrame=getVideoFrameById(fullPath,frameId+2)
if queryFrame== None or prevFrame==None or nextFrame==None:
return None
y=queryFrame
frameWidth=y.shape[0]
frameHeight=y.shape[1]
for i in range(0,frameWidth,width):
for j in range(0,frameHeight,height):
yChannel=y[j:j+height,i:i+width]
blockCoordinates = (i, j)
prevFrameYChannel=prevFrame[j:j+height,i:i+width]
diffYChannel=cv2.subtract(yChannel.astype(np.int16),prevFrameYChannel.astype(np.int16))
flatDiffChannel = np.reshape(diffYChannel, (1, width*height))
quantize(flatDiffChannel, numOfBits, frameId, blockCoordinates,255,-255,queryDiffFrames)
y=nextFrame
prevFrame=queryFrame
for i in range(0,frameWidth,width):
for j in range(0,frameHeight,height):
yChannel=y[j:j+height,i:i+width]
blockCoordinates = (i, j)
prevFrameYChannel=prevFrame[j:j+height,i:i+width]
diffYChannel=cv2.subtract(yChannel.astype(np.int16),prevFrameYChannel.astype(np.int16))
flatDiffChannel = np.reshape(diffYChannel, (1, width*height))
quantize(flatDiffChannel, numOfBits, frameId+1, blockCoordinates,255,-255,queryDiffFrames)
return queryDiffFrames
def ColormapBoundry(image, mean, std, low, high):
newMin = mean - 0.5*(8-low)*std
newMax = mean + 0.5*high*std
newSlope = 255.0/(newMax-newMin)
cv2.subtract(image, newMin, image)
cv2.multiply(image, newSlope, image)
return image.astype("uint8", copy=False)
def read_images(fpath):
lines = utils.read_image_list(fpath)
logger.info('loading data: {}'.format(fpath))
X_data, y_data = [], []
for inst_path, truth_path in lines:
inst, truth = [cv2.imread(p, cv2.IMREAD_GRAYSCALE)
for p in (inst_path, truth_path)]
assert inst is not None and truth is not None, (inst_path, truth_path)
pad_h, pad_w = [x / 2 for x in MODEL_INPUT_SHAPE]
padded = cv2.copyMakeBorder(inst, pad_h, pad_h, pad_w, pad_w,
cv2.BORDER_REFLECT)
m7 = cv2.medianBlur(padded, 7)
m15 = cv2.medianBlur(padded, 15)
c7 = 255 - cv2.subtract(m7, padded)
c15 = 255 - cv2.subtract(m15, padded)
# (c, h, w) layout
input = np.array((padded, m7, m15, c7, c15))
truth = truth.reshape((1,) + truth.shape)
# pad input image
X_data.append(input)
y_data.append(truth)
return X_data, y_data
def online_variance(new_data,curr_var,curr_iter,curr_mean): if curr_iter==1: new_mean = new_data; new_var = 0; return new_mean,new_var; else: pa=cv2.subtract(new_data,curr_mean); pa=cv2.divide(pa,curr_iter,1); new_mean=cv2.add(pa,curr_mean); #new_mean = curr_mean + (new_data - curr_mean)/curr_iter; prev_S = curr_var * (curr_iter - 2); # pd1=cv2.subtract(new_data,curr_mean); pd2=cv2.subtract(new_data,new_mean); pd=cv2.multiply(pd1,pd2); new_S=cv2.add(pd,prev_S); #new_S = prev_S + (new_data - curr_mean) .* (new_data - new_mean); new_var=cv2.divide(new_S,curr_iter-1); #new_var = new_S/(curr_iter - 1); return new_mean,new_var;
def findStartingPoint(video, numberOfFrames):
# the function will go numberOfFrames frames ahead in the video and do a subtraction
# the hope is that the fish will have moved at some point during this time
count = 0
# I don't know a better way to jump ahead so many frames
while count <= numberOfFrames:
# read in the frame for each tick of the loop
ret, frame = video.read()
# grab a frame from the middle. Assume the screens have turned on by then
if count == numberOfFrames / 2:
hsv_middle = convertToHSV(frame)
if count == numberOfFrames:
# grab the last frame in the numberOfFrames window
hsv_end = convertToHSV(frame)
count += 1
if count == 1:
print "initializing"
print "." * (count % 20)
# now we have masked HSV photos from the beginning, middle, and end of the initialization period
# now we have to do some funky subtraction to get rid of the signal that results from the screen being turn on
difference2 = cv2.subtract(hsv_end, hsv_initial)
difference1 = cv2.subtract(hsv_end, hsv_middle)
difference3 = cv2.subtract(difference1, difference2)
# now we have what we want
thresh = cv2.inRange(difference3, np.array([0, 0, 0]), np.array([255, 255, 25]))
# need to invert the colors or else we run into trouble on our call to cv2.findContours
invert = cv2.bitwise_not(thresh)
startingPoint = returnLargeContour(invert)
return (startingPoint)
def morphological_skeleton(img, maxIter=1024):
"""Summary
Args:
img (TYPE): Description
maxIter (int, optional): Description
Returns:
TYPE: Description
"""
# url: http://felix.abecassis.me/2011/09/opencv-morphological-skeleton/
element = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))
height, width = img.shape[:2]
skel = np.zeros((height, width, 1), np.uint8)
temp = np.zeros((height, width, 1), np.uint8)
done = False
nbIteration = 0
while not done:
eroded = cv2.erode(img, element)
temp = cv2.dilate(eroded, element)
cv2.subtract(img, temp, temp)
cv2.bitwise_or(skel, temp, skel)
img = eroded
nbIteration += 1
done = (cv2.countNonZero(img) == 0) or (nbIteration >= maxIter)
return skel, nbIteration
def get_LaplacePyramid(name1,name2,size):
"""
Function that creates Laplacian pyramids of two images
name1, name2: names of files containing the images
size: number of levels in the lapalacian pyramid
"""
# We first get the gaussian pyramids of each image. Notice
# the function written before is invoked here
gaussPy1,gaussPy2 = get_GaussPyrimids(name1,name2,size)
# We create a list of Laplacian pyramids; we initialize each list
# with the deeper level (smallest image) of each Gaussian pyramid
Lapl1 = [gaussPy1[size]]; Lapl2 = [gaussPy2[size]]
# We loop over each element of the Gaussian pyramid. Notice the
# looping begins with the smallest image in the Gaussian pyramid
# (deepest level)
# For each element of the Gaussian pyramid...
for k in range(size,0,-1):
# Increase size of images in turn...
G1 = cv2.pyrUp(gaussPy1[k]); G2 = cv2.pyrUp(gaussPy2[k])
#print G1.shape, G2.shape
# ... take respective differences with images in turn ...
L1 = cv2.subtract(gaussPy1[k-1],G1); L2 = cv2.subtract(gaussPy2[k-1],G2)
# ... and append to the list of Laplacian pyramids
#print k , L1.shape, L2.shape
Lapl1.append(L1); Lapl2.append(L2)
return Lapl1,Lapl2
def mask_thinning(img):
"""
returns the skeleton (thinned image) of a mask.
This uses `thinning.guo_hall_thinning` if available and otherwise falls back
to a slow python implementation taken from
http://opencvpython.blogspot.com/2012/05/skeletonization-using-opencv-python.html
"""
try:
import thinning
except ImportError:
# thinning module was not available and we use a python implementation
size = np.size(img)
skel = np.zeros(img.shape, np.uint8)
kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))
while True:
eroded = cv2.erode(img, kernel)
temp = cv2.dilate(eroded, kernel)
cv2.subtract(img, temp, temp)
cv2.bitwise_or(skel, temp, skel)
img = eroded
zeros = size - cv2.countNonZero(img)
if zeros==size:
break
else:
# use the imported thinning algorithm
skel = thinning.guo_hall_thinning(img)
return skel
def main():
displayer = Displayer()
A = cv2.cvtColor(fetch_image('apple.jpg'), cv2.COLOR_BGR2RGB)
B = cv2.cvtColor(fetch_image('orange.jpg'), cv2.COLOR_BGR2RGB)
# generate Gaussian pyramid for A
G = A.copy()
gpA = [G]
for i in xrange(6):
G = cv2.pyrDown(G)
gpA.append(G)
# generate Gaussian pyramid for B
G = B.copy()
gpB = [G]
for i in xrange(6):
G = cv2.pyrDown(G)
gpB.append(G)
# generate Laplacian Pyramid for A
lpA = [gpA[5]]
for i in xrange(5,0,-1):
GE = cv2.pyrUp(gpA[i])
L = cv2.subtract(gpA[i-1],GE)
lpA.append(L)
# generate Laplacian Pyramid for B
lpB = [gpB[5]]
for i in xrange(5,0,-1):
GE = cv2.pyrUp(gpB[i])
L = cv2.subtract(gpB[i-1],GE)
lpB.append(L)
# Now add left and right halves of images in each level
LS = []
for la,lb in zip(lpA,lpB):
rows,cols,dpt = la.shape
ls = np.hstack((la[:,0:cols/2], lb[:,cols/2:]))
LS.append(ls)
# now reconstruct
ls_ = LS[0]
for i in xrange(1,6):
ls_ = cv2.pyrUp(ls_)
displayer.add_image(ls_, i)
ls_ = cv2.add(ls_, LS[i])
# image with direct connecting each half
real = np.hstack((A[:,:cols/2],B[:,cols/2:]))
displayer.add_image(ls_, "pyramid")
#displayer.add_image(real, "stacked")
#for i in range(len(lpA)):
# displayer.add_image(LS[i], i)
displayer.display()
def get_object_grass(image):
# outputx = cv2.resize(output,(649,486))
# cv2.imshow('image',outputx)
# cv2.waitKey(0)
# cv2.destroyAllWindows()
B = image[:,:,0]
G = image[:,:,1]
R = image[:,:,2]
R_ = cv2.multiply(R, 0.25)
G = cv2.multiply(G, 0.25)
B = cv2.multiply(B, 0.5)
R = cv2.subtract(R, R_)
R = cv2.subtract(R, G)
new_image = cv2.subtract(R, B)
#gray = cv2.add(cv2.add(image[:,:,2],-image[:,:,1]/2),-image[:,:,0]/2)
# output = cv2.resize(new_image,(649,486))
# cv2.imshow('image',output)
# cv2.waitKey(0)
# cv2.destroyAllWindows()
gray = cv2.medianBlur(new_image,3)
#gray = cv2.bilateralFilter(gray,5,75,75)
# find the contours in the edged image and keep the largest one;
_, cnts, _ = cv2.findContours(gray.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
cnts = sorted(cnts, key = cv2.contourArea, reverse = True)[:10]
for c in cnts:
# approximate the contour
marker = cv2.minAreaRect(c)
x,y,w,h = cv2.boundingRect(c)
coords = (x,y,w,h)
M = cv2.moments(c)
cx,cy = int(M['m10']/M['m00']), int(M['m01']/M['m00'])
center = (cx,cy)
colors = get_colors(image,coords)
#print(marker)
area = marker[1][0]*marker[1][1]
if ((abs(marker[2]) > 60 or abs(marker[2]) < 40) and area > 7000 and area < 250000
and marker[1][0]> 50 and marker[1][1] > 50 and colors['blue']<200
):
return (marker,coords,center)
else:
continue
# if our approximated contour has four points, then
# we can assume that we have found our screen
return (((0, 0), (0, 0), 0),(0,0,0,0),(0,0))
def rowStitch(imageA,imageB,fx,switch):
##################################################
# finding information between stiched row images #
##################################################
# print " rowStitch function : finding homography"
res_max=-1
xA1=-1
yA1=-1
intervalx=16
intervaly=16
temp=imageB[:,:int(imageB.shape[1]*0.35)] #temp
if switch==1:
temp = cv2.Laplacian(temp,cv2.CV_32F)
if switch==0:
sobelx = cv2.Sobel(temp,cv2.CV_32F,1,0,ksize=11)
sobely = cv2.Sobel(temp,cv2.CV_32F,0,1,ksize=11)
temp=sobelx+sobely # to get gradient of image in both direction
temp=cv2.subtract(temp,cv2.mean(temp))
score=[]
coor=[]
steps=16
intervaly=imageA.shape[0]-100
for i in range(imageA.shape[1]-int(0.35*imageB.shape[1]),imageA.shape[1],steps):
for j in range(0,100,steps):
template=imageA[j:j+intervaly,i:i+intervalx] #template
if switch==1:
template = cv2.Laplacian(template,cv2.CV_32F)
if switch==0:
sobelx = cv2.Sobel(template,cv2.CV_32F,1,0,ksize=11)
sobely = cv2.Sobel(template,cv2.CV_32F,0,1,ksize=11)
template=sobelx+sobely#to get gradient of image
template=cv2.subtract(template,cv2.mean(template))
res=cv2.matchTemplate(temp,template,3)
_, val, _, loc = cv2.minMaxLoc(res)#val stores highest correlation from temp, loc stores coresponding starting location in temp
if(val > res_max):
res_max=val
xA1=i
yA1=j
xB1=loc[0]
yB1=loc[1]
# print(val)
# print res_max,"res_max"
pointsA=[[xA1,yA1],[xA1+intervalx,yA1],[xA1,yA1+intervaly],[xA1+intervalx,yA1+intervaly]]
pointsB=[[xB1,yB1],[xB1+intervalx,yB1],[xB1,yB1+intervaly],[xB1+intervalx,yB1+intervaly]]
xB1=xB1*(1/fx)
yB1=yB1*(1/fx)
xA1=xA1*(1/fx)
yA1=yA1*(1/fx)
pointsA=[[xA1,yA1],[xA1+intervalx,yA1],[xA1,yA1+intervaly],[xA1+intervalx,yA1+intervaly]]
pointsB=[[xB1,yB1],[xB1+intervalx,yB1],[xB1,yB1+intervaly],[xB1+intervalx,yB1+intervaly]]
H,mask=cv2.findHomography(np.asarray(pointsB,float),np.asarray(pointsA,float),cv2.RANSAC,3)
return H,res_max
def gen_multi_channel(padded):
m7 = cv2.medianBlur(padded, 7)
m15 = cv2.medianBlur(padded, 15)
c7 = 255 - cv2.subtract(m7, padded)
c15 = 255 - cv2.subtract(m15, padded)
# (c, h, w) layout
input = np.array((padded, m7, m15, c7, c15))
return input
def removeNonRed(img):
img = cv2.cvtColor(img,cv2.COLOR_HSV2BGR)
b,g,r = cv2.split(img)
deltaB = cv2.subtract(r,b)
deltaG = cv2.subtract(r,g)
r2 = cv2.bitwise_and(r,r,mask=deltaB)
g2 = cv2.bitwise_and(r2,r2,mask=deltaG)
img = cv2.merge((r2,r2,r2))
#cv2.imshow('test',img)
img = cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
return img;
def problem_7(imgA,imgB):
#Another solution using image pyramids
#For Gaussain Pyramids
diffLevels_A=imgA.copy()
GaussPyr_A=[]
GaussPyr_A.append(diffLevels_A) # Gaussian Pyramids for imgA
for itr in range(4):
diffLevels_A=cv2.pyrDown(diffLevels_A)
GaussPyr_A.append(diffLevels_A)
diffLevels_B=imgB.copy() # Gaussian Pyramids for imgB
GaussPyr_B=[];GaussPyr_B.append(diffLevels_B)
for itr in range(4):
diffLevels_B=cv2.pyrDown(diffLevels_B)
GaussPyr_B.append(diffLevels_B)
#For Laplacian Pyramids (Laplacian pyramids will be appended from lowest resolution to highest resolution)
LaplacePyr_A=[GaussPyr_A[3]] #Since we start building the Laplacian pyramids from the bottom
for itr in range(3,0,-1):
temp_A=cv2.pyrUp(GaussPyr_A[itr])
d=(GaussPyr_A[itr-1].shape[0],GaussPyr_A[itr-1].shape[1],3)
temp_A=np.resize(temp_A,d)
LDiff=cv2.subtract(GaussPyr_A[itr-1],temp_A) #Bcoz "GaussPyr_A[itr-1]" has a higher resolution than "GaussPyr_A[itr]"
LaplacePyr_A.append(LDiff)
LaplacePyr_B=[GaussPyr_B[3]]
for itr in range(3,0,-1):
temp_B=cv2.pyrUp(GaussPyr_B[itr])
d=(GaussPyr_B[itr-1].shape[0],GaussPyr_B[itr-1].shape[1],3)
temp_B=np.resize(temp_B,d)
LDiff=cv2.subtract(GaussPyr_B[itr-1],temp_B)
LaplacePyr_B.append(LDiff)
#Blending the two Laplacian Pyramids (all resolution levels)
Blend=[]
#Note: Blend will have pyramids blended from lower to higher resolution
for LapA,LapB in zip(LaplacePyr_A,LaplacePyr_B):
Lr,Lc,dimension=LapA.shape
temp=np.hstack((LapA[:,0:Lc/2],LapB[:,Lc/2:]))
# Laplacian pyramid at each level is blended. This will help reconstruction of image
Blend.append(temp)
#Reconstructing the Image from the pyramids (Laplcian to Gaussian)
final_temp=Blend[0]
for itr in range(1,4):
final_temp=cv2.pyrUp(final_temp)
d=(Blend[itr].shape[0],Blend[itr].shape[1],3)
final_temp=np.resize(final_temp,d)
final_temp=cv2.add(final_temp,Blend[itr]) #L[i]=G[i]-G[i-1]..diff of gaussian..So, G[i]=L[i]+G[i-1]
final_img=np.hstack((imgA[:,0:Lc/2],imgB[:,Lc/2:]))
cv2.imshow("Final Blended Image",final_temp)
cv2.imwrite("P_7.jpg",final_temp)
cv2.waitKey(0)
def blend(image1, image2, mask):
# generate Gaussian pyramid for image 1
G = image1.astype(np.float32)
gpA = [G]
for i in xrange(6):
G = cv2.pyrDown(G)
gpA.append(G.astype(np.float32))
# generate Gaussian pyramid for image 2
G = image2.astype(np.float32)
gpB = [G]
for i in xrange(6):
G = cv2.pyrDown(G)
gpB.append(G.astype(np.float32))
# generate Gaussian pyramid for mask
G = mask.astype(np.float32)
gpM = [G]
for i in xrange(6):
G = cv2.pyrDown(G)
gpM.append(G.astype(np.float32))
# generate Laplacian Pyramid for image 1
lpA = [gpA[5]]
for i in xrange(5,0,-1):
rows,cols = gpA[i-1].shape[:2]
GE = cv2.pyrUp(gpA[i])[:rows,:cols]
L = cv2.subtract(gpA[i-1],GE)
lpA.append(L)
# generate Laplacian Pyramid for image 2
lpB = [gpB[5]]
for i in xrange(5,0,-1):
rows,cols = gpB[i-1].shape[:2]
GE = cv2.pyrUp(gpB[i])[:rows,:cols]
L = cv2.subtract(gpB[i-1],GE)
lpB.append(L)
# Now add the images with mask
LS = []
length = len(lpA)
for i in range(length):
LS.append(lpB[i]*gpM[length-i-1] + lpA[i]*(1-gpM[length-i-1]))
# now reconstruct
ls_ = LS[0]
for i in xrange(1,6):
rows,cols = LS[i].shape[:2]
ls_ = cv2.pyrUp(ls_)[:rows,:cols]
ls_ = cv2.add(ls_, LS[i])
ls_ = np.clip(ls_, 0, 255)
return ls_.astype(np.uint8)
def test_on_video(net, vid_fn, out_fn):
# capture
# cap = cv.VideoCapture(0)
cap = cv.VideoCapture(vid_fn)
fps = cap.get(cv.cv.CV_CAP_PROP_FPS)
ret, img = cap.read()
# writer
orig_shape = (227, 227) # img.shape
fourcc = cv.cv.CV_FOURCC(*'XVID')
wri = cv.VideoWriter(out_fn, fourcc, fps, orig_shape)
frame = 0
print('before read')
## print(cap)
## print(fps)
## print(vid_fn)
## print(cap.isOpened())
while(cap.isOpened()):
ret, img = cap.read()
img_mean, img_std = cv.meanStdDev(img)
r = cv.subtract(img[:,:,0], img_mean[0])
g = cv.subtract(img[:,:,1], img_mean[1])
b = cv.subtract(img[:,:,2], img_mean[2])
r = cv.divide(r, img_std[0])
g = cv.divide(g, img_std[1])
b = cv.divide(b, img_std[2])
test_img = np.zeros(img.shape)
test_img[:,:,0] = r
test_img[:,:,1] = g
test_img[:,:,2] = b
if ret:
img = draw_joints_all(img, test_img, net)
img = cv.resize(img, (orig_shape[1], orig_shape[0]))
wri.write(img)
cv.imshow("frame", img)
frame += 1
print frame
if cv.waitKey(1) & 0xFF == ord('q'):
break
else:
print 'finished'
break
cap.release()
wri.release()
cv.destroyAllWindows()
def mask_thinning(img, method='auto'):
"""
returns the skeleton (thinned image) of a mask.
This uses `thinning.guo_hall_thinning` if available and otherwise falls back
to a slow python implementation taken from
http://opencvpython.blogspot.com/2012/05/skeletonization-using-opencv-python.html
Note that this implementation is not equivalent to guo_hall implementation
"""
# try importing the thinning module
try:
import thinning
except ImportError:
thinning = None
# determine the method to use if automatic method is requested
if method == 'auto':
if thinning is None:
method = 'python'
else:
method = 'guo-hall'
# do the thinning with the requested method
if method == 'guo-hall':
if thinning is None:
raise ImportError('Using the `guo-hall` method for thinning '
'requires the `thinning` module, which could not '
'be imported.')
skel = thinning.guo_hall_thinning(img)
elif method =='python':
# thinning module was not available and we use a python implementation
size = np.size(img)
skel = np.zeros(img.shape, np.uint8)
kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))
while True:
eroded = cv2.erode(img, kernel)
temp = cv2.dilate(eroded, kernel)
cv2.subtract(img, temp, temp)
cv2.bitwise_or(skel, temp, skel)
img = eroded
zeros = size - cv2.countNonZero(img)
if zeros==size:
break
else:
raise ValueError('Unknown thinning method `%s`' % method)
return skel
def laplacian_pyramid_blending(img_in1, img_in2):
# Write laplacian pyramid blending codes here
img_in1 = img_in1[:, :img_in1.shape[0]]
img_in2 = img_in2[:img_in1.shape[0], :img_in1.shape[0]]
# generate Gaussian pyramid for A
G = img_in1.copy()
gpA = [G]
for i in xrange(6):
G = cv2.pyrDown(G)
gpA.append(G)
# generate Gaussian pyramid for B
G = img_in2.copy()
gpB = [G]
for i in xrange(6):
G = cv2.pyrDown(G)
gpB.append(G)
# generate Laplacian Pyramid for A
lpA = [gpA[5]]
for i in xrange(5, 0, -1):
GE = cv2.pyrUp(gpA[i])
L = cv2.subtract(gpA[i - 1], GE)
lpA.append(L)
# generate Laplacian Pyramid for B
lpB = [gpB[5]]
for i in xrange(5, 0, -1):
GE = cv2.pyrUp(gpB[i])
L = cv2.subtract(gpB[i - 1], GE)
lpB.append(L)
# Now add left and right halves of images in each level
LS = []
for la, lb in zip(lpA, lpB):
rows, cols, dpt = la.shape
ls = np.hstack((la[:, 0:cols / 2], lb[:, cols / 2:]))
LS.append(ls)
# now reconstruct
ls_ = LS[0]
for i in xrange(1, 6):
ls_ = cv2.pyrUp(ls_)
ls_ = cv2.add(ls_, LS[i])
img_out = ls_ # Blending result
return True, img_out
def blend(image, tilesize):
b=1
a = len(image)
l = len(image[0])
p= image[0:tileSize,30:tileSize]
for j in range(0,len(image)-tileSize,tileSize):
for k in range(0,len(image[0])-tileSize,tileSize):
A = image[j+tileSize-3:j+tileSize,k+tileSize-3:k+tileSize]
G = A.copy()
gpA = [G]
for i in xrange(3):
G = cv2.pyrDown(G)
gpA.append(G)
B = image[j:j+tileSize,k+tileSize:k+tileSize+tileSize]
G = B.copy()
gpB = [G]
for i in xrange(3):
G = cv2.pyrDown(G)
gpB.append(G)
lpA = [gpA[2]]
for i in xrange(2,0,-1):
GE = cv2.pyrUp(gpA[i])
b = GE[0:len(gpA[i-1]),0:len(gpA[i-1])]
L = cv2.subtract(gpA[i-1],b)
lpA.append(L)
lpB = [gpB[2]]
for i in xrange(2,0,-1):
GE = cv2.pyrUp(gpB[i])
b = GE[0:len(gpB[i-1]),0:len(gpB[i-1])]
L = cv2.subtract(gpB[i-1],b)
lpB.append(L)
# Now add left and right halves of images in each level
LS = []
for la,lb in zip(lpA,lpB):
rows,cols,dpt = la.shape
p =la[:,0:2]
pp= lb[:,cols/2:]
ls = np.hstack((la[:,0:2], lb[:,cols/2:]))
LS.append(ls)
ls_ = LS[0]
# now reconstruct
for i in xrange(1,3):
ls_ = cv2.pyrUp(ls_)
b = ls_[0:len(LS[i]),0:len(LS[i])]
ls_ = cv2.add(b, LS[i])
#cv2.imwrite('Pyramid_blending2.jpg',ls_)
image[j+tileSize-2:j+tileSize-2+tileSize,k+tileSize-2:k+tileSize-2+tileSize] = ls_
return image
def findLaserImage(image, background, threshold, mask=None):
diff = cv2.subtract(image, background)
#cv2.imwrite('diff.png', diff)
channels = cv2.split(diff)
red = channels[2]
#red = cv2.addWeighted(channels[0], 1/3.0, channels[1], 1/3.0, 0)
#red = cv2.addWeighted(red, 1.0, channels[2], 1.0, 0)
cv2.imwrite('red.png', red)
if mask is not None:
cv2.subtract(red, mask, red)
retval, mask = cv2.threshold(red, threshold, 255, cv2.THRESH_BINARY)
result = mask
result = cv2.medianBlur(mask, 7)
#cv2.imwrite('laser-mask.png', result)
return result
def shift_hueCV2(frame, shift, mode="normal"):
#shift hue by desired amount
frame += shift
if mode=="normal":
pass
elif mode=="absolute":
frame = cv2.subtract(127 , cv2.absdiff(frame,127))
frame = cv2.multiply(2,frame)
elif mode=="inverted":
frame = cv2.subtract(255-frame)
return frame
def process_frame(self, frame):
if self.background is None:
self.background = np.zeros(frame.shape, dtype=np.int16)
if self.frame is not None:
mframe = (frame + self.frame) >> 1
else:
mframe = frame
self.frame = frame
frame = mframe
mean = int(cv2.mean(self.background)[0])
frame = cv2.subtract(frame, self.background - mean)
frame[frame < 0] = 0
frame = cv2.subtract(np.uint16(frame), mean)
#frame = cv2.subtract(np.uint16(frame), np.uint16(self.background))
return np.int16(frame)
def process_frame(frame):
""" Process frame based on user input """
hue = cv2.getTrackbarPos(tbar_channel_select_name, win_debug_name)
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
frame = frame[:,:,0]
#shift hue by desired amount
frame += hue
mode = 'normal'
if mode=="normal":
pass
elif mode=="absolute":
frame = cv2.subtract(127 , cv2.absdiff(frame,127))
frame = cv2.multiply(2,frame)
elif mode=="inverted":
frame = cv2.subtract(255-frame)
block_size = cv2.getTrackbarPos(tbar_block_size_name, win_debug_name)
threshold = cv2.getTrackbarPos(tbar_thresh_name, win_debug_name)
if not block_size % 2 == 1:
block_size += 1
cv2.setTrackbarPos(tbar_block_size_name, win_debug_name, block_size)
if block_size <= 1:
block_size = 3
cv2.setTrackbarPos(tbar_block_size_name, win_debug_name, block_size)
adaptive = cv2.adaptiveThreshold(frame, 255,
cv2.ADAPTIVE_THRESH_MEAN_C,
cv2.THRESH_BINARY_INV,
block_size,
threshold)
if draw_contours:
cframe = np.zeros((frame.shape[0], frame.shape[1], 3), np.uint8)
contours, hierarchy = cv2.findContours(adaptive,
cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(cframe, contours, -1, (255, 255, 255), 3)
return cframe
else:
return adaptive
def skeletonization(img):
'''
http://opencvpython.blogspot.ru/2012/05/skeletonization-using-opencv-python.html
'''
img = img.copy()
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
size = np.size(img)
skel = np.zeros(img.shape, np.uint8)
# ret, img = cv2.threshold(img, 127, 255, 0)
img = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 7, 2)
element = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))
while True:
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:
break
cv2.imwrite("skel.png", skel)
return skel
def centroMasa(self,color):
lower = color
upper = color
lower = cv2.subtract(lower,Captura.errorColor)
upper = cv2.add(upper,Captura.errorColor)
img = cv2.blur(self.img,(10,10))
hsv_img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
thres = cv2.inRange(hsv_img, lower, upper)
moments = cv2.moments(thres, 0)
area = moments['m00']
vector = None
if(area > 1000):
x = (np.uint32)(moments['m10']/area)
y = (np.uint32)(moments['m01']/area)
vector = [x, y]
return vector
def describe(self, image):
image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
features = []
(h, w) = image.shape[:2]
(cX, cY) = (int(w * 0.5), int(h * 0.5))
segments = [(0, cX, 0, cY), (cX, w, 0, cY), (cX, w, cY, h), (0, cX, cY, h)]
(xL, yL) = (int(w * 0.75) / 2, int(h * 0.75) / 2)
elli = np.zeros(image.shape[:2], dtype = 'uint8')
cv2.ellipse(elli, (cX, cY), (xL, yL), 0, 0, 360, 255, -1)
for (x0, x1, y0, y1) in segments:
rect = np.zeros(image.shape[:2], dtype = 'uint8')
cv2.rectangle(rect, (x0, y0), (x1, y1), 255, -1)
rect = cv2.subtract(rect, elli)
hist = self.histogram(image, rect)
features.extend(hist)
hist = self.histogram(image, elli)
features.extend(hist)
return features
def rgbfilter_white(self, image,image_bg):
rd = 2
rd2 = 100
diff = cv2.subtract(cv2.cvtColor(image,cv2.COLOR_BGR2GRAY),image_bg)
res = cv2.compare(diff,rd,cv2.CMP_GT)
res1 = cv2.compare(diff,rd2,cv2.CMP_LT)
return cv2.bitwise_and(res,res1)
def water(img, thresh):
kernel = np.ones((3,3),np.uint8)
opening = cv2.morphologyEx(thresh,cv2.MORPH_OPEN,kernel, iterations = 2)
# sure background area
sure_bg = cv2.dilate(opening,kernel,iterations=3)
# Finding sure foreground area
dist_transform = cv2.distanceTransform(opening,2,5)
ret, sure_fg = cv2.threshold(dist_transform,0.7*dist_transform.max(),255,0)
# Finding unknown region
sure_fg = np.uint8(sure_fg)
unknown = cv2.subtract(sure_bg,sure_fg)
# Marker labelling
ret, markers = cv2.connectedComponents(sure_fg)
# Add one to all labels so that sure background is not 0, but 1
markers += 1
# Now, mark the region of unknown with zero
markers[unknown==255] = 0
markers = cv2.watershed(img,markers)
img[markers == -1] = [255,0,0]
return sure_fg, sure_bg, markers, img
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 get(self):
r1 = cv2.getTrackbarPos('r1', self.windowname)
r2 = cv2.getTrackbarPos('r2', self.windowname)
r3 = cv2.getTrackbarPos('r3', self.windowname)
l1 = cv2.getTrackbarPos('l1', self.windowname)
l2 = cv2.getTrackbarPos('l2', self.windowname)
l3 = cv2.getTrackbarPos('l3', self.windowname)
# Remove light
h, s, v = cv2.split(self.orig_hsv)
kernel = np.ones((9*2+1, 9*2+1), np.uint8)
v_dilated = cv2.dilate(v, kernel, iterations = 1)
v_out = cv2.subtract(v_dilated, v)
#ret, v_t = cv2.threshold(v, l3, r3, cv2.THRESH_TRUNC)
# Binarization
#ret, ots = cv2.threshold(v_out, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
#et, ots2 = cv2.threshold(v, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
#self.hist(v_out)
#for i in xrange(l1):
# ret, mask = cv2.threshold(v_out, l2, 255, cv2.THRESH_TOZERO)
# v_out = cv2.bitwise_and(v_out, mask)
# v_out = cv2.add(v_out, (v_out/l3))
v_out = cv2.bitwise_not(v_out)
th3 = cv2.adaptiveThreshold(v, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY,l1*2+1,l2)
th4 = cv2.adaptiveThreshold(v_out, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY,l1*2+1,l2)
return [v_out, th3, th4]
dilation2 = cv2.dilate(g, kernel2)
# plot all the images and their histograms
gradient_image = np.array(dilation1) - np.array(dilation2)
cv2.imshow('gradient_image', gradient_image)
#blur = cv2.GaussianBlur(gradient_image,(5,5),0)
#cv2.imshow('blur',blur)
#ret3,gradient_image_th = cv2.threshold(gradient_image,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
#cv2.imshow('image',gradient_image_th)
#gradient_image_th_eroded=cv2.erode(gradient_image_th,kernel3,iterations = 1)
#res = cv2.bitwise_and(gradient_image_th,gradient_image_th, mask= gradient_image)
#cv2.imshow('final',res);
#gradient_image_th_eroded_erode=cv2.erode(gradient_image_th_eroded,kernel3,iterations = 1)
#cv2.imshow('gradient_image_th_eroded',gradient_image_th_eroded)
#cv2.imshow('gradient_image_th_eroded_erode',gradient_image_th_eroded_erode)
#opening = cv2.morphologyEx(gradient_image_th_eroded, cv2.MORPH_OPEN, kernel1)
#closing = cv2.morphologyEx(gradient_image_th_eroded, cv2.MORPH_CLOSE, kernel1)
#cv2.imshow('Opening',opening)
#cv2.imshow('Closing',closing)
#print(np.array(gradient_image_th).shape)
#print(np.array(bv002).shape)
gradient_image_th_wbv = cv2.subtract(gradient_image, g1)
cv2.imshow('gradient_image_th_wbv', gradient_image_th_wbv)
gradient_image_th_wbvod = cv2.subtract(gradient_image_th_wbv, g2)
#im = cv2.imfill(gradient_image_th,'holes');
cv2.imshow('gradient_image_th_wbvod', gradient_image_th_wbvod)
cv2.waitKey(0)
cv2.destroyAllWindows()
import cv2
import numpy as np
# Image Airthmetics
img= cv2.imread("download.jpg")
cv2.imshow("Orgnal", img)
cv2.waitKey(0)
M=np.ones(img.shape, dtype="uint8") *150
# Alternate method for matrix
# M1=np.zeros(img.shape, dtype="uint8") + 150
added=cv2.add(img, M)
cv2.imshow("Added", added)
substracted=cv2.subtract(img, M)
cv2.imshow("Substracted", substracted)
mul=cv2.multiply(img, M)
cv2.imshow("Mul", mul)
cv2.waitKey(0)
cv2.destroyAllWindows()
img = cv2.imread(path)
img, scale = resize_im(img, scale=1000, max_scale=1000)
#cv2.imshow('original' , img)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#cv2.imshow('gray', gray)
# clahe = cv2.createCLAHE(clipLimit=2, tileGridSize=(100, 100))
# cl1 = clahe.apply(gray)
# cv2.imshow('clahe', cl1)
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)
gradient = cv2.subtract(gradX, gradY)
gradient = cv2.convertScaleAbs(gradient)
#cv2.imshow("g", gradient)
blurred = cv2.blur(gradient, (3, 3)) # 9*9的核做模糊
(_, thresh) = cv2.threshold(blurred, 150, 255, cv2.THRESH_BINARY)
#cv2.imshow("binary", thresh)
closed = cv2.erode(thresh, None, iterations=3)
closed = cv2.dilate(closed, None, iterations=2)
#cv2.imshow("f", closed)
thresh = closed
# 获得水平和竖直方向的像素均值
h, w = thresh.shape
hor_mean = [np.array(thresh[i, :]).mean() for i in range(h)]
cv2.THRESH_BINARY, 11, 2)
plt.figure(figsize=(20, 20))
# dilation - erode with / without blur
kernel = np.ones((3, 3), np.uint8)
dil = cv2.dilate(blur, kernel, iterations=1)
ero = cv2.erode(blur, kernel, iterations=1)
morph = dil - ero
kernel2 = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
topHat = cv2.morphologyEx(imgray, cv2.MORPH_TOPHAT, kernel2)
blackHat = cv2.morphologyEx(imgray, cv2.MORPH_BLACKHAT, kernel2)
imgGrayscalePlusTopHat = cv2.add(imgray, topHat)
subtract = cv2.subtract(imgGrayscalePlusTopHat, blackHat)
thr2 = cv2.adaptiveThreshold(subtract, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
cv2.THRESH_BINARY, 11, 2)
plt.figure(figsize=(12, 8))
plt.subplot(221), plt.imshow(blur, 'gray')
plt.title("blurred")
plt.subplot(222), plt.imshow(thr, 'gray')
plt.title("after Adaptive Threshold")
plt.subplot(223), plt.imshow(morph, 'gray')
plt.title("Dilation - Erode (with blur)")
plt.subplot(224), plt.imshow(thr2, 'gray')
plt.title("top-black AT")
plt.savefig("Preprocess")
#plt.show()
# canny 하지 않고
def get_license_plate_char(self, image):
# Read image
img_ori = image
if type(image) == str:
if platform.system().lower() == 'windows' and image[0] == '~':
image = os.environ['USERPROFILE'] + image[1:]
image = os.path.abspath(image)
img_ori = cv2.imread(image)
if type(img_ori) is not np.ndarray:
raise ValueError('ERROR: invalid image!')
height, width, channel = img_ori.shape
# Convert image to grayscale
gray = cv2.cvtColor(img_ori, cv2.COLOR_BGR2GRAY)
# Maximize constrast
structuringElement = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
imgTopHat = cv2.morphologyEx(gray, cv2.MORPH_TOPHAT,
structuringElement)
imgBlackHat = cv2.morphologyEx(gray, cv2.MORPH_BLACKHAT,
structuringElement)
imgGrayscalePlusTopHat = cv2.add(gray, imgTopHat)
gray = cv2.subtract(imgGrayscalePlusTopHat, imgBlackHat)
# Thresholding
img_blurred = cv2.GaussianBlur(gray, ksize=(5, 5), sigmaX=0)
usingAdaptive = True
if usingAdaptive:
img_thresh = cv2.adaptiveThreshold(
img_blurred,
maxValue=255.0,
adaptiveMethod=cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
thresholdType=cv2.THRESH_BINARY_INV,
blockSize=19,
C=12)
else:
_, img_thresh = cv2.threshold(img_blurred,
thresh=0,
maxval=255,
type=cv2.THRESH_BINARY_INV
| cv2.THRESH_OTSU)
# Find contours
contours, _ = cv2.findContours(img_thresh,
mode=cv2.RETR_LIST,
method=cv2.CHAIN_APPROX_SIMPLE)
# Prepare data
contours_dict = []
for contour in contours:
x, y, w, h = cv2.boundingRect(contour)
# instert to dict
contours_dict.append({
'contour': contour,
'x': x,
'y': y,
'w': w,
'h': h,
'cx': x + (w / 2),
'cy': y + (h / 2)
})
# Select candidates by char size
MIN_AREA = 80
MIN_WIDTH, MIN_HEIGHT = 2, 8
MIN_RATIO, MAX_RATIO = 0.25, 1.0
possible_contours = []
cnt = 0
for d in contours_dict:
area = d['w'] * d['h']
ratio = d['w'] / d['h']
if area > MIN_AREA \
and d['w'] > MIN_WIDTH and d['h'] > MIN_HEIGHT \
and MIN_RATIO < ratio < MAX_RATIO:
d['idx'] = cnt
cnt += 1
possible_contours.append(d)
# Select candidates by arrangement of contours
MAX_DIAG_MULTIPLYER = 5 # 5
MAX_ANGLE_DIFF = 12.0 # 12.0
MAX_AREA_DIFF = 0.5 # 0.5
MAX_WIDTH_DIFF = 0.8 # 0.8
MAX_HEIGHT_DIFF = 0.2 # 0.2
MIN_N_MATCHED = 5 # 3
def find_chars(contour_list):
matched_result_idx = []
for d1 in contour_list:
matched_contours_idx = []
for d2 in contour_list:
if d1['idx'] == d2['idx']:
continue
dx = abs(d1['cx'] - d2['cx'])
dy = abs(d1['cy'] - d2['cy'])
diagonal_length = np.sqrt(d1['w']**2 + d1['h']**2)
distance = np.linalg.norm(
np.array((d1['cx'], d1['cy'])) -
np.array((d2['cx'], d2['cy'])))
if dx == 0:
angle_diff = 90
else:
angle_diff = np.degrees(np.arctan(dy / dx))
area_diff = abs(d1['w'] * d1['h'] -
d2['w'] * d2['h']) / (d1['w'] * d1['h'])
width_diff = abs(d1['w'] - d2['w']) / d1['w']
height_diff = abs(d1['h'] - d2['h']) / d1['h']
if distance < diagonal_length * MAX_DIAG_MULTIPLYER \
and angle_diff < MAX_ANGLE_DIFF and area_diff < MAX_AREA_DIFF \
and width_diff < MAX_WIDTH_DIFF and height_diff < MAX_HEIGHT_DIFF:
matched_contours_idx.append(d2['idx'])
# append this contour
matched_contours_idx.append(d1['idx'])
if len(matched_contours_idx) < MIN_N_MATCHED:
continue
matched_result_idx.append(matched_contours_idx)
unmatched_contour_idx = []
for d4 in contour_list:
if d4['idx'] not in matched_contours_idx:
unmatched_contour_idx.append(d4['idx'])
unmatched_contour = np.take(possible_contours,
unmatched_contour_idx)
# recursive
recursive_contour_list = find_chars(unmatched_contour)
for idx in recursive_contour_list:
matched_result_idx.append(idx)
break
# optimizing
ret = []
for idx_list in matched_result_idx:
matched_contour = np.take(possible_contours, idx_list)
sorted_contour = sorted(matched_contour, key=lambda x: x['x'])
matched = []
for i in range(len(sorted_contour) - 1):
d1 = sorted_contour[i]
d2 = sorted_contour[i + 1]
if len(matched) == 0:
matched.append(d1['idx'])
diagonal_length = np.sqrt(d1['w']**2 + d1['h']**2)
distance = np.linalg.norm(
np.array((d1['cx'], d1['cy'])) -
np.array((d2['cx'], d2['cy'])))
if distance > diagonal_length * 3:
sorted_contour = sorted_contour[:i + 1]
break
matched.append(d2['idx'])
if len(matched) > 0:
ret.append(matched)
# return matched_result_idx
return ret
result_idx = find_chars(possible_contours)
matched_result = []
for idx_list in result_idx:
matched_result.append(np.take(possible_contours, idx_list))
# Rotate plate image
PLATE_WIDTH_PADDING = 1.1
# PLATE_HEIGHT_PADDING = 1.1
MIN_PLATE_RATIO = 3
MAX_PLATE_RATIO = 12
plate_imgs = []
plate_infos = []
for matched_chars in matched_result:
sorted_chars = sorted(matched_chars, key=lambda x: x['x'])
plate_cx = (sorted_chars[0]['cx'] + sorted_chars[-1]['cx']) / 2
plate_cy = (sorted_chars[0]['cy'] + sorted_chars[-1]['cy']) / 2
plate_width = (sorted_chars[-1]['x'] + sorted_chars[-1]['w'] -
sorted_chars[0]['x']) * PLATE_WIDTH_PADDING
sum_height = 0
for d in sorted_chars:
sum_height += d['h']
plate_height = int(sum_height / len(sorted_chars) *
PLATE_WIDTH_PADDING)
triangle_height = sorted_chars[-1]['cy'] - sorted_chars[0]['cy']
triangle_hypotenus = np.linalg.norm(
np.array((sorted_chars[0]['cx'], sorted_chars[0]['cy'])) -
np.array((sorted_chars[-1]['cx'], sorted_chars[-1]['cy'])))
angle = np.degrees(np.arcsin(triangle_height / triangle_hypotenus))
rotation_matrix = cv2.getRotationMatrix2D(center=(plate_cx,
plate_cy),
angle=angle,
scale=1.0)
img_rotated = cv2.warpAffine(img_thresh,
M=rotation_matrix,
dsize=(width, height))
img_cropped = cv2.getRectSubPix(img_rotated,
patchSize=(int(plate_width),
int(plate_height)),
center=(int(plate_cx),
int(plate_cy)))
ratio = img_cropped.shape[1] / img_cropped.shape[0]
if ratio < MIN_PLATE_RATIO or ratio > MAX_PLATE_RATIO:
continue
plate_imgs.append(img_cropped)
plate_infos.append({
'x': int(plate_cx - plate_width / 2),
'y': int(plate_cy - plate_height / 2),
'w': int(plate_width),
'h': int(plate_height)
})
# Another thresholding to find chars
longest_idx, longest_text = -1, 0
plate_chars = []
for i, plate_img in enumerate(plate_imgs):
plate_img = cv2.resize(plate_img, dsize=(0, 0), fx=1.6, fy=1.6)
_, plate_img = cv2.threshold(plate_img,
thresh=0.0,
maxval=255.0,
type=cv2.THRESH_BINARY
| cv2.THRESH_OTSU)
# find contours again (same as above)
contours, _ = cv2.findContours(plate_img,
mode=cv2.RETR_LIST,
method=cv2.CHAIN_APPROX_SIMPLE)
plate_min_x, plate_min_y = plate_img.shape[1], plate_img.shape[0]
plate_max_x, plate_max_y = 0, 0
for contour in contours:
x, y, w, h = cv2.boundingRect(contour)
area = w * h
ratio = w / h
if area > MIN_AREA and w > MIN_WIDTH and h > MIN_HEIGHT and MIN_RATIO < ratio < MAX_RATIO:
if x < plate_min_x:
plate_min_x = x
if y < plate_min_y:
plate_min_y = y
if x + w > plate_max_x:
plate_max_x = x + w
if y + h > plate_max_y:
plate_max_y = y + h
img_result = plate_img[plate_min_y:plate_max_y,
plate_min_x:plate_max_x]
img_result = cv2.GaussianBlur(img_result, ksize=(3, 3), sigmaX=0)
_, img_result = cv2.threshold(img_result,
thresh=0.0,
maxval=255.0,
type=cv2.THRESH_BINARY
| cv2.THRESH_OTSU)
# dilation
kernel = np.ones((2, 2), np.uint8)
img_result = cv2.dilate(img_result, kernel=kernel)
img_result = cv2.copyMakeBorder(img_result,
top=10,
bottom=10,
left=10,
right=10,
borderType=cv2.BORDER_CONSTANT,
value=(0, 0, 0))
chars = pytesseract.image_to_string(img_result,
lang='kor',
config='--psm 7 --oem 0')
result_chars = ''
has_digit = False
for c in chars:
if ord('가') <= ord(c) <= ord('힣') or c.isdigit():
if c.isdigit():
has_digit = True
result_chars += c
plate_chars.append(result_chars)
if has_digit and len(result_chars) > longest_text:
longest_idx = i
longest_text = len(result_chars)
# Result
if len(plate_chars) == 0:
gc.collect()
return None
# info = plate_infos[longest_idx]
chars = plate_chars[longest_idx]
# print(chars)
gc.collect()
return chars
def keyframeDetection(dest, Thres, plotMetrics=False, verbose=False):
keyframePath = dest+'/keyFrames'
imageGridsPath = dest+'/imageGrids'
csvPath = dest+'/csvFile'
path2file = csvPath + '/output.csv'
prepare_dirs(keyframePath, imageGridsPath, csvPath)
cap = cv2.VideoCapture('tmp.mp4')
length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
if (cap.isOpened()== False):
print("Error opening video file")
lstfrm = []
lstdiffMag = []
timeSpans = []
images = []
full_color = []
lastFrame = None
Start_time = time.process_time()
fps = cap.get(cv2.CAP_PROP_FPS)
def timestamp(frame_number):
return float(frame_number)/fps
# Read until video is completed
for i in range(length):
ret, frame = cap.read()
grayframe, blur_gray = convert_frame_to_grayscale(frame)
frame_number = cap.get(cv2.CAP_PROP_POS_FRAMES) - 1
lstfrm.append(frame_number)
images.append(grayframe)
full_color.append(frame)
if frame_number == 0:
lastFrame = blur_gray
diff = cv2.subtract(blur_gray, lastFrame)
diffMag = cv2.countNonZero(diff)
lstdiffMag.append(diffMag)
stop_time = time.process_time()
time_Span = stop_time-Start_time
timeSpans.append(time_Span)
lastFrame = blur_gray
cap.release()
y = np.array(lstdiffMag)
base = peakutils.baseline(y, 2)
indices = peakutils.indexes(y-base, Thres, min_dist=1)
##plot to monitor the selected keyframe
if (plotMetrics):
plot_metrics(indices, lstfrm, lstdiffMag)
cnt = 1
for x in indices:
cv2.imwrite(os.path.join(keyframePath , 'keyframe'+ str(timestamp(x)) +'.jpg'), full_color[x])
cnt +=1
log_message = 'keyframe ' + str(cnt) + ' happened at ' + str(timeSpans[x]) + ' sec.'
if(verbose):
print(log_message)
with open(path2file, 'w') as csvFile:
writer = csv.writer(csvFile)
writer.writerows(log_message)
csvFile.close()
cv2.destroyAllWindows()
import os
from PIL import Image
from PIL import ImageChops
from matplotlib import pyplot as plt
image1 = cv.imread('./sample/0006_3.jpg')
image1 = cv.resize(image1, (960, 540))
# image1 = cv.cvtColor(image1, cv.COLOR_BGR2GRAY)
image2 = cv.imread('./sample/0006_3_A.jpg')
image2 = cv.resize(image2, (960, 540))
# image2 = cv.cvtColor(image2, cv.COLOR_BGR2GRAY)
[height, width, channels] = image1.shape
print(height, width)
# image2 = cv.resize(image2, (457, 395))
image3 = cv.subtract(image2, image1)
# image3 = image3 - np.mean(image3)
image3[image3 < 0] = 0
# image3 = cv.cvtColor(image3, cv.COLOR_BGR2GRAY)
cv.imshow("1", image3)
image3 = cv.cvtColor(image3, cv.COLOR_BGR2GRAY)
cv.imshow("1.1", image3)
def colorDiff(img1, img2):
b1, g1, r1 = cv.split(img1)
b2, g2, r2 = cv.split(img2)
diff1 = cv.absdiff(b1, b2)
diff2 = cv.absdiff(g1, g2)
diff3 = cv.absdiff(r1, r2)
def remove_background(self, img):
print("Removing background")
#== Parameters =======================================================================
BLUR = 21
CANNY_THRESH_1 = 5
CANNY_THRESH_2 = 10
MASK_DILATE_ITER = 10
MASK_ERODE_ITER = 10
MASK_COLOR = (255, 255, 255) # In BGR format
#== Edge Background Removal ==========================================================
#-- Read image -----------------------------------------------------------------------
arr_img = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
bg = cv2.cvtColor(arr_img, cv2.COLOR_RGB2RGBA)
gray = cv2.cvtColor(arr_img, cv2.COLOR_BGR2GRAY)
#-- Edge detection -------------------------------------------------------------------
edges = cv2.Canny(gray, CANNY_THRESH_1, CANNY_THRESH_2)
edges = cv2.dilate(edges, None)
edges = cv2.erode(edges, None)
#-- Find contours in edges, sort by area ---------------------------------------------
contour_info = []
_, contours, _ = cv2.findContours(edges, cv2.RETR_LIST,
cv2.CHAIN_APPROX_NONE)
for c in contours:
contour_info.append((
c,
cv2.isContourConvex(c),
cv2.contourArea(c),
))
contour_info = sorted(contour_info, key=lambda c: c[2], reverse=True)
max_contour = contour_info[0]
#-- Create empty mask, draw filled polygon on it corresponding to largest contour ----
# Mask is black, polygon is white
mask = np.zeros(edges.shape)
cv2.fillConvexPoly(mask, max_contour[0], (255, 255, 255))
#-- Smooth mask, then blur it --------------------------------------------------------
mask = cv2.dilate(mask, None, iterations=MASK_DILATE_ITER)
mask = cv2.erode(mask, None, iterations=MASK_ERODE_ITER)
mask = cv2.GaussianBlur(mask, (BLUR, BLUR), 0)
#== Flood-fill background removal =====================================================
im_floodfill = arr_img.copy()
# Invert floodfilled image
im_floodfill_inv = cv2.bitwise_not(im_floodfill)
# Create mask of image forground for keeping
mask_flood = self.get_foreground(im_floodfill_inv)
# Combine Edge and Flood-fill masks
combined = cv2.subtract(mask.astype("uint8"),
mask_flood.astype("uint8"))
# Apply combined mask to alpha channel of image
bg[:, :, 3] = combined
# Apply mask for visual checkpoint to see success of background removal
bg_visual = cv2.bitwise_and(arr_img,
arr_img,
mask=mask.astype("uint8"))
fg_visual = cv2.bitwise_or(arr_img,
arr_img,
mask=mask_flood.astype("uint8"))
combined_visual = cv2.subtract(bg_visual, fg_visual)
# Save test images
cv2.imwrite('./bg.jpg', bg_visual)
cv2.imwrite('./fg.jpg', fg_visual)
cv2.imwrite('./combined_masked.jpg', combined_visual)
return bg
gpManz.append(G)
#Generar una piramide Gaussiana para globo
G = globo.copy()
gpGlobo = [G]
for i in range(6):
G = cv2.pyrDown(G)
gpGlobo.append(G)
#Generar una piramide laplaciana para manzana
lpManzana = [gpManz[5]]
for i in range(5, 0, -1):
GE = cv2.pyrUp(gpManz[i])
height, width = gpManz[i - 1].shape[:2]
GE1 = cv2.resize(GE, (width, height))
L = cv2.subtract(gpManz[i - 1], GE1)
lpManzana.append(L)
#Genera una pirámide laplaciana para globo
lpGlobo = [gpGlobo[5]]
for i in range(5, 0, -1):
GE = cv2.pyrUp(gpGlobo[i])
height, width = gpGlobo[i - 1].shape[:2]
GE1 = cv2.resize(GE, (width, height))
L = cv2.subtract(gpGlobo[i - 1], GE1)
lpGlobo.append(L)
#Adicciona la mitad izquiera de la imagen 'manzana' con la mitad derecha de la imagen 'globo'
#para cada nivel
LS = []
types=[]
empty_img = cv2.imread('empty.jpg')
types.append(empty_img)
for square in all_square_list:
if not isImageExist(square, types):
types.append(square)
#这部分，将所有切割出的19*11个方块分类，加上空白方块有38种，编号0-37.然后将19*11个方块依次比较来
#做编号分类，将所有的方块，编码成数字矩阵。
record = []
line = []
for square in all_square_list:
num = 0
for type1 in types:
res = cv2.subtract(square, type1)
if not np.any(res):
line.append(num)
break
num+=1
#这里line是二维数组，len（line）是它的行数，既纵列方块个数；
#for square in all_square_list 这里是纵向遍历的，所以后面要transpose，恢复成正常视觉顺序。
if len(line) == 11:
record.append(line)
line=[]
result = np.transpose(record)
print(result)
# return record
for i in range(108):
autoRelease(result,game_x,game_y)
import cv2
import numpy as np
img = cv2.imread("../00_images/hand.jpg")
# create Gaussian pyramid
# We can find Gaussian pyramids using cv.pyrDown() and cv.pyrUp() functions.
layer = img.copy()
gaussian_pyramid = [layer]
for i in range(6):
layer = cv2.pyrDown(layer)
gaussian_pyramid.append(layer)
# create laplacian (laplaacian) pyramid
layer = gaussian_pyramid[5]
cv2.imshow("6", layer)
laplacian_pyramid = [layer]
# start =5, stop = 0, -1 = reverse order
for i in range(5, 0, -1):
size = (gaussian_pyramid[i - 1].shape[1], gaussian_pyramid[i - 1].shape[0])
gaussian_expanded = cv2.pyrUp(gaussian_pyramid[i], dstsize=size)
laplacian = cv2.subtract(gaussian_pyramid[i - 1], gaussian_expanded)
laplacian_pyramid.append(laplacian)
cv2.imshow(str(i), laplacian)
cv2.imshow("Gaussian 0", gaussian_pyramid[0])
cv2.imshow("img", img)
cv2.waitKey(0)
cv2.destroyAllWindows()
def box_detection(img_color, result, box):
''' 초기 설정 '''
blurred = cv2.GaussianBlur(img_color, (5, 5), 0) # 가우시안 블러 적용
gray = cv2.cvtColor(blurred, cv2.COLOR_BGR2GRAY) # 그레이스케일로 변환
retval, bin = cv2.threshold(gray, 0.2 * gray.max(), 255,
cv2.THRESH_BINARY) # 바이너리 이미지 생성
# cv2.imshow('bin', bin) # 생성된 바이너리 이미지 확인
# cv2.waitKey()
''' 이미지 세그멘테이션 '''
# 노이즈 제거
kernel = np.ones((5, 5), np.uint8) # 커널 크기는 5*5
# opening = cv2.morphologyEx(bin,cv2.MORPH_OPEN,kernel, iterations = 3) # 오프닝 연산으로 배경 노이즈 제거
opening = cv2.morphologyEx(bin, cv2.MORPH_CLOSE, kernel,
iterations=3) # 클로징 연산으로 객체 내부 노이즈 제거
# cv2.imshow('opening', opening) # 모폴로지 연산 후 생성된 바이너리 이미지 확인
# cv2.waitKey()
# 확실한 배경 확보
sure_bg = cv2.dilate(opening, kernel, iterations=3)
# 뼈대 이미지
dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)
result_dist_transform = cv2.normalize(dist_transform, None, 255, 0,
cv2.NORM_MINMAX, cv2.CV_8UC1)
# 확실한 전경 확보
ret, sure_fg = cv2.threshold(result_dist_transform,
0.7 * result_dist_transform.max(), 255,
cv2.THRESH_BINARY)
sure_fg = np.uint8(sure_fg)
sure_fg = cv2.dilate(sure_fg, kernel, iterations=3) # 전경을 확대해줌
# cv2.imshow('sure_fg', sure_fg)
# cv2.waitKey()
# 확실한 배경 - 확실한 전경 = 모르는 부분
unknown = cv2.subtract(sure_bg, sure_fg)
# 이미지 라벨링
ret, markers = cv2.connectedComponents(
sure_fg) # 확실한 전경 영역을 라벨링 *마커는 0(배경)부터 지정됨
markers = markers + 1 # 결과 마커를 하나 증가 시켜서 배경을 1로 설정
markers[unknown == 255] = 0 # 모르는 부분을 0으로 라벨링
# 전경, 배경에 0 이상의 값, 불명확한 것에 0 -> 이 알고리즘이 불명확한 것을 판단 + 경계선을 -1로
markers = cv2.watershed(img_color, markers)
img_color[markers == -1] = [0, 0, 0] # 객체의 외곽부분 검정색으로
img_color[markers == 1] = [0, 0, 0] # 배경 부분은 검정색으로, 객체는 원래 색 그대로
# cv2.imshow('foreground', img_color) # 알고리즘 적용되어 객체만 추출된 이미지 확인
# cv2.waitKey()
''' 검출된 전경의 꼭짓점 찾기 '''
# 전경의 꼭짓점을 찾기 위해 코너 디텍트
img_gray = cv2.cvtColor(img_color, cv2.COLOR_BGR2GRAY)
corners = cv2.goodFeaturesToTrack(
img_gray, 150, 0.01, 5) # 코너를 찾을 이미지, 코너 최대 검출 개수, 코너 강도, 코너 사이의 거리
# 코너로 검출된 점에서 최소 좌표와 최대 좌표를 찾아서 꼭짓점 결정
pos = [0, 10000, 10000, 0, 0, -1, -1,
0] # x, min_y, min_x, y, x, max_y, max_x, y
for i in corners:
x, y = i[0]
if x > 5 and y > 5 and x < 635 and y < 475: # 카메라 화면의 꼭짓점 검출 방지
if y < pos[1]: # Y의 최소 좌표 찾기 (왼쪽 상단)
pos[0] = x
pos[1] = y
if x < pos[2]: # X의 최소 좌표 찾기 (왼쪽 하단)
pos[2] = x
pos[3] = y
if y > pos[5]: # Y의 최대 좌표 찾기 (오른쪽 하단)
pos[4] = x
pos[5] = y
if x > pos[6]: # X의 최대 좌표 찾기 (오른쪽 상단)
pos[6] = x
pos[7] = y
# cv2.circle(img_color, (x, y), 3, (0, 0, 255), 2) # 코너에 원으로 표시
# cv2.imshow('corner', img_color) # 코너가 표시된 이미지 확인
# cv2.waitKey()
# print(pos)
# cv2.waitKey()
if abs(pos[5] - pos[7]) <= 30: # 박스가 카메라에 정방향으로 잡힌다면
# 컨투어 검출
retval, img_bin = cv2.threshold(img_gray, 1, 255,
cv2.THRESH_BINARY) # 바이너리 이미지 생성
val, contours, hierarchy = cv2.findContours(img_bin, cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
# 면적이 가장 작은 컨투어(=박스) 추출
min_area = 1000000
min_index = -1
index = -1
for i in contours:
area = cv2.contourArea(i)
index = index + 1
if area < min_area:
min_area = area
min_index = index
if min_index == -1: # 검출된 컨투어가 없으면
return result, box # 이전 상태 그대로 반환
# 결과 이미지에 컨투어 표시
# cv2.drawContours(result, contours, min_index, (0, 255, 0), 2)
''' 결과 반환: 박스가 카메라와 정방향 '''
# 컨투어를 둘러싸는 가장 작은 사각형 그리기
cnt = contours[min_index]
rect = cv2.minAreaRect(cnt)
box = cv2.boxPoints(rect)
box = np.int0(box) # 정수형으로 변경
result = cv2.drawContours(result, [box], 0, (0, 0, 255),
2) # 찾아낸 꼭짓점을 따라 윤곽선 그려줌
return result, box # 윤곽선 그려진 전체 이미지, 꼭짓점 반환
else:
''' 결과 반환: 박스가 카메라와 정방향 X '''
box = ((pos[0], pos[1]), (pos[2], pos[3]), (pos[4], pos[5]),
(pos[6], pos[7])) # 꼭짓점 지정
box = np.int0(box) # 정수형으로 변경
result = cv2.drawContours(result, [box], 0, (0, 0, 255),
2) # 찾아낸 꼭짓점을 따라 윤곽선 그려줌
return result, box # 윤곽선 그려진 전체 이미지, 꼭짓점 반환
import cv2 as cv
import numpy as np
image1 = cv.imread('new.jpg')
image2 = cv.imread('new2.jpg')
diff = cv.subtract(image1, image2)
result = not np.any(diff)
if result is True:
print('the images are the same')
else:
print('the images are diff')
def textDetectWatershed(img):
""" Text detection using watershed algorithm - NOT IN USE """
# According to: http://docs.opencv.org/trunk/d3/db4/tutorial_py_watershed.html
img = resize(img, 2000)
gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
ret, thresh = cv2.threshold(gray, 0, 255,
cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# ret, thresh = cv2.threshold(gray, 50, 255, cv2.THRESH_BINARY)
# noise removal
kernel = np.ones((3, 3), np.uint8)
opening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=3)
# sure background area
sure_bg = cv2.dilate(opening, kernel, iterations=3)
# Finding sure foreground area
dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)
ret, sure_fg = cv2.threshold(dist_transform, 0.01 * dist_transform.max(),
255, 0)
# Finding unknown region
sure_fg = np.uint8(sure_fg)
unknown = cv2.subtract(sure_bg, sure_fg)
# Marker labelling
ret, markers = cv2.connectedComponents(sure_fg)
# Add one to all labels so that sure background is not 0, but 1
markers += 1
# Now, mark the region of unknown with zero
markers[unknown == 255] = 0
markers = cv2.watershed(img, markers)
implt(markers, t='Markers')
image = img.copy()
for mark in np.unique(markers):
# mark == 0 --> background
if mark == 0:
continue
# Draw it on mask and detect biggest contour
mask = np.zeros(gray.shape, dtype="uint8")
mask[markers == mark] = 255
cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)[-2]
c = max(cnts, key=cv2.contourArea)
# Draw a bounding rectangle if it contains text
x, y, w, h = cv2.boundingRect(c)
cv2.drawContours(mask, c, 0, (255, 255, 255), cv2.FILLED)
maskROI = mask[y:y + h, x:x + w]
# Ratio of white pixels to area of bounding rectangle
r = cv2.countNonZero(maskROI) / (w * h)
# Limits for text
if r > 0.2 and 2000 > w > 15 and 1500 > h > 15:
cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
implt(image)
for i in range(6):
orange_copy = cv2.pyrDown(orange_copy)
gp_orange.append(orange_copy)
# Generate Laplacian pyramid for apple
apple_copy = gp_apple[5]
lp_apple = [apple_copy]
for i in range(5,0,-1):
gaussian_extended = cv2.pyrUp(gp_apple[i])
laplacian = cv2.subtract(gp_apple[i-1],gaussian_extended)
lp_apple.append(laplacian)
# Generate Laplacian pyramid for orange
orange_copy = gp_orange[5]
lp_orange = [orange_copy]
for i in range(5,0,-1):
gaussian_extended = cv2.pyrUp(gp_orange[i])
laplacian = cv2.subtract(gp_orange[i-1],gaussian_extended)
lp_orange.append(laplacian)
#PART 2
img = cv2.imread('../DATA/pennies.jpg')
img = cv2.medianBlur(img,35)
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray,0,255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)
#NOISE REMOVAL (OPTIONAL)
kernel = np.ones((3,3),np.uint8)
opening = cv2.morphologyEx(thresh,cv2.MORPH_OPEN,kernel,iterations=2)
dist_transform = cv2.distanceTransform(opening,cv2.DIST_L2,5)
ret, sure_fg = cv2.threshold(dist_transform,0.7*dist_transform.max(),255,0)
sure_bg = cv2.dilate(opening,kernel,iterations=3)
sure_fg = np.uint8(sure_fg)
unknown = cv2.subtract(sure_bg,sure_fg)
ret, markers = cv2.connectedComponents(sure_fg)
markers = markers + 1
markers[unknown==255] = 0
markers = cv2.watershed(img,markers)
# FIND CONTOURS
image, contours, hierarchy = cv2.findContours(markers.copy(),cv2.RETR_CCOMP,cv2.CHAIN_APPROX_SIMPLE)
for i in range(len(contours)):
if hierarchy[0][i][3] == -1:
cv2.drawContours(sep_coins,contours,i,(255,0,0),10)
display(sep_coins)
c = src_pts1.ravel()
d = dst_pts1.ravel()
canvas1 = gray1.copy()
canvas2 = gray2.copy()
for k in range(1,a):
cv2.circle(canvas1, (c[2*k],c[2*k-1]), 80, (255, 255, 255), -1)
cv2.circle(canvas2, (d[2*k],d[2*k-1]), 80, (255, 255, 255), -1)
blurred1 = cv2.GaussianBlur(canvas1, (9, 9),0)
blurred2 = cv2.GaussianBlur(canvas2, (9, 9),0)
gradX1 = cv2.Sobel(blurred1, ddepth=cv2.CV_32F, dx=1, dy=0)
gradY1 = cv2.Sobel(blurred1, ddepth=cv2.CV_32F, dx=0, dy=1)
gradient1 = cv2.subtract(gradX1, gradY1)
gradient1 = cv2.convertScaleAbs(gradient1)
gradX2 = cv2.Sobel(blurred2, ddepth=cv2.CV_32F, dx=1, dy=0)
gradY2 = cv2.Sobel(blurred2, ddepth=cv2.CV_32F, dx=0, dy=1)
gradient2 = cv2.subtract(gradX2, gradY2)
gradient2 = cv2.convertScaleAbs(gradient2)
blurred = cv2.GaussianBlur(gradient1, (9, 9),0)
(_, thresh) = cv2.threshold(blurred, 225, 0, 4)
(_, thresh) = cv2.threshold(thresh, 30, 0, 3)
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (25, 25))
closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)
closed = cv2.erode(closed, None, iterations=4)
closed = cv2.dilate(closed, None, iterations=4)
import cv2
from matplotlib import pyplot as plt
import numpy as np
img = cv2.imread('fieldman.jpg')
layer = img.copy()
gp = [layer]
for i in range(6):
layer = cv2.pyrDown(layer)
gp.append(layer)
#cv2.imshow(str(i), layer)
layer = gp[5]
cv2.imshow('upper level Gaussian Pyramid', layer)
lp = [layer]
for i in range(5, 0, -1):
gaussian_extended = cv2.pyrUp(gp[i])
laplacian = cv2.subtract(gp[i - 1].shape[1], gaussian_extended.shape[0])
cv2.imshow(str(i), laplacian)
cv2.imshow('Original image', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
sightX = 330
sightY = 245
while(True):
timeStamp = time.time()
if debug:
print("")
print("--New F:")
ret, img = cam.read() # 获取一帧图像
#img = cv2.imread("testImg.png")
# 图像通道分离
blueImg, greenImg, redImg = cv2.split(img) # 分离图像的RGB通道
if mode == "BLUE": # 分析识别模式
img2 = cv2.subtract(blueImg, redImg) # B通道-R通道
else:
img2 = cv2.subtract(redImg, blueImg) # R通道-B通道
img2 = cv2.subtract(img2, greenImg) # 上一步运算结果-G通道
ret, img2 = cv2.threshold(img2, 50, 255, cv2.THRESH_BINARY) # 图像二值化处理
img2 = cv2.morphologyEx(img2, cv2.MORPH_OPEN, kernel) # 开运算，减少暗斑
contours, hierarchy = cv2.findContours(
img2, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) # 获取轮廓
cv2.drawContours(img, contours, -1, (0, 255, 0), 2) # 在原始图像上绘制轮廓以进行显示
n = 0
x = []
y = []
longSide = []
shortSide = []
import cv2
from skimage.metrics import structural_similarity
import imutils
import numpy as np
from matplotlib import pyplot as plt
# load the two input images
img_1 = cv2.imread("images/red2.jpg")
img_2 = cv2.imread("images/red3.jpg")
#-----------------check both img size ----------------------------------
if img_1.shape == img_2.shape:
print("The images have same size and channels")
print("Processing...")
difference = cv2.subtract(img_1, img_2)
b, g, r = cv2.split(difference)
# convert the images to grayscale-----------------------------------
grayA = cv2.cvtColor(img_1, cv2.COLOR_BGR2GRAY)
grayB = cv2.cvtColor(img_2, cv2.COLOR_BGR2GRAY)
# compute the Structural Similarity Index (SSIM) between the two----
# images, ensuring that the difference image is returned------------
(score, diff) = structural_similarity(grayA, grayB, full=True)
diff = (diff * 255).astype("uint8")
if cv2.countNonZero(b) == 0 and cv2.countNonZero(
g) == 0 and cv2.countNonZero(r) == 0 and score == 1:
print("The images are completely Equal")
print("Similarities Percentage:- {}".format(score * 100))
_, img = capture.read()
if len(esquinasCancha) == 2:
img = img[esquinasCancha[0].pos[1] : esquinasCancha[1].pos[1] , esquinasCancha[0].pos[0] : esquinasCancha[1].pos[0]]
imgBlur = cv2.blur(img,(10,10))
hsv_img = cv2.cvtColor(imgBlur, cv2.COLOR_BGR2HSV)
for obj in [obj for obj in objetos if isinstance(obj, Movil)]:
lower[0] = obj.color
upper[0] = obj.color
lower = cv2.subtract(lower,error)
upper = cv2.add(upper,error)
ml = max(80, min(margenLocal , int(obj.area/10000)))
hsv_imgParcial , pos = subImagen(hsv_img,obj.pos,ml)
imgParcial, _ = subImagen(img,obj.pos,ml)
thresChico = cv2.inRange(hsv_imgParcial, lower, upper)
momentsChico = cv2.moments(thresChico, 0)
def finger(result_names):
#print(result_names)
global count0
global count1
global count2
global count3
global count4
global count5
global count6
original = cv2.imread("finger.bmp")
image_to_compare = cv2.imread(str(result_names) + ".bmp")
if original.shape == image_to_compare.shape:
print("The images have same size and channels")
difference = cv2.subtract(original, image_to_compare)
b, g, r = cv2.split(difference)
if cv2.countNonZero(b) == 0 and cv2.countNonZero(
g) == 0 and cv2.countNonZero(r) == 0:
print("This fingerprint image is not clear")
else:
print("This fingerprint image is clear")
sift = cv2.xfeatures2d.SIFT_create()
kp_1, desc_1 = sift.detectAndCompute(original, None)
kp_2, desc_2 = sift.detectAndCompute(image_to_compare, None)
index_params = dict(algorithm=0, trees=5)
search_params = dict()
flann = cv2.FlannBasedMatcher(index_params, search_params)
matches = flann.knnMatch(desc_1, desc_2, k=2)
good_points = []
ratio = 0.6
#serial_port.write(b'3')
for m, n in matches:
if m.distance < ratio * n.distance:
good_points.append(m)
if (len(good_points) > 1):
print("fingerprint matched")
if result_names == 'Rohit saw':
if (count0 < 1):
print("you are valid for voting")
serial_port.write(b'1')
time.sleep(0.5)
serial_port.write(b'3')
count0 = count0 + 1
else:
print("Voter blocked")
if result_names == 'Tarakeshava':
if (count1 < 1):
print("you are valid for voting")
serial_port.write(b'1')
time.sleep(0.5)
serial_port.write(b'3')
count1 = count1 + 1
else:
print("Voter Blocked")
if result_names == 'Rohan':
if (count2 < 1):
print("you are valid for voting")
serial_port.write(b'2')
time.sleep(0.5)
serial_port.write(b'3')
count2 = count2 + 1
else:
print("Voter Blocked")
if result_names == 'Sandeep':
if (count3 < 1):
print("you are valid for voting")
serial_port.write(b'2')
time.sleep(0.5)
serial_port.write(b'3')
count3 = count3 + 1
else:
print("you are not valid for voting")
else:
print("Voter Blocked")
result = cv2.drawMatches(original, kp_1, image_to_compare, kp_2,
good_points, None)
cv2.imshow("result", result)
cv2.imshow("Original", original)
cv2.imshow("Duplicate", image_to_compare)
cv2.waitKey(0)
import cv2
import numpy as np
import matplotlib.pyplot as plt
image = cv2.imread('../images/1.jpg')
M = np.ones(image.shape, dtype='uint8') * 75
sub = cv2.subtract(image, M) * 75
cv2.imshow('sub', sub)
add = cv2.add(image, M)
cv2.imshow('add', add)
cv2.imshow('m', M)
cv2.waitKey()
cv2.destroyAllWindows()
# Equalize the image and calculate histogram:
image_eq = equalize_hist_color(image)
hist_image_eq = hist_color_img(image_eq)
# Add 15 to every pixel on the grayscale image (the result will look lighter) and calculate histogram
M = np.ones(image.shape, dtype="uint8") * 15
added_image = cv2.add(image, M)
hist_color_added_image = hist_color_img(added_image)
# Equalize image and calculate histogram
added_image_eq = equalize_hist_color(added_image)
hist_added_image_eq = hist_color_img(added_image_eq)
# Subtract 15 from every pixel (the result will look darker) and calculate histogram
subtracted_image = cv2.subtract(image, M)
hist_color_subtracted_image = hist_color_img(subtracted_image)
# Equalize image and calculate histogram
subtracted_image_eq = equalize_hist_color(subtracted_image)
hist_subtracted_image_eq = hist_color_img(subtracted_image_eq)
# Plot the images and the histograms (without equalization first)
show_img_with_matplotlib(image, "image", 1)
show_hist_with_matplotlib_rgb(hist_color, "color histogram", 2,
['b', 'g', 'r'])
show_img_with_matplotlib(added_image, "image lighter", 5)
show_hist_with_matplotlib_rgb(hist_color_added_image, "color histogram", 6,
['b', 'g', 'r'])
show_img_with_matplotlib(subtracted_image, "image darker", 9)
show_hist_with_matplotlib_rgb(hist_color_subtracted_image, "color histogram",
import cv2
import numpy as np
video = cv2.VideoCapture("homework3.mp4")
while True:
TrueOrFalse, Slide = video.read()
if TrueOrFalse ==True:
GraySlide=cv2.subtract(cv2.subtract(Slide[:,:,0], Slide[:,:,2]), Slide[:,:,1])
# cv2.imshow("www", GraySlide)
BinSlide = cv2.inRange(GraySlide, 5, 65)
# cv2.imshow("m2", BinSlide)
#膨脹侵蝕
BinSlide = cv2.dilate(BinSlide, np.ones((95, 95)))
BinSlide = cv2.erode(BinSlide, np.ones((60, 60)))
#取輪廓數據
aa,bb=cv2.findContours(BinSlide ,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
#把輪廓印出來
for i in aa:
x, y, w, h =cv2.boundingRect(i)
cv2.rectangle(Slide, (x, y), (x+w, y+h), (0, 0, 255), 2) #先把紅框框全部畫上
cv2.imshow("ShowPage", Slide) #最後再一次印出
if cv2.waitKey(30) == 13:
break
else:
def init_img_filter(img):
img = cv2.imread(img, cv2.IMREAD_GRAYSCALE)
height, width = img.shape[:2]
filter_arg = int(width * 0.125)
filter_arg = filter_arg if filter_arg % 2 == 1 else filter_arg + 1
img_filtered = cv2.GaussianBlur(img, (filter_arg, 1), 0)
th, img_threshold = cv2.threshold(img_filtered, 165, 255,
cv2.THRESH_BINARY_INV)
img_open = cv2.morphologyEx(img_threshold, cv2.MORPH_OPEN,
np.ones((1, 75), np.uint8))
img_close = cv2.morphologyEx(img_open, cv2.MORPH_CLOSE,
np.ones((5, 1), np.uint8))
img_closed_blr = cv2.GaussianBlur(img_close, (3, 3), 0)
img_closed_thresh = cv2.threshold(img_closed_blr, 101, 255,
cv2.THRESH_BINARY)[1]
img_y_filter = cv2.GaussianBlur(img, (1, 55), 0)
th, img_y_thresh = cv2.threshold(img_y_filter, 150, 255,
cv2.THRESH_BINARY_INV)
img_y_open = cv2.morphologyEx(img_y_thresh, cv2.MORPH_OPEN,
np.ones((5, 5), np.uint8))
img_y_close = cv2.morphologyEx(img_y_open, cv2.MORPH_CLOSE,
np.ones((2, 2), np.uint8))
modded = cv2.subtract(img_closed_thresh, img_y_close)
th, img_threshold_1 = cv2.threshold(img, 155, 255, cv2.THRESH_BINARY_INV)
hold_0, contours_0, hierarchy = cv2.findContours(img_threshold_1,
cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
blackhat = cv2.subtract(img_threshold_1, modded)
blackhat_open = cv2.morphologyEx(blackhat, cv2.MORPH_OPEN,
np.ones((2, 2), np.uint8))
blackhat_closed = cv2.morphologyEx(blackhat_open, cv2.MORPH_CLOSE,
np.ones((2, 2), np.uint8))
blackhat_closed_blr = cv2.GaussianBlur(blackhat_closed, (1, 15), 4)
show_boxes = blackhat_closed.copy()
hold_0, contours_0, hierarchy = cv2.findContours(blackhat_closed_blr,
cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
boxes = {
'x0': np.array([], dtype=np.uint16),
'y0': np.array([], dtype=np.uint16),
'x1': np.array([], dtype=np.uint16),
'y1': np.array([], dtype=np.uint16),
'xC': np.array([], dtype=np.uint16),
'yC': np.array([], dtype=np.uint16),
'width': np.array([], dtype=np.uint16),
'height': np.array([], dtype=np.uint16),
'ratio': np.array([], dtype=np.float32),
'area': np.array([], dtype=np.float32),
'angle': np.array([], dtype=np.float32),
'pixel_mean': np.array([], dtype=np.uint16),
'pixel_mean_q0': np.array([], dtype=np.uint16),
'pixel_mean_q1': np.array([], dtype=np.uint16),
'pixel_mean_q2': np.array([], dtype=np.uint16),
'pixel_mean_q3': np.array([], dtype=np.uint16)
}
for c in contours_0:
x, y, w, h = cv2.boundingRect(c)
show_boxes = cv2.rectangle(show_boxes, (x, y), (x + w, y + h),
(155, 155, 155), 2)
boxes['x0'] = np.append(boxes['x0'], [x])
boxes['y0'] = np.append(boxes['y0'], [y])
boxes['x1'] = np.append(boxes['x1'], [x + w])
boxes['y1'] = np.append(boxes['y1'], [y + h])
boxes['xC'] = np.append(boxes['xC'], [int(x + ((w + x) * 0.5))])
boxes['yC'] = np.append(boxes['yC'], [int(y + ((h + y) * 0.5))])
boxes['width'] = np.append(boxes['width'], [w])
boxes['height'] = np.append(boxes['height'], [h])
boxes['ratio'] = np.append(boxes['ratio'], [h / w])
boxes['area'] = np.append(boxes['area'], [h * w])
if len(c) > 4:
(x, y), (MA, ma), angle = cv2.fitEllipse(c)
else:
angle = -1
boxes['angle'] = np.append(boxes['angle'], [angle])
boxes['pixel_mean'] = np.append(
boxes['pixel_mean'],
np.mean(show_boxes[int(y):int(y + h),
int(x):int(x + w)]))
if w >= 2 and h >= 2:
for index_0 in range(4):
if index_0 % 2 == 0:
x_0 = int(x)
x_1 = int(x + ((w + x) / 2))
else:
x_0 = int(x + (w / 2))
x_1 = int(x + w)
if index_0 < 2:
y_0 = int(y)
y_1 = int(y + (h / 2))
else:
y_0 = int(y + (h / 2))
y_1 = int(y + h)
value = show_boxes[y_0:y_1, x_0:x_1]
string = 'pixel_mean_q' + str(index_0)
# print(string,x_0,x_1,y_0,y_1,value)
# print(np.mean(value))
if np.mean(value) != np.nan:
boxes[string] = np.append(boxes[string], np.mean(value))
else:
boxes[string] = np.append(boxes[string], int(0))
else:
boxes['pixel_mean_q0'] = np.append(boxes['pixel_mean_q0'], [0])
boxes['pixel_mean_q1'] = np.append(boxes['pixel_mean_q1'], [0])
boxes['pixel_mean_q2'] = np.append(boxes['pixel_mean_q2'], [0])
boxes['pixel_mean_q3'] = np.append(boxes['pixel_mean_q3'], [0])
df = pd.DataFrame(data=boxes)
return df, img
#construct the argument parse and parse the argument
#ap = argparse.ArgumentParser()
#ap.add_argument("-i", "--image", requied = True, help = "/jurassic_world.jpg")
#args = vars(ap.parse_args)
#load the image and aconvert into the gray scale image
image = cv2.imread("jurassic_world.jpg")
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
#compute the scharr gradient magnitude representation of the images
#in both x and y cordiation
gradeX = cv2.Sobel(gray, ddepth=cv2.cv.CV_32F, dx=1, dy=0, ksize=-1)
gradeY = cv2.Sobel(gray, ddepth=cv2.cv.CV_32F, dx=0, dy=1, ksize=-1)
#substract the y-gradient from x- gradient
gradient = cv2.subtract(gradeX, gradeY)
gradient = cv2.convertScaleAbs(gradient)
#blur and threshold the image
bluurred = cv2.blur(gradient, (9, 9))
(_, thresh) = cv2.threshold(bluurred, 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 erosion and dialtion
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
list_repeated = []
list_unique = [0]
for i in trange(number_of_rows - 1):
bool_repeated = False
if df.iloc[i + 1]['x'] == df.iloc[i]['x'] and df.iloc[
i + 1]['y'] == df.iloc[i]['y'] and df.iloc[
i + 1]['width'] == df.iloc[i]['width'] and df.iloc[
i + 1]['height'] == df.iloc[i]['height']:
image_i = cv2.imread(
os.path.join(raw_image_directory, str(df.iloc[i]['filename'])) +
".jpg")
image_iplus1 = cv2.imread(
os.path.join(raw_image_directory, str(df.iloc[i +
1]['filename'])) +
".jpg")
difference = cv2.subtract(image_i, image_iplus1)
b, g, r = cv2.split(difference)
if cv2.countNonZero(b) == 0 and cv2.countNonZero(
g) == 0 and cv2.countNonZero(r) == 0:
number_of_repeated = number_of_repeated + 1
dict1 = {'filename': df.iloc[i + 1]['filename']}
list_repeated.append(dict1)
bool_repeated = True
if bool_repeated == False:
list_unique.append(i + 1)
print("number_of_repeated", number_of_repeated)
print("number_of_unique", len(list_unique))
output_file = "/4t/yangchihyuan/TransmittedImages/ShuffleNet/repeated.csv"
df_repeated = pd.DataFrame(list_repeated)
plt.subplot(1, 2, 2), plt.imshow(images[1], 'gray')
plt.title(titles[1])
plt.xticks([]), plt.yticks([])
plt.ion()
plt.pause(0.4) #显示秒数
plt.close()
else:
img_name = "./walk02/walk02" + str(i + 1) + ".jpg"
img_color = cv2.imread(img_name, cv2.IMREAD_COLOR)
img_name1 = "./walk02/walk02" + str(i) + ".jpg"
img_name2 = "./walk02/walk02" + str(i + 1) + ".jpg"
#print(i+2,"-YES")
img_color_1 = cv2.imread(img_name1) # 直接读为灰度图像
img_color_2 = cv2.imread(img_name2) # 直接读为灰度图像
img_sub = cv2.subtract(img_color_1, img_color_2)
#相減後相加(灰圖)
if i == 1:
add_img_sub = img_sub
else:
add_img_sub = cv2.add(add_img_sub, img_sub)
#剪完後二值化
img1 = cv2.imread(img_name1, 0) # 直接读为灰度图像
img2 = cv2.imread(img_name2, 0) # 直接读为灰度图像
img_sub = cv2.subtract(img1, img2)
ret_2, thresh3 = cv2.threshold(img_sub, 127, 255, cv2.THRESH_TRUNC)
#儲存thresh3
output_tru_name = "./walk02-out/tru/walk02-out-tru-" + str(i) + ".jpg"
cv2.imwrite(output_tru_name, thresh3)
import cv2
import numpy as np
from matplotlib import pyplot as plt
img_path = 'D:\Jatayu Unmanned Systems\dataset2\Elon.jpg'
image = cv2.imread(img_path)
img = image
print("max of 255: {}".format(cv2.add(np.uint8([200]), np.uint8([100]))))
print("min of 0: {}".format(cv2.subtract(np.uint8([50]), np.uint8([100]))))
print("wrap around: {}".format(np.uint8([200]) + np.uint8([100]))) # x1+x2-256
print("wrap around: {}".format(np.uint8([50]) - np.uint8([100]))) # x1-x2+256
M = np.ones(img.shape, dtype="uint8") * 180
added = cv2.add(img, M)
cv2.imshow("Added", added) # gets brighter
cv2.waitKey(0)
# subtract makes darker
# Bitwise operations
rectangle = np.zeros(img.shape, dtype="uint8")
cv2.rectangle(rectangle, (25, 25), (275, 275), 255, -1)
cv2.imshow("Rectangle", rectangle)
cv2.waitKey(0)
circle = np.zeros(img.shape, dtype="uint8")
cv2.circle(circle, (150, 150), 150, 255, -1)
cv2.imshow("Circle", circle)
cv2.waitKey(0)
m = cv2.bitwise_and(circle, rectangle)
