row_apple,col_apple, channel_apple = apple_db.shape
row_orange, col_orange, channel_orange = orange_db.shape
mask = np.zeros((row_apple,col_apple,channel_apple))
mask[:, :int(col_apple/2)] = 1
cv2.imshow('Mask',mask)
cv2.waitKey(0)
cv2.destroyAllWindows()
########################################################## Direct blending ######################
direct_blend = mask*apple_db + (1 - mask)*orange_db
plt.figure()
plt.imshow(direct_blend)
plt.title("Direct Blending")
plt.show()
########################################################## Alpha blending ######################
mask_blur = cv2.GaussianBlur((mask) , (15,15), 15, cv2.BORDER_WRAP)
alpha_blend = mask_blur*apple_db + (1 - mask_blur)*orange_db
plt.figure()
plt.imshow(alpha_blend)
plt.title("Alpha Blending")
plt.show()
########################################################## Multiresolution blending ######################
reconstructed_image= multiresolution(apple_db,orange_db)
plt.figure()
plt.imshow(reconstructed_image)
plt.title("Multiresolution Blending")
plt.show()
def get_contours_dict(channel_image, blur_size):
# Blur the image to make the ranges smoother
smoothed_image = cv2.GaussianBlur(channel_image,
ksize=(blur_size, blur_size),
sigmaX=0)
# Find contours on the smoothed image
contours_list = []
# contours_image_debug = np.zeros(current_image.shape, dtype=np.uint8)
# contours_image_debug[:, :, 1] = 255
for color_num in range(len(ParamsConfig.ColorRanges) - 1):
channel_min_value = ParamsConfig.ColorRanges[color_num]
channel_max_value = ParamsConfig.ColorRanges[color_num + 1]
# Create the mask using the min and max values obtained from trackbar and apply bitwise and operation to get the results
image_mask = cv2.inRange(smoothed_image, channel_min_value,
channel_max_value)
# # find contours in thresholded image, then keep only the largest
# hierarchy=[Next, Previous, First_Child, Parent]
contours, hierarchies = cv2.findContours(image_mask.copy(),
cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
# cnts = sorted(cnts, key=lambda x: cv2.contourArea(x), reverse=True)
# a = sorted(zip(contour_list, hierarchies), key=_get_contour_area_in_tuple, reverse=True)
# cnts = cnts[:num_contours]
if len(contours) > 0:
_contours_dict = {}
for idx, (contour,
hierarchy) in enumerate(zip(contours, hierarchies[0])):
contour_area = cv2.contourArea(contour)
is_hole = False
_hierarchy = hierarchy
while _hierarchy[3] != -1:
is_hole = not is_hole
parent_idx = _hierarchy[3]
_hierarchy = hierarchies[0][parent_idx]
# In case this contour is a hole, subtract its area from the parents area
if is_hole:
parent_idx = hierarchy[3]
if parent_idx != -1:
_contours_dict[parent_idx][
ContourKeys.AreaFinal] -= contour_area
_contours_dict[idx] = {
ContourKeys.Contour: contour,
ContourKeys.ColorNum: color_num,
ContourKeys.AreaFinal: contour_area,
ContourKeys.AreaFilled: contour_area,
ContourKeys.IsHole: is_hole,
}
# contours_dict.append((color_num, contour))
# hull = cv2.convexHull(cnt)
# all_contours.append((color_num, hull))
# epsilon = 0.001 * cv2.arcLength(cnt, True)
# approx = cv2.approxPolyDP(cnt, epsilon, True)
# all_contours.append((color_num, approx))
# cv2.fillPoly(contours_image_debug, pts=pts, color=(color, color, color))
for idx, obj in _contours_dict.items():
is_hole = obj[ContourKeys.IsHole]
if is_hole is False:
contours_list.append(obj)
# contour = obj[ContourKeys.Contour]
# area_final = obj[ContourKeys.AreaFinal]
# area_filled = obj[ContourKeys.AreaFilled]
# pts = [np.array(contour)]
# if is_hole:
# cv2.fillPoly(contours_image_debug, pts=pts, color=(0, 0, 0))
# else:
# cv2.fillPoly(contours_image_debug, pts=pts, color=(255, 255, 255))
# image_title = f"{color_num}.{idx}.{is_hole}, Area={int(area_final):,}({int(area_filled):,})"
# cv2.imshow(image_title, contours_image_debug) # Show the results
# k = cv2.waitKey(1) & 0xFF
# # while True:
# if k == ord("b"):
# break
sorted_contours = sorted(contours_list,
key=lambda x: x[ContourKeys.AreaFinal],
reverse=True)
# sorted_contours = sorted_contours[:num_contours]
return sorted_contours
"""
#--------------------------------------------------------------------#
conf = json.load(open("conf.json"))
print(conf["input"])
cap = cv2.VideoCapture(conf["input"])
print(cap)
avg = None
while(True):
ret, frame = cap.read()
#print(ret)
frame = cv2.resize(frame, (640,480))
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (21, 21), 0)
text = "Normal"
# if the average frame is None, initialize it
if avg is None:
print("[INFO] starting background model...")
avg = gray.copy().astype("float")
continue
cv2.accumulateWeighted(gray, avg, 0.7)
frameDelta = cv2.absdiff(gray, cv2.convertScaleAbs(avg))
thresh = cv2.threshold(frameDelta, conf["delta_thresh"], 255, cv2.THRESH_BINARY)[1]
thresh = cv2.dilate(thresh, None, iterations=2)
#cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
_, contours, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
#cnts = imutils.grab_contours(cnts)
flann=cv2.FlannBasedMatcher(indexParams,searchParams)
ratio_l=[]
vis_l=[]
applno_l=[]
result = []
outputPath='./Output/' #path of database
tmpfiles = os.listdir(outputPath)
for f in tmpfiles:
os.remove('./Output/'+str(f))
sampleImage = cv2.imread(samplePath,0)
sampleImage1 = imutils.resize(sampleImage, width = 300)
sampleImage1 = cv2.GaussianBlur(sampleImage1, (5, 5), 0)
kp1_1, des1_1 = sift.detectAndCompute(sampleImage1, None) #detect the features of sample
sampleImage = cv2.imread(samplePath,0)
sampleImage2 = imutils.resize(sampleImage, width = 300)
sampleImage2 = cv2.GaussianBlur(sampleImage2, (1, 1), 0)
ret,sampleImage2 = cv2.threshold(sampleImage2,220,255,cv2.THRESH_BINARY)
#sampleImage = cv2.Canny(sampleImage, 30, 150)
kp1_2, des1_2 = sift.detectAndCompute(sampleImage2, None) #detect the features of sample
index = 0
for t in tmark_l:
index = index + 1
print(index)
f = t['file']
queryImage=cv2.imread(f,0)
try:
def main():
imgTrainingNumbers = cv2.imread("training_chars.png") # read in training numbers image
if imgTrainingNumbers is None: # if image was not read successfully
print("error: image not read from file \n\n") # print error message to std out
os.system("pause") # pause so user can see error message
return # and exit function (which exits program)
# end if
imgGray = cv2.cvtColor(imgTrainingNumbers, cv2.COLOR_BGR2GRAY) # get grayscale image
imgBlurred = cv2.GaussianBlur(imgGray, (5,5), 0) # blur
# filter image from grayscale to black and white
imgThresh = cv2.adaptiveThreshold(imgBlurred, # input image
255, # make pixels that pass the threshold full white
cv2.ADAPTIVE_THRESH_GAUSSIAN_C, # use gaussian rather than mean, seems to give better results
cv2.THRESH_BINARY_INV, # invert so foreground will be white, background will be black
11, # size of a pixel neighborhood used to calculate threshold value
2) # constant subtracted from the mean or weighted mean
cv2.imshow("imgThresh", imgThresh) # show threshold image for reference
imgThreshCopy = imgThresh.copy() # make a copy of the thresh image, this in necessary b/c findContours modifies the image
imgContours, npaContours, npaHierarchy = cv2.findContours(imgThreshCopy, # input image, make sure to use a copy since the function will modify this image in the course of finding contours
cv2.RETR_EXTERNAL, # retrieve the outermost contours only
cv2.CHAIN_APPROX_SIMPLE) # compress horizontal, vertical, and diagonal segments and leave only their end points
# declare empty numpy array, we will use this to write to file later
# zero rows, enough cols to hold all image data
npaFlattenedImages = np.empty((0, RESIZED_IMAGE_WIDTH * RESIZED_IMAGE_HEIGHT))
intClassifications = [] # declare empty classifications list, this will be our list of how we are classifying our chars from user input, we will write to file at the end
# possible chars we are interested in are digits 0 through 9, put these in list intValidChars
intValidChars = [ord('0'), ord('1'), ord('2'), ord('3'), ord('4'), ord('5'), ord('6'), ord('7'), ord('8'), ord('9'),
ord('A'), ord('B'), ord('C'), ord('D'), ord('E'), ord('F'), ord('G'), ord('H'), ord('I'), ord('J'),
ord('K'), ord('L'), ord('M'), ord('N'), ord('O'), ord('P'), ord('Q'), ord('R'), ord('S'), ord('T'),
ord('U'), ord('V'), ord('W'), ord('X'), ord('Y'), ord('Z')]
for npaContour in npaContours: # for each contour
if cv2.contourArea(npaContour) > MIN_CONTOUR_AREA: # if contour is big enough to consider
[intX, intY, intW, intH] = cv2.boundingRect(npaContour) # get and break out bounding rect
# draw rectangle around each contour as we ask user for input
cv2.rectangle(imgTrainingNumbers, # draw rectangle on original training image
(intX, intY), # upper left corner
(intX+intW,intY+intH), # lower right corner
(0, 0, 255), # red
2) # thickness
imgROI = imgThresh[intY:intY+intH, intX:intX+intW] # crop char out of threshold image
imgROIResized = cv2.resize(imgROI, (RESIZED_IMAGE_WIDTH, RESIZED_IMAGE_HEIGHT)) # resize image, this will be more consistent for recognition and storage
cv2.imshow("imgROI", imgROI) # show cropped out char for reference
cv2.imshow("imgROIResized", imgROIResized) # show resized image for reference
cv2.imshow("training_numbers.png", imgTrainingNumbers) # show training numbers image, this will now have red rectangles drawn on it
intChar = cv2.waitKey(0) # get key press
if intChar == 27: # if esc key was pressed
sys.exit() # exit program
elif intChar in intValidChars: # else if the char is in the list of chars we are looking for . . .
intClassifications.append(intChar) # append classification char to integer list of chars (we will convert to float later before writing to file)
npaFlattenedImage = imgROIResized.reshape((1, RESIZED_IMAGE_WIDTH * RESIZED_IMAGE_HEIGHT)) # flatten image to 1d numpy array so we can write to file later
npaFlattenedImages = np.append(npaFlattenedImages, npaFlattenedImage, 0) # add current flattened impage numpy array to list of flattened image numpy arrays
# end if
# end if
# end for
fltClassifications = np.array(intClassifications, np.float32) # convert classifications list of ints to numpy array of floats
npaClassifications = fltClassifications.reshape((fltClassifications.size, 1)) # flatten numpy array of floats to 1d so we can write to file later
print ("\n\ntraining complete !!\n")
np.savetxt("classifications.txt", npaClassifications) # write flattened images to file
np.savetxt("flattened_images.txt", npaFlattenedImages) #
cv2.destroyAllWindows() # remove windows from memory
return
def sketch(image):
gray_image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
blur= cv2.GaussianBlur(gray_image,ksize=(3,3),sigmaX=0,sigmaY=0)
edge = cv2.Canny(blur,5,70)
ret,th = cv2.threshold(edge,100,255,cv2.THRESH_BINARY_INV)
return th
##### first
mask = cv2.threshold(gray, 255, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1]
stats = cv2.connectedComponentsWithStats(mask, 8)[2]
label_area = stats[1:, cv2.CC_STAT_AREA]
min_area, max_area = 150, 200 # min/max for a single circle
singular_mask = (min_area < label_area) & (label_area <= max_area)
circle_area = np.mean(label_area[singular_mask])
#this is should be the number of circles retreived by the treshold but I am not sure about
n_circles = int(np.sum(np.round(label_area / circle_area)))
print('Total circles:', n_circles)
##### second findContours
blur = cv2.GaussianBlur(gray, (7, 7), 2)
ret,thresh = cv2.threshold(gray,127,255,1)
contours,h = cv2.findContours(thresh,1,2)
print(' Lenght contours ', len(contours) )
#imCopy = imgArray.copy()
#ret,thresh = cv2.threshold(imgArray,127,255,0)from skimage import morphology
##image, contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
#cv2.drawContours(imCopy,contours,-1,(0,255,0), 3)
#imCopy = cv2.resize(imCopy, (2000, 1500))
#cv2.imshow('draw contours',imCopy)
#cv2.waitKey(0)
index = 1
os.mkdir(log1Path + "/" + file_name + "/" + folder1 + "/" +
folder2)
os.mkdir(log05Path + "/" + file_name + "/" + folder1 +
"/" + folder2)
os.mkdir(dogPath + "/" + file_name + "/" + folder1 + "/" +
folder2)
img = cv2.imread(imagePath, 0)
# HE
HE = cv2.equalizeHist(img)
# LoG
LoG05 = ndimage.gaussian_laplace(img, sigma=0.5)
LoG1 = ndimage.gaussian_laplace(img, sigma=1)
# DoG
blur5 = cv2.GaussianBlur(img, (5, 5), 0)
blur3 = cv2.GaussianBlur(img, (3, 3), 0)
DoG = blur5 - blur3
# SIFT
''' descs= None
sift = cv2.xfeatures2d.SIFT_create()
(kps, descs) = sift.detectAndCompute(img, None)'''
# Paths
siftImage = siftPath + "/" + file_name + "/" + folder1 + "/" + folder2 + imagePath[
-8:-4] + "SIFT.txt"
heImage = hePath + "/" + file_name + "/" + folder1 + "/" + folder2 + imagePath[
-8:-4] + "HE.png"
log1Image = log1Path + "/" + file_name + "/" + folder1 + "/" + folder2 + imagePath[
-8:-4] + "LoG1.png"
log05Image = log05Path + "/" + file_name + "/" + folder1 + "/" + folder2 + imagePath[
from skimage.color import rgb2gray, gray2rgb
from skimage.filters import difference_of_gaussians
import cv2
from sklearn.utils import shuffle
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
'dog', 'frog', 'horse', 'ship', 'truck']
train_imagesClear=np.copy(train_images)
for i in range(len(train_images)):
# gauss = np.random.normal(0,.1,(32,32,3))
# gauss = gauss.reshape(32,32,3)
# image=(train_imagesBlur[i]+gauss)
# image=np.clip(image, 0, 1)
image=train_imagesClear[i]
image= cv2.GaussianBlur(image,(3,3),0)
image= rgb2gray(image)
image= gray2rgb(image)
train_imagesClear[i]=image
train_imagesNoisy=np.copy(train_images)
# for i in range(len(train_images)):
# gauss = np.random.normal(0,.1,(32,32,3))
# gauss = gauss.reshape(32,32,3)
# image=(train_imagesNoisy[i]+gauss)
# image=np.clip(image, 0, 1)
# train_imagesNoisy[i]=image
train_imagesGray=np.copy(train_images)
for i in range(len(train_images)):
image=train_imagesGray[i]
#!/usr/bin/python3
import cv2
import matplotlib.pyplot as plt
img = cv2.imread("images/rose.png")
img_blur = cv2.GaussianBlur(img, (5, 5), 0)
plt.imshow(img_blur)
plt.show()
50: 0.2,
70: 0.4,
90: 0.2,
100: 0.1
},
input_noise_std=0.03,
plot_every=0,
device='cuda'),
transforms.ToTensor(),
transforms.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010])
])
gaussian_blur_transform = transforms.Compose([
transforms.RandomResizedCrop(32),
transforms.Lambda(lambda img: pil_to_np(img)),
transforms.Lambda(lambda img: cv2.GaussianBlur(img, (5, 5), 0)),
transforms.Lambda(lambda img: np_to_pil(img)),
transforms.ToTensor(),
transforms.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010])
])
random_blur_transform = transforms.Compose([
transforms.RandomResizedCrop(32),
transforms.Lambda(lambda img: pil_to_np(img)),
transforms.RandomChoice([
transforms.Lambda(lambda img: cv2.blur(img, (5, 5))),
transforms.Lambda(lambda img: cv2.GaussianBlur(img, (5, 5), 0)),
transforms.Lambda(lambda img: cv2.medianBlur(img, 5)),
]),
transforms.Lambda(lambda img: np_to_pil(img)),
transforms.ToTensor(),
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
raise NotImplementedError("noise type {} not supported!".format(noise_type))
# Image Blurring (Image Smoothing)
noise_type_list = ["", "gauss", "s&p", "poisson", "speckle"]
for i, noise_type in enumerate(noise_type_list, start=1):
if noise_type == "":
src_title = "Original"
src_img = img
else:
src_title = noise_type
src_img = add_noise(img, noise_type=noise_type)
averaging_blur = cv.blur(src_img, (5, 5))
gassian_blur = cv.GaussianBlur(src_img, (5, 5), 0)
median_blur = cv.medianBlur(src_img, 5)
bilateral_filtering = cv.bilateralFilter(src_img, 9, 75, 75)
plt.subplot(1, 5, 1), plt.imshow(cv.cvtColor(src_img, cv.COLOR_BGR2RGB)), plt.title(src_title)
plt.xticks([]), plt.yticks([])
plt.subplot(1, 5, 2), plt.imshow(cv.cvtColor(averaging_blur, cv.COLOR_BGR2RGB)), plt.title("Averaging Blurred")
plt.xticks([]), plt.yticks([])
plt.subplot(1, 5, 3), plt.imshow(cv.cvtColor(gassian_blur, cv.COLOR_BGR2RGB)), plt.title("Gaussian Blurred")
plt.xticks([]), plt.yticks([])
plt.subplot(1, 5, 4), plt.imshow(cv.cvtColor(median_blur, cv.COLOR_BGR2RGB)), plt.title("Median Blurred")
plt.xticks([]), plt.yticks([])
plt.subplot(1, 5, 5), plt.imshow(cv.cvtColor(bilateral_filtering, cv.COLOR_BGR2RGB)), plt.title(
"Bilateral Filtering"
)
plt.xticks([]), plt.yticks([])
found_images = np.empty((len(file_class_mapping), 32, 32, 3), dtype=np.uint8)
num_cols = 5
num_rows = math.ceil(len(file_class_mapping)/num_cols)
subplot_setup(num_cols, num_rows)
for index, (filename, class_number) in enumerate(file_class_mapping.items()):
print(index, filename, class_number)
found_images[index] = cv2.imread(file_dir + "/" + filename, cv2.IMREAD_COLOR)
found_images[index] = cv2.cvtColor(found_images[index], cv2.COLOR_BGR2RGB)
subplot_next(found_images[index])
plt.show()
cv2.GaussianBlur(found_images[0], (5, 5), 0)
found_images_gray = convert_to_gray(found_images)
# Poor-man's normalization.
found_images_gray = (found_images_gray-128)/128
subplot_setup(num_cols, num_rows)
for image in found_images_gray:
subplot_next(image)
plt.show()
print('done')
cap = cv2.VideoCapture(
"forest5.avi") # If you want to use webcam use Index like 0,1.
print("video read successssssss", "\n")
fps = int(cap.get(cv2.CAP_PROP_FPS))
print("FPS is ", fps)
length = cap.get(7)
print("Frame count is ", length)
while True:
(grabbed, frame) = cap.read()
if not grabbed:
break
frame = cv2.resize(frame, (320, 240))
blur = cv2.GaussianBlur(frame, (21, 21), 0)
hsv = cv2.cvtColor(blur, cv2.COLOR_BGR2HSV)
#Image.fromarray(hsv).save('hsv_frame_testing.jpg')
lower = [0, 10, 165]
upper = [30, 255, 255]
lower = np.array(lower, dtype="uint8")
upper = np.array(upper, dtype="uint8")
mask = cv2.inRange(hsv, lower, upper)
output = cv2.bitwise_and(frame, hsv, mask=mask)
no_of_red = cv2.countNonZero(mask)
if int(no_of_red) > 1000:
import cv2
import numpy as np
import matplotlib.pyplot as plt
import os, sys
OriginalImage = cv2.imread('hand.jpg', 0) # get the a gray-scale image
plt.figure(1)
plt.subplot(221), plt.imshow(OriginalImage, 'gray')
GaussianImage = cv2.GaussianBlur(OriginalImage, (3, 3), 0)
plt.subplot(222), plt.imshow(GaussianImage, 'gray')
ret, thrsh_GaussianImage = cv2.threshold(GaussianImage, 225, 255,
cv2.THRESH_BINARY)
plt.subplot(223), plt.imshow(thrsh_GaussianImage, 'gray')
plt.show()
im, contours, hierarchy = cv2.findContours(thrsh_GaussianImage, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(thrsh_GaussianImage, contours, -1, (0, 255, 0), 3)
cv2.imshow("j", im)
cv2.waitKey()
img = img[i1_start:i1_stop, i2_start:i2_stop,:] #Retain the central 1280x1280 sub-region to create 25 central patches later
cv2.imwrite('img_CV2_70.jpg', img[:,:,1], [int(cv2.IMWRITE_JPEG_QUALITY), 70]) #JPEG QF=70
tmprs = misc.imresize(img[:,:,1], 1.5) #resampling with scaling 150% of the green channel
i1_start = (tmprs.shape[0]-n)/2 #Find the new coordinates of the central 1280x1280 sub-region
i1_stop = i1_start + n
i2_start = (tmprs.shape[1]-m)/2
i2_stop = i2_start + m
tmprs = tmprs[i1_start:i1_stop, i2_start:i2_stop] #Retain the central 1280x1280 image patch
tmpj= cv2.imread('img_CV2_70.jpg')
os.remove('img_CV2_70.jpg') #Delete the saved JPEG image from dresden images folder
tmp = img[:(img.shape[0]/256)*256,:(img.shape[1]/256)*256,1] #Retain the green channel
tmprs = tmprs[:(tmprs.shape[0]/256)*256,:(tmprs.shape[1]/256)*256]
tmpj = tmpj[:(tmpj.shape[0]/256)*256,:(tmpj.shape[1]/256)*256,1] #Retain the green channel
del(img)
tmpm = cv2.medianBlur(tmp,5) #Median filtering with 5x5 kernel
tmpg = cv2.GaussianBlur(tmp,(5,5),0) #Gaussian blur with default sigma=1.1 and kernel size 5x5
awgn = 2.0*np.random.randn(tmp.shape[0],tmp.shape[1]) #Additive While Gaussian Noise with sigma=2
tmpw = (tmp+awgn)
tmpw = np.clip(tmpw,0,255) #Keep image pixel values within [0,255] range
tmpw = tmpw.astype(np.uint8)
vblocks = np.vsplit(tmp, tmp.shape[0]/256) #split image patch into vertical blocks
shuffle(vblocks)
vblocks = vblocks[:len(vblocks)]
imcount = 0
for v in vblocks:
hblocks = np.hsplit(v, v.shape[1]/256) #split each vertical block into horizantal blocks
shuffle(hblocks)
hblocks = hblocks[:len(hblocks)]
for h in hblocks:
X[count-1] = h.reshape((1,1,256,256))
y[count-1] = 0
cv2.putText(frame_rev, str(park['id']), centroid, cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)
while (cap.isOpened()):
current_count = 0
video_cur_pos = cap.get(cv2.CAP_PROP_POS_MSEC) / 1000.0 # Vị trí hiện tại của video file tính theo giây
video_cur_frame = cap.get(cv2.CAP_PROP_POS_FRAMES) # Vị trí tính theo frame
ret, frame_initial = cap.read()
if ret == True:
frame = cv2.resize(frame_initial, None, fx=0.6, fy=0.6)
if ret == False:
print("Video ended")
break
# Background Subtraction
frame_blur = cv2.GaussianBlur(frame.copy(), (5, 5), 3)
frame_gray = cv2.cvtColor(frame_blur, cv2.COLOR_BGR2GRAY)
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
def main():
# initialize frame dimensions, resized frame dimensions, and the ratio between them
(W, H) = (None, None)
(newW, newH) = (320, 320) # needs to be multiples of 32
(rW, rH) = (None, None)
# layer names that will be used, one for output probabilities and the other for box coordinates
layerNames = ["feature_fusion/Conv_7/Sigmoid", "feature_fusion/concat_3"]
# laod the text detector
net = cv2.dnn.readNet('frozen_east_text_detection.pb')
# start the video stream
vs = VideoStream(src=0).start()
#vs = cv2.VideoCapture('test_video.mp4')
# start fps calculator
fps = FPS().start()
fourcc = cv2.VideoWriter_fourcc('M', 'J', 'P', 'G')
out = cv2.VideoWriter('video_demo.avi', fourcc, 10, (1000, 562))
# video processing loop
while True:
frame = vs.read() # get a frame
frame = frame[1]
if frame is None:
break
# resize the frame
frame = imutils.resize(frame, width=1000)
frame_original = frame.copy()
if W is None or H is None:
(H, W) = frame.shape[:2]
print(H, W)
rW = W / float(newW)
rH = H / float(newH)
frame = cv2.resize(frame, (newW, newH))
# create a blob and use it for text detection
blob = cv2.dnn.blobFromImage(frame,
1.0, (newW, newH),
(123.68, 116.78, 103.94),
swapRB=True,
crop=False)
net.setInput(blob)
(scores, geometry) = net.forward(layerNames)
# get bounding boxes for predictions that pass the minimum confidence requirement
(rects, confidences) = decode_predictions(scores, geometry)
# eliminate unnecessary overlapping boxes
boxes = non_max_suppression(np.array(rects), probs=confidences)
# loop over each box
for (startX, startY, endX, endY) in boxes:
# 2 px buffer added to each side of each box
startX = int(startX * rW - 2)
startY = int(startY * rH - 2)
endX = int(endX * rW + 2)
endY = int(endY * rH + 2)
cv2.rectangle(frame_original, (startX, startY), (endX, endY),
(0, 255, 0), 2)
# crop the image to just the bounding box
image_cropped = frame_original[startY:endY, startX:endX]
# uncomment the line below to detect black text instead of white text
#image_cropped = cv2.bitwise_not(image_cropped)
# attempt preprocessing on the image
try:
image_gray = cv2.cvtColor(image_cropped, cv2.COLOR_BGR2GRAY)
except:
continue
image_blur = cv2.GaussianBlur(image_gray, (1, 1), 0)
# thresh, image_thresh = cv2.threshold(image_blur, 0, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)
thresh, image_thresh = cv2.threshold(image_blur, 150, 255,
cv2.THRESH_BINARY)
# print(pytesseract.image_to_string(image_thresh, config='-c tessedit_char_whitelist=0123456789 -psm 7'))
# detect text in the cropped image after preprocessing is done
text = pytesseract.image_to_string(image_thresh, config='-psm 7')
cv2.putText(frame_original,
text, (endX, endY),
cv2.FONT_HERSHEY_SIMPLEX,
1.0, (0, 255, 0),
lineType=cv2.LINE_AA)
# show the frame with bounding boxes drawn
cv2.imshow("Text Detection", frame_original)
out.write(frame_original)
# if q is pressed, quit
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
break
fps.stop()
print("Elapsed Time: ", fps.elapsed())
print("FPS: ", fps.fps())
# stop the webcam and destroy all windows
#vs.stop()
vs.release()
out.release()
cv2.destroyAllWindows()
# commencing subtraction
while True:
try:
# fetching each frame
flag, frame = capture.read()
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)
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#@TIME :2020/5/19 22:24
#@Author:Michael.ma
# Chapter-2
# 灰度,高斯模糊,边缘,扩张,侵蚀
import cv2
import numpy as np
img = cv2.imread("Resources/lena.png")
kernel = np.ones((5, 5), np.uint8)
# 灰度
imgGray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 高斯模糊
imgBlur = cv2.GaussianBlur(imgGray, (7, 7), sigmaX=0)
# 边缘
imgCanny = cv2.Canny(img, 150, 150)
# 扩张
imgDilation = cv2.dilate(imgCanny, kernel, iterations=1)
# 侵蚀
imgEroded = cv2.erode(imgDilation, kernel, iterations=1)
cv2.imshow("Gray", imgGray)
cv2.imshow("Blur", imgBlur)
cv2.imshow('Canny', imgCanny)
cv2.imshow('Dilation', imgDilation)
cv2.imshow('Eroded', imgEroded)
cv2.waitKey(0)
def canny(img):
gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
kernel = 5
blur = cv2.GaussianBlur(gray, (kernel, kernel), 0)
canny = cv2.Canny(blur, 50, 150)
return canny
def __blur(img, sigma):
if sigma > 0.01:
img[0] = cv2.GaussianBlur(img[0], (7, 7), sigma)
img[1] = cv2.GaussianBlur(img[1], (7, 7), sigma)
img[2] = cv2.GaussianBlur(img[2], (7, 7), sigma)
return img
#print ("Straight")
valServo = int(degree)
#print (valServo)
outServo = valServo
return outServo
else:
#reverse
print ("REVERSE")
cap = cv2.VideoCapture(0)
#print (cap)
while(True):
ret, frame = cap.read()
#print(frame.shape)
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
blur = cv2.GaussianBlur(hsv,(15,15),0)
low_yellow = np.array([20, 110, 180 ])
high_yellow = np.array ([50, 200, 230])
yellow_mask = cv2.inRange(blur, low_yellow, high_yellow)
yellow = cv2.bitwise_and(frame, frame, mask=yellow_mask)
edge = cv2.Canny(yellow, 100, 200)
pix = np.asarray(edge)
#print(edge.shape)
get = np.where(pix[lineCY-1] == 255) # find 255 value at 480th rows
print(get[0])
center = show_center()
val_from_center = drawText()
#val_from_line = int(lineC - center)
import numpy as np
import cv2
img = cv2.imread('flower.jpg')
matrix = (7,7)
blur = cv2.GaussianBlur(img, matrix, 0)
cv2.imshow('blur', blur)
cv2.waitKey(0)
cv2.destroyAllWindows()
# 대비 극대화
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)
plt.figure(figsize=(12, 10))
plt.imshow(gray, cmap='gray')
# Adaptive Thresholding = 적응형 임계값
img_blurred = cv2.GaussianBlur(gray, ksize=(5, 5), sigmaX=0)
img_thresh = cv2.adaptiveThreshold(
img_blurred,
maxValue=255.0,
adaptiveMethod=cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
thresholdType=cv2.THRESH_BINARY_INV,
blockSize=19,
C=9
)
plt.figure(figsize=(12, 10))
plt.imshow(img_thresh, cmap='gray')
# 컨투어링 찾기
contours, hierarchy = cv2.findContours(
def process_image(self, line, data_dir, mode):
""" process_image """
img, grt, img_name, grt_name = self.load_image(
line, data_dir, mode=mode)
if mode == ModelPhase.TRAIN:
img, grt = aug.resize(img, grt, mode)
# 使用不同增强
if cfg.AUG.MY_AUG:
try:
if cfg.AUG.MY_AUG_TYPE == 'aug_baseline':
img, grt = aug_baseline(image=img, mask=grt)
elif cfg.AUG.MY_AUG_TYPE == 'aug_baseline_randRotate90':
img, grt = aug_baseline_randRotate90(image=img, mask=grt)
elif cfg.AUG.MY_AUG_TYPE == 'aug_baseline_randCrop':
img, grt = aug_baseline_randCrop(image=img, mask=grt)
elif cfg.AUG.MY_AUG_TYPE == 'aug_baseline_CLAHE_Sharpen':
img, grt = aug_baseline_CLAHE_Sharpen(image=img, mask=grt)
elif cfg.AUG.MY_AUG_TYPE == 'aug_baseline_simple':
img, grt = aug_baseline_simple(image=img, mask=grt)
elif cfg.AUG.MY_AUG_TYPE == 'aug_baseline_simple_motionBlur':
img, grt = aug_baseline_simple_motionBlur(image=img, mask=grt)
elif cfg.AUG.MY_AUG_TYPE == 'aug_baseline_simple_gaussNoise':
img, grt = aug_baseline_simple_gaussNoise(image=img, mask=grt)
elif cfg.AUG.MY_AUG_TYPE == 'aug_baseline_simple_maskDropout':
img, grt = aug_baseline_simple_maskDropout(image=img, mask=grt)
elif cfg.AUG.MY_AUG_TYPE == 'aug_baseline_simple_gridDropout':
img, grt = aug_baseline_simple_gridDropout(image=img, mask=grt)
elif cfg.AUG.MY_AUG_TYPE == 'aug_baseline_simple_randBC':
img, grt = aug_baseline_simple_randBC(image=img, mask=grt)
elif cfg.AUG.MY_AUG_TYPE == 'aug_baseline_simple_randCrop':
img, grt = aug_baseline_simple_randCrop(image=img, mask=grt)
elif cfg.AUG.MY_AUG_TYPE == 'aug_baseline_simple_randRotate90':
img, grt = aug_baseline_simple_randRotate90(image=img, mask=grt)
else:
raise NotImplementedError
except Exception as e:
print(str(e))
else:
if cfg.AUG.RICH_CROP.ENABLE:
if cfg.AUG.RICH_CROP.BLUR:
if cfg.AUG.RICH_CROP.BLUR_RATIO <= 0:
n = 0
elif cfg.AUG.RICH_CROP.BLUR_RATIO >= 1:
n = 1
else:
n = int(1.0 / cfg.AUG.RICH_CROP.BLUR_RATIO)
if n > 0:
if np.random.randint(0, n) == 0:
radius = np.random.randint(3, 10)
if radius % 2 != 1:
radius = radius + 1
if radius > 9:
radius = 9
img = cv2.GaussianBlur(img, (radius, radius), 0, 0)
img, grt = aug_gaussNoise(image=img, mask=grt)
img, grt = aug_RandomRotate90(image=img, mask=grt)
img, grt = aug.random_rotation(
img,
grt,
rich_crop_max_rotation=cfg.AUG.RICH_CROP.MAX_ROTATION,
mean_value=cfg.DATASET.PADDING_VALUE)
img, grt = aug.rand_scale_aspect(
img,
grt,
rich_crop_min_scale=cfg.AUG.RICH_CROP.MIN_AREA_RATIO,
rich_crop_aspect_ratio=cfg.AUG.RICH_CROP.ASPECT_RATIO)
img = aug.hsv_color_jitter(
img,
brightness_jitter_ratio=cfg.AUG.RICH_CROP.
BRIGHTNESS_JITTER_RATIO,
saturation_jitter_ratio=cfg.AUG.RICH_CROP.
SATURATION_JITTER_RATIO,
contrast_jitter_ratio=cfg.AUG.RICH_CROP.
CONTRAST_JITTER_RATIO)
if cfg.AUG.FLIP:
if cfg.AUG.FLIP_RATIO <= 0:
n = 0
elif cfg.AUG.FLIP_RATIO >= 1:
n = 1
else:
n = int(1.0 / cfg.AUG.FLIP_RATIO)
if n > 0:
if np.random.randint(0, n) == 0:
img = img[::-1, :, :]
grt = grt[::-1, :]
if cfg.AUG.MIRROR:
if np.random.randint(0, 2) == 1:
img = img[:, ::-1, :]
grt = grt[:, ::-1]
img, grt = aug.rand_crop(img, grt, mode=mode)
elif ModelPhase.is_eval(mode):
img, grt = aug.resize(img, grt, mode=mode)
img, grt = aug.rand_crop(img, grt, mode=mode)
elif ModelPhase.is_visual(mode):
org_shape = [img.shape[0], img.shape[1]]
img, grt = aug.resize(img, grt, mode=mode)
valid_shape = [img.shape[0], img.shape[1]]
img, grt = aug.rand_crop(img, grt, mode=mode)
else:
raise ValueError("Dataset mode={} Error!".format(mode))
# Normalize image
if cfg.AUG.TO_RGB:
img = img[..., ::-1]
img = self.normalize_image(img)
if ModelPhase.is_train(mode) or ModelPhase.is_eval(mode):
grt = np.expand_dims(np.array(grt).astype('int32'), axis=0)
ignore = (grt != cfg.DATASET.IGNORE_INDEX).astype('int32')
if ModelPhase.is_train(mode):
return (img, grt, ignore)
elif ModelPhase.is_eval(mode):
return (img, grt, ignore)
elif ModelPhase.is_visual(mode):
return (img, grt, img_name, valid_shape, org_shape)
#Start video capture
video_capture = cv2.VideoCapture(0)
#Sleep for 2 seconds to let camera initialize properly.
time.sleep(2)
#Loop until OpenCV window is not closed
while True:
#Store the readed frame in frame, ret defines return value
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
def GetFiveFeatures(frame):
# 判空
if frame == None:
return [False, 0.0, 0.0, 0.0, 0.0, 0.0, frame]
origin = frame
grayimage = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# 高斯滤波
blur = cv2.GaussianBlur(grayimage, (5, 5), 0)
# 二值化：用大津法，此处选项若是THRESH_BINARY_INV，则同意选用白色背景的图片样本
ret, otsu = cv2.threshold(blur, 0, 255,
cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
# 找轮廓
contours = cv2.findContours(otsu, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
# 轮廓集数目
largest_area = 0
largest_contour_index = 0
num = len(contours[1])
for i in range(num):
area = cv2.contourArea(contours[1][i], False)
if area > largest_area:
largest_area = area
largest_contour_index = i
print "最大面积" + str(largest_area)
maxContour = contours[1][largest_contour_index]
# 画轮廓
cv2.drawContours(origin, maxContour, -1, (0, 0, 255), 2)
# 1. 矩形度
# 查找最小外接矩形
minAreaRect = cv2.minAreaRect(maxContour)
box = cv2.boxPoints(minAreaRect)
box = np.int0(box)
# 画轮廓
cv2.drawContours(origin, [box], 0, (0, 255, 0), 2)
# 计算最小外接矩形面积
minAreaRect_Area = int(cv2.contourArea(box, False))
print "最小外接矩形面积" + str(minAreaRect_Area)
# 错误判断，如果分母为零，直接报错
if minAreaRect_Area == 0.0:
return [False, 0.0, 0.0, 0.0, 0.0, 0.0, origin]
# 特征一：矩形度的计算
P_rect = largest_area * 1.0 / minAreaRect_Area
# 统一结果为3位有理数
P_rect = round(P_rect, 3)
print "矩形度" + str(P_rect)
# 2. 延长度
# 质心计算
M = cv2.moments(maxContour)
Centroid_x = int(M['m10'] / M['m00'])
Centroid_y = int(M['m01'] / M['m00'])
print "质心" + str(Centroid_x) + " " + str(Centroid_y)
cv2.circle(origin, (Centroid_x, Centroid_y), 3, (255, 255, 255), -1)
# 获取长轴
Major_Axis_Length = 0
Major_Axis_Angle = 0
Major_Axis_End_x = 0
Major_Axis_End_y = 0
Major_Axis_Begin_x = 0
Major_Axis_Begin_y = 0
# 此处需要注意质心是否在轮廓内
# 找长轴
for angle in range(180):
theta = angle * 3.14 / 180.0
lengthBackward = 0
lengthForward = 0
point_End_x = Centroid_x
point_End_y = Centroid_y
point_Begin_x = Centroid_x
point_Begin_y = Centroid_y
# 步进越小准确率越高，设置成1可以先找到准确的直线角度，再根据角度和质心得到的直线计算出正确的长轴和轮廓交点
while cv2.pointPolygonTest(maxContour,
(point_End_x, point_End_y), False) > 0:
lengthForward = lengthForward + 0.1
point_End_x = int(
round(point_End_x + lengthForward * math.cos(theta)))
point_End_y = int(
round(point_End_y + lengthForward * math.sin(theta)))
while cv2.pointPolygonTest(maxContour,
(point_Begin_x, point_Begin_y), False) > 0:
lengthBackward = lengthBackward + 0.1
point_Begin_x = int(
round(point_Begin_x - lengthBackward * math.cos(theta)))
point_Begin_y = int(
round(point_Begin_y - lengthBackward * math.sin(theta)))
if lengthForward + lengthBackward >= Major_Axis_Length:
Major_Axis_Length = lengthForward + lengthBackward
Major_Axis_Angle = angle
Major_Axis_End_x = point_End_x
Major_Axis_End_y = point_End_y
Major_Axis_Begin_x = point_Begin_x
Major_Axis_Begin_y = point_Begin_y
# 计算实际长轴长度
Real_Major_Axis_Length = math.sqrt(
math.pow((Major_Axis_End_x - Major_Axis_Begin_x), 2) +
math.pow((Major_Axis_End_y - Major_Axis_Begin_y), 2))
Real_Major_Axis_Length = round(Real_Major_Axis_Length, 1)
print "长轴长度 = " + str(Real_Major_Axis_Length)
print "长轴角度 = " + str(Major_Axis_Angle)
# print "起点 = " + "x: " + str(Major_Axis_Begin_x) + " y: " + str(Major_Axis_Begin_y)
# print "起点 = " + "x: " + str(Major_Axis_End_x) + " y: " + str(Major_Axis_End_y)
# 画长轴
cv2.line(origin, (Major_Axis_Begin_x, Major_Axis_Begin_y),
(Major_Axis_End_x, Major_Axis_End_y), (255, 0, 0), 2)
# 找短轴
# 1. 先得到长轴直线的表达式y=k*x+b，用来计算点到直线距离和判断点在直线上方还是下方
Major_Axis_k = math.tan(Major_Axis_Angle * 3.14 / 180.0)
Major_Axis_b = Centroid_y - Major_Axis_k * Centroid_x
# 2. 点(x0,y0)到直线(Ax+By+C=0)的距离为d =abs (A*x0+B*y0+C)/sqrt(A^2+B^2)
Minor_Axis_A = Major_Axis_k
Minor_Axis_B = -1
Minor_Axis_C = Major_Axis_b
# 3. 遍历轮廓上的点
Minor_Axis_Under_length = 0
Minor_Axis_Above_length = 0
Minor_Axis_Under_End_x = 0
Minor_Axis_Under_End_y = 0
Minor_Axis_Above_End_x = 0
Minor_Axis_Above_End_y = 0
# 轮廓点集
ContourItems = maxContour.shape[0]
for item in range(ContourItems):
point_x = maxContour[item][0][0]
point_y = maxContour[item][0][1]
# 判断点在直线哪一侧
# 上侧
if point_y > int(Major_Axis_k * point_x + Major_Axis_b):
# 点到直线距离
dis = abs((Minor_Axis_A * point_x + Minor_Axis_B * point_y +
Minor_Axis_C) / math.sqrt(Minor_Axis_A * Minor_Axis_A +
Minor_Axis_B * Minor_Axis_B))
if dis >= Minor_Axis_Above_length:
Minor_Axis_Above_length = dis
Minor_Axis_Above_End_x = point_x
Minor_Axis_Above_End_y = point_y
# 下侧
elif point_y < int(Major_Axis_k * point_x + Major_Axis_b):
# 点到直线距离
dis = abs((Minor_Axis_A * point_x + Minor_Axis_B * point_y +
Minor_Axis_C) / math.sqrt(Minor_Axis_A * Minor_Axis_A +
Minor_Axis_B * Minor_Axis_B))
if dis >= Minor_Axis_Under_length:
Minor_Axis_Under_length = dis
Minor_Axis_Under_End_x = point_x
Minor_Axis_Under_End_y = point_y
# 第三种可能就是轮廓与直线的交点
# # 标记两个点,可以忽略
cv2.circle(origin, (Minor_Axis_Above_End_x, Minor_Axis_Above_End_y), 4,
(255, 255, 255), -1)
cv2.circle(origin, (Minor_Axis_Under_End_x, Minor_Axis_Under_End_y), 4,
(255, 255, 255), -1)
# 画出两点直线
cv2.line(origin, (Minor_Axis_Under_End_x, Minor_Axis_Under_End_y),
(Minor_Axis_Above_End_x, Minor_Axis_Above_End_y), (0, 255, 255),
3)
# 计算实际短轴长度
Real_Minor_Axis_Length = math.sqrt(
math.pow((Minor_Axis_Above_End_x - Minor_Axis_Under_End_x), 2) +
math.pow((Minor_Axis_Above_End_y - Minor_Axis_Under_End_y), 2))
Real_Minor_Axis_Length = round(Real_Minor_Axis_Length, 1)
print "短轴长度 = " + str(Real_Minor_Axis_Length)
# 错误判断，如果分母为零，直接报错
if Real_Minor_Axis_Length == 0.0:
return [False, P_rect, 0.0, 0.0, 0.0, 0.0, origin]
# 计算延长度
P_extend = Real_Major_Axis_Length * 1.0 / Real_Minor_Axis_Length
P_extend = round(P_extend, 3)
print "延长度 = " + str(P_extend)
# 画出与长轴距离最远的两点的辅助线,使用时可以不用，画图用作论文使用
# 画出长轴右方
line_above_k = math.tan((Major_Axis_Angle - 90) * 3.14 / 180.0)
line_above_b = Minor_Axis_Above_End_y - line_above_k * Minor_Axis_Above_End_x
Minor_Axis_Above_Begin_x = int(
(line_above_b - Major_Axis_b) / (Major_Axis_k - line_above_k))
Minor_Axis_Above_Begin_y = int(line_above_k * Minor_Axis_Above_Begin_x +
line_above_b)
cv2.line(origin, (Minor_Axis_Above_Begin_x, Minor_Axis_Above_Begin_y),
(Minor_Axis_Above_End_x, Minor_Axis_Above_End_y), (255, 0, 255),
3)
line_under_k = math.tan((Major_Axis_Angle - 90) * 3.14 / 180.0)
line_under_b = Minor_Axis_Under_End_y - line_under_k * Minor_Axis_Under_End_x
Minor_Axis_Under_Begin_x = int(
(line_under_b - Major_Axis_b) / (Major_Axis_k - line_under_k))
Minor_Axis_Under_Begin_y = int(line_under_k * Minor_Axis_Under_Begin_x +
line_under_b)
cv2.line(origin, (Minor_Axis_Under_Begin_x, Minor_Axis_Under_Begin_y),
(Minor_Axis_Under_End_x, Minor_Axis_Under_End_y), (255, 255, 0),
3)
# 3. 球状型
# 遍历轮廓每个点，求与质心最近的距离，作为最大内接圆半径,
# 初始化一个距离
min_radius = math.pow((maxContour[0][0][0] - Centroid_x), 2) + math.pow(
(maxContour[0][0][1] - Centroid_y), 2)
for item in range(ContourItems):
point_x = maxContour[item][0][0]
point_y = maxContour[item][0][1]
local_radius = math.pow((point_x - Centroid_x), 2) + math.pow(
(point_y - Centroid_y), 2)
if local_radius <= min_radius:
min_radius = local_radius
min_radius = int(math.sqrt(min_radius))
cv2.circle(origin, (Centroid_x, Centroid_y), min_radius, (0, 255, 255), 2)
# 遍历轮廓每个点，求与质心最远的距离，作为最小外接圆半径,
# 初始化一个距离
max_radius = math.pow((maxContour[0][0][0] - Centroid_x), 2) + math.pow(
(maxContour[0][0][1] - Centroid_y), 2)
for item in range(ContourItems):
point_x = maxContour[item][0][0]
point_y = maxContour[item][0][1]
local_radius = math.pow((point_x - Centroid_x), 2) + math.pow(
(point_y - Centroid_y), 2)
if local_radius >= max_radius:
max_radius = local_radius
max_radius = int(math.sqrt(max_radius))
cv2.circle(origin, (Centroid_x, Centroid_y), max_radius, (255, 0, 255), 2)
# 错误判断，如果分母为零，直接报错
if max_radius == 0.0:
return [False, P_rect, P_extend, 0.0, 0.0, 0.0, origin]
P_spherical = min_radius * 1.0 / max_radius
P_spherical = round(P_spherical, 3)
print "球状型： " + str(P_spherical)
# 错误判断，如果分母为零，直接报错
if Real_Major_Axis_Length == 0.0:
return [False, P_rect, P_extend, P_spherical, 0.0, 0.0, origin]
# 4. 叶状型
P_leaf = min_radius * 1.0 / Real_Major_Axis_Length
P_leaf = round(P_leaf, 3)
print "叶状型 = " + str(P_leaf)
# 错误判断，如果分母为零，直接报错
if Real_Major_Axis_Length == 0.0:
return [False, P_rect, P_extend, P_spherical, P_leaf, 0.0, origin]
# 5. 似圆度
P_circle = largest_area * 4.0 / (3.14 * Real_Major_Axis_Length *
Real_Major_Axis_Length)
P_circle = round(P_circle, 2)
print "似圆度 = " + str(P_circle)
# 错误判断，如果分母为零，直接报错
if Real_Major_Axis_Length == 0.0:
return [False, P_rect, P_extend, P_spherical, P_leaf, P_circle, origin]
# 6. 复杂度
ArcLength = cv2.arcLength(maxContour, True)
P_complecate = ArcLength * ArcLength * 1.0 / (4 * 3.14 * largest_area)
P_complecate = round(P_complecate, 2)
print "复杂度 = " + str(P_complecate)
# 可以捎带返回处理完之后的画完辅助线的图
return [True, P_rect, P_extend, P_spherical, P_leaf, P_circle, origin]
import cv2
import numpy as np
img_ori = cv2.imread('1.jpg')
img_gray = cv2.cvtColor(img_ori, cv2.COLOR_BGR2GRAY)
img_blurred = cv2.GaussianBlur(img_gray, ksize=(5, 5), sigmaX=0)
img_thresh = cv2.adaptiveThreshold(
img_blurred, maxValue=255.0, adaptiveMethod=cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
thresholdType=cv2.THRESH_BINARY_INV,
blockSize=19,
C=9
)
#ret, img_binary = cv.threshold(img_gray, 127, 255, 0) #검은창에 도형두개잇는거
contours, hierachy = cv2.findContours(img_thresh, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
min_x=[]
max = 0
mix = 0
may = 0
miy = 0
min_y=[]
max_w=[]
max_h=[]
a = []
cnt =0
xy=[]
#xy = [[0 for rows in range(2)] for cols in range(len(contours))] #len(contours) x 2 행렬
for t in range(len(contours)):
for u in range(len(contours[t])):
#xy[cnt][0] = contours[t][u][0][0]
#xy[cnt][1] = contours[t][u][0][1]
