Found 575 images belonging to 3 classes.
Found 69 images belonging to 3 classes.
2021-11-29 07:23:46.324131: I tensorflow/core/platform/cpu_feature_guard.cc:151] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX AVX2
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2021-11-29 07:23:46.991234: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 1401 MB memory:  -> device: 0, name: GeForce GT 710, 
pci bus id: 0000:08:00.0, compute capability: 3.5
C:\Users\kamil\.conda\envs\tensorflow\lib\site-packages\keras\optimizer_v2\adam.py:105: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.
  super(Adam, self).__init__(name, **kwargs)
Epoch 1/30
C:\Users\kamil\.conda\envs\tensorflow\lib\site-packages\tensorflow\python\util\dispatch.py:1096: UserWarning: "`categorical_crossentropy` received `from_logits=True`, but the `output` argument was produced by a sigmoid or softmax activation and thus does not represent logits. Was this intended?"
  return dispatch_target(*args, **kwargs)
2021-11-29 07:23:49.612822: I tensorflow/stream_executor/cuda/cuda_dnn.cc:366] Loaded cuDNN version 8100
2021-11-29 07:23:50.894726: W tensorflow/core/common_runtime/bfc_allocator.cc:275] Allocator (GPU_0_bfc) ran out of memory trying to allocate 1.08GiB with freed_by_count=0. The caller indicates that this is not a failure, but may mean that there could be performance gains if more memory were available.
2021-11-29 07:23:51.946854: W tensorflow/core/common_runtime/bfc_allocator.cc:275] Allocator (GPU_0_bfc) ran out of memory trying to allocate 1018.38MiB with freed_by_count=0. The caller indicates that this is not a failure, but may mean that there could be performance gains if more memory were available.
2021-11-29 07:23:53.234559: W tensorflow/core/common_runtime/bfc_allocator.cc:275] Allocator (GPU_0_bfc) ran out of memory trying to allocate 729.89MiB with freed_by_count=0. The caller indicates that this is not a failure, but may mean that there could be performance gains if more memory were available.
2021-11-29 07:23:53.563607: W tensorflow/core/common_runtime/bfc_allocator.cc:275] Allocator (GPU_0_bfc) ran out of memory trying to allocate 562.77MiB with freed_by_count=0. The caller indicates that this is not a failure, but may mean that there could be performance gains if more memory were available.
2021-11-29 07:23:53.979189: W tensorflow/core/common_runtime/bfc_allocator.cc:275] Allocator (GPU_0_bfc) ran out of memory trying to allocate 360.53MiB with freed_by_count=0. The caller indicates that this is not a failure, but may mean that there could be performance gains if more memory were available.
2021-11-29 07:23:53.984987: W tensorflow/core/common_runtime/bfc_allocator.cc:275] Allocator (GPU_0_bfc) ran out of memory trying to allocate 532.02MiB with freed_by_count=0. The caller indicates that this is not a failure, but may mean that there could be performance gains if more memory were available.
2021-11-29 07:23:54.724332: W tensorflow/core/common_runtime/bfc_allocator.cc:275] Allocator (GPU_0_bfc) ran out of memory trying to allocate 790.02MiB with freed_by_count=0. The caller indicates that this is not a failure, but may mean that there could be performance gains if more memory were available.
2021-11-29 07:23:54.878406: W tensorflow/core/common_runtime/bfc_allocator.cc:275] Allocator (GPU_0_bfc) ran out of memory trying to allocate 289.45MiB with freed_by_count=0. The caller indicates that this is not a failure, but may mean that there could be performance gains if more memory were available.
2021-11-29 07:23:55.423657: W tensorflow/core/common_runtime/bfc_allocator.cc:275] Allocator (GPU_0_bfc) ran out of memory trying to allocate 866.56MiB with freed_by_count=0. The caller indicates that this is not a failure, but may mean that there could be performance gains if more memory were available.
2021-11-29 07:23:59.404689: E tensorflow/stream_executor/cuda/cuda_driver.cc:1018] failed to synchronize the stop event: CUDA_ERROR_LAUNCH_TIMEOUT: the launch timed out and was terminated
2021-11-29 07:23:59.408237: E tensorflow/stream_executor/gpu/gpu_timer.cc:55] INTERNAL: Error destroying CUDA event: CUDA_ERROR_LAUNCH_TIMEOUT: the launch timed out and was terminated
2021-11-29 07:23:59.411331: E tensorflow/stream_executor/gpu/gpu_timer.cc:60] INTERNAL: Error destroying CUDA event: CUDA_ERROR_LAUNCH_TIMEOUT: the launch timed out and was terminated
2021-11-29 07:23:59.414816: I tensorflow/stream_executor/cuda/cuda_driver.cc:739] failed to allocate 8B (8 bytes) from device: CUDA_ERROR_LAUNCH_TIMEOUT: the launch timed out and was terminated
2021-11-29 07:23:59.418365: E tensorflow/stream_executor/stream.cc:4476] INTERNAL: Failed to enqueue async memset operation: CUDA_ERROR_LAUNCH_TIMEOUT: the launch timed out and was terminated
2021-11-29 07:23:59.422467: I tensorflow/stream_executor/cuda/cuda_driver.cc:739] failed to allocate 8B (8 bytes) from device: CUDA_ERROR_LAUNCH_TIMEOUT: the launch timed out and was terminated
2021-11-29 07:23:59.425739: E tensorflow/stream_executor/stream.cc:4476] INTERNAL: Failed to enqueue async memset operation: CUDA_ERROR_LAUNCH_TIMEOUT: the launch timed out and was terminated
2021-11-29 07:23:59.429235: E tensorflow/stream_executor/cuda/cuda_driver.cc:1163] failed to enqueue async memcpy from device to host: CUDA_ERROR_LAUNCH_TIMEOUT: the launch timed out and was terminated; 
host dst: 0xd4cd14bb90; GPU src: (nil); size: 8=0x8
2021-11-29 07:23:59.434156: I tensorflow/stream_executor/stream.cc:4442] [stream=000002486DC6B350,impl=000002486F3F0610] INTERNAL: stream did not block host until done; was already in an error state     
2021-11-29 07:23:59.437962: W tensorflow/core/kernels/gpu_utils.cc:69] Failed to check cudnn convolutions for out-of-bounds reads and writes with an error message: 'stream did not block host until done; 
was already in an error state'; skipping this check. This only means that we won't check cudnn for out-of-bounds reads and writes. This message will only be printed once.
2021-11-29 07:23:59.444743: F tensorflow/stream_executor/cuda/cuda_dnn.cc:213] Check failed: status == CUDNN_STATUS_SUCCESS (7 vs. 0)Failed to set cuDNN stream.

    _, frame = cap.read()
    hsv = cv2.cvtColor(frame, cv2.COLOR_RGB2HSV)

    red = np.zeros_like(frame, np.uint8)
    red1 = cv2.inRange(hsv, (0, 70, 50), (10, 255, 255))
    red2 = cv2.inRange(hsv, (170, 70, 50), (180, 255, 255))
    mask_red1 = red > 0
    mask_red2 = red2 > 0
    red[mask_red1] = frame[mask_red1]
    red[mask_red2] = frame[mask_red2]

    im = frame.copy()

    gray = cv2.cvtColor(red, cv2.COLOR_BGR2GRAY)
    ret, thresh = cv2.threshold(gray, 1, 255, cv2.THRESH_BINARY)
    contours, hierarchy = cv2.findContours(image=thresh, mode=cv2.RETR_TREE, method=cv2.CHAIN_APPROX_NONE)
    for c in contours:

        approx = cv2.approxPolyDP(c, 0.04 * cv2.arcLength(c, True), True)
        area = cv2.contourArea(c)
        if 500 < area < 2000:
            cv2.drawContours(image=im, contours=contours, contourIdx=-1, color=(0, 0, 255), thickness=-1,
                             lineType=cv2.LINE_AA)

            cv2.imshow("im", im)

    mask1 = cv2.inRange(hsv, (0, 0, 0), (179, 255, 70))  # detecting of black(mixed filter)
    image_copy1 = frame.copy()

    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
    opening = cv2.morphologyEx(mask1, cv2.MORPH_OPEN, kernel, iterations=1)
    close = cv2.morphologyEx(opening, cv2.MORPH_CLOSE, kernel, iterations=2)  # monchrome image

    circles = cv2.HoughtCircles = (frame, cv2.HOUGH_GRADIENT, 1, 300, np.array([]), 10, 30, 60, 300)

    contours, h = cv2.findContours(close, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

    final = np.zeros(hsv.shape, np.uint8)
    mask = np.zeros(hsv.shape[:2], np.uint8)

    for c in contours:
        approx = cv2.approxPolyDP(c, 0.04 * cv2.arcLength(c, True), True)
        area = cv2.contourArea(c)
        if 1000 < area < 25000:
            cv2.drawContours(image_copy1, [c], -1, (0, 255, 0), -1)
        cv2.imshow("blue", image_copy1)

    for i in range(0, len(contours)):
        cv2.drawContours(image_copy1, contours, i, (0, 255, 0), -1)
        mask[...] = 0
        cv2.drawContours(mask, contours, i, 255, -1)  # contours
        averagecolor = cv2.mean(frame, mask)
        draw_arerage_color = cv2.drawContours(final, contours, i, averagecolor, -1)  # final result
        cv2.imshow('final', final)

    for cont in contours:
        x1,y1,w1,h1 = cv2.boundingRect(cont)
        area_red = cv2.contourArea(cont)
        if (1000 > area_red >200):
            cv2.rectangle(frame, (x1,y1), (x1+w1, y1+h1), (255,0,0, 2))

            image1 = cv2.drawContours(blank.copy(), contours, 0, 1)

    for c in cnts:
        x,y,w,h = cv2.boundingRect(c)
        approx = cv2.approxPolyDP(c, 0.04 * cv2.arcLength(c, True), True)
        area = cv2.contourArea(c)
        if (1000 > area > 250):
            cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 2)
            image2 = cv2.drawContours(blank.copy(), cnts, 1, 1)

    if np.logical_and(cnts, contours):
        print("Intersection idenifyed")

    cv2.imshow("Video from camera", frame)
    if cv2.waitKey(10) & 0xFF == ord('q'):
        break

cap = cv2.VideoCapture('path')

while(True):

    _, frame = cap.read()

    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

    black1 = np.array([0, 0, 0], np.uint8)

    black2 = np.array([45,35,35], np.uint8)

    red1 = np.array([170, 70, 50], np.uint8)

    red2 = np.array([180, 255, 255], np.uint8)

    red_mask = cv2.inRange(hsv, red1, red2)

    black_mask = cv2.inRange(hsv, black1, black2)

    kernel = np.ones((7, 7), "uint8")

    black_mask = cv2.dilate(black_mask, kernel)

    red_mask = cv2.dilate(red_mask, kernel)

    res_red = cv2.bitwise_and(frame, frame, mask = red_mask)

    res_black = cv2.bitwise_and(frame, frame, mask = black_mask)

    cnts, _ = cv2.findContours(black_mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

    contours, _ = cv2.findContours(red_mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

    for cont in contours:
        x1,y1,w1,h1 = cv2.boundingRect(cont)
        area_red = cv2.contourArea(cont)
        if (1000 > area_red >200):
            cv2.rectangle(frame, (x1,y1), (x1+w1, y1+h1), (255,0,0, 2))

    for c in cnts:
        x,y,w,h = cv2.boundingRect(c)
        approx = cv2.approxPolyDP(c, 0.04 * cv2.arcLength(c, True), True)
        area = cv2.contourArea(c)
        if (1000 > area > 250):
            cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 2)

    cv2.imshow("Video from camera", frame)
    if cv2.waitKey(10) & 0xFF == ord('q'):
        break

while(True):

    _, frame = cap.read()
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    a, b = 0, 0

    height, width, layers = frame.shape
    start_height = height - height
    left_x = width - 500

    #right_area = frame[y:y+height, x:x+300]
    #left_area = frame[y:y+height,]

    black_min = np.array([0, 0, 0], np.uint8)
    black_max = np.array([179, 255, 70], np.uint8)

    red_min = np.array([0, 70, 50], np.uint8)
    red_max = np.array([20, 255, 255], np.uint8)

    red1 = np.array([170, 70, 50], np.uint8)
    red2 = np.array([180, 255, 255], np.uint8)

    red_mask = cv2.inRange(hsv, red1, red2)
    red_mask2 = cv2.inRange(hsv, red_min, red_max)
    kernel = np.ones((7, 7), "uint8")

    red_mask = cv2.dilate(red_mask, kernel)
    res_red = cv2.bitwise_and(frame, frame, mask=red_mask)
    red_mask2 = cv2.dilate(red_mask2, kernel)
    res_red2 = cv2.bitwise_and(frame, frame, mask=red_mask2)

    area1 = frame[a:a + height, b:b + 300]
    area2 = frame[a:a + height, left_x:left_x + 500]

    cnts, _ = cv2.findContours(red_mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)


    for pic, c in enumerate(cnts):

        area = cv2.contourArea(c)
        if (700 > area > 350):
            x,y,w,h = cv2.boundingRect(c)
            cv2.rectangle(frame, (x, y),(x + w, y + h),(0, 0, 255), 2)
            cv2.putText(frame, "Red detected", (x, y), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 255))


    cv2.imshow("Video from camera", frame)
    if cv2.waitKey(10) & 0xFF == ord('q'):
        break

findContours(Mask(cv::Rect(x,y,width,height)), contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE, 
Point(0,0) );

cnts, _ = cv2.findContours(red_mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE), #вот эта область меня интересует frame[a:a + height, b:b + 300]

height = frame.shape[0]
width = frame.shape[1]
number_slices = 3
width_slices = width/number_slices
width_slices = round(width_slices)
start_width = width - (width_slices * number_slices)
start_height = height - height
print(width_slices)
#y,x =  0, 0
crop = frame[start_height:start_height+height, start_width:start_width+width_slices]

cv2.imshow("image", crop)
if cv2.waitKey(0):
   cv2.destroyAllWindows()

532
Traceback (most recent call last):
  File "04.py", line 28, in <module>
    cv2.imshow("image", crop)
cv2.error: OpenCV(4.5.3) C:\Users\runneradmin\AppData\Local\Temp\pip-req-build-q3d_8t8e\opencv\modules\imgproc\src\color.cpp:182: error: (-215:Assertion failed) !_src.empty() in function 'cv::cvtColor'

cv2.error: OpenCV(4.5.3) :-1: error: (-5:Bad argument) in function 'imshow'
> Overload resolution failed:
>  - imshow() missing required argument 'mat' (pos 2)
>  - imshow() missing required argument 'mat' (pos 2)
>  - imshow() missing required argument 'mat' (pos 2)

while(True):

    _, frame = cap.read()

    height = frame.shape[0]
    width = frame.shape[1]
    number_slices = 3
    slices_width = width//number_slices
    #slices_height = height
    #M = width/number_slices

    tiles = [frame[x:x + slices_width, y:y + height]
             for x in range(0, frame.shape[0], slices_width) for y in range(0, frame.shape[1], height)]
    #cv2.imshow("w", tiles)
    print(tiles)
    for i in tiles:
        cv2.imshow(i)

        ...,
        [ 58, 133, 143],
        [ 46, 121, 131],
        [ 47, 122, 132]],

       [[ 85, 185, 196],
        [ 78, 178, 189],
        [ 75, 175, 186],
        ...,
        [ 49, 124, 134],
        [ 42, 117, 127],
        [ 48, 123, 133]]], dtype=uint8)]

import cv2
import numpy as np

image = cv2.imread("2.jpg")
blank = np.zeros(image.shape[0:2])

clahe = cv2.createCLAHE(clipLimit=3., tileGridSize=(8,8))
lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)  #convert from BGR to LAB color space
l, a, b = cv2.split(lab)# split on 3 different channels
l2 = clahe.apply(l)#apply CLAHE to the L-channel
lab = cv2.merge((l2,a,b))#merge channels
img2 = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)#convert from LAB to BGR
blur = cv2.GaussianBlur(img2, (7,7), 0)
hsv = cv2.cvtColor(blur, cv2.COLOR_BGR2HSV)
original = hsv.copy()

red = np.zeros_like(image, np.uint8)
red = cv2.inRange(hsv, (0, 70, 50), (10, 255, 255))
red2 = cv2.inRange(hsv, (170, 70, 50), (180, 255, 255))
mask_red = red>0
mask_red = red2>0
red[mask_red] = image[mask_red]
red[mask_red2] = image[mask_red2]

im = image.copy()

gray = cv2.cvtColor(red, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray, 1, 255, cv2.THRESH_BINARY)
contours1, hierarchy = cv2.findContours(image=thresh, mode=cv2.RETR_TREE, method=cv2.CHAIN_APPROX_NONE)
contour_list1 = []
for c in contours1:

    approx = cv2.approxPolyDP(c, 0.04 * cv2.arcLength(c, True), True)
    area1 = cv2.contourArea(c)
    if 500 < area1 < 2000:
        contour_list1.append(c)
        cv2.drawContours(image=im, contours=contours1, contourIdx=-1, color=(0, 0, 255), thickness=-1, lineType=cv2.LINE_AA)
        cv2.imshow("im", im)
    image1 = cv2.drawContours(blank.copy(), contours1, 0, 1)

mask1 = cv2.inRange(hsv,(0,0,0),(179,255,70))#detecting of black(mixed filter)
image_copy1 = image.copy()

kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7,7))
opening = cv2.morphologyEx(mask1, cv2.MORPH_OPEN, kernel, iterations=1)
close = cv2.morphologyEx(opening, cv2.MORPH_CLOSE, kernel, iterations=2)#monchrome image

circles = cv2.HoughtCircles = (image, cv2.HOUGH_GRADIENT, 1, 300, np.array([]), 10, 30, 60, 300)

contours2,h = cv2.findContours(close,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)

final = np.zeros(hsv.shape, np.uint8)
mask = np.zeros(hsv.shape[:2], np.uint8)
contour_list = []
for a in contours2:
    approx = cv2.approxPolyDP(a, 0.04 * cv2.arcLength(c, True), True)
    area2 = cv2.contourArea(a)

    if 1000 < area2 < 25000:
        contour_list.append(c)
        cv2.drawContours(image_copy1, [a], -1, (0,255,0), -1)
    cv2.imshow("blue", image_copy1)
    image2 = cv2.drawContours(blank.copy(), contours2, 1, 1)

for i in range(0,len(contours2)):
    cv2.drawContours(image_copy1, contours2, i, (0, 255, 0), -1)
    mask[...]=0
    cv2.drawContours(mask,contours2,i,255,-1)#contours
    averagecolor = cv2.mean(image, mask)
    draw_arerage_color = cv2.drawContours(final,contours2,i,averagecolor,-1)#final result
cv2.imshow('final', final)

contours = [contours1, contours2]
intersection = np.logical_and(image1, image2)
for g in contours:
    if intersection.any():
        cv2.drawContours(blank, contours, g, (0, 255, 0), 1)
    cv2.imshow("8",blank)

circles = cv2.HoughCircles(close, cv2.HOUGH_GRADIENT,1,20,param1=50,param2=30,minRadius=0,maxRadius=0)

if circles is not None:
    print(len(circles))
circles = np.uint16(np.around(circles))

if cv2.waitKey(0):
    cv2.destroyAllWindows()

cv2.waitKey(0)

import cv2
import numpy as np
image = cv2.imread("3.jpg")


clahe = cv2.createCLAHE(clipLimit=3., tileGridSize=(8,8))

lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)  #convert from BGR to LAB color space
l, a, b = cv2.split(lab)  # split on 3 different channels

l2 = clahe.apply(l)  #apply CLAHE to the L-channel

lab = cv2.merge((l2,a,b))  #merge channels
img2 = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)  #convert from LAB to BGR

blur = cv2.GaussianBlur(img2, (7,7), 0)
hsv = cv2.cvtColor(blur, cv2.COLOR_BGR2HSV)

mask1 = cv2.inRange(hsv, (0,0,0), (179,255,70))

kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7,7))
opening = cv2.morphologyEx(mask1, cv2.MORPH_OPEN, kernel, iterations=1)

close = cv2.morphologyEx(opening, cv2.MORPH_CLOSE, kernel, iterations=2)#this is monchrome image for recognition

   
contours,h = cv2.findContours(close,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)

final = np.zeros(image.shape,np.uint8)
mask = np.zeros(hsv.shape,np.uint8)

for i in range(0,len(contours)):
    mask[...]=0
    cv2.drawContours(mask,contours,i,255,-1)
    cv2.drawContours(final,contours,i,cv2.mean(image,mask),-1)

 
cv2.imshow('final',final)
cv2.waitKey(0)

cv2.error: OpenCV(4.5.3) C:\Users\runneradmin\AppData\Local\Temp\pip-req-build-sn_xpupm\opencv\modules\core\src\mean.dispatch.cpp:126: error: (-215:Assertion failed) mask.empty() || mask.type() == CV_8U in function 'cv::mean'

clahe = cv2.createCLAHE(clipLimit=3., tileGridSize=(8,8))

lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)  #convert from BGR to LAB color space
l, a, b = cv2.split(lab)  # split on 3 different channels

l2 = clahe.apply(l)  #apply CLAHE to the L-channel

lab = cv2.merge((l2,a,b))  #merge channels
img2 = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)  #convert from LAB to BGR

blur = cv2.GaussianBlur(img2, (7,7), 0)
hsv = cv2.cvtColor(blur, cv2.COLOR_BGR2HSV)

mask = cv2.inRange(hsv, (0,0,0), (179,255,70))

kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7,7))
opening = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel, iterations=1)

close = cv2.morphologyEx(opening, cv2.MORPH_CLOSE, kernel, iterations=2)

cnts,_ = cv2.findContours(close, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

circles = cv2.HoughtCircles = (image, cv2.HOUGH_GRADIENT, 1, 300, np.array([]), 10, 30, 60, 300)
if circles is not None:
  circles = np.uint16(np.around(circles))
  for i in circles[0,:]:
      cv2.circle(image, (i[0], i[1]), i[2], (0, 255, 0), 1)
      cv2.circle(image, (i[0], i[1]), 2, (0, 0, 255), 3)

cv2.imshow("thing", image)



for c in cnts:

    approx = cv2.approxPolyDP(c, 0.04 * cv2.arcLength(c, True), True)
    area = cv2.contourArea(c)

    if len(approx) > 3 and area > 50:
        cv2.drawContours(image, [c], -1, (0, 255, 0), -1)

import cv2 as cv2
import numpy as np
import skimage
import imutils
from imutils import contours
from skimage import measure
import argparse
import array

image = cv2.imread('1.jpeg',0)
cv2.imshow("tests", image)
cv2.waitKey()

theta = 1
phi = 1
maxIntensity = 255.0
# Decrease intensity such that
# dark pixels become much darker,
# bright pixels become slightly dark
newImage1 = (maxIntensity/phi)*(image/(maxIntensity/theta))**2
newImage1 = np.array(newImage1, dtype=np.uint8)
cv2.imshow("tests", newImage1)
cv2.waitKey()
blur = cv2.GaussianBlur(newImage1, (7,7), 0)
hsv = cv2.cvtColor(blur, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv, (0,0,0), (179,50,55))
cv2.imshow("tests", mask)
#cv2.waitKey()

kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7,7))
opening = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel, iterations=1)
cv2.imshow("tests", opening)
cv2.waitKey()
close = cv2.morphologyEx(opening, cv2.MORPH_CLOSE, kernel, iterations=2)
cv2.imshow("tests", close)
cv2.waitKey()
cnts,_ = cv2.findContours(close, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

for c in cnts:
    approx = cv2.approxPolyDP(c, 0.04 * cv2.arcLength(c, True), True)
    area = cv2.contourArea(c)
    if len(approx) > 3 and area > 200:
        cv2.drawContours(image, [c], -1, (0,255,0), -1)

cv2.imshow('image', image)
if cv2.waitKey(0):
    cv2.destroyAllWindows()

    hsv = cv2.cvtColor(blur, cv2.COLOR_BGR2HSV)
cv2.error: OpenCV(4.5.3) c:\users\runneradmin\appdata\local\temp\pip-req-build-sn_xpupm\opencv\modules\imgproc\src\color.simd_helpers.hpp:92: error: (-2:Unspecified error) in function '__cdecl cv::impl::`anonymous-namespace'::CvtHelper<struct cv::impl::`anonymous namespace'::Set<3,4,-1>,struct cv::impl::A0x2f9e5da8::Set<3,-1,-1>,struct cv::impl::A0x2f9e5da8::Set<0,5,-1>,2>::CvtHelper(const class cv::_InputArray &,const class cv::_OutputArray &,int)'
> Invalid number of channels in input image:
>     'VScn::contains(scn)'
> where
>     'scn' is 1

hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (5, 5), 0)
edged = cv2.Canny(blurred, 30, 150)

czarny = cv2.inRange(hsv, (0, 0, 0), (40, 40, 40))

mask_gray = gray>0

mask_czarny = czarny>0

czarny = np.zeros_like(image, np.uint8)

czarny[mask_czarny] = image[mask_czarny]

gray = cv2.cvtColor(czarny, cv2.COLOR_BGR2GRAY)

ret, thresh = cv2.threshold(edged, 1, 255, cv2.THRESH_BINARY)

import cv2
import numpy as np
import skimage
import imutils
from imutils import contours
from skimage import measure
import argparse
from skimage.transform import hough_circle
from skimage.feature import canny
from skimage.draw import circle_perimeter
from skimage.util import img_as_ubyte

from skimage.transform import hough_circle, hough_circle_peaks

image = cv2.imread("2.jpg")

low = np.array([0,0,0])

up = np.array([350, 55, 100])

imgmask = cv2.inRange(image, low, up)
cv2.imshow("edweewe", imgmask)

edges = canny(imgmask, sigma=2.0, low_threshold=0.55, high_threshold=0.8)

result = hough_ellipse(edges, accuracy=20, threshold=250, min_size=100, max_size=120)


result.sort(order='accumulator')


best = list(result[-1])
yc, xc, a, b = [int(round(x)) for x in best[1:5]]
orientation = best[5]


cy, cx = ellipse_perimeter(yc, xc, a, b, orientation)
image_rgb[cy, cx] = (0, 0, 255)

edges = color.gray2rgb(img_as_ubyte(edges))
edges[cy, cx] = (250, 0, 0)

fig2, (ax1, ax2) = plt.subplots(ncols=2, nrows=1, figsize=(8, 4),
                                sharex=True, sharey=True)

ax1.set_title('Original picture')
ax1.imshow(image_rgb)

ax2.set_title('Edge (white) and result (red)')
ax2.imshow(edges)

plt.show()

 circles2 = cv2.circle(image_copy, center, radius2, (255, 0, 0), 2)

        circles = cv2.circle(image_copy, center, radius, (0, 255, 0), 2)

        #if circles2 (тут проверить на каком цвете находиться контур)

for c in contours:
    x, y, w, h = cv2.boundingRect(c)

    #if cv2.contourArea(cnt) > 800:

    if (cv2.contourArea(c)) > 700:

        Rectangles = cv2.rectangle(image_copy, (x, y), (x + w, y + h), (255, 0, 0), 5)

(x,y),radius = cv.minEnclosingCircle(cnt)
center = (int(x),int(y))
radius = int(radius)
cv.circle(img,center,radius,(0,255,0),2)

for c in contours:
    x, y, w, h = cv2.boundingRect(c)
    #if cv2.contourArea(cnt) > 800:

    if (cv2.contourArea(c)) > 10:
        Rectangles = cv2.rectangle(image_copy, (x, y), (x + w, y + h), (255, 0, 0), 5)
    #    lower_gray = np.array([0, 5, 50], np.uint8)
     #   upper_gray = np.array([350, 50, 255], np.uint8)

    #    mask = cv2.inRange(Rectangles, lower_gray, upper_gray)
    #    img_res = cv2.bitwise_and(hsv, hsv, mask=mask)
    #    cv2.imwrite('gray.png', img_res)

        #cv2.ellipse()
        #cv2.ellipse(Rectangles, )
        #if cv2.inRange(Rectangles) == (hsv, (1, 0, 0), (85, 95, 85)):
            #cv2.cvtColor(Rectangles, (85, 95, 85), 5)
        #    print("wow")
        #if cv2.boundingRect(c) == cv2.inRange(hsv, (1, 0, 0), (85, 95, 85)):
            #cv2.rectangle(image_copy, (x, y), (x + w, y + h), (255, 0, 0), 5)
#cv2.imshow('All contours with bounding box', image_copy)

#cv2.imshow('All contours with bounding box', image_copy)

        cv2.imshow("image", image_copy)
#if rectan
if cv2.waitKey(0):
    cv2.destroyAllWindows()

import cv2
import numpy as np
#import scikit-imag
#from scikit-imag import measure
import skimage
import imutils
from imutils import contours
from skimage import measure
import argparse

image = cv2.imread("2.jpg")

hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

red= cv2.inRange(hsv, (0, 70, 50), (10, 255, 255))
red2 = cv2.inRange(hsv, (170, 70, 50), (180, 255, 255))
orange = cv2.inRange(hsv, (10, 100, 20), (25, 255, 255))
yellow = cv2.inRange(hsv, (21, 39, 64), (40, 255, 255))

mask_red = red>0
mask_red2 = red2>0
mask_orange = orange>0
mask_yellow = yellow>0
red = np.zeros_like(image, np.uint8)
red[mask_red] = image[mask_red]
red[mask_red2] = image[mask_red2]
red[mask_orange] = image[mask_orange]
red[mask_yellow] = image[mask_yellow]

#cv2.imshow("red color detection ", red)


gray = cv2.cvtColor(red, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (11, 11), 0)
thresh = cv2.threshold(blurred, 200, 255, cv2.THRESH_BINARY)[1]
thresh = cv2.erode(thresh, None, iterations=2)
thresh = cv2.dilate(thresh, None, iterations=4)

labels = measure.label(thresh, connectivity=1, background=0)
mask = np.zeros(thresh.shape, dtype="uint8")

for label in np.unique(labels):

    if label == 0:
        continue

    labelMask = np.zeros(thresh.shape, dtype="uint8")
    labelMask[labels == label] = 255
    numPixels = cv2.countNonZero(labelMask)

    if numPixels > 300:
        mask = cv2.add(mask, labelMask)

cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours(cnts)
cnts = contours.sort_contours(cnts)[0]

for (i, c) in enumerate(cnts):

    (x, y, w, h) = cv2.boundingRect(c)
    ((cX, cY), radius) = cv2.minEnclosingCircle(c)
    cv2.circle(red, (int(cX), int(cY)), int(radius), (0, 0, 255), 3)
    cv2.putText(red, "#{}".format(i + 1), (x, y - 15), cv2.FONT_HERSHEY_SIMPLEX, 0.45, (0, 0, 255), 2)

cv2.imshow("Image", red)

if cv2.waitKey(0):
    cv2.destroyAllWindows()

cnts = contours.sort_contours(cnts)[0]

(cnts, boundingBoxes) = zip(*sorted(zip(cnts, boundingBoxes),
ValueError: not enough values to unpack (expected 2, got 0)