cringe

app.py

@@ -1,7 +1,73 @@
+from typing import Any, List
+import numpy as np
 import gradio as gr
+from PIL import Image, ImageDraw
+import yolo_detect as yod
+import cv2
+import fiftyone as fo 
+from flagging import FlaggingCallback, SimpleCSVLogger
 
-def greet(name):
-    return "Hello " + name + "!!"
+class NewLogger(FlaggingCallback):
+    def __init__(self):
+        self.flag_data = None
+        self.flag_option = None
+        self.flag_index = None
 
-iface = gr.Interface(fn=greet, inputs="text", outputs="text")
-iface.launch()
+        super().__init__()
+    def flag(
+        self,
+        flag_data: List[Any],
+        flag_option= None,
+        flag_index = None,
+        username = None,
+    ) -> int:
+        self.flag_data = flag_data
+        self.flag_option = flag_option
+        self.flag_index = flag_index
+
+        if flag_option == "Bad":
+            print(flag_option)
+
+        # log_filepath = Path(flagging_dir) / "log.csv"
+
+        # csv_data = []
+        # for component, sample in zip(self.components, flag_data):
+        #     save_dir = Path(flagging_dir) / utils.strip_invalid_filename_characters(
+        #         component.label or ""
+        #     )
+
+        return 2
+
+
+def draw_boxes(input_img, iou_threshold, confidence_threshdol):
+    # Convert the input to a PIL Image
+    img = cv2.resize(input_img, (640, 640))
+    img = Image.fromarray(img)
+    draw = ImageDraw.Draw(img)
+
+    # Example bounding boxes: (x1, y1, x2, y2)
+    boxes = yod.identifications(input_img, iou_threshold, confidence_threshdol)
+
+    # Draw rectangles on the image
+    for box in boxes:
+        bbox = box[:4]
+        draw.rectangle(bbox, outline="red", width=2)
+        draw.text((bbox[0], bbox[1] - 16), f"{box[5]} -> {str(round(box[4], 2))}", fill="red")
+
+    # Convert back to array
+    return np.array(img)
+
+
+# Define the Gradio Interface with a title
+title = "Vic and the boyzzzzzz"
+# Define a slider
+iou_slider = gr.Slider(minimum=0, maximum=1, step=0.01, label="IoU Threshold", value=0.0)
+conf_slider = gr.Slider(minimum=0, maximum=1, step=0.01, label="Confidence Threshold", value=0.0)
+
+text_box = gr.Textbox(label="Write a description for bad behavior")
+
+
+demo = gr.Interface(fn=draw_boxes, inputs=[gr.Image(), iou_slider, conf_slider], outputs=gr.Image(), title=title, flagging_options=["Good", "Bad"], allow_flagging="manual", flagging_callback=SimpleCSVLogger())
+
+# Launch the app
+demo.launch()

flagged/log.csv

@@ -0,0 +1,6 @@
+input_img,output,flag,username,timestamp
+/Users/danielfortunato/Documents/Git/VicAndTheBoys/flagged/e687ba4e209c22a72a92e3add6994bda33807df0/tmpsuaxx26y.png,0,0.49,/Users/danielfortunato/Documents/Git/VicAndTheBoys/flagged/4ab16a5c5d5c5055b98a90e85059dbbb23d38b7f/tmpr8_73fxf.png
+/Users/danielfortunato/Documents/Git/VicAndTheBoys/flagged/1f349fc84b10da520a20ab6964db933ae8d590ba/tmpgn9ufqfe.jpg,0,0.43,/Users/danielfortunato/Documents/Git/VicAndTheBoys/flagged/c58e510d763082622c59b728d2057d4eeab7e07f/tmpzsm69w45.png
+,,,,2024-01-18 12:46:19.105462
+"{""path"":""flagged/input_img/bd0e0e1ebebb34c3eb44/transferir.jpeg"",""url"":""http://localhost:7860/file=/private/var/folders/0w/531wr_3j4p9d2_zb_mgp020m0000gn/T/gradio/8272ecf51cc787e0b8282d005733b969178a9885/transferir.jpeg"",""size"":9327,""orig_name"":""transferir.jpeg"",""mime_type"":""""}","{""path"":""flagged/output/ad29fe502fe750df8930/image.png"",""url"":null,""size"":null,""orig_name"":""image.png"",""mime_type"":null}",,,2024-01-18 12:47:25.023152
+/Users/danielfortunato/Documents/Git/VicAndTheBoys/flagged/input_img/4f471d893279e3e34d84a5ece1c34bb2480f3f22/tmpqtk_ji2b.jpg,50,50,/Users/danielfortunato/Documents/Git/VicAndTheBoys/flagged/output/e7885bcf6480d6927dc3afb9b2df5b16210f8a71/tmppql5erh5.png,Bad,,2024-01-18 14:20:26.757729

flagging.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import csv
+import datetime
+import io
+import json
+import os
+import uuid
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, List
+import fo_utils as fou 
+
+import gradio as gr
+from gradio import utils
+
+if TYPE_CHECKING:
+    from gradio.components import IOComponent
+
+
+
+def _get_dataset_features_info(is_new, components):
+    """
+    Takes in a list of components and returns a dataset features info
+
+    Parameters:
+    is_new: boolean, whether the dataset is new or not
+    components: list of components
+
+    Returns:
+    infos: a dictionary of the dataset features
+    file_preview_types: dictionary mapping of gradio components to appropriate string.
+    header: list of header strings
+
+    """
+    infos = {"flagged": {"features": {}}}
+    # File previews for certain input and output types
+    file_preview_types = {gr.Audio: "Audio", gr.Image: "Image"}
+    headers = []
+
+    # Generate the headers and dataset_infos
+    if is_new:
+
+        for component in components:
+            headers.append(component.label)
+            infos["flagged"]["features"][component.label] = {
+                "dtype": "string",
+                "_type": "Value",
+            }
+            if isinstance(component, tuple(file_preview_types)):
+                headers.append(component.label + " file")
+                for _component, _type in file_preview_types.items():
+                    if isinstance(component, _component):
+                        infos["flagged"]["features"][
+                            (component.label or "") + " file"
+                        ] = {"_type": _type}
+                        break
+
+        headers.append("flag")
+        infos["flagged"]["features"]["flag"] = {
+            "dtype": "string",
+            "_type": "Value",
+        }
+
+    return infos, file_preview_types, headers
+
+
+class FlaggingCallback(ABC):
+    """
+    An abstract class for defining the methods that any FlaggingCallback should have.
+    """
+
+    @abstractmethod
+    def setup(self, components: List[IOComponent], flagging_dir: str):
+        """
+        This method should be overridden and ensure that everything is set up correctly for flag().
+        This method gets called once at the beginning of the Interface.launch() method.
+        Parameters:
+        components: Set of components that will provide flagged data.
+        flagging_dir: A string, typically containing the path to the directory where the flagging file should be storied (provided as an argument to Interface.__init__()).
+        """
+        pass
+
+    @abstractmethod
+    def flag(
+        self,
+        flag_data: List[Any],
+        flag_option: str | None = None,
+        flag_index: int | None = None,
+        username: str | None = None,
+    ) -> int:
+        """
+        This method should be overridden by the FlaggingCallback subclass and may contain optional additional arguments.
+        This gets called every time the <flag> button is pressed.
+        Parameters:
+        interface: The Interface object that is being used to launch the flagging interface.
+        flag_data: The data to be flagged.
+        flag_option (optional): In the case that flagging_options are provided, the flag option that is being used.
+        flag_index (optional): The index of the sample that is being flagged.
+        username (optional): The username of the user that is flagging the data, if logged in.
+        Returns:
+        (int) The total number of samples that have been flagged.
+        """
+        pass
+
+
+class SimpleCSVLogger(FlaggingCallback):
+    """
+    A simplified implementation of the FlaggingCallback abstract class
+    provided for illustrative purposes.  Each flagged sample (both the input and output data)
+    is logged to a CSV file on the machine running the gradio app.
+    Example:
+        import gradio as gr
+        def image_classifier(inp):
+            return {'cat': 0.3, 'dog': 0.7}
+        demo = gr.Interface(fn=image_classifier, inputs="image", outputs="label",
+                            flagging_callback=SimpleCSVLogger())
+    """
+
+    def __init__(self):
+        pass
+
+    def setup(self, components: List[IOComponent], flagging_dir: str | Path):
+        self.components = components
+        self.flagging_dir = flagging_dir
+        os.makedirs(flagging_dir, exist_ok=True)
+
+    def flag(
+        self,
+        flag_data: List[Any],
+        flag_option: str | None = None,
+        flag_index: int | None = None,
+        username: str | None = None,
+    ) -> int:
+        flagging_dir = self.flagging_dir
+        log_filepath = Path(flagging_dir) / "log.csv"
+
+        csv_data = []
+        for component, sample in zip(self.components, flag_data):
+            save_dir = Path(flagging_dir) 
+            # / utils.strip_invalid_filename_characters(
+            #     component.label or ""
+            # )
+            csv_data.append(
+                component.deserialize(
+                    sample,
+                    save_dir,
+                    None,
+                )
+            )
+
+        with open(log_filepath, "a", newline="") as csvfile:
+            writer = csv.writer(csvfile)
+            writer.writerow(utils.sanitize_list_for_csv(csv_data))
+
+        with open(log_filepath, "r") as csvfile:
+            line_count = len([None for row in csv.reader(csvfile)]) - 1
+        
+        # if flag_option == "Bad":
+        #     #get the image path
+        #     image_path = csv_data
+        #     #get the image name
+        #     print(image_path)
+        #     fou.upload_image_to_cvat(image_path[0])
+            
+        return line_count
+
+
+
+class FlagMethod:
+    """
+    Helper class that contains the flagging button option and callback
+    """
+
+    def __init__(self, flagging_callback: FlaggingCallback, flag_option=None):
+        self.flagging_callback = flagging_callback
+        self.flag_option = flag_option
+        self.__name__ = "Flag"
+
+    def __call__(self, *flag_data):
+        self.flagging_callback.flag(list(flag_data), flag_option=self.flag_option)

fo_utils.py

@@ -0,0 +1,53 @@
+import fiftyone as fo
+import requests
+
+DATASET_NAME = "VIC_AND_THE_BOYZ"
+CVAT_PROJECT_NAME = "VIC_AND_THE_BOYZ"
+
+# Replace with your CVAT credentials and URL
+cvat_url = "http://app.cvat.ai"
+username = 'daniel.fortunato'
+password = 'Lasanha123'
+
+def load_vic_and_boyz_dataset(dataset_name=DATASET_NAME):
+    if dataset_name in fo.list_datasets():
+        dataset_name = fo.load_dataset(dataset_name)
+    else:
+        dataset_name = fo.Dataset(name=dataset_name, persistent=True, overwrite=True)
+
+def bad_image_upload(dataset: fo.Dataset, image_filepath, description):
+    sample = fo.Sample(filepath=image_filepath, description=description)
+    dataset.add_sample(sample)
+
+
+def upload_image_to_cvat(image_path, description="HEY"):
+    auth_data = {
+            'username': username,
+            'password': password
+        }
+
+    response = requests.post(f'{cvat_url}/api/auth/login', json=auth_data)
+    response.raise_for_status()
+    token = response.json()['key']
+
+    response = requests.get(f'{cvat_url}/api/projects', headers={'Authorization': f'Token {token}'})
+    response.raise_for_status()
+    projects = response.json()["results"]
+
+    task_name = description
+    project_id = projects[0]['id']  # replace with your specific project ID on the official CVAT server
+
+    headers = {'Authorization': f'Token {token}'}
+    task_data = {
+        "name": task_name,
+        "project_id": project_id
+    }
+    task_response = requests.post(f"{cvat_url}/api/tasks", headers=headers, json=task_data)
+    task_id = task_response.json()["id"]
+    print("TASK ID: ", task_id)
+
+    with open('/Users/danielfortunato/Documents/Git/VicAndTheBoys/flagged/0647ac81eec7ca0472cbefb31326eb75bc33941e/tmpgbwsvy4t.png', 'rb') as f:
+        files = {'image': f}
+        upload_response = requests.post(f"{cvat_url}/api/tasks/{task_id}/data", headers=headers, files=files, data={"image_quality": 50})
+
+        print("UPLOAD RESPONSE: ", upload_response.json())

inference.py

@@ -0,0 +1,50 @@
+import torch
+from PIL import Image, ImageDraw
+from pathlib import Path
+from yolov5.models.experimental import attempt_load
+from yolov5.utils.general import non_max_suppression, scale_coords
+from yolov5.utils.torch_utils import select_device
+
+# Set the device
+device = select_device('')
+
+# Load YOLOv5 model
+weights_path = './model/yolov5n6_RGB_D2304-v1_9C.pt'
+model = attempt_load(weights_path, map_location=device)
+stride = int(model.stride.max())  # model stride
+
+# Set image size
+img_size = 640
+
+# Load the single image
+image_path = 'path/to/single/image.jpg'
+img0 = Image.open(image_path)
+img = img0.convert('RGB')
+
+# Inference
+img = torch.from_numpy(img).to(device)
+img = img.float() / 255.0  # 0-255 to 0.0-1.0
+img = img.unsqueeze(0)  # add batch dimension
+img = img.permute(0, 3, 1, 2)  # BGR to RGB, to 4D tensor (NCHW)
+
+# Inference
+pred = model(img)[0]
+
+# Non-maximum suppression
+pred = non_max_suppression(pred, conf_thres=0.25, iou_thres=0.45)[0]
+
+# Draw bounding boxes on the image
+for det in pred:
+    det[:, :4] = scale_coords(img.shape[2:], det[:, :4], img0.size).round()
+    for *xyxy, conf, cls in det:
+        xyxy = [int(x) for x in xyxy]
+        label = f'{model.names[int(cls)]} {conf:.2f}'
+        img0 = ImageDraw.Draw(img0)
+        img0.rectangle(xyxy, outline='red', width=3)
+        img0.text((xyxy[0], xyxy[1]), label, fill='red')
+
+# Save the result
+output_path = 'output/result.jpg'
+img0.save(output_path)
+
+print(f"Inference completed. Result saved at {output_path}")

try_import.py

@@ -0,0 +1 @@
+import torch

yolo_detect.py

@@ -0,0 +1,66 @@
+import cv2
+import torch
+import numpy as np
+from yolov5.models.experimental import attempt_load
+from yolov5.utils.general import non_max_suppression
+import sys
+
+from yolov5.models.common import DetectMultiBackend
+
+torch.cuda.empty_cache()
+ 
+weights = "./model/yolov5n6_RGB_D2304-v1_9C.pt"
+model = DetectMultiBackend(weights)
+ 
+model.eval()
+
+colors = np.random.randint(0, 256, (32, 3)).tolist()
+
+# Set device
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+# Define class labels
+#class_names = ['person', 'bicycle', 'car', 'motorbike', 'aeroplane', 'bus', 'train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'sofa', 'pottedplant', 'bed', 'diningtable', 'toilet', 'tvmonitor', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush']
+class_names = ["ANIMAL", "BOAT", "BUOY", "FAR_AWAY_OBJECT", "FLOTSAM", "HUMAN", "LEISURE_VEHICLE", "SAILING_BOAT", "SHIP"]
+# Set detection threshold
+#conf_thres = 0.2
+
+# Define the classes we want to detect
+classes_of_interest = class_names
+
+def identifications(frame, iou_threshold, conf_thres):
+    # Resize frame
+    img = cv2.resize(frame, (640, 640))
+    # Convert color format
+    img = img[:, :, ::-1].transpose(2, 0, 1)
+    img = np.ascontiguousarray(img)
+
+    # Convert to torch tensor
+    img = torch.from_numpy(img).float().to(device)
+    img /= 255.0
+    if img.ndimension() == 3:
+        img = img.unsqueeze(0)
+    # [1,3,502,848]
+    # Detect objects in the image
+    pred = model(img)[0]
+    pred = non_max_suppression(pred, conf_thres, iou_threshold)
+    ret_preds = []
+    # Draw bounding boxes around detected objects
+    for det in pred[0]:
+        x1, y1, x2, y2, conf, cls = det.cpu().numpy()
+        label = class_names[int(cls)]
+        if label not in classes_of_interest:
+            continue
+        x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
+        #ret_preds.append((x1, y1, x2, y2, conf, class_names[int(cls)]))
+        ret_preds.append((x1, y1, x2, y2, conf, class_names[int(cls)]))
+
+    return ret_preds
+
+
+# img = cv2.imread('download.jpeg')
+
+# # perform object identification on the frame
+# preds = identifications(img)
+
+# print(preds)

yolov5n.pt

@@ -0,0 +1,3 @@
+<��r�{�Z��d�PYe�Ye�Ye�Yf�ަ�!���z�~+gz�*5y�u�jrjz[2�Z�ץ�������)��j��z׫���Y^rب�ëu��t8���j_��}����Q���z�"�ק���}������?����ا�����F��m�$����(�ʡF����ߺYm�$����(��W��+����(�ʡF��~��j������$��Q�쵫^�؜��h�K*���Zw�-j׿v'-����(�ʡF����n��*��r�+r皇n���{Z�w�I�z{bjZ��aF�aF�a��j�j��aF�aF�aF�aF����ү���^��(�j'
+�絛��aF�a������j�Q��M�j�Q��aF�a����r���h��g�j�W�r��
+����