import numpy as np
img = cv.imread('imagen/wppstalkerlarge.jpg')
cv.imshow('stalker', img)
blank = np.zeros(img.shape, dtype='uint8')
cv.imshow('blank', blank)
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
cv.imshow('Gray', gray)
grayblurred = cv.GaussianBlur(gray, (5,5), cv.BORDER_DEFAULT)
#corners
canny = cv.Canny(grayblurred, 125, 175)
cv.imshow('CannyEdges', canny)
#corners can also be found by threesholding
#threeshold
#ret, thresh = cv.threshold(gray, 125, 255, cv.THRESH_BINARY)
#cv.imshow('Thresh', thresh)
#contours
contours, hierarchies = cv.findContours(canny, cv.RETR_LIST, cv.CHAIN_APPROX_SIMPLE)
print(f'{len(contours)} contour(s) found!')
cv.drawContours(blank, contours, -1, (0,255,0), 1)
cv.imshow('contoursDrawn', blank)
cv.waitKey(0)
from cv2 import cv2
import numpy as np
from skimage.morphology import opening
#dulieu=str(input("Enter link image:"))
img = cv2.imread('beans.jpg')
kernel = np.ones((5, 5), np.uint8)
# Bước 1: Chuyển về ảnh xám
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Bước 2: Làm mờ ảnh
blur = cv2.GaussianBlur(gray, (9, 9), 1)
cv2.imshow('new', blur)
# Bước 3: Lọc nhiễu
new = cv2.adaptiveThreshold(blur, 255, cv2.ADAPTIVE_THRESH_MEAN_C,
cv2.THRESH_BINARY, 9, -5)
# Bước 4: Opening
opening = cv2.morphologyEx(new, cv2.MORPH_OPEN, kernel)
# Bước 5: Đếm
contours = cv2.findContours(opening, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[0]
# Kiểm tra kết quả
cv2.drawContours(img, contours, -1, (255, 0, 0), 3)
cv2.imshow('opening', opening)
print("Count: " + str(len(contours)))
cv2.waitKey(0)
cv2.destroyAllWindows()
cv2.imshow('Threshold', thresh)
major = cv2.__version__.split('.')[0]
if major == '3':
image, contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
else:
contours, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
try:
contour = max(contours, key=lambda x: cv2.contourArea(x))
x, y, w, h = cv2.boundingRect(contour)
cv2.rectangle(crop_image, (x, y), (x + w, y + h), (0, 0, 255), 0)
hull = cv2.convexHull(contour)
drawing = np.zeros(crop_image.shape, np.uint8)
cv2.drawContours(drawing, [contour], -1, (0, 255, 0), 0)
cv2.drawContours(drawing, [hull], -1, (0, 255, 0), 0)
hull = cv2.convexHull(contour, returnPoints=False)
defects = cv2.convexityDefects(contour, hull)
count_defects = 0
for i in range(defects.shape[0]):
s, e, f, d = defects[i, 0]
start = tuple(contour[s][0])
end = tuple(contour[e][0])
far = tuple(contour[f][0])
a = math.sqrt((end[0] - start[0])**2 + (end[1] - start[1])**2)
b = math.sqrt((far[0] - start[0])**2 + (far[1] - start[1])**2)
c = math.sqrt((end[0] - far[0])**2 + (end[1] - far[1])**2)
angle = (math.acos(
def test(self, saved_region_parent_dir=None):
print("Pre-processing test data...")
img_hsv = self.training_data[self.test_img_name]['hsv_img']
img_rgb = cv2.cvtColor(img_hsv, cv2.COLOR_HSV2RGB)
img_s = img_hsv[:, :, 1]
img_shape = (img_hsv.shape[0], img_hsv.shape[1])
# blur kernels
large_blur_kernel = (95, 95)
med_blur_kernel = (63, 63)
small_blur_kernel = (31, 31)
# Dilation/erosion kernels
cross_strel = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))
block_strel = np.ones((3, 3))
ellipse_strel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
ellipse90_strel = np.rot90(ellipse_strel)
circle_strel = np.bitwise_or(ellipse_strel, ellipse90_strel)
b_over_r = img_rgb[:, :, 0] < img_rgb[:, :, 2]
b_over_g = img_rgb[:, :, 1] < img_rgb[:, :, 2]
b_over_rg = np.bitwise_and(b_over_r, b_over_g)
b_replace = np.max([img_rgb[:, :, 0], img_rgb[:, :, 1]], axis=0)
b_suppress_img = img_rgb.copy()
b_suppress_img[b_over_rg, 2] = b_replace[b_over_rg]
b_suppress_img_hsv = cv2.cvtColor(b_suppress_img, cv2.COLOR_RGB2HSV)
enhanced_v_img = b_suppress_img_hsv[:, :, 2]
# diff of gaussians
img_blur_1 = cv2.blur(enhanced_v_img, (15, 15))
img_blur_2 = cv2.blur(enhanced_v_img, (127, 127))
tmp_img_1 = img_blur_1.astype(np.int16)
tmp_img_2 = img_blur_2.astype(np.int16)
edge_mask = tmp_img_2 - tmp_img_1
edge_mask[edge_mask > 0] = 0
edge_mask[edge_mask < 0] = 255
edge_mask = edge_mask.astype(np.uint8)
contours = cv2x.filter_contours_by_size(edge_mask, min_size=15 * 15)
edge_mask = np.zeros(img_shape, dtype=np.uint8)
cv2.drawContours(edge_mask, contours, -1, 255, -1)
edge_mask = cv2.dilate(edge_mask, cross_strel, iterations=1)
# color candidates (all non-monochrome, non-blue colors)
print("Generating color candidates...")
tmp_color_img = cv2.cvtColor(b_suppress_img_hsv, cv2.COLOR_HSV2RGB)
tmp_color_img = cv2.blur(tmp_color_img, (9, 9))
tmp_color_img = cv2.cvtColor(tmp_color_img, cv2.COLOR_RGB2HSV)
color_mask = color_utils.create_mask(
tmp_color_img, ['green', 'cyan', 'red', 'violet', 'yellow'])
# Next, clean up any "noise", say, ~ 11 x 11
contours = cv2x.filter_contours_by_size(color_mask, min_size=5 * 5)
color_mask2 = np.zeros(img_shape, dtype=np.uint8)
cv2.drawContours(color_mask2, contours, -1, 255, -1)
# do a couple dilations to smooth some outside edges & connect any
# adjacent cells each other
color_mask3 = cv2.dilate(color_mask2, cross_strel, iterations=2)
color_mask3 = cv2.erode(color_mask3, cross_strel, iterations=3)
# filter out any remaining contours that are the size of roughly 2 cells
contours = cv2x.filter_contours_by_size(color_mask3,
min_size=2 * 40 * 40)
color_mask3 = np.zeros(img_shape, dtype=np.uint8)
cv2.drawContours(color_mask3, contours, -1, 255, -1)
good_color_contours = []
for i, c in enumerate(contours):
filled_c_mask = np.zeros(img_shape, dtype=np.uint8)
cv2.drawContours(filled_c_mask, [c], -1, 255, cv2.FILLED)
new_mask, signal, orig = cv2x.find_border_by_mask(
edge_mask,
filled_c_mask,
max_dilate_percentage=0.3,
dilate_iterations=1)
if not orig and signal > 0.7:
_, contours, _ = cv2.findContours(new_mask, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
good_color_contours.append(contours[0])
elif orig and signal > 0.7:
good_color_contours.append(c)
else:
pass # don't include contour
# The previous contours represent the final count of contours for the color group,
# but not their final shape/size. The final step is to use approxPolyDP, followed
# by a few more dilations, but we won't re-draw and extract the contours, as that
# would possibly connect some of them together. However, we will draw them for
# the mask to exclude these regions from the next 2 groups of candidates
final_color_contours = []
for c in good_color_contours:
peri = cv2.arcLength(c, True)
smooth_c = cv2.approxPolyDP(c, 0.007 * peri, True)
single_cnt_mask = np.zeros(img_shape, dtype=np.uint8)
cv2.drawContours(single_cnt_mask, [smooth_c], 0, 255, -1)
# erode & dilate
single_cnt_mask = cv2.erode(single_cnt_mask,
block_strel,
iterations=1)
single_cnt_mask = cv2.dilate(single_cnt_mask,
block_strel,
iterations=8)
_, contours, _ = cv2.findContours(single_cnt_mask,
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
if len(contours) > 0:
final_color_contours.append(contours[0])
# final color mask to use for exclusion from further groups
final_color_mask = np.zeros(img_shape, dtype=np.uint8)
cv2.drawContours(final_color_mask, final_color_contours, -1, 255, -1)
# start large structure saturation candidates
print("Generating large saturation candidates...")
img_s_large_blur = cv2.GaussianBlur(img_s, large_blur_kernel, 0, 0)
med = np.median(img_s_large_blur[img_s_large_blur > 0])
img_s_large_blur = cv2.bitwise_and(img_s_large_blur,
img_s_large_blur,
mask=~final_color_mask)
mode_s_large = cv2.inRange(img_s_large_blur, med, 255)
mode_s_large = cv2.erode(mode_s_large, block_strel, iterations=5)
good_contours_large = cv2x.filter_contours_by_size(
mode_s_large,
min_size=10 * 32 * 32,
max_size=(img_shape[0] * img_shape[1]) * .33)
# update the signal mask by removing the previous color candidates
edge_mask = cv2.bitwise_and(edge_mask,
edge_mask,
mask=~final_color_mask)
contours = cv2x.filter_contours_by_size(edge_mask, min_size=21 * 21)
edge_mask = np.zeros(img_shape, dtype=np.uint8)
cv2.drawContours(edge_mask, contours, -1, 255, -1)
edge_mask = cv2.dilate(edge_mask, (3, 3), iterations=2)
good_large_sat_val_contours = []
for i, c in enumerate(good_contours_large):
filled_c_mask = np.zeros(img_shape, dtype=np.uint8)
cv2.drawContours(filled_c_mask, [c], -1, 255, cv2.FILLED)
new_mask, signal, orig = cv2x.find_border_by_mask(
edge_mask,
filled_c_mask,
max_dilate_percentage=2.0,
dilate_iterations=1)
if not orig and signal > 0.7:
_, contours, _ = cv2.findContours(new_mask, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
good_large_sat_val_contours.append(contours[0])
elif signal > 0.7:
good_large_sat_val_contours.append(c)
else:
pass # ignore contour
# The previous contours represent the final contour count for the large sat-val group,
# but not their final shape/size. The final step is to use approxPolyDP, followed
# by a few more dilations, but we won't re-draw and extract the contours, as that
# would possibly connect some of them together. However, we will draw them for
# the mask to exclude these regions from the next group of candidates
final_large_sat_val_contours = []
for c in good_large_sat_val_contours:
peri = cv2.arcLength(c, True)
smooth_c = cv2.approxPolyDP(c, 0.0035 * peri, True)
single_cnt_mask = np.zeros(img_shape, dtype=np.uint8)
cv2.drawContours(single_cnt_mask, [smooth_c], 0, 255, -1)
# erode & dilate
single_cnt_mask = cv2.dilate(single_cnt_mask,
circle_strel,
iterations=10)
_, tmp_contours, _ = cv2.findContours(single_cnt_mask,
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
final_large_sat_val_contours.append(tmp_contours[0])
# final group mask to use for exclusion from further groups
final_large_sat_val_mask = np.zeros(img_shape, dtype=np.uint8)
cv2.drawContours(final_large_sat_val_mask,
final_large_sat_val_contours, -1, 255, -1)
# start medium structure saturation candidates
print("Generating medium saturation candidates...")
img_s_medium_blur = cv2.GaussianBlur(img_s, med_blur_kernel, 0, 0)
med = np.median(img_s_medium_blur[img_s_medium_blur > 0])
# make intermediate candidate mask
tmp_candidate_mask = np.bitwise_or(final_color_mask,
final_large_sat_val_mask)
img_s_medium_blur = cv2.bitwise_and(img_s_medium_blur,
img_s_medium_blur,
mask=~tmp_candidate_mask)
mode_s_med = cv2.inRange(img_s_medium_blur, np.ceil(med), 255)
mode_s_med = cv2.erode(mode_s_med, block_strel, iterations=8)
good_contours_med = cv2x.filter_contours_by_size(
mode_s_med,
min_size=2 * 32 * 32,
max_size=(img_shape[0] * img_shape[1]) * .125)
# update signal mask with last group of candidates
edge_mask = cv2.bitwise_and(edge_mask,
edge_mask,
mask=~final_large_sat_val_mask)
contours = cv2x.filter_contours_by_size(edge_mask, min_size=21 * 21)
edge_mask = np.zeros(img_shape, dtype=np.uint8)
cv2.drawContours(edge_mask, contours, -1, 255, -1)
edge_mask = cv2.dilate(edge_mask, (3, 3), iterations=2)
final_med_sat_val_contours = []
for i, c in enumerate(good_contours_med):
filled_c_mask = np.zeros(img_shape, dtype=np.uint8)
cv2.drawContours(filled_c_mask, [c], -1, 255, cv2.FILLED)
new_mask, signal, orig = cv2x.find_border_by_mask(
edge_mask,
filled_c_mask,
max_dilate_percentage=1.5,
dilate_iterations=1)
if not orig and signal > 0.7:
_, contours, _ = cv2.findContours(new_mask, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
final_med_sat_val_contours.append(contours[0])
elif signal > 0.7:
final_med_sat_val_contours.append(c)
else:
pass # ignore contour
med_sat_val_mask = np.zeros(img_shape, dtype=np.uint8)
cv2.drawContours(med_sat_val_mask, final_med_sat_val_contours, -1, 255,
cv2.FILLED)
# The previous contours represent the final count of contours for the med sat-val group,
# but not their final shape/size. The final step is to use approxPolyDP, followed
# by a few more dilations, but we won't re-draw and extract the contours, as that
# would possibly connect some of them together. However, we will draw them for
# the mask to exclude these regions from the next group of candidates
_, contours, _ = cv2.findContours(med_sat_val_mask, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
final_med_sat_val_contours = []
for c in contours:
peri = cv2.arcLength(c, True)
smooth_c = cv2.approxPolyDP(c, 0.0035 * peri, True)
single_cnt_mask = np.zeros(img_shape, dtype=np.uint8)
cv2.drawContours(single_cnt_mask, [smooth_c], 0, 255, -1)
# erode & dilate
single_cnt_mask = cv2.dilate(single_cnt_mask,
ellipse90_strel,
iterations=10)
_, tmp_contours, _ = cv2.findContours(single_cnt_mask,
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
final_med_sat_val_contours.append(tmp_contours[0])
# final color mask to use for exclusion from further groups
final_med_sat_val_mask = np.zeros(img_shape, dtype=np.uint8)
cv2.drawContours(final_med_sat_val_mask, final_med_sat_val_contours,
-1, 255, -1)
# start small structure saturation candidates
print("Generating small saturation candidates...")
img_s_small_blur = cv2.bilateralFilter(img_s, small_blur_kernel[0], 31,
31)
med = np.median(img_s_small_blur[img_s_small_blur > 0])
# make intermediate candidate mask
tmp_candidate_mask = np.bitwise_or(tmp_candidate_mask,
final_med_sat_val_mask)
img_s_small_blur = cv2.bitwise_and(img_s_small_blur,
img_s_small_blur,
mask=~tmp_candidate_mask)
mode_s_small = cv2.inRange(img_s_small_blur, np.ceil(med), 255)
mode_s_small = cv2.erode(mode_s_small, block_strel, iterations=2)
good_contours_small = cv2x.filter_contours_by_size(
mode_s_small,
min_size=15 * 15,
max_size=(img_shape[0] * img_shape[1]) * .05)
# update signal mask with last group of candidates
edge_mask = cv2.bitwise_and(edge_mask,
edge_mask,
mask=~final_med_sat_val_mask)
contours = cv2x.filter_contours_by_size(edge_mask, min_size=31 * 31)
edge_mask = np.zeros(img_shape, dtype=np.uint8)
cv2.drawContours(edge_mask, contours, -1, 255, -1)
edge_mask = cv2.dilate(edge_mask, (3, 3), iterations=3)
good_small_sat_val_contours = []
for i, c in enumerate(good_contours_small):
filled_c_mask = np.zeros(img_shape, dtype=np.uint8)
cv2.drawContours(filled_c_mask, [c], -1, 255, cv2.FILLED)
new_mask, signal, orig = cv2x.find_border_by_mask(
edge_mask,
filled_c_mask,
max_dilate_percentage=2.5,
dilate_iterations=1)
if not orig and signal > 0.7:
_, contours, _ = cv2.findContours(new_mask, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
good_small_sat_val_contours.append(contours[0])
elif signal > 0.7:
good_small_sat_val_contours.append(c)
else:
pass # ignore contour
tmp_small_sat_val_contours = good_small_sat_val_contours.copy()
good_small_sat_val_contours = []
for c in tmp_small_sat_val_contours:
area = cv2.contourArea(c)
if area > 27 * 27:
good_small_sat_val_contours.append(c)
# The previous contours represent the final countour count for the small sat-val group,
# but not their final shape/size. The final step is to use approxPolyDP, followed
# by a few more dilations, but we won't re-draw and extract the contours, as that
# would possibly connect some of them together. However, we will draw them for
# the mask to exclude these regions from the next group of candidates
final_small_sat_val_contours = []
for c in good_small_sat_val_contours:
peri = cv2.arcLength(c, True)
smooth_c = cv2.approxPolyDP(c, 0.007 * peri, True)
single_cnt_mask = np.zeros(img_shape, dtype=np.uint8)
cv2.drawContours(single_cnt_mask, [smooth_c], 0, 255, -1)
# erode & dilate
single_cnt_mask = cv2.dilate(single_cnt_mask,
block_strel,
iterations=10)
_, tmp_contours, _ = cv2.findContours(single_cnt_mask,
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
final_small_sat_val_contours.append(tmp_contours[0])
all_contours = final_color_contours + \
final_large_sat_val_contours + \
final_med_sat_val_contours + \
final_small_sat_val_contours
model_classes = list(self.pipe.named_steps['classification'].classes_)
final_contour_results = []
test_data_processed = []
for c_idx, c in enumerate(all_contours):
if saved_region_parent_dir is not None:
region_base_name = '.'.join([str(c_idx), 'png'])
region_file_path = os.path.join(saved_region_parent_dir,
region_base_name)
if not os.path.exists(saved_region_parent_dir):
os.makedirs(saved_region_parent_dir)
else:
region_file_path = None
region_base_name = None
features = color_utils.generate_features(
img_hsv, c, region_file_path=region_file_path)
features_df = pd.DataFrame([features])
probabilities = self.pipe.predict_proba(
features_df.drop('label', axis=1))
labelled_probs = {
a: probabilities[0][i]
for i, a in enumerate(model_classes)
}
pred_label = max(labelled_probs,
key=lambda key: labelled_probs[key])
pred_label_prob = labelled_probs[pred_label]
final_contour_results.append({
'test_index': c_idx,
'contour': c,
'prob': labelled_probs
})
features['pred_label'] = pred_label
features['pred_label_prob'] = pred_label_prob
features['region_file'] = region_base_name
features['region_index'] = c_idx
test_data_processed.append(features)
self.test_data_processed = pd.DataFrame(test_data_processed)
self.test_data_processed.set_index('region_index')
self.test_results = final_contour_results
import numpy as np
from cv2 import cv2
# Load image - resize hình do kích thước hình quá to
image = cv2.imread('cell.jpg')
image = cv2.resize(image, (1200, 900))
# Convert to Gray image
gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
# Image binarization
ret, binary_image = cv2.threshold(gray_image, 165, 255, cv2.THRESH_BINARY)
# Contour detection
_, contours, _ = cv2.findContours(binary_image, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
for contour in contours:
cv2.drawContours(image, contour, -1, (255, 0, 0), 3)
cv2.imshow('Image', image)
cv2.imshow('Gray image', gray_image)
cv2.imshow('Binary image', binary_image)
cv2.waitKey(0)
cv2.destroyAllWindows()
_, im = cv2.threshold(gray_img, 220, 1,
cv2.THRESH_BINARY + cv2.THRESH_OTSU)
if sum(sum(gray_img.astype('double'))) > 1000:
cnts, hier = cv2.findContours(im, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
center = None
for c in cnts:
x, y, w, h = cv2.boundingRect(c)
#cv2.rectangle(img, (x,y),(x+w,y+h),(0,255,0),2)
rect = cv2.minAreaRect(c)
box = cv2.boxPoints(rect)
box = np.int0(box)
cv2.drawContours(img, [box], 0, (0, 0, 255))
if len(cnts) > 1:
c = sorted(cnts, key=cv2.contourArea)[-1] # The largest area
((x, y), radius) = cv2.minEnclosingCircle(c)
M = cv2.moments(c)
#deal with division by zero
if M["m00"] != 0:
center = (int(M["m10"] / M["m00"]),
int(M["m01"] / M["m00"]))
else:
center = (0, 0)
CX = center[0]
CY = center[1]
center_string = "CX:{}, CY:{}".format(CX, CY)
cv2.putText(img, center_string, (0, 128),
cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 1)
from cv2 import cv2
img = cv2.imread('tomato2.jpg', 1)
img = cv2.resize(img, (0, 0), fx=0.6, fy=0.6)
#Convert to hsv channel for segmentation, then contour miscalculation due to segmentation overlap
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
ret, seg_img = cv2.threshold(
hsv[:, :, 0], 25, 255,
cv2.THRESH_BINARY_INV) #red in hue channel is b/w 0-25 and 250-255
cv2.imshow("Poor Segmentation", seg_img)
#Try contouring on overlapped segments, tomatoes group considered one object
contours, heirarchy = cv2.findContours(seg_img, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
img2 = img.copy()
cv2.drawContours(img2, contours, -1, (0, 0, 0), 2)
cv2.imshow("Wrong Contours", img2)
#Canny Edges
edges = cv2.Canny(img, 100, 70) #Lower and upper limit of threshold edges
cv2.imshow("Canny", edges)
#Canny Contours, using edges to find better segmented img for better contour
improve_seg_img = seg_img - edges
cv2.imshow("Canny Segmentation", improve_seg_img)
contours, heirarchy = cv2.findContours(improve_seg_img, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(img, contours, -1, (0, 0, 0), 1)
cv2.imshow("Canny Contours", img)
#膨胀操作
kernel = np.ones((3, 3), np.uint8)
paper1 = cv2.dilate(paper1, kernel, iterations=1)
if show_process:
imshow(paper1)
#轮廓检测
cnts = cv2.findContours(paper1, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[1]
#提取面积最大的轮廓
cnts = sorted(cnts, key=lambda x: cv2.contourArea(x), reverse=True)
#绘制面积最大的轮廓
show = org1.copy()
show = cv2.drawContours(show, cnts, 0, (0, 255, 0), 1)
if show_process:
imshow(show)
cnt = []
#步长设置为周长的0.0001倍，一般来说取epsilon = 0.001倍周长
step = 0.0001 * cv2.arcLength(cnts[0], True)
epsilon = step
#不断递增epsilon直到近似所得轮廓正好包含四个点
while len(cnt) != 4:
cnt = cv2.approxPolyDP(cnts[0], epsilon, True)
#步增epsilon
def gestos_mano():
cap = cv2.VideoCapture(0)
# cap = cv2.VideoCapture(1)
bg = None
# COLORES PARA VISUALIZACIÓN
color_start = (204, 204, 0)
color_end = (204, 0, 204)
color_far = (255, 0, 0)
color_start_far = (204, 204, 0)
color_far_end = (204, 0, 204)
color_start_end = (0, 255, 255)
color_contorno = (0, 255, 0)
color_ymin = (0, 130, 255) # Punto más alto del contorno
# color_angulo = (0,255,255)
# color_d = (0,255,255)
color_fingers = (0, 255, 255)
while True:
ret, frame = cap.read()
if ret == False: break
# Redimensionar la imagen para que tenga un ancho de 640
frame = imutils.resize(frame, width=640)
frame = cv2.flip(frame, 1)
frameAux = frame.copy()
if bg is not None:
# Determinar la región de interés
ROI = frame[50:300, 380:600]
cv2.rectangle(frame, (380 - 2, 50 - 2), (600 + 2, 300 + 2),
color_fingers, 1)
grayROI = cv2.cvtColor(ROI, cv2.COLOR_BGR2GRAY)
# Región de interés del fondo de la imagen
bgROI = bg[50:300, 380:600]
# Determinar la imagen binaria (background vs foreground)
dif = cv2.absdiff(grayROI, bgROI)
_, th = cv2.threshold(dif, 30, 255, cv2.THRESH_BINARY)
th = cv2.medianBlur(th, 7)
# Encontrando los contornos de la imagen binaria
cnts, _ = cv2.findContours(th, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = sorted(cnts, key=cv2.contourArea, reverse=True)[:1]
for cnt in cnts:
# Encontrar el centro del contorno
M = cv2.moments(cnt)
if M["m00"] == 0: M["m00"] = 1
x = int(M["m10"] / M["m00"])
y = int(M["m01"] / M["m00"])
cv2.circle(ROI, tuple([x, y]), 5, (0, 255, 0), -1)
# Punto más alto del contorno
ymin = cnt.min(axis=1)
cv2.circle(ROI, tuple(ymin[0]), 5, color_ymin, -1)
# Contorno encontrado a través de cv2.convexHull
hull1 = cv2.convexHull(cnt)
cv2.drawContours(ROI, [hull1], 0, color_contorno, 2)
# Defectos convexos
hull2 = cv2.convexHull(cnt, returnPoints=False)
defects = cv2.convexityDefects(cnt, hull2)
# Seguimos con la condición si es que existen defectos convexos
if defects is not None:
inicio = [
] # Contenedor en donde se almacenarán los puntos iniciales de los defectos convexos
fin = [
] # Contenedor en donde se almacenarán los puntos finales de los defectos convexos
fingers = 0 # Contador para el número de dedos levantados
for i in range(defects.shape[0]):
s, e, f, d = defects[i, 0]
start = cnt[s][0]
end = cnt[e][0]
far = cnt[f][0]
# Encontrar el triángulo asociado a cada defecto convexo para determinar ángulo
a = np.linalg.norm(far - end)
b = np.linalg.norm(far - start)
c = np.linalg.norm(start - end)
angulo = np.arccos(
(np.power(a, 2) + np.power(b, 2) - np.power(c, 2))
/ (2 * a * b))
angulo = np.degrees(angulo)
angulo = int(angulo)
# Se descartarán los defectos convexos encontrados de acuerdo a la distnacia
# entre los puntos inicial, final y más alelago, por el ángulo y d
if np.linalg.norm(start - end
) > 20 and angulo < 90 and d > 12000:
# Almacenamos todos los puntos iniciales y finales que han sido
# obtenidos
inicio.append(start)
fin.append(end)
# Visualización de distintos datos obtenidos
# cv2.putText(ROI,'{}'.format(angulo),tuple(far), 1, 1.5,color_angulo,2,cv2.LINE_AA)
# cv2.putText(ROI,'{}'.format(d),tuple(far), 1, 1.1,color_d,1,cv2.LINE_AA)
cv2.circle(ROI, tuple(start), 5, color_start, 2)
cv2.circle(ROI, tuple(end), 5, color_end, 2)
cv2.circle(ROI, tuple(far), 7, color_far, -1)
# cv2.line(ROI,tuple(start),tuple(far),color_start_far,2)
# cv2.line(ROI,tuple(far),tuple(end),color_far_end,2)
# cv2.line(ROI,tuple(start),tuple(end),color_start_end,2)
# Si no se han almacenado puntos de inicio (o fin), puede tratarse de
# 0 dedos levantados o 1 dedo levantado
if len(inicio) == 0:
minY = np.linalg.norm(ymin[0] - [x, y])
if minY >= 110:
fingers = fingers + 1
cv2.putText(ROI, '{}'.format(fingers),
tuple(ymin[0]), 1, 1.7,
(color_fingers), 1, cv2.LINE_AA)
# Si se han almacenado puntos de inicio, se contará el número de dedos levantados
for i in range(len(inicio)):
fingers = fingers + 1
cv2.putText(ROI, '{}'.format(fingers),
tuple(inicio[i]), 1, 1.7, (color_fingers),
1, cv2.LINE_AA)
if i == len(inicio) - 1:
fingers = fingers + 1
cv2.putText(ROI, '{}'.format(fingers),
tuple(fin[i]), 1, 1.7, (color_fingers),
1, cv2.LINE_AA)
# Se visualiza el número de dedos levantados en el rectángulo izquierdo
if fingers == 0:
cv2.putText(frame, 'Auxilio', (390, 45), 1, 2,
(color_fingers), 2, cv2.LINE_AA)
else:
if fingers == 1:
cv2.putText(frame, 'Estoy bien!', (390, 45), 1, 2,
(color_fingers), 2, cv2.LINE_AA)
else:
if fingers == 2:
if angulo > 60:
cv2.putText(frame, 'Tengo hambre',
(390, 45), 1, 2,
(color_fingers), 2,
cv2.LINE_AA)
else:
if angulo < 40:
cv2.putText(frame, 'Tengo sueño',
(390, 45), 1, 2,
(color_fingers), 2,
cv2.LINE_AA)
else:
if fingers == 3:
cv2.putText(frame, 'Te quiero', (390, 45),
1, 2, (color_fingers), 2,
cv2.LINE_AA)
else:
if fingers == 4:
cv2.putText(frame, 'Gesto desconocido',
(300, 45), 1, 2,
(color_fingers), 2,
cv2.LINE_AA)
else:
cv2.putText(frame, 'Hola mundo!',
(300, 45), 1, 2,
(color_fingers), 2,
cv2.LINE_AA)
cv2.imshow('th', th)
cv2.imshow('Frame', frame)
k = cv2.waitKey(20)
if k == ord('i'):
bg = cv2.cvtColor(frameAux, cv2.COLOR_BGR2GRAY)
if k == 27:
break
cap.release()
cv2.destroyAllWindows()
import numpy as np
from cv2 import cv2
img = cv2.imread('detect_blob.png', 1)
gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
thresh_img = cv2.adaptiveThreshold(
gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 115,
1) #guassion threshold with output binary threshold type
#Make sure to binarize image before using contour functions
cv2.imshow("Adaptive Thresh Image", thresh_img)
#Contours
contours, hierarchy = cv2.findContours(thresh_img, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
img2 = img.copy()
index = -1 #if negative all contours are drawn, index of contour to be drawn
thickness = 4
color = (255, 0, 255)
cv2.drawContours(img2, contours, index, color, thickness)
cv2.imshow('Contours', img2)
print("Contours", contours)
cv2.waitKey(0)
cv2.destroyAllWindows()
def plot_test_results(trained_pipeline, report):
hsv_img = trained_pipeline.training_data[
trained_pipeline.test_img_name]['hsv_img'].copy()
ground_truth = trained_pipeline.training_data[
trained_pipeline.test_img_name]['regions']
test_results = trained_pipeline.test_results
# first, map ground truth indices by label
gt_by_label_map = {}
for i, gt in enumerate(ground_truth):
if gt['label'] not in gt_by_label_map:
gt_by_label_map[gt['label']] = []
gt_by_label_map[gt['label']].append(gt['points'])
tp_by_label_map = {}
fp_by_label_map = {}
fn_by_label_map = {}
for k, v in report.items():
if k not in tp_by_label_map:
tp_by_label_map[k] = []
fp_by_label_map[k] = []
fn_by_label_map[k] = []
for tp in v['tp']:
if 'test_ind' in tp:
tp_by_label_map[k].append(
test_results[tp['test_ind']]['contour'])
for fp in v['fp']:
if 'test_ind' in fp:
fp_by_label_map[k].append(
test_results[fp['test_ind']]['contour'])
for fn in v['fn']:
if 'gt_ind' in fn:
fn_by_label_map[k].append(ground_truth[fn['gt_ind']]['points'])
# create separate set of images for each class label
for class_label in sorted(report.keys()):
# ground truth
if class_label != 'background':
new_img = cv2.cvtColor(hsv_img.copy(), cv2.COLOR_HSV2RGB)
cv2.drawContours(new_img, gt_by_label_map[class_label], -1,
(0, 255, 0), 5)
plt.figure(figsize=(8, 8))
plt.imshow(new_img)
plt.title("%s - %s" % (class_label, 'Ground Truth'))
plt.show()
# true positive
new_img = cv2.cvtColor(hsv_img.copy(), cv2.COLOR_HSV2RGB)
cv2.drawContours(new_img, tp_by_label_map[class_label], -1,
(0, 255, 0), 5)
plt.figure(figsize=(8, 8))
plt.imshow(new_img)
plt.title("%s - %s" % (class_label, 'True Positive'))
plt.show()
# false negative
new_img = cv2.cvtColor(hsv_img.copy(), cv2.COLOR_HSV2RGB)
cv2.drawContours(new_img, fn_by_label_map[class_label], -1,
(0, 255, 0), 5)
plt.figure(figsize=(8, 8))
plt.imshow(new_img)
plt.title("%s - %s" % (class_label, 'False Negative'))
plt.show()
# false positive
new_img = cv2.cvtColor(hsv_img.copy(), cv2.COLOR_HSV2RGB)
cv2.drawContours(new_img, fp_by_label_map[class_label], -1,
(0, 255, 0), 5)
plt.figure(figsize=(8, 8))
plt.imshow(new_img)
plt.title("%s - %s" % (class_label, 'False Positive'))
plt.show()
def contourAnalyze(self, contours, pname, **numContours):
if ('num' in numContours):
self.numContours = numContours['num']
#print(self.numContours)
#takes contours above {minArea} and below {maxArea}
rcontours = []
#holds the {# of contours} indices
indList = []
#holds the {# of contours} positions
mxyList = []
ind1 = -1
for i in range(len(contours)):
#------ Basic Declarations ---------------------
p = contours[i]
#desired area
area = cv2.contourArea(contours[i])
#-------------------------------------------------
#------- Contour Calculations --------------------
if area >= self.minArea and area <= self.maxArea:
#increase the first indice for position saving
ind1 = ind1 + 1
indList.append(ind1)
#make rotating boxes around points
rect = cv2.minAreaRect(p)
box = cv2.boxPoints(rect)
box = np.int0(box)
#put the box onto the original frame
cv2.drawContours(self.frame, [box], 0, (0, 255, 0), 2)
#store the position of the contoured objects
#ASSUMES THAT NEW CONTOURS AREN'T BEING INTRODUCED
m = cv2.moments(p)
mx = int(m['m10'] / m['m00'])
my = int(m['m01'] / m['m00'])
mxyList.append([mx, my])
cv2.circle(self.frame, (mx, my), 5, (0, 0, 255), 2)
cv2.putText(self.frame, 'HEY', (mx, my),
cv2.FONT_HERSHEY_SIMPLEX, 1, 255, 2)
rcontours.append(p)
if len(rcontours) != self.numContours:
#print('\nduck\n')
return False, rcontours
elif len(rcontours) == self.numContours:
#print('\nPEEPEE\n')
self.save(pname, indList, mxyList, pos)
#saves newly edited pos to file
with open(pname, 'w+b') as file:
pickle.dump(pos, file)
#returns check and contours that meet area standards
return True, rcontours
def show_contours(img, contour, text, x, y):
cv.drawContours(img, [contour], 0, [0, 0, 255], 2)
cv.putText(img, text, (x, y), cv.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 0), 2)
cv.imshow(window_source, img)
approx = cv2.approxPolyDP(c, 0.05 * peri, True)
# if our approximated contour has four points, then
# we can assume that we have found our screen
if len(approx) == 4 and max_size > cv2.contourArea(c) > min_size:
screenCnt = approx
break
if screenCnt is None:
detected = 0
print("No plate detected")
else:
detected = 1
if detected == 1:
cv2.drawContours(img, [screenCnt], -1, (0, 255, 0), 3)
# Masking the part other than the number plate
mask = np.zeros(gray.shape, np.uint8)
new_image = cv2.drawContours(mask, [screenCnt], 0, 255, -1, )
new_image = cv2.bitwise_and(img, img, mask=mask)
# Now crop
(x, y) = np.where(mask == 255)
(topx, topy) = (np.min(x), np.min(y))
(bottomx, bottomy) = (np.max(x), np.max(y))
Cropped = gray[topx:bottomx + 1, topy:bottomy + 1]
# Print number
text = pytesseract.image_to_string(Cropped, config='--psm 11')
print("programming_fever's License Plate Recognition\n")
cv2.CHAIN_APPROX_SIMPLE)
"""
for cnt in contours:
area = cv2.contourArea(cnt)
if (area > 50000) & (area < 52000):
print(area)
epsilon = 0.01*cv2.arcLength(cnt,True)
approx = cv2.approxPolyDP(cnt,epsilon,True)
cv2.drawContours(img, [approx],0, (0,255,0),3)
"""
#it is necessary to filter the contours via a parameter,
# in this case, we use the concept of area of a geometric figure
for cnt in contours:
area = cv2.contourArea(cnt)
if (area > 95000) & (area < 100600):
print(area)
epsilon = 0.01 * cv2.arcLength(cnt, True)
approx = cv2.approxPolyDP(cnt, epsilon, True)
cv2.drawContours(img, [approx], 0, (0, 255, 0), 3)
"""
for cnt in contours:
epsilon = 0.01*cv2.arcLength(cnt,True)
approx = cv2.approxPolyDP(cnt,epsilon,True)
cv2.drawContours(img, [approx],0, (0,255,0), 3)
"""
cv2.imshow('img', img) #display final result
cv2.imwrite('8_Detct_black_aera.jpg', img)
#cv2.imwrite("triangl_sh.jpg",img)#save image
cv2.waitKey(0)
edges = cv2.Canny(img,100,100)
plot_images(blur, edges)
cv2.imwrite("data/images/blr.png", laplacian)
image_pat = "{}/{}".format(images_dir, "blr.png")
edg = cv2.imread(image_pat)
_, cnts, new = cv2.findContours(edges.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
image_copy = image.copy()
_ = cv2.drawContours(image_copy, cnts, -1, (106,0,255),2)
plot_images(image, image_copy)
cnts = sorted(cnts, key=cv2.contourArea, reverse=True)[:1000]
image_copy = image.copy()
_ = cv2.drawContours(image_copy, cnts, -1, (255,0,255),2)
plot_images(image, image_copy)
plate = None
for c in cnts:
perimeter = cv2.arcLength(c, True)
edges_count = cv2.approxPolyDP(c, 0.02 * perimeter, True)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imshow("gray Scale Image", gray)
cv2.waitKey(0)
gray = cv2.bilateralFilter(gray, 11, 17, 17)
#cv2.imshow("Smoother Image", gray)
#cv2.waitKey(0)
edged = cv2.Canny(gray, 170, 200)
cv2.imshow("Canny edge", edged)
cv2.waitKey(0)
cnts, new = cv2.findContours(edged.copy(), cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
image1 = image.copy()
cv2.drawContours(image1, cnts, -1, (0, 255, 0), 3)
cv2.imshow("Canny after contouring", image1)
cv2.waitKey(0)
cnts = sorted(cnts, key=cv2.contourArea, reverse=True)[:30]
NumberPlateCount = None
image2 = image.copy()
cv2.drawContours(image2, cnts, -1, (0, 255, 0), 3)
#cv2.imshow("TOP 30 Contours", image2)
#cv2.waitKey(0)
count = 0
name = 1
for i in cnts:
def get_contours(raw_img, img, img_contour, frame_w, frame_h, dead_zone,
area_min, green_trackbars):
direction = 0
area = 0
crop_xywh = None
contours, hierarchy = cv2.findContours(img, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
dead_zone_w = dead_zone
dea_zone_h = dead_zone - 15
for cnt in contours:
area = cv2.contourArea(cnt)
if area > area_min:
cv2.drawContours(img_contour, cnt, -1, (255, 0, 255), 3)
peri = cv2.arcLength(cnt, True)
approx = cv2.approxPolyDP(cnt, 0.02 * peri, True)
x, y, w, h = cv2.boundingRect(approx)
crop_xywh = x, y, w, h
if crop_xywh is not None:
x, y, w, h = crop_xywh
candidate_img = raw_img[y:y + h, x:x + w]
candidate_img = cv2.resize(candidate_img, (320, 240))
mask = np.ones(raw_img.shape[:2])
mask = cv2.drawContours(mask, [cnt], -1, 0, cv2.FILLED)
candidate_img2 = raw_img.copy()
candidate_img2[mask.astype(np.bool), :] = 0
candidate_img2 = candidate_img2[y:y + h, x:x + w]
candidate_img2 = cv2.resize(candidate_img2, (320, 240))
else:
candidate_img = np.zeros((240, 320, 3), np.uint8)
candidate_img2 = np.zeros((240, 320, 3), np.uint8)
cand_contour = candidate_img.copy()
data_green = green_trackbars.get_trackbar_values()
area_min_green = data_green[-1]
cand_dil, cand_res = prepare_img(data_green, candidate_img)
correct_candidate = get_candidate_contours(cand_dil, cand_contour,
area_min_green)
if not correct_candidate:
no_candidate = np.zeros((240, 320, 3), np.uint8)
candidate_img2 = np.zeros((240, 320, 3), np.uint8)
stack_cand = stack_images(
1, ([no_candidate, cand_res, img_contour], [
cand_dil, candidate_img2,
np.zeros((240, 320, 3), np.uint8)
]))
cv2.imshow('candidate', stack_cand)
elif correct_candidate:
cv2.rectangle(img_contour, (x, y), (x + w, y + h), (0, 255, 0),
5)
stack_cand = stack_images(
1, ([candidate_img, cand_res, img_contour], [
cand_dil, candidate_img2,
np.zeros((240, 320, 3), np.uint8)
]))
cv2.imshow('candidate', stack_cand)
# cv2.putText(img_contour, "Points: " + str(len(approx)), (x + w + 20, y + 20), cv2.FONT_HERSHEY_COMPLEX, .7,
# (0, 255, 0), 2)
# cv2.putText(img_contour, "Area: " + str(int(area)), (x + w + 20, y + 45), cv2.FONT_HERSHEY_COMPLEX, 0.7,
# (0, 255, 0), 2)
# print(area)
# cv2.putText(img_contour, " " + str(int(x)) + " " + str(int(y)), (x - 20, y - 45), cv2.FONT_HERSHEY_COMPLEX,
# 0.7,
# (0, 255, 0), 2)
cx = int(x + (w / 2))
cy = int(y + (h / 2))
# print(cx, cy)
# if cx < int(frame_w / 2) - dead_zone_w:
# cv2.putText(img_contour, " GO LEFT ", (20, 50), cv2.FONT_HERSHEY_COMPLEX, 1, (0, 0, 255), 3)
# cv2.rectangle(img_contour, (0, int(frame_h / 2 - dea_zone_h)),
# (int(frame_w / 2) - dead_zone_w, int(frame_h / 2) + dea_zone_h), (0, 0, 255),
# cv2.FILLED)
# direction = 1
# elif cx > int(frame_w / 2) + dead_zone_w:
# cv2.putText(img_contour, " GO RIGHT ", (20, 50), cv2.FONT_HERSHEY_COMPLEX, 1, (0, 0, 255), 3)
# cv2.rectangle(img_contour, (int(frame_w / 2 + dead_zone_w), int(frame_h / 2 - dea_zone_h)),
# (frame_w, int(frame_h / 2) + dea_zone_h), (0, 0, 255), cv2.FILLED)
# direction = 2
# elif cy < int(frame_h / 2) - dea_zone_h:
# cv2.putText(img_contour, " GO UP ", (20, 50), cv2.FONT_HERSHEY_COMPLEX, 1, (0, 0, 255), 3)
# cv2.rectangle(img_contour, (int(frame_w / 2 - dead_zone_w), 0),
# (int(frame_w / 2 + dead_zone_w), int(frame_h / 2) - dea_zone_h), (0, 0, 255),
# cv2.FILLED)
# direction = 3
# elif cy > int(frame_h / 2) + dea_zone_h:
# cv2.putText(img_contour, " GO DOWN ", (20, 50), cv2.FONT_HERSHEY_COMPLEX, 1, (0, 0, 255), 3)
# cv2.rectangle(img_contour, (int(frame_w / 2 - dead_zone_w), int(frame_h / 2) + dea_zone_h),
# (int(frame_w / 2 + dead_zone_w), frame_h), (0, 0, 255), cv2.FILLED)
# direction = 4
# else:
# direction = 0
cv2.line(img_contour, (int(frame_w / 2), int(frame_h / 2)),
(cx, cy), (0, 0, 255), 3)
return direction, area, crop_xywh
return direction, area, crop_xywh
from cv2 import cv2
imagen=cv2.imread('contorno.jpg')
grises=cv2.cvtColor(imagen,cv2.COLOR_BGR2GRAY)
_,umbral=cv2.threshold(grises,100,255,cv2.THRESH_BINARY)
contorno,jerarquía = cv2.findContours(umbral,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(imagen,contorno,-1,(251, 63, 52),3)
#Mostrar
cv2.imshow('Imagen original',imagen)
#cv2.imshow('Imagen en grises',grises)
#cv2.imshow('Imagen Umbral',umbral)
cv2.waitKey(0)
cv2.destroyAllWindows()
moments = cv2.moments(max_contour)
if moments['m00'] != 0:
cx = int(moments['m10'] /
moments['m00']) #Calculation for the center points of hand
cy = int(moments['m01'] / moments['m00'])
center = (cx, cy)
cv2.circle(cropped, center, 10, [0, 0, 255], 2)
if max_area != 0:
epsilon = 0.25 * cv2.arcLength(max_contour, True)
approx = cv2.approxPolyDP(max_contour, epsilon, True)
cv2.drawContours(cropped, [max_contour], -1, (0, 255, 0), 2)
hull = cv2.convexHull(max_contour, returnPoints=True)
hull_area = cv2.contourArea(hull)
cv2.drawContours(cropped, [hull], 0, (0, 0, 255), 2)
hull = cv2.convexHull(max_contour, returnPoints=False)
defects = cv2.convexityDefects(max_contour, hull)
if defects is not None:
count = 0
for i in range(defects.shape[0]):
s, e, f, d = defects[i, 0]
start = tuple(max_contour[s][0])
end = tuple(max_contour[e][0])
far = tuple(max_contour[f][0])
# ........gray_left = cv2.cvtColor(left_eye_image, cv2.COLOR_BGR2GRAY)
# ........gray_right = cv2.cvtColor(right_eye_image, cv2.COLOR_BGR2GRAY)
# ........gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# ........ret,thresh_left = cv2.threshold(gray_left,THRESH_CONST,255,cv2.THRESH_BINARY_INV)
# ........ret,thresh_right = cv2.threshold(gray_right,THRESH_CONST,255,cv2.THRESH_BINARY_INV)
# average the eye aspect ratio together for both eyes
ear = (leftEAR + rightEAR) / 2.0
# compute the convex hull for the left and right eye, then
# visualize each of the eyes
leftEyeHull = cv2.convexHull(leftEye)
rightEyeHull = cv2.convexHull(rightEye)
cv2.drawContours(frame, [leftEyeHull], -1, (0, 0xFF, 0), 1)
cv2.drawContours(frame, [rightEyeHull], -1, (0, 0xFF, 0), 1)
# check to see if the eye aspect ratio is below the blink
# threshold, and if so, increment the blink frame counter
if ear < EYE_AR_THRESH:
COUNTER += 1
else:
# otherwise, the eye aspect ratio is not below the blink
# threshold
# if the eyes were closed for a sufficient number of
# then increment the total number of blinks
if COUNTER >= EYE_AR_CONSEC_FRAMES:
from cv2 import cv2 as cv
img_color = cv.imread("datas/images/shapes.png")
img_gray = cv.cvtColor(img_color, cv.COLOR_BGR2GRAY)
ret, img_binary = cv.threshold(img_gray, 127, 255, 0)
contours, _ = cv.findContours(
img_binary, cv.RETR_LIST,
cv.CHAIN_APPROX_SIMPLE) # findContours(img, mode, method)
# https://docs.opencv.org/4.4.0/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0
for contour in contours:
area = cv.contourArea(contour)
cv.drawContours(
img_color, [contour], 0, (255, 0, 0),
1) # contours가 list형태로 되어있어, 형변환 없이 contour도 list타입으로 받기 위해 []를 씌워줌
cv.imshow("Result", img_color)
cv.waitKey(0)
'''
What is contours?
A curve joining all the continuous points, havinig same color or intensity(강도,세기).
Contours are a useful tool for Shape Analysis and Object Detection and Recognition
1. better accuracy, use binary images. So before finding contours, apply threshold or canny edge detection.
2. FindContours function modifies the source images.
3. Findig contours is like finding white object from black background. So, object to be found should be white and background should be black.
Reference : https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_imgproc/py_contours/py_contours_begin/py_contours_begin.html#contours-getting-started
'''
ret,frame2=cam.read()
cv2.imshow('original frame',frame1)
emailImg=cam.read()[1]
frame1=frame1[290:480,320:490]
frame2=frame2[290:480,320:490]
black=np.zeros(frame1.shape,np.uint8)
diff=cv2.absdiff(frame1,frame2)
diff=cv2.cvtColor(diff,cv2.COLOR_BGR2GRAY)
diff=cv2.GaussianBlur(diff,(5,5),0)
ret,diff=cv2.threshold(diff,34,255,cv2.THRESH_BINARY)
diff=cv2.dilate(diff,None,iterations=3)
contours,_=cv2.findContours(diff,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(frame1,contours,-1,(0,255,255),2)
path=f'opencv tut/{t.ctime(t.time())[11:19]}.png'.replace(':','')
for c in contours:
if cv2.contourArea(c)<7000:
continue
x,y,w,h=cv2.boundingRect(c)
cv2.rectangle(frame1,(x,y),(x+w,y+h),(0,255,255),4)
cv2.rectangle(black,(x,y),(x+w,y+h),(0,255,255),-1)
if flag:
pass
cv2.imwrite(path,emailImg)
sendmail(path)
flag=False
#cv2.imwrite('hi.png',emailImg)
def make_binary_mask(contour, img_dims):
mask = np.zeros(img_dims, dtype=np.uint8)
cv2.drawContours(mask, [contour], 0, 1, cv2.FILLED)
# return boolean array
return mask
def drawContours(img_rgb, contours):
for cnt in contours:
area = cv2.contourArea(cnt)
cv2.drawContours(img_rgb, [cnt], 0, (255,0,0), 1)
return img_rgb
def tracker(video_path,
background_full,
rois,
threshold=5,
display=True,
area_min=0,
area_max=1000,
split_range=False):
""" Function that takes a video path, a background file, rois, threshold and display switch. This then uses
background subtraction and centroid tracking to find the XZ coordinates of the largest contour. Saves out a csv file
with frame #, X, Y, contour area"""
print("tracking {}".format(video_path))
# As camera is often excluded, check here and buffer if not included
if len(rois) == 1:
rois['cam'] = 'unknown'
# load video
video = cv2.VideoCapture(video_path)
if display:
# create display window
cv2.namedWindow("Live thresholded")
cv2.namedWindow("Live")
# as there can be multiple rois the writer, data and moviename are kept in lists
data = list()
frame_id = 0
for roi in np.arange(0, len(rois) - 1):
data.append(list())
if split_range is False:
total = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
split_range = [0, total + 1]
split_name = False
else:
split_name = True
while video.isOpened():
ret, frame = video.read()
if not ret:
print("reached end of video")
video.release()
break
if frame_id in np.arange(split_range[0], split_range[1]):
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
frameDelta_full = cv2.absdiff(background_full, gray)
# tracking
cx = list()
cy = list()
contourOI = list()
contourOI_ = list()
for roi in range(0, len(rois) - 1):
# for the frame define an ROI and crop image
curr_roi = rois["roi_" + str(roi)]
frameDelta = frameDelta_full[curr_roi[1]:curr_roi[1] +
curr_roi[3],
curr_roi[0]:curr_roi[0] +
curr_roi[2]]
image_thresholded = cv2.threshold(frameDelta, threshold, 255,
cv2.THRESH_TOZERO)[1]
(contours, _) = cv2.findContours(image_thresholded,
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
if len(contours) > 0:
contourOI_.append(max(contours, key=cv2.contourArea))
area = cv2.contourArea(contourOI_[roi])
if (area > area_min) and (area < area_max):
contourOI.append(cv2.convexHull(contourOI_[roi]))
M = cv2.moments(contourOI[roi])
cx.append(int(M["m10"] / M["m00"]))
cy.append(int(M["m01"] / M["m00"]))
data[roi].append((frame_id, cx[roi], cy[roi], area))
else:
print(
"no large enough contour found for roi {}!".format(
roi))
data[roi].append((frame_id, np.nan, np.nan, np.nan))
contourOI_[-1] = False
contourOI.append(False)
cx.append(np.nan)
cy.append(np.nan)
else:
print("no contour found for roi {}!".format(roi))
data[roi].append((frame_id, np.nan, np.nan, np.nan))
contourOI_.append(False)
contourOI.append(False)
cx.append(np.nan)
cy.append(np.nan)
if frame_id % 500 == 0:
print("Frame {}".format(frame_id))
if display:
full_image_thresholded = (cv2.threshold(
frameDelta_full, threshold, 255, cv2.THRESH_TOZERO)[1])
# Live display of full resolution and ROIs
cv2.putText(full_image_thresholded,
"Framenum: {}".format(frame_id),
(30, full_image_thresholded.shape[0] - 30),
cv2.FONT_HERSHEY_SIMPLEX,
fontScale=0.5,
color=255)
for roi in range(0, len(rois) - 1):
if np.all(contourOI_[roi] != False):
curr_roi = rois["roi_" + str(roi)]
# add in contours
corrected_contour = np.empty(contourOI_[roi].shape)
corrected_contour[:, 0,
0] = contourOI_[roi][:, 0,
0] + curr_roi[0]
corrected_contour[:, 0,
1] = contourOI_[roi][:, 0,
1] + curr_roi[1]
cv2.drawContours(full_image_thresholded,
corrected_contour.astype(int), -1,
255, 1)
# add in centroid
cv2.circle(
full_image_thresholded,
(cx[roi] + curr_roi[0], cy[roi] + curr_roi[1]), 8,
255, 1)
cv2.imshow("Live thresholded", full_image_thresholded)
cv2.imshow("Live", gray)
cv2.waitKey(1)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
frame_id += 1
# saving data
print("Saving data output")
date = datetime.datetime.now().strftime("%Y%m%d")
for roi in range(0, len(rois) - 1):
datanp = np.array(data[roi])
if split_name is False:
filename = video_path[
0:-4] + "_tracks_{}_Thresh_{}_Area_{}_roi-{}.csv".format(
date, threshold, area_min, roi)
else:
range_s = str(split_range[0]).zfill(5)
range_e = str(split_range[1]).zfill(5)
filename = video_path[
0:-4] + "_tracks_{}_Thresh_{}_Area_{}_Range{}-{}_.csv".format(
date, threshold, area_min, range_s, range_e)
os.makedirs(os.path.dirname(filename), exist_ok=True)
np.savetxt(filename, datanp, delimiter=",")
print("Tracking finished on video cleaning up")
cv2.destroyAllWindows()
img = cv.imread('Photos/cat.jpg')
cv.imshow('Cat', img)
# To draw contours
blank1 = np.zeros(img.shape, dtype='uint8')
# cv.imshow('Blank1',blank1)
blank2 = np.zeros(img.shape, dtype='uint8')
# cv.imshow('Blank2',blank2)
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
cv.imshow('Gray', gray)
canny = cv.Canny(gray, 125, 125)
cv.imshow('Canny Edges', canny)
contours, hierarchies = cv.findContours(canny, cv.RETR_LIST,
cv.CHAIN_APPROX_NONE)
print(f'{len(contours)} contour(s) found in canny!')
cv.drawContours(blank1, contours, -1, (255, 255, 255), 1)
cv.imshow('Contours drawn for canny', blank1)
ret, thresh = cv.threshold(gray, 125, 255, cv.THRESH_BINARY)
cv.imshow('Thresh', thresh)
contours, hierarchies = cv.findContours(thresh, cv.RETR_LIST,
cv.CHAIN_APPROX_NONE)
print(f'{len(contours)} contour(s) found in thresh!')
cv.drawContours(blank2, contours, -1, (255, 255, 255), 1)
cv.imshow('Contours drawn for thresh', blank2)
cv.waitKey(0)
#variable para cargar la imagen
original = cv2.imread('monedassoles.jpg')
#pasar a escalas grises
gris = cv2.cvtColor(original, cv2.COLOR_BGR2GRAY)
#es un suavizado para desenfoque para eliminar ruidos
gauss = cv2.GaussianBlur(gris, (valorGauss, valorGauss),
0) #para el modelado gausiano se necesita una matriz
canny = cv2.Canny(gauss, 60, 100)
#contornos de afuera, se trabaja con matrices
kernel = np.ones((valorKernel, valorKernel), np.uint8)
cierre = cv2.morphologyEx(canny, cv2.MORPH_CLOSE, kernel)
#devuelven dos valores contornos y jerarquía
contornos, jerarquía = cv2.findContours(cierre.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
print("monedas encontradas: {}".format(len(contornos)))
#dibuja el contorno de linea 19
cv2.drawContours(original, contornos, -1, (0, 0, 255), 2)
#Mostrar resultados
#cv2.imshow("Grises",gris)
#cv2.imshow("gauss",gauss)
#cv2.imshow("canny",canny)
#cv2.imshow("cierre",cierre)
#mostrar las imagenes
cv2.imshow("Resultado", original)
#para que no se cierre la imagen y quede hasta cerrar
cv2.waitKey(0)
thresh=thresh,
maxval=max_val,
type=cv2.THRESH_BINARY_INV)
print(dst_bin.shape)
# find all contours in the image
contours, hierarchy = cv2.findContours(dst_bin, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
# # then find bounding box ROI
# new_image = dst_bin.copy()
# print(new_image.shape)
# print(contours)
cv2.drawContours(raw_img, contours, -1, (0, 255, 0), 1)
# cv2.imshow("out", new_image)
plt.imshow(raw_img[:, :, ::-1])
#plt.show()
#%%
for cnt in contours:
x, y, w, h = cv2.boundingRect(cnt)
print(x, y, w, h)
# extract the ROI
pad = 0
print("gone")
# roi = new_image[y - pad:y + h + pad, x - pad:x + w + pad]
img = cv2.imread("fuzzy.png",1)
hsv = cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
hsv_split = np.concatenate((hsv[:,:,0],hsv[:,:,1],hsv[:,:,2]),axis=1)
cv2.imshow("HSV Split",hsv_split)
#Dilating Saturation channel and thresholding to get segmentation
kernel=np.ones((3,3),'uint8')
dilate=cv2.dilate(hsv[:,:,1],kernel,iterations=1)
cv2.imshow("S Dilation",dilate)
ret,dilate_thresh = cv2.threshold(dilate,200,255,cv2.THRESH_BINARY)
cv2.imshow("S Dilate Trheshold",dilate_thresh)
#Contours
canvas = np.ones(img.shape,'uint8') * 255
contours,heirarchy = cv2.findContours(dilate_thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
for c in contours:
area = cv2.contourArea(c)
perim = cv2.arcLength(c,True)
print("Perimeter: {}, Area: {}".format(perim,area))
if area > 1000:
cv2.drawContours(canvas,[c],-1,(rand.randint(0,255),0,rand.randint(0,255)),-1)
cv2.imshow("FINAL RESULT",canvas)
cv2.waitKey(0)
cv2.destroyAllWindows()
