Untitled

mail@pastecode.io avatarunknown
plain_text
a month ago
67 kB
1
Indexable
Never
import requests
import cv2
import urllib.request
import numpy as np
from matplotlib import pyplot as plt
import re
import math
import pytesseract
from pytesseract import Output
from spellchecker import SpellChecker
import datetime
import test_funcs
# def merge_contours(contours, max_distance=200):
#     merged_contours = []
#     for contour in contours:
#         if not merged_contours:
#             merged_contours.append(contour)
#         else:
#             merged = False
#             for i, merged_contour in enumerate(merged_contours):
#                 print(tuple(contour[0][0]))
#                 pt = tuple(map(int, contour[0][0]))
#                 distance = cv2.pointPolygonTest(merged_contour, pt, measureDist=True)
#                 if distance >= 0 and distance <= max_distance:
#                     merged_contours[i] = np.concatenate((merged_contour, contour))
#                     merged = True
#                     break
#             if not merged:
#                 merged_contours.append(contour)
#     return merged_contours
# # def template(url, f_name):
# #     n = '(1)'
# #     req = urllib.request.urlopen(url)
# #     files = []
# #     arr = np.asarray(bytearray(req.read()), dtype=np.uint8)
# #     labels = []
# #     image = cv2.imdecode(arr, cv2.IMREAD_COLOR) # Получение фото по изображению
# #
# #     # image = cv2.imread("tets.JPG") # Получение фото по изображению
# #     cv2.imwrite('ph.jpeg', image)
# #     # cv2.imshow('ph.jpeg', image)
# #     y_img = cv2.cvtColor(image, cv2.COLOR_BGR2YUV)
# #     img = image.copy()
# #     # image = cv2.imread('tsts1.png')
# #     # print('123', arr)
# #     cv2.imshow('1', img)
# #     y_channel = y_img[:, :, 0]
# #
# #     # Вычисление среднего значения яркости
# #     brightness = int(y_channel.mean())
# #     print("яркость", brightness)
# #     img = image.copy()
# #     # return 0
# #     # cv2.imshow('Оригинал', image)
# #     # cv2.waitKey(0)
# #     # cv2.destroyAllWindows()
# #
# #     blur = cv2.GaussianBlur(img, (3, 3), 1)
# #
# #     gray = cv2.cvtColor(blur, cv2.COLOR_BGR2GRAY)
# #     sharpen_kernel = np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]])
# #     # gray = cv2.filter2D(gray, -1, sharpen_kernel)
# #     # edges = cv2.Canny(gray, 80, 150)
# #
# #     # edges = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C,cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 17, 7)
# #     ret,edges = cv2.threshold(gray,170,255,cv2.THRESH_BINARY)
# #     # edges = cv2.Canny(img, 160,230)
# #     # cv2.th
# #     # ret,edges = cv2.threshold(gray,brightness,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
# #     # print(ret)
# #
# #     cv2.imshow('canny', edges)
# #     # cv2.imshow('gray', gray)
# #     # cv2.waitKey(0)
# #     # cv2.destroyAllWindows()
# #
# #
# #     contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# #     contours = sorted(contours, key=cv2.contourArea, reverse=True)
# #     # print('len(contours)',len(contours))
# #
# #
# #     # d_img = cv2.drawContours(img,contours, -1,(0, 255, 0),3)
# #
# #     mask = np.zeros_like(image)
# #     cv2.drawContours(mask, contours, -1, (255, 255, 255), thickness=cv2.FILLED)
# #
# #     result = cv2.bitwise_and(image, mask)
# #
# #
# #
# #
# #     gray = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY)
# #
# #     cv2.imshow('result', gray)
# #
# #     # edges = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.ADAPTIVE_THRESH_MEAN_C, 11, 2)
# #     # ret, edges = cv2.threshold(gray, 230, 255, cv2.THRESH_BINARY_INV)
# #     edges = cv2.Canny(result,190,220)
# #     contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# #     d_img = cv2.drawContours(result, contours, -1, (0, 255, 0), 1)
# #     cv2.imshow('d_img', d_img)
# #     # cv2.waitKey(0)
# #     # cv2.destroyAllWindows()
# #
# #     for i in range(len(contours)):
# #         x,y,h,w = cv2.boundingRect(contours[i])
# #         area = cv2.contourArea(contours[i])
# #         text = f"x:{x} y:{y} w:{w} h:{h} area:{area}"
# #         # if w:
# #
# #         if 10 < w and 10 < h and w+h>20:
# #             print(x, y, h, w, w * h)
# #             # print(w*h)
# #             # w,h,x,y = correct_rct(w,h,x,y)
# #             cv2.rectangle(image, (x + 1, y + 1 ), (x + h + 1, y + w + 1), (255, 0, 0), 1)
# #             # print(x,y,w,h)
# #             is_mine = lambda x: 0 if x<0 else x
# #             x,y,h,w = map(is_mine, [x,y,h,w])
# #             crop_img = image[y: y  + w, x :x + h]
# #             # crop_img = image[10: 110, 10:110]
# #             # cv2.imshow('img', image)
# #             # cv2.waitKey(0)
# #             # cv2.destroyAllWindows()
# #             # f_name = n + f_name
# #             # filename = f'{f_name}'
# #             # print("имя файла:", f_name)
# #             # output_folder = r'C:\Users\gleb\PycharmProjects\Bot\crops'
# #             # os.makedirs(output_folder, exist_ok=True)
# #             # output_filename = f'{f_name}'
# #             # output_path = os.path.join(output_folder, output_filename)
# #             # cv2.imwrite(output_path, crop_img)
# #             # server_base_url = 'http://192.168.0.158/'
# #             # new_image_url = server_base_url + output_filename
# #             # print(new_image_url)
# #             # cv2.imwrite(n + f_name, crop_img)
# #             files.append(n + f_name)
# #
# #     cv2.imshow("res", image)
# #     cv2.waitKey(0)
# #     cv2.destroyAllWindows()
# #     return 0
# #     # Фильтрация контуров по характеристикам
# #     mx = 0
# #     filtered_contours = []
# #     for contour in contours[:len(contours)//2]:
# #         x, y, h, w = cv2.boundingRect(contour)
# #         area = cv2.contourArea(contour)
# #         # print(area)
# #         mx = max(area, mx)
# #         if 100 < h < 450 and 100 < w < 450 and w*h>12_000:  # Пример условия фильтрации по площади
# #             filtered_contours.append(contour)
# #     # print(mx)
# #     # exit()
# #     # Создание чистого изображения только с нужными контурами
# #
# #     filtered_contours = merge_contours(filtered_contours)
# #
# #     mask = np.zeros_like(image)
# #     cv2.drawContours(mask, filtered_contours, -1, (255, 255, 255), thickness=cv2.FILLED)
# #
# #     result = cv2.bitwise_and(image, mask)
# #
# #     cv2.imshow('Result', result)
# #     cv2.waitKey(0)
# #     cv2.destroyAllWindows()
# #     #
# #     # edges = cv2.Canny(result, 150, 250)
# #     imgray = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY)
# #     q, edges = cv2.threshold(imgray,127,255,cv2.THRESH_BINARY)
# #
# #
# #     conts, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# #     conts = sorted(conts, key= cv2.contourArea, reverse=True)
# #     # image_with_contours = cv2.drawContours(image, conts, -1, (0, 255, 0))
# #     # cv2.imshow('I', image_with_contours)
# #     print('len(conts)',len(conts))
# #     count = 0
# #     for i in range(len(conts)):
# #         x,y,h,w = cv2.boundingRect(conts[i])
# #         area = cv2.contourArea(conts[i])
# #         text = f"x:{x} y:{y} w:{w} h:{h} area:{area}"
# #
# #
# #         # x = int(x)
# #         # y = int(y)
# #         # print(y + h)
# #         if w:
# #             print(x,y,h,w, w*h)
# #             if 150 < w < 400 and 150 < h < 400 and w*h < 65_000:
# #                 # print(w*h)
# #                 # w,h,x,y = correct_rct(w,h,x,y)
# #                 cv2.rectangle(image, (x + 1, y + 1 ), (x + h + 1, y + w + 1), (255, 0, 0), 1)
# #                 # print(x,y,w,h)
# #                 is_mine = lambda x: 0 if x<0 else x
# #                 x,y,h,w = map(is_mine, [x,y,h,w])
# #                 crop_img = image[y: y  + w, x :x + h]
# #                 # crop_img = image[10: 110, 10:110]
# #                 # cv2.imshow('img', image)
# #                 # cv2.waitKey(0)
# #                 # cv2.destroyAllWindows()
# #                 # f_name = n + f_name
# #                 # filename = f'{f_name}'
# #                 print("имя файла:", f_name)
# #                 # output_folder = r'C:\Users\gleb\PycharmProjects\Bot\crops'
# #                 # os.makedirs(output_folder, exist_ok=True)
# #                 # output_filename = f'{f_name}'
# #                 # output_path = os.path.join(output_folder, output_filename)
# #                 # cv2.imwrite(output_path, crop_img)
# #                 # server_base_url = 'http://192.168.0.158/'
# #                 # new_image_url = server_base_url + output_filename
# #                 # print(new_image_url)
# #                 cv2.imwrite(n + f_name, crop_img)
# #                 count += 1
# #                 files.append(n + f_name)
# #                 # return f_name
# #
# #                 # angle  =  find_rotation_angle2(crop_img)
# #                 # res_img = OCR(crop_img)
# #                 # cv2.imshow("res", res_img)
# #                 # cv2.waitKey(0)
# #                 # cv2.destroyAllWindows()
# #                 # read = easyocr.Reader(["ru"], gpu=True)
# #                 # result = read.readtext(res_img, detail=0, rotation_info=[90,180])
# #                 # print(result)
# #                 # print(angle)
# #
# #                 # text = str(OCR(crop_img))
# #                 # cv2.putText(image, text, (10, 20), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 2)
# #                 # labels.append(text)
# #
# #                 # exit()
# #                 # n + f_name
# #                 n = '(2)'
# #     print('counrt',count)
# #     if count == 0:
# #         # cv2.imwrite('Not Find', image)
# #         w, h, c = image.shape
# #         # text = OCR(image)
# #         # cv2.putText(image, text, (10, 20), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 0), 2)
# #         cv2.imwrite(f_name + ".jpg", image)
# #         files.append(f_name + ".jpg")
# #         # return f_name
# #         # labels.append(text)
# #     # cv2.imwrite('test' + str(74) + '.jpg', image)
# #     cv2.imshow('I1', image)
# #     cv2.waitKey(0)
# #     cv2.destroyAllWindows()
# #     # return 0
# #     # return labels
# #     return files
# def filt_box(boxs):
#     boreds = []
#     for box in boxs:
#         x,y,w,h,s = box
#         if 140 < w < 400 and 150 < h < 400 and w * h < 65_000:
#             boreds.append([x,y,w,h,s])
#     return boreds
#
# def templ(image, d = 170, r = 3):
#
#     img = image.copy()
#
#     # gray = cv2.cvtColor(blur, cv2.COLOR_BGR2GRAY)
#
#     gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#     #
#     blur = cv2.GaussianBlur(gray, (3, 3), 1)
#
#     ret, thes = cv2.threshold(blur, d, 255, cv2.THRESH_BINARY)
#
#     # kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (25, 25))
#
#     # Применяем морфологическую операцию расширения к изображению
#     # dilated_image = cv2.dilate(img, kernel)
#
#     # gray = cv2.cvtColor(thes, cv2.COLOR_BGR2GRAY)
#
#     # ret, thes = cv2.threshold(gray, d, 255, cv2.THRESH_BINARY)
#
#
#     # mask_3_channels = cv2.merge((dilated_mask, dilated_mask, dilated_mask))
#
#     # Наложение маски на исходное изображение
#     # mask = np.zeros_like(thes)
#     # mask = cv2.bitwise_not(thes)
#     result = cv2.bitwise_and(img, img, mask=thes)
#
#     # gray = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY)
#     #
#     # ret, thes = cv2.threshold(gray, 240, 255, cv2.THRESH_BINARY_INV)
#
#     # result = cv2.bitwise_and(img, img, mask=thes)
#
#     # cv2.imshow("thes", thes)
#     cv2.imshow("dilate", result)
#     # cv2.imshow("MSK", mask)
#     # cv2.waitKey(0)
#     # cv2.destroyAllWindows()
#
#     # edges = cv2.Canny(cv2.cvtColor(result, cv2.COLOR_BGR2GRAY), 100, 200, apertureSize=r,L2gradient= True)
#     edges = cv2.Canny(cv2.cvtColor(result, cv2.COLOR_BGR2GRAY), 100, 200)
#
#     cv2.imshow("edges", edges)
#     cv2.waitKey(0)
#     cv2.destroyAllWindows()
#     borders = []
#     # Найдите контуры на изображении
#     contours, _ = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
#     for cont in contours:
#         x,y,w,h = cv2.boundingRect(cont)
#         borders.append([x,y,w,h,w*h])
#         # img = cv2.rectangle(img, (x,y), (x+w, y+h), (255,0,0), 2)
#
#
#
#     # y_img = cv2.cvtColor(image, cv2.COLOR_BGR2YUV)
#     # img = image.copy()
#     # # image = cv2.imread('tsts1.png')
#     # # print('123', arr)
#     # # cv2.imshow('1', img)
#     # y_channel = y_img[:, :, 0]
#     #
#     # # Вычисление среднего значения яркости
#     # brightness = int(y_channel.mean())
#     # print("яркость", brightness)
#     # img = image.copy()
#     # # return  0
#     # # cv2.imshow('Оригинал', image)
#     # # cv2.waitKey(0)
#     # # cv2.destroyAllWindows()
#     #
#     # blur = cv2.GaussianBlur(img, (3, 3), 1)
#     #
#     # gray = cv2.cvtColor(blur, cv2.COLOR_BGR2GRAY)
#     # sharpen_kernel = np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]])
#     # # gray = cv2.filter2D(gray, -1, sharpen_kernel)
#     # # edges = cv2.Canny(gray, 80, 150)
#     #
#     # # edges = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C,cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 11, 2)
#     # ret, edges = cv2.threshold(gray, d, 255, cv2.THRESH_BINARY)
#     #
#     #
#     # # rect_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (12,12))
#     # # dilation = cv2.dilate(edges, rect_kernel, iterations = 3)
#     # # cv2.imshow('dill', dilation)
#     # # Mask = cv2.bitwise_and(dilation)
#     #
#     # # Mask = cv2.bitwise_and(img, img, mask=Mask)
#     # # cv2.imshow('mask', Mask)
#     # # cv2.waitKey(0)
#     # # cv2.destroyAllWindows()
#     #
#     #
#     # # edges = cv2.Canny(img, 160,230)
#     # # cv2.th
#     # # ret,edges = cv2.threshold(gray,brightness,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
#     # # print(ret)
#     #
#     # # cv2.imshow('canny', edges)
#     # # cv2.imshow('gray', gray)
#     # # cv2.waitKey(0)
#     # # cv2.destroyAllWindows()
#     #
#     # contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
#     # # # # print('len(contours)',len(contours))
#     # #
#     # # mask = np.zeros_like(image)
#     #
#     # # d_img = cv2.drawContours(img,contours, -1,(0, 255, 0),3)
#     #
#     # mask = np.zeros_like(image)
#     # cv2.drawContours(mask, contours, -1, (255, 255, 255), thickness=cv2.FILLED)
#     # cv2.imshow("x,",  edges)
#     # cv2.waitKey(0)
#     # cv2.destroyAllWindows()
#     # result = cv2.bitwise_and(image, mask)
#     # #
#     # # result = cv2.bitwise_and(img, mask)
#     # gray = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY)
#     #
#     # # edges = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.ADAPTIVE_THRESH_MEAN_C, 11, 2)
#     # # ret, edges = cv2.threshold(gray, 190, 255, cv2.THRESH_BINARY_INV)
#     # edges = cv2.Canny(gray, 100, 200, apertureSize=7)
#     # contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
#     # d_img = cv2.drawContours(result, contours, -1, (0, 255, 0), 1)
#     # cv2.imshow("x,", d_img)
#     # cv2.waitKey(0)
#     # cv2.destroyAllWindows()
#     # # borders = map(cv2.boundingRect, contours)
#     # borders = []
#     #
#     # for cont in contours:
#     #     x, y, w, h = cv2.boundingRect(cont)
#     #     borders.append([x, y, w, h, w * h])
#     #     cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 255), 1)
#     # # cv2.imshow('dimg', img)
#     # # cv2.waitKey(0)
#     # # cv2.destroyAllWindows()
#     #
#     # # if len(borders)<10:
#     # #     return 0
#
#
#     # ###########################################
#
#     # arr = [[148, 600, 12, 2, 24], [170, 599, 13, 3, 39], [228, 587, 3, 3, 9], [296, 552, 19, 16, 304], [296, 552, 19, 16, 304], [0, 540, 3, 6, 18], [367, 514, 5, 5, 25], [367, 514, 5, 5, 25], [10, 497, 3, 4, 12], [10, 497, 3, 4, 12], [9, 479, 7, 13, 91], [9, 479, 7, 13, 91], [201, 457, 36, 16, 576], [201, 457, 36, 16, 576], [0, 453, 39, 108, 4212], [307, 438, 3, 3, 9], [307, 438, 3, 3, 9], [311, 421, 3, 3, 9], [311, 421, 3, 3, 9], [301, 418, 41, 124, 5084], [301, 418, 41, 124, 5084], [314, 452, 5, 22, 110], [331, 403, 9, 13, 117], [331, 403, 9, 13, 117], [315, 398, 3, 3, 9], [315, 398, 3, 3, 9], [175, 320, 37, 25, 925], [175, 320, 37, 25, 925], [218, 314, 4, 3, 12], [218, 314, 4, 3, 12], [176, 311, 3, 3, 9], [176, 311, 3, 3, 9], [40, 293, 13, 13, 169], [40, 293, 13, 13, 169], [44, 270, 11, 15, 165], [44, 270, 11, 15, 165], [93, 262, 3, 3, 9], [93, 262, 3, 3, 9], [405, 253, 299, 298, 89102], [405, 253, 299, 298, 89102], [517, 518, 21, 15, 315], [517, 518, 21, 15, 315], [492, 511, 21, 15, 315], [492, 511, 21, 15, 315], [521, 508, 20, 9, 180], [521, 508, 20, 9, 180], [538, 504, 5, 5, 25], [538, 504, 5, 5, 25], [467, 503, 21, 16, 336], [467, 503, 21, 16, 336], [496, 498, 21, 16, 336], [500, 504, 3, 4, 12], [496, 498, 21, 16, 336], [514, 496, 4, 4, 16], [514, 496, 4, 4, 16], [436, 494, 12, 12, 144], [436, 494, 12, 12, 144], [471, 490, 21, 16, 336], [471, 490, 21, 16, 336], [489, 489, 4, 4, 16], [489, 489, 4, 4, 16], [526, 487, 22, 15, 330], [526, 487, 22, 15, 330], [531, 491, 11, 7, 77], [531, 491, 11, 7, 77], [502, 478, 20, 16, 320], [502, 478, 20, 16, 320], [506, 482, 12, 7, 84], [506, 482, 12, 7, 84], [439, 478, 27, 23, 621], [439, 478, 27, 23, 621], [444, 483, 14, 10, 140], [444, 483, 14, 10, 140], [429, 476, 4, 3, 12], [429, 476, 4, 3, 12], [548, 474, 5, 5, 25], [548, 474, 5, 5, 25], [529, 474, 21, 15, 315], [529, 474, 21, 15, 315], [477, 471, 19, 15, 285], [477, 471, 19, 15, 285], [481, 474, 11, 9, 99], [481, 474, 11, 9, 99], [505, 466, 20, 14, 280], [505, 466, 20, 14, 280], [523, 465, 5, 5, 25], [523, 465, 5, 5, 25], [449, 462, 18, 19, 342], [449, 462, 18, 19, 342], [458, 473, 3, 3, 9], [480, 458, 19, 14, 266], [480, 458, 19, 14, 266], [536, 457, 22, 17, 374], [536, 457, 22, 17, 374], [499, 457, 4, 4, 16], [499, 457, 4, 4, 16], [511, 449, 22, 15, 330], [511, 449, 22, 15, 330], [433, 447, 4, 4, 16], [433, 447, 4, 4, 16], [540, 444, 21, 16, 336], [540, 444, 21, 16, 336], [558, 441, 8, 8, 64], [558, 441, 8, 8, 64], [486, 440, 21, 16, 336], [486, 440, 21, 16, 336], [515, 436, 21, 15, 315], [515, 436, 21, 15, 315], [534, 433, 8, 7, 56], [534, 433, 8, 7, 56], [455, 432, 21, 33, 693], [466, 451, 3, 3, 9], [464, 446, 5, 3, 15], [459, 432, 17, 16, 272], [464, 436, 8, 8, 64], [464, 436, 8, 8, 64], [490, 428, 21, 15, 315], [490, 428, 21, 15, 315], [412, 426, 40, 73, 2920], [440, 443, 5, 3, 15], [438, 442, 4, 3, 12], [442, 438, 4, 3, 12], [432, 426, 20, 19, 380], [508, 425, 9, 7, 63], [508, 425, 9, 7, 63], [464, 420, 16, 14, 224], [464, 420, 16, 14, 224], [473, 426, 3, 4, 12], [473, 426, 3, 4, 12], [467, 425, 3, 3, 9], [467, 425, 3, 3, 9], [523, 413, 20, 11, 220], [523, 413, 20, 11, 220], [437, 411, 19, 17, 323], [548, 409, 24, 24, 576], [551, 409, 21, 14, 294], [555, 413, 6, 6, 36], [555, 413, 6, 6, 36], [463, 408, 12, 11, 132], [463, 408, 12, 11, 132], [568, 406, 5, 5, 25], [568, 406, 5, 5, 25], [499, 406, 18, 9, 162], [499, 406, 18, 9, 162], [557, 402, 7, 6, 42], [557, 402, 7, 6, 42], [526, 399, 20, 15, 300], [526, 399, 20, 15, 300], [530, 403, 6, 6, 36], [530, 403, 6, 6, 36], [544, 397, 4, 4, 16], [544, 397, 4, 4, 16], [532, 393, 5, 5, 25], [532, 393, 5, 5, 25], [501, 392, 20, 14, 280], [501, 392, 20, 14, 280], [506, 397, 5, 5, 25], [506, 397, 5, 5, 25], [518, 389, 5, 5, 25], [518, 389, 5, 5, 25], [507, 386, 4, 4, 16], [507, 386, 4, 4, 16], [453, 384, 8, 7, 56], [453, 384, 8, 7, 56], [532, 379, 21, 16, 336], [532, 379, 21, 16, 336], [537, 383, 12, 8, 96], [537, 383, 12, 8, 96], [558, 375, 26, 29, 754], [558, 388, 21, 16, 336], [563, 393, 10, 7, 70], [563, 393, 10, 7, 70], [561, 375, 23, 17, 391], [507, 372, 21, 15, 315], [507, 372, 21, 15, 315], [511, 376, 12, 7, 84], [511, 376, 12, 7, 84], [536, 366, 22, 17, 374], [536, 366, 22, 17, 374], [511, 359, 21, 16, 336], [511, 359, 21, 16, 336], [440, 352, 34, 55, 1870], [451, 392, 4, 3, 12], [452, 366, 20, 17, 340], [457, 370, 8, 6, 48], [457, 370, 8, 6, 48], [460, 327, 22, 27, 594], [465, 345, 3, 5, 15], [460, 327, 22, 27, 594], [470, 331, 8, 7, 56], [470, 331, 8, 7, 56], [26, 214, 6, 6, 36], [26, 214, 6, 6, 36], [376, 197, 12, 28, 336], [376, 197, 12, 28, 336], [7, 183, 10, 10, 100], [7, 183, 10, 10, 100], [0, 160, 12, 12, 144], [38, 157, 8, 8, 64], [38, 157, 8, 8, 64], [75, 114, 179, 488, 87352], [431, 107, 3, 3, 9], [431, 107, 3, 3, 9], [66, 107, 3, 3, 9], [66, 107, 3, 3, 9], [456, 101, 101, 38, 3838], [456, 101, 101, 38, 3838], [71, 99, 4, 5, 20], [71, 99, 4, 5, 20], [63, 88, 6, 6, 36], [63, 88, 6, 6, 36], [0, 67, 7, 10, 70], [0, 25, 66, 223, 14718], [227, 17, 4, 3, 12], [227, 17, 4, 3, 12], [230, 0, 33, 55, 1815], [196, 0, 33, 38, 1254], [176, 0, 19, 9, 171], [22, 0, 79, 83, 6557], [97, 78, 4, 5, 20], [96, 76, 3, 4, 12], [95, 73, 3, 5, 15], [9, 0, 44, 27, 1188]]
#
#     # ###############################################
#     # arr = list(filter(lambda x: 0.3 < x[2] / x[3] < 2.1 and 100 < x[2] * x[3] < 400, borders))
#     #
#     # for cont in arr:
#     #     x, y, w, h, *_ = cont
#     #     # borders.append([x,y,w,h,w*h])
#     #     img = cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 4)
#     #
#     #
#     #
#     #
#     # arr[0].append(0)
#     # arr[0].append(0)
#     # sr_deltx = sr_delty = 0
#     # sr_x = arr[0][0]
#     # sr_y = arr[0][1]
#     # for i in range(1, len(arr)):
#     #     sr_x += arr[i][0]
#     #     sr_y += arr[i][1]
#     #     sr_deltx += abs(arr[i][0] - arr[i-1][0])
#     #     sr_delty += abs(arr[i][1] - arr[i-1][1])
#     #
#     #     arr[i].append(arr[i][0] - arr[i-1][0])
#     #     arr[i].append(arr[i][1] - arr[i-1][1])
#     #
#     # x_med = my_median(np.array(arr)[:, 0])
#     # y_med = my_median(np.array(arr)[:, 1])
#     # sr_deltx = sr_deltx/len(arr)
#     # sr_delty = sr_delty/len(arr)
#     # sr_x = sr_x/len(arr)
#     # sr_y = sr_y/len(arr)
#     # # img = cv2.circle(img, (sr_x,sr_y),5,(0,0,255))
#     #
#     # print("Среднее x",sr_x)
#     # print("Среднее y",sr_y)
#     # # img = cv2.circle(img, (int(sr_x), int(sr_y)), 10, (0, 0, 255), thickness=cv2.FILLED)
#     # img = cv2.circle(img, (int(x_med), int(y_med)), 10, (0, 100, 255), thickness=cv2.FILLED)
#     # print("Среднее deltx",sr_deltx)
#     # print("Среднее delty",sr_delty)
#     # print(np.array(arr))
#     # print(len(arr))
#     # print("-------------------------------")
#     # print(arr[2][5], arr[2][6])
#     # ar_1 = []
#     # # arr = list(filter(lambda x: abs(x[5])!=0, arr))
#     # for ar in arr:
#     #     # print(abs(ar[5]) , sr_x,  abs(ar[6]) , sr_y)
#     #     if x_med - 100 < abs(ar[0]) < x_med + 100 and y_med - 100 < abs(ar[1]) < y_med + 100:
#     #         ar_1.append(ar)
#     # print(np.array(ar_1))
#     # print(len(ar_1))
#     # arr = ar_1
#     # for cont in arr:
#     #     x, y, w, h, *_ = cont
#     #     # borders.append([x,y,w,h,w*h])
#     #     img = cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)
#
#     # ##########################################
#
#     cv2.imshow("img", img)
#     cv2.waitKey(0)
#     cv2.destroyAllWindows()
#
#     # exit()
#     # borders = arr
#     return borders
#
#
# def get_letter(url, f_name):
#     req = urllib.request.urlopen(url)
#     files = []
#     arr = np.asarray(bytearray(req.read()), dtype=np.uint8)
#     labels = []
#     image = cv2.imdecode(arr, cv2.IMREAD_COLOR)  # Получение фото по изображению
#
#     # image = cv2.imread("tets.JPG") # Получение фото по изображению
#     cv2.imwrite('ph.jpeg', image)
#     # cv2.imshow('ph.jpeg', image)
#
#     # print(list(borders), end='\n')
#     # print(my_median([1,2,3,4,5,6]))
#     # exit()
#     d = 170
#     r = 3
#     borders = templ(image, d, r)
#     # return 0
#     bors = [borders]
#     bors_ln = [len(borders)]
#     mx = 0
#     img1 = image.copy()
#     print("Коробки ", len(borders))
#     while len(borders) < 10 or d>150:
#        d -= 10
#        r+=2
#        borders = templ(image, d, r)
#        bors.append(borders)
#        bors_ln.append(len(borders))
#        # mx = max(bors_ln, mx)
#        print("Коробки ", len(borders), d)
#     print(bors_ln)
#     mx_len = max(bors_ln)
#     mx_inx = bors_ln.index(mx_len)
#     mn_len = min(bors_ln)
#     mn_inx = bors_ln.index(mn_len)
#     # mn_bords = filt_box((bors[mx_inx]))
#     # for box in mn_bords:
#     #     x,y,w,h,*_ = box
#     #     img1 = cv2.rectangle(img1, (x,y), (x+w, h+y), 2)
#     mx_bor = max([bor[1] for bor in bors])
#     # cv2.imshow("1", img1)
#     # cv2.waitKey(0)
#     # cv2.destroyAllWindows()
#     # print(mx_bor)
#     # borders = list(map(lambda x: x[1] == mx_bor, bors))
#     borders = bors[mx_inx]
#
#     print(borders)
#     # exit()
#     # return 0
#     img = image.copy()
#
#     borders = list(filter(lambda x: 0.3 < x[2] / x[3] < 2.1 and 130 < x[2] * x[3] < 350, borders))
#     # if len(borders) < 10:
#     #     template(image, 160)
#     if len(borders) <3:
#         print("После фильтра")
#         return 0
#     for bor in borders:
#         x,y,w,h,s = bor
#         cv2.rectangle(img, (x, y), (x + w, y + h), (0, 0, 255), 1)
#     cv2.imshow('dimg', img)
#     cv2.waitKey(0)
#     cv2.destroyAllWindows()
#
#     borders = sorted(borders,key=lambda x:(x[0],x[1]))
#     print(borders)
#     # print(np.array(borders))
#     # print('-----------------------------------------------')
#     del_x = 10
#     del_y = 10
#     borders[0].append(0)
#     borders[0].append(0)
#     borders[0].append(borders[0][0]//del_x)
#     borders[0].append(borders[0][1]//del_y)
#     for i in range(1,len(borders)):
#         borders[i].append(dis(borders[i][0], borders[i-1][0]))
#         borders[i].append(dis(borders[i][1], borders[i-1][1]))
#         borders[i].append(math.floor(borders[i][0]/del_x))
#         borders[i].append(math.floor(borders[i][1]/del_y))
#
#     print(len(borders))
#     print(np.array(borders))
#     print('-----------------------------------------------')
#     borders = sorted(borders, key=lambda x: (x[5], x[6]))
#     med_x = borders[math.ceil(len(borders)/2)][0]
#     med_y = borders[math.ceil(len(borders)/2)][1]
#     print(med_x, med_y)
#
#     sr_w = sr_h = 0
#
#
#     # f = lambda x: [x[0]//delit, x[1]//delit,x[2],x[3],x[4],x[5],x[6], x[7], x[8]]
#     # borders_2 = list(map(f, borders))
#
#     print(np.array(borders))
#     print('-----------------------------------------------')
#
#     # count_p([1,1,1,2,3,3,5,6])
#     # exit()
#
#
#     x_med = my_median(np.array(borders)[:,0])
#     y_med = my_median(np.array(borders)[:,1])
#
#     arr_x = sorted(np.array(borders)[:,7])
#     # res_x = count_p(arr_x)
#     res_x = (1,1)
#     # print(arr_x)
#     # exit()
#     arr_y = sorted(np.array(borders)[:,8])
#
#     print('----------------------------')
#     # res_y = count_p(arr_y)
#     res_y = (1,1)
#     mx_x, mn_x = res_x
#     mx_y, mn_y = res_y
#     mx_x, mn_x = map(lambda x:(x*del_x), [mx_x, mn_x])
#     mx_y, mn_y = map(lambda x:(x*del_y), [mx_y, mn_y])
#     print(mx_x, mn_x)
#     print(mx_y, mn_y)
#     print("Медианы ", x_med, y_med)
#     print("pyf ", res_x, res_y)
#     if len(borders) <3:
#         print("res_x")
#         return
#     # print([list(np.array(borders)[:,1]),list.(np.array(borders)[:,5])])
#     x_znach = count_p(list(np.array(borders)[:,0]),list(np.array(borders)[:,5]))
#     y_znach = count_p(list(np.array(borders)[:,1]),list(np.array(borders)[:,6]))
#     # print(x_znach)
#     # d = lambda x: x[0] = 0
#     # obl = lambda x: x if x[5] in x_znach else x[0] = 0
#     for bor in borders:
#         if bor[5] not in x_znach or bor[6] not in y_znach:
#             bor[0] = bor[1] = 0
#     # for bor in borders:
#     #     if bor[6] not in y_znach:
#     #         bor[1] = 0
#     # borders = list(map(obl(),borders))
#     borders = list(filter(lambda x:x[0] != 0 and x[1] != 0, borders))
#     print('---------------------------------------------------------------------')
#     print(np.array(borders))
#     # exit()
#
#     if len(borders) <3:
#         print("После фильтра 2")
#         return {"boreders": borders,
#             "x_med":x_med,
#             "y_med":y_med,}
#     # cv2.rectangle(img1, (mn_x , mn_y), (mx_x + 2 , mx_y + 15), (0, 255, 0), 1)
#     # print()
#     cv2.circle(img1, (x_med, y_med), 10, (255, 0, 0),thickness=cv2.FILLED)
#     mx_x, mn_x = max(np.array(borders)[:,0]), min(np.array(borders)[:,0])
#     mx_y, mn_y = max(np.array(borders)[:,1]), min(np.array(borders)[:,1])
#
#
#     # rRect = cv2.RotatedRect(cv2.Point2f(mn_x,mn_y), cv2.Size2f(mx_x, mx_y), 7)
#
#     # Point2f
#     # vertices[4];
#     # rRect.points(vertices);
#     #
#     # for i in range(4)
#     #     cv2.line(img1, vertices[i], vertices[(i + 1) % 4], Scalar(0, 255, 0), 2);
#     #
#
#
#     for border in borders:
#         x,y,w,h, *_ = border
#         cv2.rectangle(img1, (x, y), (x + w, y + h), (255, 0, 0), 1)
#     rows, cols = img1.shape[:2]
#     delt_x = 0
#     delt_y = 0
#     for i in range(len(borders)):
#         delt_x+=borders[i][5]
#         delt_y+=borders[i][6]
#     delt_x = delt_x//len(borders)
#     delt_y = delt_y//len(borders)
#     if delt_y ==0 :
#         print("На 0")
#         return {"boreders": borders,
#             "x_med":x_med,
#             "y_med":y_med,}
#     print(delt_x, delt_y)
#     print(delt_x - delt_y)
#     # exit()
#     arr_wh = []
#     for i in range(len(borders)):
#         sr_w += borders[i][2]
#         arr_wh.append(borders[i][3] / borders[i][2])
#         sr_h += borders[i][3]
#     print(sr_w/len(borders), sr_h/len(borders))
#     sr_del = get_angle(borders,(sr_w)/len(borders)-(sr_h)/len(borders))
#     print(sr_del)
#     print(math.degrees(math.atan(sr_del)))
#
#     print("среднее_ ", (sum(arr_wh) / len(borders)))
#     print("Угол ", math.degrees(math.atan(sum(arr_wh) / len(borders))))
#
#
#     rows, cols = img1.shape[:2]
#     # angle = int(input())
#     M = cv2.getRotationMatrix2D((int(mn_x + (mx_x - mn_x)//2), int(mn_y + (mx_y - mn_y)//2)), 0, 1)
#     # M = cv2.getRotationMatrix2D((int(mn_x + (mx_x - mn_x)//2), int(mn_y + (mx_y - mn_y)//2)), 123, 1)
#     # M1 = cv2.getRotationMatrix2D((int(mn_x + (mx_x - mn_x)//2), int(mn_y + (mx_y - mn_y)//2)), 210, 1)
#     img1 = cv2.warpAffine(img1, M, (cols, rows))
#     # img2 = cv2.warpAffine(image, M1, (cols, rows))
#     cv2.rectangle(img1, (mn_x,mn_y), (mx_x, mx_y), (0, 0, 255), 1)
#     # print(f"w{mx_x-mn_x} ")
#     print(f"max{mx_x, mx_y}, min{mn_x, mn_y}")
#     # for border in borders:
#     #     x,y,w,h, *_ = border
#     #     cv2.rectangle(img1, (x, y), (x + w, y + h), (255, 0, 0), 1)
#
#     print(sr_w // len(borders), sr_h // len(borders))
#     print("w/h  ", abs((sr_w // len(borders)) / (sr_h // len(borders))))
#     print("h/w  ", abs((sr_h // len(borders)) / (sr_w // len(borders))))
#     print("Среднее  ", abs((sr_w // len(borders)) / (sr_h // len(borders)) - (sr_h // len(borders)) / (sr_w // len(borders))))
#
#
#     cv2.imshow('result', img1)
#     # cv2.imshow('result1', img2)
#     cv2.waitKey(0)
#     cv2.destroyAllWindows()
#
#
#     return {"borders": borders,
#             "x_med":x_med,
#             "y_med":y_med,}
# def get_angle(arr, sr_d):
#     sr_angle_wh = sr_angle_hw = sr_angle = 0
#     for bor in arr:
#         sr_angle_wh = bor[2]-bor[3] + sr_d
#         print("w - h", sr_angle_wh)
#         sr_angle_hw = bor[3]-bor[2] + sr_d
#         print("h - w",sr_angle_hw)
#         sr_angle += sr_angle_wh/sr_angle_hw
#         print("angle ", sr_angle_wh/sr_angle_hw)
#         # sr_angle_hw = sr_angle_hw/len(arr)
#         # sr_angle_wh = sr_angle_wh/len(arr)
#     return sr_angle/len(arr)
# def obl(x,n, znach):
#     if x[n] in znach:
#         return x
#     else:
#         x[0] = 0
#         return x
# def dis(a,b):
#     return a-b
# def my_median(sample):
#     # 1,2,3,4,5,6
#     sample = sorted(sample)
#     print(sample)
#     n = len(sample)
#     index = n // 2
#     # Sample with an odd number of observations
#     if n % 2:
#         return sorted(sample)[index]
#     # Sample with an even number of observations
#     return int(sum(sorted(sample)[index - 1:index + 1])/2)
# def count_p(arr, arr_1 = None):
#     res = []
#     sr = 0
#     if arr_1 is None:
#         for n in list(set(arr)):
#             c = arr.count(n)
#             res.append([n, c])
#             sr += c
#         # print(np.array(res))
#         sr = sr//len(res)
#         # print("Сред ", sr)
#         v = list(filter(lambda x: x[1] > sr, res))
#     else:
#         # arr_1 = np.array(arr)[:, 1]
#         for n in list(set(arr_1)):
#             c = arr_1.count(n)
#             res.append([n, c])
#             sr += c
#         print(np.array(res))
#         sr = sr//len(res)
#         print("SR2", sr)
#         v = list(filter(lambda x: x[1] > sr, res))
#         res_c1 = list(np.array(v)[:,0])
#         print(res_c1)
#         # for i in range(len(arr)):
#         #     if arr_1[i] in res_c1:
#
#
#         # print(np.array(v))
#         return res_c1
#     print("SR", sr)
#     print(np.array(v))
#     return (max(v)[0], min(v)[0])
# def correct_rct(w, h,x,y):
#     if h>w or abs(h-w)>30:
#         return w+100, h+100,x-30,y-30
#     return w,h,x,y
# def get_mark(token = '6268498821:AAGGDDITcRI2RFtyljkGUff5IB39ihtWtOk', id = 'AgACAgIAAxkBAAIDJGS9QN0bJOudNf8f_HVUVomWYfoIAALayTEbFEjwSZjx0YeSoooXAQADAgADeAADLwQ', n = 0):
#     url = "https://api.telegram.org/bot" + token + "/getFile?file_id=" + id
#     res = file_path = requests.get(f'https://api.telegram.org/bot{token}/getFile?file_id={id}').json()['result']['file_path']
#     # print(res)
#     UrlPhoto = "https://api.telegram.org/file/bot" + token + "/" + res
#     print(UrlPhoto, id)
#     result = get_letter(UrlPhoto, res.split("/")[1])
#     return result
# # def dtime(now):
def getURL(id, token = '6268498821:AAGGDDITcRI2RFtyljkGUff5IB39ihtWtOk'):
    res = file_path = requests.get(f'https://api.telegram.org/bot{token}/getFile?file_id={id}').json()['result']['file_path']
    # print(res.split("/")[1])
    UrlPhoto = "https://api.telegram.org/file/bot" + token + "/" + res
    return [UrlPhoto, res]
# # get_mark()
#
# def get_letters(borders, img):
#     borders = sorted(borders, key=lambda x: (x[0], x[1]))
#     print(borders)
#     # print(np.array(borders))
#     # print('-----------------------------------------------')
#     del_x = 10
#     del_y = 10
#     borders[0].append(0)
#     borders[0].append(0)
#     borders[0].append(borders[0][0] // del_x)
#     borders[0].append(borders[0][1] // del_y)
#     for i in range(1, len(borders)):
#         borders[i].append(dis(borders[i][0], borders[i - 1][0]))
#         borders[i].append(dis(borders[i][1], borders[i - 1][1]))
#         borders[i].append(math.floor(borders[i][0] / del_x))
#         borders[i].append(math.floor(borders[i][1] / del_y))
#
#     print(len(borders))
#     print(np.array(borders))
#     print('-----------------------------------------------')
#     borders = sorted(borders, key=lambda x: (x[5], x[6]))
#     med_x = borders[math.ceil(len(borders) / 2)][0]
#     med_y = borders[math.ceil(len(borders) / 2)][1]
#     print(med_x, med_y)
#
#     sr_w = sr_h = 0
#
#     # f = lambda x: [x[0]//delit, x[1]//delit,x[2],x[3],x[4],x[5],x[6], x[7], x[8]]
#     # borders_2 = list(map(f, borders))
#
#     print(np.array(borders))
#     print('-----------------------------------------------')
#
#     # count_p([1,1,1,2,3,3,5,6])
#     # exit()
#
#     x_med = my_median(np.array(borders)[:, 0])
#     y_med = my_median(np.array(borders)[:, 1])
#
#     arr_x = sorted(np.array(borders)[:, 7])
#     res_x = count_p(arr_x)
#     # print(arr_x)
#     # exit()
#     arr_y = sorted(np.array(borders)[:, 8])
#
#     print('----------------------------')
#     res_y = count_p(arr_y)
#     mx_x, mn_x = res_x
#     mx_y, mn_y = res_y
#     mx_x, mn_x = map(lambda x: (x * del_x), [mx_x, mn_x])
#     mx_y, mn_y = map(lambda x: (x * del_y), [mx_y, mn_y])
#     print(mx_x, mn_x)
#     print(mx_y, mn_y)
#     print("Медианы ", x_med, y_med)
#     print("pyf ", res_x, res_y)
#     if len(borders) < 3:
#         print("res_x")
#         return "2"
#     # print([list(np.array(borders)[:,1]),list.(np.array(borders)[:,5])])
#     x_znach = count_p(list(np.array(borders)[:, 0]), list(np.array(borders)[:, 5]))
#     y_znach = count_p(list(np.array(borders)[:, 1]), list(np.array(borders)[:, 6]))
#     # print(x_znach)
#     # d = lambda x: x[0] = 0
#     # obl = lambda x: x if x[5] in x_znach else x[0] = 0
#     for bor in borders:
#         if bor[5] not in x_znach or bor[6] not in y_znach:
#             bor[0] = bor[1] = 0
#     # for bor in borders:
#     #     if bor[6] not in y_znach:
#     #         bor[1] = 0
#     # borders = list(map(obl(),borders))
#     borders = list(filter(lambda x: x[0] != 0 and x[1] != 0, borders))
#     print('---------------------------------------------------------------------')
#     print(np.array(borders))
#     # exit()
#
#     if len(borders) < 3:
#         print("После фильтра 2")
#         return "3"
#     # cv2.rectangle(img1, (mn_x , mn_y), (mx_x + 2 , mx_y + 15), (0, 255, 0), 1)
#     # print()
#     # cv2.circle(img1, (x_med, y_med), 10, (255, 0, 0), thickness=cv2.FILLED)
#     mx_x, mn_x = max(np.array(borders)[:, 0]), min(np.array(borders)[:, 0])
#     mx_y, mn_y = max(np.array(borders)[:, 1]), min(np.array(borders)[:, 1])
#
#     # rRect = cv2.RotatedRect(cv2.Point2f(mn_x,mn_y), cv2.Size2f(mx_x, mx_y), 7)
#
#     # Point2f
#     # vertices[4];
#     # rRect.points(vertices);
#     #
#     # for i in range(4)
#     #     cv2.line(img1, vertices[i], vertices[(i + 1) % 4], Scalar(0, 255, 0), 2);
#     #
#
#     # for border in borders:
#     #     x, y, w, h, *_ = border
#     #     cv2.rectangle(img1, (x, y), (x + w, y + h), (255, 0, 0), 1)
#     # rows, cols = img1.shape[:2]
#     delt_x = 0
#     delt_y = 0
#     for i in range(len(borders)):
#         delt_x += borders[i][5]
#         delt_y += borders[i][6]
#     delt_x = delt_x // len(borders)
#     delt_y = delt_y // len(borders)
#     if delt_y == 0:
#         print("На 0")
#         return "4"
#     print(delt_x, delt_y)
#     print(delt_x - delt_y)
#     # exit()
#     arr_wh = []
#     for i in range(len(borders)):
#         sr_w += borders[i][2]
#         arr_wh.append(borders[i][3] / borders[i][2])
#         sr_h += borders[i][3]
#     print(sr_w / len(borders), sr_h / len(borders))
#     sr_del = get_angle(borders, (sr_w) / len(borders) - (sr_h) / len(borders))
#     print(sr_del)
#     print(math.degrees(math.atan(sr_del)))
#
#     print("среднее_ ", (sum(arr_wh) / len(borders)))
#     print("Угол ", math.degrees(math.atan(sum(arr_wh) / len(borders))))
#
#     # rows, cols = img1.shape[:2]
#     # angle = int(input())
#     # M = cv2.getRotationMatrix2D((int(mn_x + (mx_x - mn_x) // 2), int(mn_y + (mx_y - mn_y) // 2)), 0, 1)
#     # M = cv2.getRotationMatrix2D((int(mn_x + (mx_x - mn_x)//2), int(mn_y + (mx_y - mn_y)//2)), 123, 1)
#     # M1 = cv2.getRotationMatrix2D((int(mn_x + (mx_x - mn_x)//2), int(mn_y + (mx_y - mn_y)//2)), 210, 1)
#     # img1 = cv2.warpAffine(img1, M, (cols, rows))
#     # img2 = cv2.warpAffine(image, M1, (cols, rows))
#     # cv2.rectangle(img1, (mn_x, mn_y), (mx_x, mx_y), (0, 0, 255), 1)
#     # print(f"w{mx_x-mn_x} ")
#     print(f"max{mx_x, mx_y}, min{mn_x, mn_y}")
#     for border in borders:
#         x,y,w,h, *_ = border
#         cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 1)
#
#     print(sr_w // len(borders), sr_h // len(borders))
#     print("w/h  ", abs((sr_w // len(borders)) / (sr_h // len(borders))))
#     print("h/w  ", abs((sr_h // len(borders)) / (sr_w // len(borders))))
#     print("Среднее  ",
#           abs((sr_w // len(borders)) / (sr_h // len(borders)) - (sr_h // len(borders)) / (sr_w // len(borders))))
#
#     cv2.imshow('result', img)
#     # cv2.imshow('result1', img2)
#     cv2.waitKey(0)
#     cv2.destroyAllWindows()
#
#     return {"boreders": borders,
#             "x_med":x_med,
#             "y_med":y_med,}
# def virez(url = '', token = '',id = '',d = 150):
#     url = "https://api.telegram.org/bot" + token + "/getFile?file_id=" + id
#     res = file_path = requests.get(f'https://api.telegram.org/bot{token}/getFile?file_id={id}').json()['result'][
#         'file_path']
#     # print(res)
#     url = "https://api.telegram.org/file/bot" + token + "/" + res
#     req = urllib.request.urlopen(url)
#     arr = np.asarray(bytearray(req.read()), dtype=np.uint8)
#
#     image = cv2.imdecode(arr, cv2.IMREAD_COLOR)  # Получение фото по изображению
#     img = image.copy()
#
#     cv2.imshow("img", img)
#     # (1)
#     gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#     #
#     blur = cv2.GaussianBlur(gray, (3, 3), 1)
#
#     ret, thes = cv2.threshold(blur, d, 255, cv2.THRESH_BINARY)
#
#     # kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (25, 25))
#
#     # Применяем морфологическую операцию расширения к изображению
#     # dilated_image = cv2.dilate(img, kernel)
#
#     gray = cv2.cvtColor(thes, cv2.COLOR_BGR2GRAY)
#
#     ret, thes = cv2.threshold(gray, d, 255, cv2.THRESH_BINARY)
#
#     letters = get_letter(url,'')
#     # return 0
#     b = True
#     x_m, y_m = letters["x_med"], letters["y_med"]
#     if letters == "4":
#        b = False
#     print("letters", np.array(letters))
#     if b:
#     for let in letters["borders"]:
#         x,y,w,h,*_ = let
#         img = cv2.rectangle(img, (x,y),(x+w,y+h),(0,0,255) ,1)
#     img = cv2.circle(img, (x_m, y_m), 10, (255, 0, 0), thickness=cv2.FILLED)
#
#     # cv2.imshow("thes", thes)
#     # cv2.imshow("dilate", dilated_image)
#     # cv2.waitKey(0)
#     # cv2.destroyAllWindows()
#
#     # mask_3_channels = cv2.merge((dilated_mask, dilated_mask, dilated_mask))
#
#     # Наложение маски на исходное изображение
#     mask = np.zeros_like(thes)
#     # mask = cv2.bitwise_not(thes)
#     result = cv2.bitwise_and(img, img, mask=thes)
#
#     # gray = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY)
#     #
#     # ret, thes = cv2.threshold(gray, 240, 255, cv2.THRESH_BINARY_INV)
#
#     # result = cv2.bitwise_and(img, img, mask=thes)
#
#     # cv2.imshow("thes", thes)
#     cv2.imshow("dilate", result)
#     # cv2.waitKey(0)
#     # cv2.destroyAllWindows()
#
#     edges = cv2.Canny(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY), 100, 200, apertureSize=7)
#
#     cv2.imshow("edges", edges)
#
#
#     # Найдите контуры на изображении
#     contours, _ = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
#     borders = []
#
#     # for cont in contours:
#     #     x,y,w,h = cv2.boundingRect(cont)
#     #     borders.append([x,y,w,h,w*h])
#     # borders = list(filter(lambda x: 0.3 < x[2] / x[3] < 2.1 and 100 < x[2] * x[3] < 300, borders))
#
#     # letters = get_letters(borders, img)
#     # print("letters", letters)
#     #
#     # for let in letters:
#     #     x, y, w, h, *_ = let
#     #     img = cv2.rectangle(img, (x, y), (x + w, y + h), (0, 0, 255), 1)
#
#     filtered_conts = []
#     # approx = 0
#     for cont in contours:
#         x,y,h,w = cv2.boundingRect(cont)
#         if w>100 and h>100 and w*h>20_000:
#             # epsilon = 0.2 * cv2.arcLength(cont, True)
#             # approx = cv2.approxPolyDP(cont, 10, False)
#             # print(approx)
#             # img = cv2.drawContours(img, approx, -1, (255, 0, 0), 3)
#
#             filtered_conts.append(cv2.convexHull(cont))
#     # print(filtered_conts)
#
#     for i, contour in enumerate(filtered_conts):
#         # pass
#         # if markers.min() < 0:
#             # continue
#         # epsilon = 0.01 * cv2.arcLength(contour, False)
#         # print(epsilon)
#         # approx = cv2.approxPolyDP(contour, epsilon, False)
#         # print("1", contour)
#         # print("2", approx)
#         x, y, w, h = cv2.boundingRect(contour)
#         # img = cv2.drawContours(img, approx, -1, (255, 0, 0), 3)
#
#         find = Correct((x, y, w, h), letters["borders"], x_m, y_m)
#         print("Нашлось", find, "Всего ", len(letters["borders"]))
#         print(find / len(letters["borders"]))
#         if b:
#             if find/len(letters) > 0.8:
#                 img = cv2.drawContours(img, [contour], 0, (255, 0, 0), 2)
#                 cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 1)
#         else:
#             if 150 < w < 400 and 150 < h < 400:
#                 img = cv2.drawContours(img, [contour], 0, (255, 0, 0), 2)
#                 cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 1)
#
#
#     cv2.imshow('Segmented Image', img)
#     cv2.waitKey(0)
#     cv2.destroyAllWindows()
#
# def Correct(box, words, x_m, y_m):
#     x,y,w,h = box
#     c_word = 0
#     for word in words:
#         x_w, y_w,*_ = word
#         if x<=x_w<= x+w and y<=y_w<= y+h:
#             c_word +=1
#     return c_word
def virez(url = '', token = '', id = '', d = 150, products = []):
    # ### Получение фото по url
    result = {
        "file" : [],
        "text" : []
    }
    url = "https://api.telegram.org/bot" + token + "/getFile?file_id=" + id
    res = file_path = requests.get(f'https://api.telegram.org/bot{token}/getFile?file_id={id}').json()['result']['file_path']
    # print(res)
    url = "https://api.telegram.org/file/bot" + token + "/" + res
    print(url)
    req = urllib.request.urlopen(url)
    arr = np.asarray(bytearray(req.read()), dtype=np.uint8)

    image = cv2.imdecode(arr, cv2.IMREAD_COLOR)  # Получение фото по изображению
    # cv2.imwrite(id+".jpg", image)
    img = image.copy()

    # ########
    # ### Обработка фото

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

    blur = cv2.GaussianBlur(gray, (3, 3), 1)


    z = lambda x: x if x>0 else 0
    letters = getConts(img,blur,[130,140,150,160,170],0)
    # for let in letters:
    #     x,y,w,h = let
    #     image =cv2.rectangle(image, (x,y), (x + w, y + h), (0,0,255), 1)
    print("1")

    rows, cols = image.shape[:2]
    c_x, c_y = cols // 2, rows // 2
    res = test_funcs.filter_conts(letters, image)
    print(res)
    text = False
    if res["ok"]:
        for i in range(len(res["points"])):
            img = image.copy()
            letters = res["points"][i]
            angle = res["angle"][i]
            M = cv2.getRotationMatrix2D((int(c_x), int(c_y)), angle, 1)
            img = cv2.warpAffine(img, M, (cols, rows))
            # letters.sort(key = lambda x:x[0])
            mx_x = mx_y = 0
            mn_x = mn_y = 10000000000
            for let in letters:
                mx_x = max(mx_x, let[0])
                mx_y = max(mx_y, let[1])
                mn_x = min(mn_x, let[0])
                mn_y = min(mn_y, let[1])

            print(mn_y-40, mx_y+50, mn_x-130,mx_x+70)
            res_img = img[z(mn_y-40): z(mx_y+50), z(mn_x-130):z(mx_x+70)]
            # image = cv2.rectangle(image, (mn_y-40, mx_y+50), (z(mn_x-130),z(mx_x+70)), (0,255,0), 2)
            print("rs ",res_img)
            print("rsL ",len(res_img))
            # cv2.imshow("d", image)
            # cv2.waitKey(0)
            # cv2.destroyAllWindows()
            if res_img is not None or res_img != [] or len(res_img) > 0:
                text = tesseract_check(image= res_img,  products = products)
            if text != False:
                # cv2.rectangle(image, (mn_x - 150, mn_y - 35), (mx_x + 75, mx_y + 55), (0, 255, 0), 3)
                result["text"].append(text)
                cv2.imwrite(id + '.jpg', res_img)
                result["file"].append(id + '.jpg')
            # cv2.imshow("2", res_img)
            # cv2.waitKey(0)
            # cv2.destroyAllWindows()

    # else:
    #     edges = cv2.Canny(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY),130,240,apertureSize=7)
    #     cv2.imshow("1", edges)
    #     cv2.waitKey(0)
    #     cv2.destroyAllWindows()
    #     contours, _ = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
    #     filtered_conts = []
    #     for cont in contours:
    #         x, y, h, w = cv2.boundingRect(cont)
    #         if w > 100 and h > 100 and 20_000< w * h:
    #             # epsilon = 0.2 * cv2.arcLength(cont, True)
    #             # approx = cv2.approxPolyDP(cont, 10, False)
    #             # print(approx)
    #             # img = cv2.drawContours(img, approx, -1, (255, 0, 0), 3)
    #             filtered_conts.append(cv2.convexHull(cont))
    #     for cont in filtered_conts:
    #         x, y, w, h = cv2.boundingRect(cont)
    #         # img = cv2.drawContours(img, approx, -1, (255, 0, 0), 3)
    #         if 150 < w < 400 and 150 < h < 400 and w/h :
    #             cv2.rectangle(image, (x,y), (x+w,y+h), (0,255,0), 3)
    # cv2.imshow("1", image)
    # cv2.waitKey(0)
    # cv2.destroyAllWindows()

    return result


    # return 0
    # plt = res["plt"]
    # print("Угол ",angle)
    # points = rotate(letters, -angle, c_x, c_y)
    # y_arr = list(np.array(points)[:,1])
    count_p(y_arr)
    x = []
    y = []
    M = cv2.getRotationMatrix2D((int(c_x), int(c_y)), angle, 1)
    # M = cv2.getRotationMatrix2D((0, 0), -angle[0], 1)
    image = cv2.warpAffine(image, M, (cols, rows))
    mx_x = mx_y = 0
    mn_x = mn_y = 10000000000
    for point in points:
        x.append(point[0])
        y.append(point[1])
        # cv2.circle(image,(point[0], point[1]),3, (255,0,0), thickness=cv2.FILLED)
        mx_x = max(mx_x, point[0])
        mx_y = max(mx_y, point[1])
        mn_x = min(mn_x, point[0])
        mn_y = min(mn_y, point[1])
        cv2.rectangle(image,(point[0], point[1]), (point[0] + 10, point[1] + 10),(255,0,0), 2)
    # print((mn_x, mn_y), (mx_x, mx_y))
    cv2.rectangle(image, (mn_x, mn_y), (mx_x + 100, mx_y + 100), (0, 0, 255), 3)
    # plt.plot(x,y)

    cv2.imshow("1", image)
    plt.gca().yaxis.grid(False)
    plt.show()
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    # exit()
    return 0
    print(letters)
    # print(np.array(letters))
    x = np.array(letters)[:,6]
    y = np.array(letters)[:,7]
    plt.scatter(x, y)
    plt.show()
    # return 0
    # for let in letters:
    #     # print(let)
    #     x,y,w,h,*_ = let
    #     cv2.rectangle(image, (x,y), (x+w,y+h), (0,255,0), 1)
    # print("letters", np.array(letters))

    if len(letters) == 0:
        print("Фильтрация")
        # return 0

    # cv2.imshow("t", image)

    angle = alfa(letters, c_x, c_y)
    # M = cv2.getRotationMatrix2D((c_x, c_y), -angle[0], 1)
    # M = cv2.getRotationMatrix2D((0, 0), -angle[0], 1)
    # image = cv2.warpAffine(image, M, (cols, rows))
    print("Угол", angle)


    # return 0




    # cv2.imshow("t1", image)
    # cv2.waitKey(0)
    # cv2.destroyAllWindows()
    # return 0

    # exit()
    # draw_box(letters, image, angle[5] + c_y ,angle[6] + c_x ,angle[7] + c_y, angle[8] + c_x, -angle[0], 20, 20)
    # exit()
    borders = []
    contours, _ = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
    for cont in contours:
        x,y,w,h = cv2.boundingRect(cont)
        borders.append([x,y,w,h])
    # marks = list(filter(lambda x: x[2]>150 and x[3]>150 and x[2]*x[3]>25_000, borders))

    # print("letters" , np.array(marks))
    marks = []
    for let in letters:
        # print(let)
        x,y,w,h,*_ = let
        cv2.rectangle(image, (x,y), (x+w,y+h), (255,0,0), 2)
    for cont in contours:
        x, y, h, w = cv2.boundingRect(cont)
        if w > 100 and h > 100 and w * h > 20_000:
            marks.append(cv2.convexHull(cont))


    # img = cv2.drawContours(image, marks, -1, (255, 0, 0), 2)
    img = image.copy()
    M = cv2.getRotationMatrix2D((int(c_x), int(c_y)), -angle[0], 1)
    # M = cv2.getRotationMatrix2D((0, 0), -angle[0], 1)
    image = cv2.warpAffine(image, M, (cols, rows))
    res_img = None
    ist = False
    n = rotate(letters, angle[0], c_x, c_y)
    # print(n)
    # exit()
    for mark in marks:
        x, y, w, h = cv2.boundingRect(mark)

        r = rotate([[x + (w//2), y + (h//2),w,h]], angle[0], c_x, c_y)
        r = r[0]

        x,y,x1,y1 = int(r[0] - (w//2)), int(r[1] - (h//2)), int(r[0] + (w//2)), int(r[1] + (h//2))
        if abs(angle[0]) > 45:
            x, y, x1, y1 = int(r[0] - (h // 2)), int(r[1] - (w // 2)), int(r[0] + (h // 2)), int(r[1] + (w // 2))
        ist = Correct([x, y, x1 - x, y1-y], n)
        if ist:
            cv2.rectangle(image, (x, y), (x1, y1), (0, 0, 255), 1)
            res_img = image[y-5:y1+5, x-5:x1+5]
            # rows, cols = res_img.shape[:2]
            # M = cv2.getRotationMatrix2D(((int(rows) // 2), int(cols) // 2), 0, 1)
            # res_img = cv2.warpAffine(res_img, M, (cols, rows))
            break
    if not ist:
        x0,y0,x1,y1 = angle[5] + c_x ,angle[6] + c_y ,angle[7] + c_x, angle[8] + c_y
        # res_img = draw_box(letters, image, x0,y0,x1,y1, -angle[0], 20, 20)
        print("1 ", letters)


        print("2 ", n)

        mn_x, mn_y, *_ = n[0]
        mx_x = mn_x
        mx_y = mn_y
        for box in n:
            x, y, w, h = box
            cv2.rectangle(image, (x, y), (x + w, y + h), (100, 0, 200), 2)
            mn_x = min(mn_x, x - abs(w))
            mn_y = min(mn_y, y - abs(h))
            mx_x = max(mx_x, x + abs(2 * w))
            mx_y = max(mx_y, y + abs(2 * h))
        print((mn_x, mn_y), (mx_x, mx_y))
        cv2.rectangle(image, (mn_x, mn_y), (mx_x, mx_y), (0, 0, 255), 3)
        w, h = mx_x - mn_x, mx_y - mn_y
        print(w,h, h/w)
        f = lambda x: x+60 if x<230 else x
        w = f(w)
        h = f(h)
        mx_x = mn_x + w
        mx_y = mn_y + h
        print(w, h, h / w)
        # if h/w>=1:
        #     w+=30
        cv2.rectangle(image, (mn_x, mn_y), (mx_x, mx_y), (0, 255, 0), 3)
    # OCR(res_img)
    # image = cv2.drawContours(image, contours,-1,(255,0,0))
    cv2.imshow("contours", image)
    cv2.imshow("P", img)
    # cv2.imshow("contours", res_img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

def Correct(mark, words):
    # if 4 < len(words) < 10:
    #     return True
    x,y,w,h = mark
    c_word = 0
    for word in words:
        x_w, y_w, *_ = word
        if x <= x_w <= x + w and y <= y_w <= y + h:
            c_word += 1
    return c_word/len(words) == 1

def getConts(img,blur, d, mx):
    mx = -float('inf')
    let_ret = None
    q = 0
    for i in range(len(d)):
        ret, th = cv2.threshold(blur, d[i], 255, cv2.THRESH_BINARY)
        ms = cv2.bitwise_and(img, img, mask=th)

        edge = cv2.Canny(ms, 100, 200, apertureSize=3)
        res, _ = cv2.findContours(edge, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
        # img = cv2.drawContours(ms, res, -1,(0,255,0), 1)
        letters = list(map(lambda x: cv2.boundingRect(x), res))
        letters.sort(key=lambda x: x[0])
        # letters = del_double(letters)

        letters = list(filter(lambda x: 0.4 < x[2] / x[3] < 2.1 and 130 < x[2] * x[3] < 400, letters))
        if mx < len(letters):
            mx = len(letters)
            let_ret = letters
    return let_ret
def del_double(arr):
    arr.append([])
    a = []
    for i in range(len(arr) - 1):
        # print(i)
        if arr[i] != arr[i + 1]:
            a.append(arr[i])
    return a
def filt_letters(letters,maxd=50,mind=5):
    # print(maxd)
    npoint = []
    cashp = []
    s_w = s_h = 0
    for i in range(len(letters)):
        x1, y1,w,h, *_  = letters[i]
        twp = 0
        s_w += w
        s_h += h
        for j in range( len(letters)):
            x2,y2,wl, hl, *_ = letters[j]
            dx = x2 - x1
            dy = y2 - y1
            if h == 0 :
                k = 0
            else:
                k = w / h
            # print(w,h,w+h, maxd, mind)
            if mind < math.sqrt(w**2+h**2) < maxd:
                twp+=1
        if twp>3:
            # cashp.append([x1,y1,wl,hl,x2,y2,w,h,k,y2-k*x2])
        # else:
            npoint.append([x1,y1,w,h,x2, y2, dx, dy, k, y2-k * x2])
        # print("1", x2,y2,w,h,h/w)
    # if twp > 3:
        # for c in cashp:
        #     npoint.append(c)
    # print(s_h/len(letters))
    # print(s_w/len(letters))
    # print(len(npoint))
    return npoint
def alfa(points, x_cen, y_cen):
    wh = 0
    minx = 1000
    miny = 1000
    for a in points:
        wh = wh+(int(a[2]) / int(a[3]))
        if minx > int(a[0]): minx = int(a[0])
        if miny > int(a[1]): miny = int(a[1])
    whs = wh/len(points)
    # print(wh, whs, a)
    st_angle = 0
    direct = 1
    if whs < 1:
        # st_angle = 180
        direct = -1
    end_angle = (st_angle + 90) *direct
    test = {
        "minp":160,
        "al": 0,
        "mx": 0,
        "my": 0
    }
    test["minp"] = len(points)
    ret = []
    rt = 0
    m_unx = [0]
    m_uny = [0]
    s_xy = rotate(points, st_angle, x_cen, y_cen, True)
    for a in range(st_angle, end_angle + 1, direct):
        xy = rotate(points, a, x_cen, y_cen, True)
        # s_xy = xy
        unx = set(xy["x"])
        uny = set(xy["y"])
        # print("x" , unx, len(unx))
        # print("y" , uny, len(uny))
        # print(len(uny) + len(unx))
        ratio = len(unx)/len(uny)
        if (len(unx) + len(uny)) < test["minp"]:
            test["minp"] = len(unx) + len(uny)
            test["mx"] = len(unx)
            test["my"] = len(uny)
            s_xy = xy
            m_unx = unx
            m_uny = uny
            test["al"] = a
            ret.append([a,len(unx), len(uny), test["minp"]])
            if test["my"] == 0:
                rt = 0
            else:
                rt = test["mx"] / test["my"]

        if (test["minp"] + 30) < len(unx) + len(uny):
            # arr = list(map(lambda x: x + y_cen, xy["y"]))
            arr = s_xy["y"]
            if len(set(s_xy["y"])) > len(set(s_xy["x"])):
                print("x")
                # arr = list(map(lambda x: x + x_cen, xy["x"]))
                arr = s_xy["x"]
            print(count_p(arr))
            return [test["al"], test["mx"], test["my"], a, rt, min(m_unx), min(m_uny), max(m_unx), max(m_uny)] ###

    # arr = list(map(lambda x: x + y_cen, xy["y"]))
    arr = s_xy["y"]
    if len(set(s_xy["y"])) > len(set(s_xy["x"])):
        print("x")
        # arr = list(map(lambda x: x + x_cen, xy["x"]))
        arr = s_xy["x"]
    print("Угол ", a)
    print(count_p(arr))
    # print(f'unx: {xy["x"]}')
    # print(count_p(list(map(lambda x: x + x_cen, xy["x"]))))
    return [test["al"], test["mx"], test["my"], a, rt, min(m_unx), min(m_uny), max(m_unx), max(m_uny)]

def draw_box(letters, img,x0,y0,x1,y1, angle = 0,dx = 20,dy = 10):
    boxes = []
    # x1+=20
    # y1+=20
    # if abs(angle):

    d = angle//45
    print(d)
    cv2.circle(img,((x0 - (dx *d) - dx,y0 - (dy * d) - dy)), 5, (0,0,255), thickness=cv2.FILLED)
    cv2.circle(img,(x0,y0), 5, (0,100,255), thickness=cv2.FILLED)
    cv2.rectangle(img, (x0 - (dx *d) - dx,y0 - (dy * d) - dy), ((x1 + dx * abs(d - 1)) + dx, y1 + dy * abs(d - 1) + dy), (0,0,255), 1)
    cv2.rectangle(img, (x0,y0), (x1, y1), (255,0,0), 1)

    cv2.imshow("1", img)
    # cv2.waitKey(0)
    # cv2.destroyAllWindows()


    # (x0 - (dx *d) - dx: (x1 + dx * abs(d - 1)) + dx,   y0 - (dy * d) - dy : y1 + dy * abs(d - 1) + dy
    return img[y0 - (dy * d) - dy : y1 + dy * abs(d - 1) + dy, x0 - (dx *d) - dx: (x1 + dx * abs(d - 1)) + dx]

def OCR(image):
    if image is not None:
        cv2.imwrite('res.jpg', image)
        image = cv2.imread('res.jpg')

        tesseract_path = r'C:\Program Files\Tesseract-OCR'
        pytesseract.pytesseract.tesseract_cmd = tesseract_path + r'\tesseract.exe'
        # tessdata_dir_config = '--tessdata-dir ' + tesseract_path + r'\tessdata'


        config = r'--oem 3 --psm 6 --dpi 100'
        text = pytesseract.image_to_string(image, config= config, lang="rus")
        confidences = pytesseract.image_to_data(cv2.cvtColor(image, cv2.COLOR_BGR2GRAY), lang='rus', config=config, output_type=pytesseract.Output.DICT)['conf']
    print("conf ",confidences)
    # newdata = pytesseract.image_to_osd(image)
    print(text)

def rotate(points, alfa_new = 1 , mx = 0, my = 0, ret_obj = False):
    ret = []
    retx = []
    rety =[]
    for point in points:
        x = point[0] - mx
        y = point[1] - my
        # alfa = alfa_new*math.pi/180
        w = point[2]
        h = point[3]
        tan_wh = h/w
        if x == 0: tan = 0
        else: tan = y/x
        alfa_wh = math.atan(tan_wh)
        alfa_wh_rad = alfa_new*math.pi/180
        one_wh = w/math.cos(alfa_wh)
        new_w = int(one_wh * math.cos(alfa_wh+alfa_wh_rad))
        new_h = int(one_wh * math.sin(alfa_wh+alfa_wh_rad))
        # print("w, h", new_w, new_h)

        alfa = math.atan(tan)
        alfa_rad = alfa_new * math.pi / 180
        one = x/math.cos(alfa)
        newx = int(one * math.cos(alfa + alfa_rad))
        newy = int(one * math.sin(alfa + alfa_rad))
        if ret_obj:
            retx.append(newx)
            rety.append(newy)

        else:
            ret.append(([newx + mx + w, newy + my + h, new_w, new_h]))
    if ret_obj:
        return {
            "x": retx,
            "y": rety
        }
    return ret
def count_p(arr, img = None):
    image = cv2.imread("res.jpg")
    ret_arr = []
    for i in range(15):
        ret_arr.append([])
    arr = sorted(arr)
    # print("sore ",arr)
    n = 0
    s_arr = list(arr)
    row_c = 0
    # ret_arr.append([arr[0]])
    cur = -float('inf')
    # print(ret_arr)
    arr.append(0)
    for i in range(len(s_arr) - 1):
        if abs(s_arr[i] - s_arr[i+1]) < 10:
            # print(row_c)
            ret_arr[row_c].append(s_arr[i])
        else:
            row_c+=1


    ret_arr = list(filter(lambda x: len(x)>2, ret_arr))

    print("Количество строк", len(ret_arr))
    print("ret ",ret_arr)
    # for line in ret_arr:
    #     image = cv2.line(image, (50,int(min(line))), (355,int(min(line))), (0,0,255), 2)
    # cv2.imshow("lines", image)
    # cv2.waitKey(0)
    # cv2.destroyAllWindows()
    # exit()
    # ret_arsr = sorted(ret_arr, key = lambda x:x[1])
    return ret_arr

def tesseract_check(image, check = True, products = []):

    ts_check = {
        "all": '',
        "write-off":'',
        "product": '',
        "cooked":'',
        "worker":'',
        "status":'',
        "ready":''
    }
    spell = SpellChecker(language='ru')
    clahe = cv2.createCLAHE(clipLimit=3., tileGridSize=(8, 8))
    lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
    l, a, b = cv2.split(lab)
    l2 = clahe.apply(l)
    lab = cv2.merge((l2, a, b))  # merge channels
    image = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)  # convert from LAB to BGR
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    image = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]
    # cv2.imshow("ts_check", image)
    # cv2.waitKey(0)
    # cv2.destroyAllWindows()
    tesseract_path = r'C:\Program Files\Tesseract-OCR'
    pytesseract.pytesseract.tesseract_cmd = tesseract_path + r'\tesseract.exe'
    config = r'--oem 2 --psm 6'
    boxes = pytesseract.image_to_data(image, config= config, lang="rus", output_type=Output.DICT)
    keys = list(boxes.keys())
    dates = []
    names = []
    times = []
    for i in range(len(boxes['text'])):
        # print(i)
        word = boxes['text'][i]
        # print(word, boxes['conf'][i])

        if int(boxes['conf'][i]) > -1:#40
            # print(spell.correction(word),  word)
            if bool(re.search(r'\b\d{2}\.\d{2}\.\d{2}\b', boxes['text'][i])) :
                dates.append(word)
            elif bool(re.search(r'\b\d{2}\:\d{2}', word)):
                times.append(word)
            else:
                w = spell_ch(word.lower(), dict=products)
                print(w, word)
                if w!= None and w != 'i':
                    names.append(w)

    if len(dates) >=2 and len(names)> 2:
        names = list(filter(lambda x: len(x)>2, names))
        print(names)
        print(dates)
        # exit()
        txt = ' '.join(names)
        date = ' '.join(dates)
        ts_check["product"] = txt
        txt+= ' '+ date
        ts_check["all"] = txt
        print(dates[-2] + ' ' + dates[-1])
        ts_check["cooked"] = datetime.datetime.strptime(dates[0] + ' ' + times[1], '%d.%m.%y, %H:%M')
        ts_check["write-off"] = datetime.datetime.strptime(dates[-1] + ' ' + times[-1], '%d.%m.%y, %H:%M')
        ts_check["status"] = 'Добавлено'
        return ts_check

    return False

def spell_ch(word, dict):
    # print(word.lower())
    # print("Словарь ", dict)
    spell = SpellChecker()
    spell.word_frequency.load_words(dict)
    cr = spell.correction(word)
    if cr not in dict:
        cr = None
    return cr