Computer-Vision-Assistant-Package 1.0__py3-none-any.whl

Computer_Vision_Assistant_Package/AI_Metrics.py

@@ -0,0 +1,241 @@
+"""Detection metrics for object detectors.
+
+Functions to score how well a detector's boxes match the ground-truth boxes:
+IoU, precision / recall and mAP. All boxes are in
+``(x_min, y_min, x_max, y_max)`` pixel format.
+
+The overall flow is::
+
+    detection_metrics
+        |-- provide_annotations()  (Basic_Utils)  -> ground-truth boxes
+        |-- ai_analytics()         (Basic_Utils)  -> predicted boxes
+        |-- IOU_calc()             -> IoU of each prediction vs the GT boxes
+        |-- mAP_calc()             -> precision / recall at each IoU threshold
+        `-- AUC_calc()             -> smoothed precision curve for the area
+
+Functions
+---------
+IOU_calc
+    Intersection-over-Union of one box against a list of boxes.
+mAP_calc
+    Precision and recall lists for IoU thresholds 0.50 to 0.90.
+AUC_calc
+    Builds the (recall, smoothed precision) curve used to compute the area.
+detection_metrics
+    End-to-end mAP@0.5 and mAP@0.5:0.95 for one image.
+
+Author: Shounak Sanyal
+"""
+import os, json, cv2
+import numpy as np
+from .Basic_Utils import *
+
+
+def IOU_calc(target_pts, gt_pts):
+    """Compute the IoU of one predicted box against every ground-truth box.
+
+    IoU (Intersection over Union) tells how much two boxes overlap:
+    0 means no overlap and 1 means the boxes are identical.
+
+    Parameters
+    ----------
+    target_pts : sequence of 4 numbers
+        The predicted box as ``(x_min, y_min, x_max, y_max)``.
+    gt_pts : list of sequence of 4 numbers
+        Ground-truth boxes, each as ``(x_min, y_min, x_max, y_max)``.
+
+    Returns
+    -------
+    IOU_arr : list of float
+        One IoU value (0 to 1) per ground-truth box, in the same order as
+        ``gt_pts``.
+
+    Examples
+    --------
+    >>> IOU_calc((0, 0, 10, 10), [(5, 5, 15, 15), (0, 0, 10, 10)])
+    [0.14285714285714285, 1.0]
+    """
+    IOU_arr=[]
+    for i in range(0, len(gt_pts)):
+        x_gt0, y_gt0,x_gt1, y_gt1=gt_pts[i]
+        x_tgt0, y_tgt0, x_tgt1, y_tgt1= target_pts
+        w_gt, h_gt, w_tgt, h_tgt= x_gt1- x_gt0, y_gt1- y_gt0, x_tgt1- x_tgt0, y_tgt1- y_tgt0
+        x_edge, y_edge= min(x_gt1, x_tgt1), min(y_gt1, y_tgt1)
+        x_ref, y_ref= max(x_gt0, x_tgt0), max(y_gt0, y_tgt0)
+
+        if (x_ref>=x_edge) or (y_ref>= y_edge):
+            Intersection=0
+        else:
+            w,h= x_edge-x_ref, y_edge-y_ref
+            Intersection= h*w
+        Union= (h_gt*w_gt)+ (h_tgt*w_tgt)- Intersection
+        IOU= Intersection/Union
+
+        IOU_arr.append(IOU)
+
+    return IOU_arr
+
+def mAP_calc(bboxes, gt_bboxes):
+    """Compute running precision and recall for IoU thresholds 0.50 to 0.90.
+
+    The predictions must be sorted by confidence (highest first). For each IoU
+    threshold (0.50, 0.55, ..., 0.90) the predictions are visited in order. A
+    prediction counts as a true positive if its IoU reaches the threshold and its
+    matched ground-truth box has not been used yet; otherwise it is a false
+    positive. Precision and recall are recorded after every prediction.
+
+    Parameters
+    ----------
+    bboxes : array-like of float
+        The IoU value of each prediction, sorted by descending confidence.
+    gt_bboxes : array-like of int
+        For each prediction, the index of the ground-truth box it overlaps
+        most (same length and order as ``bboxes``).
+
+    Returns
+    -------
+    net_precision_arr : list of list of float
+        One list per threshold; each holds the precision after every
+        prediction.
+    net_recall_arr : list of list of float
+        Same layout as ``net_precision_arr``, but for recall.
+    """
+    thresh_limits= np.arange(0.5, 1, 0.05)
+    net_precision_arr, net_recall_arr=[],[]
+    for index in range(0, len(thresh_limits)):
+        net_positive= len(np.unique(gt_bboxes))
+        true_positive, false_positive=0,0
+        precision_arr, recall_arr=[],[]
+        checked_gt=[]
+        for i in range(0, len(bboxes)):
+            if bboxes[i]< thresh_limits[index]:
+                
+                false_positive+=1
+            else:
+                if gt_bboxes[i] not in checked_gt:
+                    true_positive+=1
+                    checked_gt.append(gt_bboxes[i])
+                else:
+                    false_positive+=1
+                
+            precision= true_positive/(true_positive+false_positive)
+            recall= true_positive/net_positive
+            precision_arr.append(precision)
+            recall_arr.append(recall)
+        net_precision_arr.append(precision_arr)
+        net_recall_arr.append(recall_arr)
+
+    return net_precision_arr, net_recall_arr
+
+def AUC_calc(precision, recall):
+    """Build the smoothed precision-recall curve used to get the area.
+
+    Each precision value is replaced by the highest precision found at or after
+    that point, so the curve never goes up as recall increases. The recall values
+    are returned unchanged.
+
+    Parameters
+    ----------
+    precision : sequence of float
+        Precision values in prediction order (one list from ``mAP_calc``).
+    recall : sequence of float
+        Recall values in the same order.
+
+    Returns
+    -------
+    x_arr : sequence of float
+        The recall values.
+    y_arr : list of float
+        The smoothed precision values, same length as ``precision``.
+    """
+    x_arr, y_arr=[],[]
+    for i in range(0, len(precision)):
+        if precision[i]> np.max(precision[i:]):
+            y_arr.append(precision[i])
+        else:
+            y_arr.append(np.max(precision[i:]))
+    x_arr= recall
+
+    return x_arr, y_arr
+
+def detection_metrics(json_file, img_file, model_test):
+    """Evaluate a detector on one image and return mAP@0.5 and mAP@0.5:0.95.
+
+    Steps: load the ground truth from a COCO json, run the model, match every
+    prediction to its best-overlapping ground-truth box, sort by confidence,
+    compute precision / recall for each IoU threshold and integrate the area.
+
+    Parameters
+    ----------
+    json_file : str
+        Path to the COCO-format annotation file that lists ``img_file``.
+    img_file : str
+        Path to the image to evaluate.
+    model_test : object
+        Loaded detection model (RF-DETR style) with a ``.predict(image_path)``
+        method that returns boxes, labels and confidence scores.
+
+    Returns
+    -------
+    mAP_50 : float
+        Score at IoU threshold 0.50, rounded to 3 decimals.
+    mAP_50_95 : float
+        Score averaged over the IoU thresholds, rounded to 3 decimals.
+
+    Examples
+    --------
+    >>> mAP_50, mAP_50_95 = detection_metrics("annotations.json", "img_01.png", model)
+    """
+    gt_pts, gt_indices=[],[]
+    gt_coords, gt_labels=provide_annotations(json_file, img_file)
+
+    for j in range(0, len(gt_coords)):
+        x0, y0 = int(gt_coords[j][0]), int(gt_coords[j][1])
+        x1, y1 = int(gt_coords[j][2])+ x0, int(gt_coords[j][3])+ y0
+        gt_pts.append((x0,y0, x1,y1))
+        gt_indices.append(j)
+
+    IOU_arr=[]
+    IOU_checkpoints_gt=[]
+
+    _, coords, labels, _,confidence= ai_analytics(None, img_file, model_test)
+    for j in range(0, len(coords)):
+        x0, y0 = int(coords[j][0]), int(coords[j][1])
+        x1, y1 = int(coords[j][2]), int(coords[j][3])
+        tgt_pt=(x0,y0 ,x1,y1)
+        IOU=IOU_calc(tgt_pt, gt_pts)
+        IOU_checkpoints_gt.append(gt_indices[np.argmax(IOU)])
+        IOU=round(np.max(IOU),2)
+        IOU_arr.append(IOU)
+    
+    confidence_arr= np.array(confidence)
+    IOU_arr= np.array(IOU_arr)
+    IOU_checkpoints_gt= np.array(IOU_checkpoints_gt)
+    index= np.argsort(confidence_arr)[::-1]
+    IOU_arr= IOU_arr[index]
+    IOU_checkpoints_gt= IOU_checkpoints_gt[index]
+
+    net_precision, net_recall= mAP_calc(IOU_arr, IOU_checkpoints_gt)
+    net_area=0
+    for j in range(0, len(net_precision)):
+        x,y= AUC_calc(net_precision[j], net_recall[j])
+
+        area_arr=[]
+        area_i=0
+        for k in range(0, len(x)):
+            if k<len(x)-1:
+                w= x[k+1]-x[k]
+            else:
+                w=0
+            h= y[k]
+            area=(h*w)+ area_i
+            area_arr.append(area)
+            area_i= area_arr[-1]
+        net_area+=area_i
+        if j==0:
+            mAP_50= area_i
+    mAP_50_95= net_area/10
+    mAP_50, mAP_50_95= round(mAP_50,3), round(mAP_50_95,3)
+
+    print('net mAP_50', mAP_50, 'net mAP_50:95', mAP_50_95)
+    return mAP_50, mAP_50_95

Computer_Vision_Assistant_Package/Basic_Utils.py

@@ -0,0 +1,597 @@
+"""Core dataset, annotation, inference and SAHI-tiling helpers.
+
+This is the main working module of the package. It covers four jobs:
+
+1. **File discovery**: find images, ``.json`` and ``.txt`` files in a folder
+   tree (``img_loc``).
+2. **Dataset checks and annotations**: validate a COCO dataset folder
+   (``dataset_check``) and fetch the ground-truth boxes for one image
+   (``provide_annotations``).
+3. **Inference**: run a detector or classifier on one image and optionally
+   draw the predictions next to the ground truth (``ai_analytics``).
+4. **SAHI tiling**: cut a large image into tiles and run detection (and
+   optional classification) on every tile (``SAHI_generation``,
+   ``SAHI_analysis``).
+
+Functions
+---------
+img_loc
+    Recursively list image, json and txt files.
+ai_analytics
+    Run a model on one image and return its predictions.
+dataset_check
+    Sanity-check a folder of images plus a COCO json.
+provide_annotations
+    Get the ground-truth boxes and labels for one image.
+SAHI_generation
+    Slice a large image into tiles.
+SAHI_analysis
+    Run detection / classification on tiles and draw the results on the
+    full image.
+
+Module Constants
+----------------
+IMAGE_EXTENSIONS : tuple of str
+    File extensions treated as images (matched case-insensitively).
+
+Requires
+--------
+``numpy``, ``opencv-python``, ``torch``, ``torchvision``, ``matplotlib`` and
+``sahi``. Uses ``cell_geometry`` and ``cell_transform`` from ``Image_Utils``.
+
+Author: Shounak Sanyal
+"""
+import os, cv2, json, torch, shutil
+import numpy as np
+from sahi.slicing import slice_image
+import matplotlib.pyplot as plt  # currently unused in this module
+from torchvision.transforms import v2
+from torchvision import datasets, models, transforms
+from .Image_Utils import *
+
+# Common image file extensions to recognize when scanning directories.
+# Add/remove extensions here if your office image sources use other formats.
+# Matching is case-insensitive (names are lowercased before comparing).
+IMAGE_EXTENSIONS = ('png', 'jpg', 'jpeg', 'bmp', 'tif', 'tiff', 'webp')
+
+
+
+def img_loc(path):
+    """Recursively collect image, json and txt file paths under a folder.
+
+    Parameters
+    ----------
+    path : str
+        Root directory to search. All sub-folders are searched too.
+
+    Returns
+    -------
+    img_list : list of str
+        Paths of all image files (extensions from ``IMAGE_EXTENSIONS``).
+    json_list : list of str
+        Paths of all ``.json`` files.
+    txt_list : list of str
+        Paths of all ``.txt`` files.
+
+    Examples
+    --------
+    >>> images, jsons, txts = img_loc("my_dataset")
+    """
+    
+    global img_list
+    global json_list
+    global txt_list
+
+    img_list=[]
+    json_list=[]
+    txt_list=[]
+
+    def find_all_images(path):
+        """Append every image file under ``path`` to the global
+        ``img_list``, entering each sub-folder recursively."""
+        global img_list
+        list_path= os.listdir(path)
+        for i in range(0, len(list_path)):
+            new_path= os.path.join(path, list_path[i])
+            if os.path.isfile(new_path):
+                if new_path.lower().endswith(IMAGE_EXTENSIONS):
+                    img_list.append(new_path)
+            if os.path.isdir(new_path):
+                find_all_images(new_path)
+
+    def find_all_json(path):
+        """Append every path ending in ``'json'`` under ``path`` to the
+        global ``json_list``, entering each sub-folder recursively."""
+        global json_list
+        list_path= os.listdir(path)
+        for i in range(0, len(list_path)):
+            new_path= os.path.join(path, list_path[i])
+           
+            if new_path.endswith('json'):
+                json_list.append(new_path)
+            if os.path.isdir(new_path):
+                find_all_json(new_path)
+
+    def find_all_txt(path):
+        """Append every file ending in ``'txt'`` under ``path`` to the
+        global ``txt_list``, entering each sub-folder recursively."""
+        global txt_list
+        list_path= os.listdir(path)
+        for i in range(0, len(list_path)):
+            new_path= os.path.join(path, list_path[i])
+            if os.path.isfile(new_path):
+                if new_path.lower().endswith('txt'):
+                    txt_list.append(new_path)
+            if os.path.isdir(new_path):
+                find_all_txt(new_path)
+
+
+    find_all_images(path)
+    find_all_json(path)
+    find_all_txt(path)
+    return img_list, json_list, txt_list
+
+def ai_analytics(file, image_path, model, name='RFDETR', key=True, mode='Detection'):
+    """Run a model on one image and return its predictions.
+
+    For detection, the ground-truth boxes are also looked up in a COCO json so
+    the predictions can be compared with them (and optionally drawn on the
+    image).
+
+    Supported ``(name, mode)`` combinations:
+
+    * ``('RFDETR', 'Detection')``: ``model.predict(image_path)``
+    * ``('YOLO', 'Detection')``: ``model.predict(image_path)``
+    * ``('CNN', 'Classification')``: ``model(img)``, where ``img`` is a tensor
+
+    Parameters
+    ----------
+    file : str or None
+        Path to a COCO-format JSON annotation file. If it is ``None`` or cannot
+        be read, the function continues without ground truth. Use ``None`` for
+        classification.
+    image_path : str or torch.Tensor
+        Detection: path to the image. Classification: the image tensor itself.
+    model : object
+        The loaded model (moved to the GPU if available, else the CPU). For
+        detection it must have ``.predict()``.
+    name : {'RFDETR', 'YOLO', 'CNN'}, optional
+        Model type; decides how the output is read. Default is ``'RFDETR'``.
+    key : bool, optional
+        If True and the image has ground-truth annotations, draw the predicted
+        boxes (blue) and the ground-truth boxes (green) on the returned image.
+        Default is True.
+    mode : {'Detection', 'Classification'}, optional
+        Task type. Default is ``'Detection'``.
+
+    Returns
+    -------
+    Classification (``'CNN'``):
+        pred : numpy.int64
+            Index of the class with the highest score.
+        results : numpy.ndarray
+            Raw model scores for the first item in the batch.
+    Detection:
+        n_gt : int
+            Number of ground-truth boxes found for this image.
+        coords : array-like
+            Predicted boxes in ``xyxy`` format.
+        labels : array-like
+            Predicted labels (RFDETR: class names, YOLO: numeric class ids).
+        img : numpy.ndarray
+            The image (BGR), with the boxes drawn on it when ``key=True`` and
+            ground truth was found.
+        confidence : array-like
+            Confidence score of each prediction.
+
+    Examples
+    --------
+    >>> n_gt, coords, labels, img, conf = ai_analytics("annotations.json", "img_01.png", model)
+    >>> pred, scores = ai_analytics(None, tensor, cnn_model, name="CNN", mode="Classification")
+    """
+
+    device= "cuda" if torch.cuda.is_available() else "cpu"
+
+    def find_annots(id, file):
+        """Return all bboxes (``[x, y, w, h]``) and category ids from the
+        loaded COCO dict ``file`` whose annotations belong to the image id
+        ``id``."""
+        bbox_list, labels_list=[],[]
+        for i in range(0, len(file['annotations'])):
+            annot_id= file['annotations'][i]['image_id']
+            if annot_id == id:
+                bbox_list.append(file['annotations'][i]['bbox'])
+                labels_list.append(file['annotations'][i]['category_id'])
+
+        return bbox_list, labels_list
+
+    def find_img_id(id, file):
+        """Look up the COCO image id of the image file name ``id`` in the
+        loaded COCO dict ``file`` and return its ground truth as
+        ``(boxes, category ids)`` via ``find_annots``. Prints a message if
+        the image has no annotations or is not listed in the json."""
+        coords, labels=[],[]
+        for i in range(0, len(file['images'])):
+            if id== file['images'][i]['file_name']:
+                img_id= file['images'][i]['id']
+                coords, labels= find_annots(img_id, file)
+                if len(coords)==0:
+                    print('The image', id, 'has no listed annotations')
+                break
+        if len(coords)==0:
+            # Note: this message also shows when the image IS listed but
+            # has no annotations (the message above is printed as well).
+            print('The image',id, 'is not listed in the json')            
+        return coords, labels
+
+    # Run model inference on the target image.
+    if mode=='Detection':
+        results= model.predict(image_path)
+
+    if mode=='Classification':
+        # If image_path is a file path, read it with cv2; if that fails
+        # (e.g. it is already a tensor), use it as it is.
+        try:
+            img= cv2.imread(image_path)
+        except:
+            img= image_path
+        img= img.to(device)
+        results= model(img)
+    
+    # The image file name (last part of the path) is used to find the
+    # matching entry in the COCO json. Skipped if image_path is not a string.
+    try:
+        img_title= os.path.basename(image_path)
+    except:
+        pass
+
+
+    # Attempt to load ground-truth annotations for this image; if the
+    # annotation file is missing/invalid, proceed with empty ground truth.
+    # (Note: 'file' is re-used here to hold the loaded json data.)
+    try:
+        with open(file, 'r') as f:
+            file= json.load(f)
+            gt_annots, gt_labels= find_img_id(img_title,file)
+    except:
+        print('No annotation files, proceeding without it')
+        gt_annots, gt_labels=[],[]
+
+    confidence=0
+    # Read the model output according to the model type.
+    if name=='RFDETR' and mode=='Detection':
+        # RFDETR (supervision-style Detections): boxes in .xyxy,
+        # class names in .data['class_name'].
+        coords= results.xyxy
+        labels= results.data['class_name']
+        confidence= results.confidence
+        img= cv2.imread(image_path)
+
+    if name=='YOLO' and mode=='Detection':
+        # YOLO (ultralytics-style Results): boxes in .boxes.xyxy,
+        # numeric class ids in .boxes.cls (moved to numpy).
+        coords= results[0].boxes.xyxy
+        labels= results[0].boxes.cls.cpu().numpy()
+        img= cv2.imread(image_path)
+
+    if name=='CNN' and mode=='Classification':
+        # Classification returns early: (predicted class index, raw scores).
+        results= results.cpu()
+        results=(results.detach().numpy())[0]
+        pred= np.argmax(results)
+        return pred, results
+
+    if key==True and len(gt_labels)>0:
+        # Draw predicted boxes with colour (255,0,0). OpenCV uses BGR,
+        # so this shows up as BLUE.
+        for i in range(0, len(coords)):
+            x0,y0= int(float(coords[i][0])),int(float(coords[i][1]))
+            x1,y1= int(float(coords[i][2])),int(float(coords[i][3]))
+            cv2.rectangle(img, (x0,y0), (x1,y1), (255,0,0), 5)
+        
+        # Draw ground-truth boxes with colour (0,255,0) (GREEN).
+        # Note: COCO bbox format is [x, y, width, height], so x1/y1 here
+        # are computed as x0+width, y0+height.
+        for i in range(0, len(gt_annots)):
+            x0,y0= int(float(gt_annots[i][0])),int(float(gt_annots[i][1]))
+            x1,y1= int(float(gt_annots[i][2]))+x0,int(float(gt_annots[i][3]))+y0
+            cv2.rectangle(img, (x0,y0), (x1,y1), (0,255,0), 5)
+
+    print(labels, len(coords), len(gt_annots))
+    return len(gt_annots), coords, labels, img, confidence
+
+def dataset_check(file):
+    """Sanity-check a dataset folder that holds images and a COCO json.
+
+    Checks done:
+
+    1. Every image listed in the json exists in the folder.
+    2. Every annotation points to an image id that exists in the json.
+
+    A warning is printed when a check fails, and the counts are always returned.
+
+    Parameters
+    ----------
+    file : str
+        Path to the dataset folder (only its top level is scanned). The first
+        ``.json`` file found is used as the annotation file.
+
+    Returns
+    -------
+    n_images : int
+        Number of image files in the folder.
+    n_json_images : int
+        Number of images listed in the json.
+    n_annotated_images : int
+        Number of distinct images that have at least one annotation.
+    n_categories : int
+        Number of categories defined in the json.
+    n_used_categories : int
+        Number of distinct categories actually used by annotations.
+
+    Examples
+    --------
+    >>> counts = dataset_check("my_dataset")
+    """
+    list_files= os.listdir(file)
+    # Locate the annotation file (first file ending with '.json').
+    json_path= [list_files[i] for i in range(0, len(list_files)) if list_files[i].endswith('.json')]
+    json_annotation_categories=[]
+    print(json_path)
+    json_path= os.path.join(file, json_path[0])
+    # Collect image files by any recognized image extension (case-insensitive)
+    # instead of only '.png'.
+    img_list= [os.path.basename(list_files[i]) for i in range(0, len(list_files)) if list_files[i].lower().endswith(IMAGE_EXTENSIONS)]
+
+    with open(json_path, 'r') as f:
+        json_file= json.load(f)
+
+    # Check that every image referenced in the COCO file is present in img_list.
+    for i in range(0,len(json_file['images'])):
+        if json_file['images'][i]['file_name'] not in img_list:
+            print('json images are not properly subset of the listed images!')
+            # return 0
+
+    json_img_list= [json_file['images'][i]['id'] for i in range(0, len(json_file['images']))]
+
+    # Check that every annotation's image_id corresponds to a known image.
+    for i in range(0, len(json_file['annotations'])):
+        if json_file['annotations'][i]['image_id'] not in json_img_list:
+            print('json annotations do not exists for few images!')
+            # return 0
+        
+    json_annot_list= [json_file['annotations'][i]['image_id'] for i in range(0, len(json_file['annotations']))]
+    json_annotation_categories= [json_file['annotations'][i]['category_id'] for i in range(0, len(json_file['annotations']))]
+    
+    
+    return len(img_list), len(json_img_list), len(np.unique(json_annot_list)), len(json_file['categories']), len(np.unique(json_annotation_categories))
+
+def provide_annotations(json_path, file_name, key='COCO'):
+    """Get the ground-truth boxes and labels for one image.
+
+    Two annotation formats are supported, chosen with ``key``.
+
+    Parameters
+    ----------
+    json_path : str or list of str
+        ``key='COCO'``: path to one COCO-format json file.
+        ``key='Vanila'``: list of json file paths (all are read and merged).
+        Each json is a list of entries with ``entry['image']['pathname']`` and
+        ``entry['objects']``; each object has ``'bounding_box'`` (with
+        ``'minimum'`` and ``'maximum'``, each holding ``'r'`` and ``'c'``) and
+        ``'category'``.
+    file_name : str
+        Image file name, or a full path (only the last part is used).
+    key : {'COCO', 'Vanila'}, optional
+        Annotation format. Default is ``'COCO'``.
+
+    Returns
+    -------
+    ``key='COCO'`` returns ``(coords, labels)``:
+        coords : list of list of float
+            Boxes in COCO format ``[x, y, width, height]``.
+        labels : list of str
+            Category names, one per box.
+    ``key='Vanila'`` returns ``coords``:
+        coords : list of list
+            ``[min_r, min_c, max_r, max_c, label]`` for each object
+            (``r`` = row, ``c`` = column), or ``0`` if the image is not found.
+
+    Examples
+    --------
+    >>> coords, labels = provide_annotations("annotations.json", "img_01.png")
+    >>> coords = provide_annotations(["a.json", "b.json"], "img_01.png", key="Vanila")
+    """
+
+
+    if key=='COCO':
+        with open(json_path, 'r') as f:
+            json_file= json.load(f)
+
+        file_name= os.path.basename(file_name)
+        def get_annots(json_file, image_id):
+            """Return all bboxes and category NAMES (looked up from
+            ``json_file['categories']``) whose annotations belong to the
+            COCO image id ``image_id``."""
+            coords, labels=[],[]
+            for i in range(0, len(json_file['annotations'])):
+                annot_id= json_file['annotations'][i]['image_id']
+                if annot_id==image_id:
+                    coords.append(json_file['annotations'][i]['bbox'])
+                    label=json_file['annotations'][i]['category_id']
+                    label=[json_file['categories'][j]['name'] for j in range(0, len(json_file['categories'])) if json_file['categories'][j]['id']==label]
+                    labels.append(label[0])
+            return coords, labels
+
+        # Find the image entry matching file_name, then fetch its annotations.
+        coords, labels=[],[]
+        for i in range(0, len(json_file['images'])):
+            image_file= json_file['images'][i]['file_name']
+
+            if image_file==file_name:
+                print(f'Image {image_file} found!')
+                image_id= json_file['images'][i]['id']
+                coords, labels= get_annots(json_file, image_id)
+
+        if len(coords)==0:
+            print(f'No coordinate annotations found for image {file_name}')
+            return coords, labels
+        else:
+            print(f'Coordinate annotations found for image {file_name}')
+            return coords, labels
+
+    if key=='Vanila':
+        # Build a lookup table {image name: [[min_r, min_c, max_r, max_c, label], ...]}
+        # from all the json files in the list.
+        img_bank={}
+        for index in range(0, len(json_path)):
+            with open (json_path[index],'rb') as f:
+                json_file=json.load(f)
+
+
+            for i in range(0, len(json_file)):
+                img_name= os.path.basename(json_file[i]['image']['pathname'])
+                img_bank[img_name]=[]
+
+                coord_list= json_file[i]['objects']
+
+
+                for j in range(0, len(coord_list)):
+                    coord_min_x, coord_min_y= int(coord_list[j]['bounding_box']['minimum']['r']), int(coord_list[j]['bounding_box']['minimum']['c'])
+                    coord_max_x, coord_max_y= int(coord_list[j]['bounding_box']['maximum']['r']), int(coord_list[j]['bounding_box']['maximum']['c'])
+                    label= coord_list[j]['category']
+
+                    img_bank[img_name].append([coord_min_x, coord_min_y, coord_max_x, coord_max_y, label])
+
+
+        def img_search(file_name):
+            """Look up an image name in ``img_bank`` and return its list of
+            boxes, or ``0`` if the image is not in the bank."""
+            img_name= os.path.basename(file_name)
+            img_name_list= list(img_bank.keys())
+            coords=0
+
+            if img_name in img_name_list:
+                coords= img_bank[img_name]
+            return coords
+
+        coords=img_search(file_name)
+        return coords
+
+def SAHI_generation(image_path, output_file_name='tiled', output_dir='SAHI_results', slice_height=256, slice_width=256, overlap_h=0, overlap_w=0):
+    """Cut one large image into smaller tiles (SAHI slicing).
+
+    The tiles are saved to a folder, which is useful for running a detector on
+    small objects in big images. If ``output_dir`` already exists it is replaced
+    by the new tiles.
+
+    Parameters
+    ----------
+    image_path : str
+        Path to the image to slice.
+    output_file_name : str, optional
+        Base name for the saved tiles. Default is ``'tiled'``.
+    output_dir : str, optional
+        Folder where the tiles are saved. Default is ``'SAHI_results'``.
+    slice_height : int, optional
+        Tile height in pixels. Default is 256.
+    slice_width : int, optional
+        Tile width in pixels. Default is 256.
+    overlap_h : float, optional
+        Vertical overlap between tiles as a fraction of the tile height
+        (0 to 1). Default is 0 (no overlap).
+    overlap_w : float, optional
+        Horizontal overlap between tiles as a fraction of the tile width
+        (0 to 1). Default is 0 (no overlap).
+
+    Returns
+    -------
+    None
+        The tiles are written to ``output_dir``. Each tile file name ends with
+        its corner coordinates (``..._x0_y0_x1_y1``), which ``SAHI_analysis``
+        uses to place detections back on the full image.
+
+    Examples
+    --------
+    >>> SAHI_generation("large_image.png", slice_height=512, slice_width=512)
+    """
+    if os.path.exists(output_dir):
+        shutil.rmtree(output_dir)
+    slice_image_result = slice_image(
+    image=image_path,
+    output_file_name=output_file_name,
+    output_dir=output_dir,
+    slice_height=slice_height,
+    slice_width=slice_width,
+    overlap_height_ratio=overlap_h,
+    overlap_width_ratio=overlap_w,
+)
+
+def SAHI_analysis(image_path, model_det, model_clss=None, output_dir= 'SAHI_results',key=1):
+    """Run detection (and optional classification) on SAHI tiles and draw
+    the results on the full image.
+
+    For every tile in ``output_dir``: detect objects, optionally classify each
+    detected crop, shift the box from tile coordinates to full-image coordinates
+    and draw it on the original image.
+
+    Parameters
+    ----------
+    image_path : str
+        Path to the original full-size image (the one that was tiled).
+    model_det : object
+        Detection model (needs ``.predict()``), used through ``ai_analytics``.
+    model_clss : object, optional
+        Classification model (CNN) applied to every detected crop. If ``None``
+        (default), no classification is done.
+    output_dir : str, optional
+        Folder containing the tiles made by ``SAHI_generation``. Default is
+        ``'SAHI_results'``.
+    key : {0, 1}, optional
+        Transform key passed to ``Image_Utils.cell_transform`` (0 = with ImageNet
+        normalisation, 1 = without). Default is 1.
+
+    Returns
+    -------
+    img : numpy.ndarray
+        The full image (BGR) with the boxes drawn. Without a classifier every
+        box is blue. With a classifier, predicted class 0 is drawn green and any
+        other class red.
+
+    Examples
+    --------
+    >>> SAHI_generation("large_image.png")
+    >>> result = SAHI_analysis("large_image.png", det_model, cnn_model)
+    """
+    image_slice_path, json_path, txt_path= img_loc(output_dir)
+    IMAGE_EXTENSIONS = ('png', 'jpg', 'jpeg', 'bmp', 'tif', 'tiff', 'webp')
+    img=cv2.imread(image_path)
+
+    for i in range(0, len(image_slice_path)):
+        img_name = os.path.splitext(image_slice_path[i])[0]
+        x_n0,y_n0= int(img_name.split('_')[-4]), int(img_name.split('_')[-3])
+        x_n1, y_n1= int(img_name.split('_')[-2]), int(img_name.split('_')[-1])
+        print(img_name, x_n0, y_n0, x_n1, y_n1)
+        len_gt, coords,_,_,_= ai_analytics(None, image_slice_path[i], model_det)
+        img_SAHI= cv2.imread(image_slice_path[i])
+        for j in range(0, len(coords)):
+            x0,y0= int(float(coords[j][0])),int(float(coords[j][1]))
+            x1,y1= int(float(coords[j][2])),int(float(coords[j][3]))
+            color= (255,0,0)
+            if model_clss:
+                img_slice= img_SAHI[y0:y1, x0:x1]
+                img_slice= cell_geometry(img_slice)
+                img_slice= cv2.resize(img_slice, (224,224))
+                img_slice= cv2.cvtColor(img_slice, cv2.COLOR_BGR2RGB)
+                img_slice= cell_transform(img_slice, key)[np.newaxis,:,:]
+                pred, results= ai_analytics(None, img_slice, model_clss, name='CNN',mode='Classification')
+                print('pred', pred)
+                if pred==0:
+                    color= (0,255,0)
+                else:
+                    color=(0,0,255)
+            x0,y0= x0+x_n0, y0+y_n0
+            x1,y1= x1+x_n0, y1+y_n0
+            cv2.rectangle(img, (x0,y0), (x1,y1), color,2)
+
+    return img

Computer_Vision_Assistant_Package/Image_Utils.py

@@ -0,0 +1,265 @@
+"""Image pre-processing helpers.
+
+Functions that prepare images (for example single-cell crops) before they are
+shown to a classifier or used for training: normalisation, augmentation,
+padding to a square and conversion to tensors. Images are NumPy arrays read
+with OpenCV, so colour images are in BGR order unless stated otherwise.
+
+Functions
+---------
+image_processing
+    Colour / contrast normalisation (CLAHE, Reinhard colour transfer or
+    Otsu thresholding).
+data_augmentation
+    Generates rotated and blurred copies of an image.
+cell_geometry
+    Makes an image even-sized and pads it with black to a square.
+cell_transform
+    Converts an image to a PyTorch tensor, with or without ImageNet
+    normalisation.
+
+Author: Shounak Sanyal
+"""
+import os
+import cv2
+import matplotlib.pyplot as plt
+import numpy as np
+from torchvision.transforms import v2
+import os, cv2, json, torch, shutil
+from torchvision import datasets, models, transforms
+
+
+def image_processing(img, ref_img=None, normalisation='Clahe', grid_window=(8,8)):
+    """Normalise an image using CLAHE, Reinhard colour transfer or Otsu.
+
+    Parameters
+    ----------
+    img : numpy.ndarray
+        Input image. BGR for ``'Clahe'`` (grayscale also works) and
+        ``'Reinhard'``; single-channel 8-bit grayscale for ``'Otsu'``.
+    ref_img : numpy.ndarray, optional
+        Reference image in BGR format. Needed only for ``'Reinhard'``.
+    normalisation : {'Clahe', 'Reinhard', 'Otsu'}, optional
+        Method to use (case-sensitive). Default is ``'Clahe'``.
+
+        * ``'Clahe'``: improves local contrast by equalising the lightness
+          channel (adaptive histogram equalisation, clip limit 2.0).
+        * ``'Reinhard'``: matches the colour statistics of ``img`` to those of
+          ``ref_img``.
+        * ``'Otsu'``: automatic thresholding that returns an inverted binary
+          mask (values 0 and 255).
+    grid_window : tuple of int, optional
+        CLAHE tile grid size ``(rows, cols)``. Used only by ``'Clahe'``.
+        Default is ``(8, 8)``.
+
+    Returns
+    -------
+    img_norm : numpy.ndarray
+        The normalised image (BGR for colour input, single-channel for
+        grayscale input and ``'Otsu'``).
+
+    Examples
+    --------
+    >>> img_norm = image_processing(img)                           # CLAHE
+    >>> img_norm = image_processing(img, ref_img, "Reinhard")      # match colours
+    """
+    # --- Reinhard Color Transfer ---
+    if normalisation == 'Reinhard':
+        # Convert images from BGR to LAB color space (float32 for precise math)
+        img_lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB).astype(np.float32)
+        ref_lab = cv2.cvtColor(ref_img, cv2.COLOR_BGR2LAB).astype(np.float32)
+
+        # Calculate mean and standard deviation for reference image
+        ref_mean = ref_lab.reshape(-1, 3).mean(axis=0)
+        ref_sd = ref_lab.reshape(-1, 3).std(axis=0)
+
+        # Calculate mean and standard deviation for input image
+        img_mean = img_lab.reshape(-1, 3).mean(axis=0)
+        img_sd = img_lab.reshape(-1, 3).std(axis=0)
+
+        # Normalize channel distributions to match reference statistics
+        normalized = (
+            (img_lab - img_mean) / (img_sd + 1e-8) * ref_sd + ref_mean
+        )
+
+        # Ensure pixel values stay within valid range [0, 255]
+        normalized = np.clip(normalized, 0, 255).astype(np.uint8)
+        img_norm = cv2.cvtColor(normalized, cv2.COLOR_Lab2BGR)
+
+    # --- CLAHE (Contrast Limited Adaptive Histogram Equalization) ---
+    if normalisation == 'Clahe':
+        # Convert BGR image to LAB color space
+        try:
+            lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
+
+            # Configure CLAHE parameters
+            clahe = cv2.createCLAHE(
+                clipLimit=2.0,
+                tileGridSize=grid_window
+            )
+
+            # Apply histogram equalization exclusively to the L (lightness) channel
+            lab[:, :, 0] = clahe.apply(lab[:, :, 0])
+
+            # Convert image back from LAB to BGR color space
+            img_norm = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
+        except:
+            clahe = cv2.createCLAHE(
+                clipLimit=2.0,
+                tileGridSize=grid_window
+            )
+
+            img_norm= clahe.apply(img)
+
+
+    if normalisation=='Otsu':
+        _, img_norm= cv2.threshold(img, 0,255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)
+    return img_norm
+
+def data_augmentation(img, n_rotate=3, blur=True):
+    """Generate rotated (and optionally blurred) copies of an image.
+
+    Parameters
+    ----------
+    img : numpy.ndarray
+        Input image.
+    n_rotate : int, optional
+        Number of rotations to apply, from 0 to 3. Default is 3. The rotations
+        are, in order: 90 degrees clockwise, 180 degrees, 90 degrees
+        counter-clockwise.
+    blur : bool, optional
+        If True, also add a Gaussian-blurred copy of the original image
+        (5x5 kernel, sigma 1). Default is True.
+
+    Returns
+    -------
+    img_aug : list of numpy.ndarray
+        The rotated images in order, followed by the blurred image when
+        ``blur`` is True. The original image is not included.
+
+    Examples
+    --------
+    >>> augmented = data_augmentation(img)          # 3 rotations + 1 blur = 4 images
+    """
+
+    img_aug=[]
+
+    for i in range(0,n_rotate):
+
+        img_aug.append(cv2.rotate(img, i))
+
+    if blur:
+
+        img_aug.append(cv2.GaussianBlur(img, (5,5),1))
+
+    return img_aug
+
+def cell_geometry(img):
+    """Make an image even-sized and pad it with black to a square.
+
+    Steps:
+
+    1. If the height or width is odd, that side is resized by +1 pixel.
+    2. If the image is not square, the shorter side is padded with black so the
+       original image stays centred. The result is square, with side equal to
+       the longer dimension.
+
+    Parameters
+    ----------
+    img : numpy.ndarray
+        Grayscale image of shape ``(H, W)`` or colour image of shape
+        ``(H, W, C)``.
+
+    Returns
+    -------
+    numpy.ndarray
+        Square image of dtype ``uint8``.
+
+    Examples
+    --------
+    >>> square = cell_geometry(crop)     # e.g. a 40x60 crop becomes 60x60
+    """
+    # Get dimensions
+    if img.ndim == 3:
+        h, w, c = img.shape
+    elif img.ndim == 2:
+        h, w = img.shape
+    else:
+        raise ValueError(f"Expected 2D or 3D image, got shape {img.shape}")
+
+    # Make dimensions even
+    if h % 2 != 0:
+        h_new = h + 1
+        img = cv2.resize(img, (w, h_new))
+        h = h_new
+
+    if w % 2 != 0:
+        w_new = w + 1
+        img = cv2.resize(img, (w_new, h))
+        w = w_new
+
+    # Already square
+    if h == w:
+        return img.astype(np.uint8)
+
+    # Width > height
+    if w > h:
+        dx = w - h
+
+        if img.ndim == 3:
+            new_img = np.zeros((w, w, c), dtype=np.uint8)
+        else:
+            new_img = np.zeros((w, w), dtype=np.uint8)
+
+        top = dx // 2
+        bottom = top + h
+
+        new_img[top:bottom, :] = img
+
+    # Height > width
+    else:
+        dy = h - w
+
+        if img.ndim == 3:
+            new_img = np.zeros((h, h, c), dtype=np.uint8)
+        else:
+            new_img = np.zeros((h, h), dtype=np.uint8)
+
+        left = dy // 2
+        right = left + w
+
+        new_img[:, left:right] = img
+
+    return new_img
+
+def cell_transform(img, key):
+    """Convert an image to a float PyTorch tensor for a classifier.
+
+    Parameters
+    ----------
+    img : numpy.ndarray or PIL.Image.Image
+        Input image, typically RGB ``uint8`` of shape ``(H, W, 3)``.
+    key : {0, 1}
+        Transform to apply.
+
+        * ``0``: convert to a tensor with values in ``[0, 1]`` and normalise
+          with the ImageNet mean ``[0.485, 0.456, 0.406]`` and standard
+          deviation ``[0.229, 0.224, 0.225]``.
+        * ``1``: convert to a tensor with values in ``[0, 1]`` only (no
+          normalisation).
+
+    Returns
+    -------
+    img : torch.Tensor
+        Tensor of shape ``(C, H, W)`` and dtype ``float32``.
+
+    Examples
+    --------
+    >>> tensor = cell_transform(rgb_img, 0)
+    """
+    if key==0:
+        transform=v2.Compose([v2.ToImage(), v2.ToDtype(torch.float32, scale=True), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])
+    if key==1:
+        transform=v2.Compose([v2.ToImage(), v2.ToDtype(torch.float32, scale=True)])
+    img= transform(img)
+    return img

Computer_Vision_Assistant_Package/__innit__.py

@@ -0,0 +1,21 @@
+"""Computer_vision_assisting_tools
+================================
+
+A small toolbox of helpers for computer-vision projects: image
+pre-processing, dataset / annotation handling, model inference, SAHI tiling
+and detection metrics.
+
+Modules
+-------
+Image_Utils
+    Image normalisation, augmentation, padding and tensor transforms.
+Basic_Utils
+    File discovery, COCO dataset checks, annotation lookup, model inference
+    and SAHI tiling.
+AI_Metrics
+    IoU, precision / recall and mAP for object detection.
+
+See ``README.md`` for the full description and the module hierarchy.
+
+Author: Shounak Sanyal
+"""

computer_vision_assistant_package-1.0.dist-info/METADATA

@@ -0,0 +1,151 @@
+Metadata-Version: 2.5
+Name: Computer_Vision_Assistant_Package
+Version: 1.0
+Summary: A user friendly package assiting in the most common computer vision tasks
+Author-email: Shounak Sanyal <shounaksanyal1902@outlook.com>
+License-Expression: MIT
+License-File: License.txt
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# Computer_vision_assisting_tools
+
+**Author:** Shounak Sanyal
+
+A small toolbox of helpers for computer-vision projects. It bundles the
+functions that were most useful in a detection + classification workflow:
+
+* find images and annotation files in a folder tree,
+* check and read COCO-style datasets,
+* run a detector (RF-DETR, YOLO) or a CNN classifier on an image and draw the
+  predictions next to the ground truth,
+* slice large images into tiles (SAHI) and run detection / classification on
+  every tile,
+* pre-process images (CLAHE, Reinhard colour transfer, Otsu, augmentation,
+  square padding, tensor transforms),
+* score a detector with IoU, precision / recall and mAP.
+
+---
+
+## Package hierarchy
+
+```
+.
+├── README.md
+└── Computer_vision_assisting_tools/
+    ├── __innit__.py        Package docstring (no code)
+    ├── AI_Metrics.py       Detection metrics
+    │   ├── IOU_calc
+    │   ├── mAP_calc
+    │   ├── AUC_calc
+    │   └── detection_metrics
+    ├── Basic_Utils.py      Files, datasets, annotations, inference, SAHI
+    │   ├── IMAGE_EXTENSIONS            (constant)
+    │   ├── img_loc
+    │   ├── ai_analytics
+    │   ├── dataset_check
+    │   ├── provide_annotations
+    │   ├── SAHI_generation
+    │   └── SAHI_analysis
+    └── Image_Utils.py      Image pre-processing
+        ├── image_processing
+        ├── data_augmentation
+        ├── cell_geometry
+        └── cell_transform
+```
+
+### How the modules depend on each other
+
+```
+AI_Metrics.py  ──►  Basic_Utils.py  ──►  Image_Utils.py
+ (metrics)           (data + models)      (image helpers)
+```
+
+`AI_Metrics` uses `provide_annotations` and `ai_analytics` from `Basic_Utils`;
+`Basic_Utils` uses `cell_geometry` and `cell_transform` from `Image_Utils`.
+`Image_Utils` depends on none of the others. The modules import each other
+with relative imports (`from .Basic_Utils import *`), so they must be used as
+part of the package, not run directly as scripts.
+
+---
+
+## Module descriptions
+
+### `Image_Utils.py` — image pre-processing
+
+Helpers that prepare images (for example single-cell crops) before they reach
+a classifier. Images are NumPy arrays read with OpenCV, so colour images are in
+BGR order unless stated otherwise.
+
+| Function | What it does |
+|---|---|
+| `image_processing(img, ref_img=None, normalisation='Clahe', grid_window=(8,8))` | Normalises an image with CLAHE (default), Reinhard colour transfer (needs `ref_img`) or Otsu thresholding (`'Otsu'`). |
+| `data_augmentation(img, n_rotate=3, blur=True)` | Returns up to three rotated copies (90°, 180°, 270°; default 3) and, optionally, a Gaussian-blurred copy. |
+| `cell_geometry(img)` | Makes both sides even, then pads the shorter side with black so the image becomes a centred square. |
+| `cell_transform(img, key)` | Converts an image to a `float32` tensor. `key=0` adds ImageNet normalisation, `key=1` only scales to [0, 1]. |
+
+### `Basic_Utils.py` — data, annotations, inference and SAHI
+
+The main working module. It finds files, checks datasets, reads ground truth,
+runs models and handles SAHI tiling.
+
+| Function | What it does |
+|---|---|
+| `IMAGE_EXTENSIONS` | Tuple of file extensions treated as images (case-insensitive). |
+| `img_loc(path)` | Recursively lists image, `.json` and `.txt` files under a folder. Returns `(img_list, json_list, txt_list)`. |
+| `ai_analytics(file, image_path, model, name='RFDETR', key=True, mode='Detection')` | Runs RF-DETR / YOLO detection or CNN classification on one image (the model is moved to the GPU if available). For detection it also reads the COCO ground truth and can draw predictions (blue) and ground truth (green). |
+| `dataset_check(file)` | Checks that the images in a folder and the COCO json agree. Returns five counts (images, json images, annotated images, categories, used categories). |
+| `provide_annotations(json_path, file_name, key='COCO')` | Returns the ground-truth boxes and labels for one image, from a COCO json or from the `'Vanila'` multi-json format. |
+| `SAHI_generation(image_path, ...)` | Slices a large image into tiles and saves them (the output folder is deleted first if it exists). |
+| `SAHI_analysis(image_path, model_det, model_clss=None, ...)` | Detects (and optionally classifies) objects on every tile and draws them on the full image. |
+
+### `AI_Metrics.py` — detection metrics
+
+Scores a detector on a single image against COCO ground truth. Boxes are in
+`(x_min, y_min, x_max, y_max)` format.
+
+| Function | What it does |
+|---|---|
+| `IOU_calc(target_pts, gt_pts)` | IoU of one box against a list of ground-truth boxes. |
+| `mAP_calc(bboxes, gt_bboxes)` | Running precision and recall for IoU thresholds 0.50 – 0.90. |
+| `AUC_calc(precision, recall)` | Builds the smoothed precision curve used for the area under the curve. |
+| `detection_metrics(json_file, img_file, model_test)` | End-to-end evaluation. Returns `(mAP_50, mAP_50_95)`. |
+
+---
+
+## Requirements
+
+* Python 3.9+
+* `numpy`
+* `opencv-python`
+* `torch`
+* `torchvision` (0.16 or newer, for `torchvision.transforms.v2.ToImage`)
+* `matplotlib` (imported by the modules)
+* `sahi`
+* A detector with a `.predict()` method (RF-DETR or Ultralytics YOLO) if you
+  use `ai_analytics`, `SAHI_analysis` or `detection_metrics`.
+
+## Quick example
+
+```python
+from Computer_vision_assisting_tools.Basic_Utils import img_loc, dataset_check
+from Computer_vision_assisting_tools.Image_Utils import image_processing
+
+images, jsons, txts = img_loc("my_dataset")      # find all files
+print(dataset_check("my_dataset"))               # sanity-check images vs json
+
+import cv2
+img = cv2.imread(images[0])
+img_clahe = image_processing(img, normalisation="Clahe")
+```
+
+## Documentation style
+
+Every module, function and inner helper has a NumPy-style docstring
+(`Parameters`, `Returns`, `Examples`). Use `help(function_name)` to read
+them.
+
+## Author
+
+Created and maintained by **Shounak Sanyal**.

computer_vision_assistant_package-1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+Computer_Vision_Assistant_Package/AI_Metrics.py,sha256=iQ3da7iqlgKuqyJlDDelegWCIhBJ5eXDJl24Z2-2o-4,8289
+Computer_Vision_Assistant_Package/Basic_Utils.py,sha256=RPHRfnx8BYMYhPet-crzLqzngHt3KeGU9uyEUc2pLDQ,23720
+Computer_Vision_Assistant_Package/Image_Utils.py,sha256=gGIOt-R9Odrw-B3Pw2mhy_i6nal5tFSPN9Qe51AktcE,8325
+Computer_Vision_Assistant_Package/__innit__.py,sha256=Ee5avxb60YFZgm7DSw2qrkxq4BgpSZjg0oF8y57XUog,606
+computer_vision_assistant_package-1.0.dist-info/METADATA,sha256=d9Een0WErNCDVCdngXyThP-esoiazh4TYNHYzEOs_fg,6420
+computer_vision_assistant_package-1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+computer_vision_assistant_package-1.0.dist-info/licenses/License.txt,sha256=PlCLU6XTp8wrSeEQOxQBUoeLxWIfc4wP71Sc6FOE_t4,1070
+computer_vision_assistant_package-1.0.dist-info/RECORD,,

computer_vision_assistant_package-1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

computer_vision_assistant_package-1.0.dist-info/licenses/License.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shounak Sanyal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE