Upload 2 files

app_utils.py

@@ -0,0 +1,196 @@
+import glob
+import json
+import os
+import xml.etree.ElementTree as ET
+
+import cv2
+
+# from sklearn.externals import joblib
+import joblib
+import numpy as np
+import pandas as pd
+
+# from .variables import old_ocr_req_cols
+# from .skew_correction import  PageSkewWraper
+
+const_HW = 1.294117647
+const_W = 600
+# https://www.forbes.com/sites/forbestechcouncil/2020/06/02/leveraging-technologies-to-align-realograms-and-planograms-for-grocery/?sh=506b8b78e86c
+
+
+# https://stackoverflow.com/questions/39403183/python-opencv-sorting-contours
+# http://devdoc.net/linux/OpenCV-3.2.0/da/d0c/tutorial_bounding_rects_circles.html
+# https://stackoverflow.com/questions/10297713/find-contour-of-the-set-of-points-in-opencv
+# https://stackoverflow.com/questions/16538774/dealing-with-contours-and-bounding-rectangle-in-opencv-2-4-python-2-7
+# https://stackoverflow.com/questions/50308055/creating-bounding-boxes-for-contours
+# https://stackoverflow.com/questions/57296398/how-can-i-get-better-results-of-bounding-box-using-find-contours-of-opencv
+# http://amroamroamro.github.io/mexopencv/opencv/generalContours_demo1.html
+# https://gist.github.com/bigsnarfdude/d811e31ee17495f82f10db12651ae82d
+# http://man.hubwiz.com/docset/OpenCV.docset/Contents/Resources/Documents/da/d0c/tutorial_bounding_rects_circles.html
+# https://www.analyticsvidhya.com/blog/2021/05/document-layout-detection-and-ocr-with-detectron2/
+# https://colab.research.google.com/drive/1m6gaQF6Q4M0IaSjoo_4jWllKJjK-i6fw?usp=sharing#scrollTo=lEyl3wYKHAe1
+# https://stackoverflow.com/questions/39403183/python-opencv-sorting-contours
+# https://docs.opencv.org/2.4/doc/tutorials/imgproc/shapedescriptors/bounding_rects_circles/bounding_rects_circles.html
+# https://www.pyimagesearch.com/2016/03/21/ordering-coordinates-clockwise-with-python-and-opencv/
+
+
+def bucket_sort(df, colmn, ymax_col="ymax", ymin_col="ymin"):
+    df["line_number"] = 0
+    colmn.append("line_number")
+    array_value = df[colmn].values
+    start_index = Line_counter = counter = 0
+    ymax, ymin, line_no = (
+        colmn.index(ymax_col),
+        colmn.index(ymin_col),
+        colmn.index("line_number"),
+    )
+    while counter < len(array_value):
+        current_ymax = array_value[start_index][ymax]
+        for next_index in range(start_index, len(array_value)):
+            counter += 1
+
+            next_ymin = array_value[next_index][ymin]
+            next_ymax = array_value[next_index][ymax]
+            if current_ymax > next_ymin:
+
+                array_value[next_index][line_no] = Line_counter + 1
+            #                 if current_ymax < next_ymax:
+
+            #                     current_ymax = next_ymax
+            else:
+                counter -= 1
+                break
+        # print(counter, len(array_value), start_index)
+        start_index = counter
+        Line_counter += 1
+    return pd.DataFrame(array_value, columns=colmn)
+
+
+def do_sorting(df):
+    df.sort_values(["ymin", "xmin"], ascending=True, inplace=True)
+    df["idx"] = df.index
+    if "line_number" in df.columns:
+        print("line number removed")
+        df.drop("line_number", axis=1, inplace=True)
+    req_colns = ["xmin", "ymin", "xmax", "ymax", "idx"]
+    temp_df = df.copy()
+    temp = bucket_sort(temp_df.copy(), req_colns)
+    df = df.merge(temp[["idx", "line_number"]], on="idx")
+    df.sort_values(["line_number", "xmin"], ascending=True, inplace=True)
+    df = df.reset_index(drop=True)
+    df = df.reset_index(drop=True)
+    return df
+
+
+def xml_to_csv(xml_file):
+    # https://gist.github.com/rotemtam/88d9a4efae243fc77ed4a0f9917c8f6c
+    xml_list = []
+    # for xml_file in glob.glob(path + '/*.xml'):
+    # https://discuss.streamlit.io/t/unable-to-read-files-using-standard-file-uploader/2258/2
+    tree = ET.parse(xml_file)
+    root = tree.getroot()
+    for member in root.findall("object"):
+        bbx = member.find("bndbox")
+        xmin = int(bbx.find("xmin").text)
+        ymin = int(bbx.find("ymin").text)
+        xmax = int(bbx.find("xmax").text)
+        ymax = int(bbx.find("ymax").text)
+        label = member.find("name").text
+
+        value = (
+            root.find("filename").text,
+            int(root.find("size")[0].text),
+            int(root.find("size")[1].text),
+            label,
+            xmin,
+            ymin,
+            xmax,
+            ymax,
+        )
+        xml_list.append(value)
+    column_name = [
+        "filename",
+        "width",
+        "height",
+        "cls",
+        "xmin",
+        "ymin",
+        "xmax",
+        "ymax",
+    ]
+    xml_df = pd.DataFrame(xml_list, columns=column_name)
+    return xml_df
+
+
+# def annotate_planogram_compliance(img0, sorted_xml_df, wrong_indexes, target_names):
+#     # annotator = Annotator(img0, line_width=3, pil=True)
+#     det = sorted_xml_df[['xmin', 'ymin', 'xmax', 'ymax','cls']].values
+#     # det[:, :4] = scale_coords((640, 640), det[:, :4], img0.shape).round()
+#     for i, (*xyxy, cls) in enumerate(det):
+
+#         c = int(cls)  # integer class
+
+#         if i in wrong_indexes:
+#             # print(xyxy, "Wrong detection", (255, 0, 0))
+#             label =  "Wrong detection"
+#             color = (0,0,255)
+#         else:
+#             # print(xyxy, label, (0, 255, 0))
+#             label = f'{target_names[c]}'
+#             color = (0,255, 0)
+#         org = (int(xyxy[0]), int(xyxy[1]) )
+#         top_left = org
+#         bottom_right = (int(xyxy[2]), int(xyxy[3]))
+#         # print("#"*50)
+#         # print(f"Anooatting cv2 rectangle with shape: { img0.shape}, top left: { top_left}, bottom right: { bottom_right} , color : { color },  thickness: {3}, cv2.LINE_8")
+#         # print("#"*50)
+#         cv2.rectangle(img0, top_left, bottom_right , color,  3, cv2.LINE_8)
+
+#         cv2.putText(img0, label, tuple(org), cv2. FONT_HERSHEY_SIMPLEX  , 0.5, color)
+
+#     return img0
+
+
+def annotate_planogram_compliance(
+    img0, sorted_df, correct_indexes, wrong_indexes, target_names
+):
+    # annotator = Annotator(img0, line_width=3, pil=True)
+    det = sorted_df[["xmin", "ymin", "xmax", "ymax", "cls"]].values
+    # det[:, :4] = scale_coords((640, 640), det[:, :4], img0.shape).round()
+    for x, y in zip(*correct_indexes):
+        try:
+            row = sorted_df[sorted_df["line_number"] == x + 1].iloc[y]
+            xyxy = row[["xmin", "ymin", "xmax", "ymax"]].values
+            label = f'{target_names[row["cls"]]}'
+            color = (0, 255, 0)
+            # org = (int(xyxy[0]), int(xyxy[1]) )
+            top_left = (int(row["xmin"]), int(row["ymin"]))
+            bottom_right = (int(row["xmax"]), int(row["ymax"]))
+            cv2.rectangle(img0, top_left, bottom_right, color, 3, cv2.LINE_8)
+
+            cv2.putText(
+                img0, label, top_left, cv2.FONT_HERSHEY_SIMPLEX, 0.5, color
+            )
+        except Exception as e:
+            print("Error: " + str(e))
+            continue
+
+    for x, y in zip(*wrong_indexes):
+        try:
+            row = sorted_df[sorted_df["line_number"] == x + 1].iloc[y]
+            xyxy = row[["xmin", "ymin", "xmax", "ymax"]].values
+            label = f'{target_names[row["cls"]]}'
+            color = (0, 0, 255)
+            # org = (int(xyxy[0]), int(xyxy[1]) )
+            top_left = (row["xmin"], row["ymin"])
+            bottom_right = (row["xmax"], row["ymax"])
+            cv2.rectangle(img0, top_left, bottom_right, color, 3, cv2.LINE_8)
+
+            cv2.putText(
+                img0, label, top_left, cv2.FONT_HERSHEY_SIMPLEX, 0.5, color
+            )
+        except Exception as e:
+            print("Error: " + str(e))
+            continue
+
+    return img0

inference.py

@@ -0,0 +1,226 @@
+# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
+"""
+Run YOLOv5 detection inference on images, videos, directories, globs, YouTube, webcam, streams, etc.
+
+Usage - sources:
+    $ python detect.py --weights yolov5s.pt --source 0                               # webcam
+                                                     img.jpg                         # image
+                                                     vid.mp4                         # video
+                                                     screen                          # screenshot
+                                                     path/                           # directory
+                                                     list.txt                        # list of images
+                                                     list.streams                    # list of streams
+                                                     'path/*.jpg'                    # glob
+                                                     'https://youtu.be/Zgi9g1ksQHc'  # YouTube
+                                                     'rtsp://example.com/media.mp4'  # RTSP, RTMP, HTTP stream
+
+Usage - formats:
+    $ python detect.py --weights yolov5s.pt                 # PyTorch
+                                 yolov5s.torchscript        # TorchScript
+                                 yolov5s.onnx               # ONNX Runtime or OpenCV DNN with --dnn
+                                 yolov5s_openvino_model     # OpenVINO
+                                 yolov5s.engine             # TensorRT
+                                 yolov5s.mlmodel            # CoreML (macOS-only)
+                                 yolov5s_saved_model        # TensorFlow SavedModel
+                                 yolov5s.pb                 # TensorFlow GraphDef
+                                 yolov5s.tflite             # TensorFlow Lite
+                                 yolov5s_edgetpu.tflite     # TensorFlow Edge TPU
+                                 yolov5s_paddle_model       # PaddlePaddle
+"""
+
+import argparse
+import os
+import platform
+import sys
+from pathlib import Path
+
+import torch
+
+FILE = Path(__file__).resolve()
+ROOT = FILE.parents[0]  # YOLOv5 root directory
+if str(ROOT) not in sys.path:
+    sys.path.append(str(ROOT))  # add ROOT to PATH
+ROOT = Path(os.path.relpath(ROOT, Path.cwd()))  # relative
+
+from models.common import DetectMultiBackend
+from utils.dataloaders import (
+    IMG_FORMATS,
+    VID_FORMATS,
+    LoadImages,
+    LoadScreenshots,
+    LoadStreams,
+)
+from utils.general import (
+    LOGGER,
+    Profile,
+    check_file,
+    check_img_size,
+    check_imshow,
+    check_requirements,
+    colorstr,
+    cv2,
+    increment_path,
+    non_max_suppression,
+    print_args,
+    scale_boxes,
+    strip_optimizer,
+    xyxy2xywh,
+)
+from utils.plots import Annotator, colors, save_one_box
+from utils.torch_utils import select_device, smart_inference_mode
+
+
+@smart_inference_mode()
+def run(
+    weights=ROOT / "yolov5s.pt",  # model path or triton URL
+    source=ROOT / "data/images",  # file/dir/URL/glob/screen/0(webcam)
+    data=ROOT / "data/coco128.yaml",  # dataset.yaml path
+    imgsz=(640, 640),  # inference size (height, width)
+    conf_thres=0.25,  # confidence threshold
+    iou_thres=0.45,  # NMS IOU threshold
+    max_det=1000,  # maximum detections per image
+    device="",  # cuda device, i.e. 0 or 0,1,2,3 or cpu
+    view_img=False,  # show results
+    save_txt=False,  # save results to *.txt
+    save_conf=False,  # save confidences in --save-txt labels
+    save_crop=False,  # save cropped prediction boxes
+    nosave=False,  # do not save images/videos
+    classes=None,  # filter by class: --class 0, or --class 0 2 3
+    agnostic_nms=False,  # class-agnostic NMS
+    augment=False,  # augmented inference
+    visualize=False,  # visualize features
+    update=False,  # update all models
+    project=ROOT / "runs/detect",  # save results to project/name
+    name="exp",  # save results to project/name
+    exist_ok=False,  # existing project/name ok, do not increment
+    line_thickness=3,  # bounding box thickness (pixels)
+    hide_labels=False,  # hide labels
+    hide_conf=False,  # hide confidences
+    half=False,  # use FP16 half-precision inference
+    dnn=False,  # use OpenCV DNN for ONNX inference
+    vid_stride=1,  # video frame-rate stride
+):
+    source = str(source)
+    save_img = not nosave and not source.endswith(
+        ".txt"
+    )  # save inference images
+    is_file = Path(source).suffix[1:] in (IMG_FORMATS + VID_FORMATS)
+    is_url = source.lower().startswith(
+        ("rtsp://", "rtmp://", "http://", "https://")
+    )
+    webcam = (
+        source.isnumeric()
+        or source.endswith(".streams")
+        or (is_url and not is_file)
+    )
+    screenshot = source.lower().startswith("screen")
+    if is_url and is_file:
+        source = check_file(source)  # download
+
+    # Directories
+    save_dir = increment_path(
+        Path(project) / name, exist_ok=exist_ok
+    )  # increment run
+    (save_dir / "labels" if save_txt else save_dir).mkdir(
+        parents=True, exist_ok=True
+    )  # make dir
+
+    # Load model
+    device = select_device(device)
+    model = DetectMultiBackend(
+        weights, device=device, dnn=dnn, data=data, fp16=half
+    )
+    stride, names, pt = model.stride, model.names, model.pt
+    imgsz = check_img_size(imgsz, s=stride)  # check image size
+
+    # Dataloader
+    bs = 1  # batch_size
+    if webcam:
+        view_img = check_imshow(warn=True)
+        dataset = LoadStreams(
+            source,
+            img_size=imgsz,
+            stride=stride,
+            auto=pt,
+            vid_stride=vid_stride,
+        )
+        bs = len(dataset)
+    elif screenshot:
+        dataset = LoadScreenshots(
+            source, img_size=imgsz, stride=stride, auto=pt
+        )
+    else:
+        dataset = LoadImages(
+            source,
+            img_size=imgsz,
+            stride=stride,
+            auto=pt,
+            vid_stride=vid_stride,
+        )
+    vid_path, vid_writer = [None] * bs, [None] * bs
+
+    # Run inference
+    model.warmup(imgsz=(1 if pt or model.triton else bs, 3, *imgsz))  # warmup
+    seen, windows, dt = 0, [], (Profile(), Profile(), Profile())
+    for path, im, im0s, vid_cap, s in dataset:
+        with dt[0]:
+            im = torch.from_numpy(im).to(model.device)
+            im = im.half() if model.fp16 else im.float()  # uint8 to fp16/32
+            im /= 255  # 0 - 255 to 0.0 - 1.0
+            if len(im.shape) == 3:
+                im = im[None]  # expand for batch dim
+
+        # Inference
+        with dt[1]:
+            visualize = (
+                increment_path(save_dir / Path(path).stem, mkdir=True)
+                if visualize
+                else False
+            )
+            pred = model(im, augment=augment, visualize=visualize)
+
+        # NMS
+        with dt[2]:
+            pred = non_max_suppression(
+                pred,
+                conf_thres,
+                iou_thres,
+                classes,
+                agnostic_nms,
+                max_det=max_det,
+            )
+
+        # Second-stage classifier (optional)
+        # pred = utils.general.apply_classifier(pred, classifier_model, im, im0s)
+
+        # Process predictions
+        for i, det in enumerate(pred):  # per image
+            seen += 1
+            if webcam:  # batch_size >= 1
+                p, im0, frame = path[i], im0s[i].copy(), dataset.count
+                s += f"{i}: "
+            else:
+                p, im0, frame = path, im0s.copy(), getattr(dataset, "frame", 0)
+
+            p = Path(p)  # to Path
+            save_path = str(save_dir / p.name)  # im.jpg
+            txt_path = str(save_dir / "labels" / p.stem) + (
+                "" if dataset.mode == "image" else f"_{frame}"
+            )  # im.txt
+            s += "%gx%g " % im.shape[2:]  # print string
+            gn = torch.tensor(im0.shape)[
+                [1, 0, 1, 0]
+            ]  # normalization gain whwh
+            imc = im0.copy() if save_crop else im0  # for save_crop
+            annotator = Annotator(
+                im0, line_width=line_thickness, example=str(names)
+            )
+            results = []
+            if len(det):
+                # Rescale boxes from img_size to im0 size
+                det[:, :4] = scale_boxes(
+                    im.shape[2:], det[:, :4], im0.shape
+                ).round()
+                results.append((path, det))
+
+    return results