^jHLddlmZddlZddlmZmZddlmZddlm Z ddl m Z ddl m Z ddlZddlZddlmZddlmZdd lmZdd lmZmZdd lmZmZdd lmZm Z m!Z!dd l"m#Z#m$Z$m%Z%m&Z&m'Z'ddl(m)Z)ddl*m+Z+ddl,m-Z-GddeZ.Gdde.Z/e Gdde.Z0y)) annotationsN)ABCabstractmethod)Iterator) dataclass)chain)Path)Classifications)CLASS_NAME_DATA_FIELD)load_coco_annotationssave_coco_annotations)detections_to_pascal_vocload_pascal_voc_annotations)load_yolo_annotationssave_data_yamlsave_yolo_annotations)build_class_index_mappingmap_detections_class_idmerge_class_listssave_dataset_imagestrain_test_split) Detections)warn_deprecated)find_duplicatescFeZdZeddZe d ddZy) BaseDatasetcyNselfs c/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/supervision/dataset/core.py__len__zBaseDataset.__len__*s Ncyrr)r! split_ratio random_stateshuffles r"splitzBaseDataset.split.s r$returnintg?NT)r&floatr' int | Noner(boolr+ztuple[BaseDataset, BaseDataset])__name__ __module__ __qualname__rr#r)rr$r"rr)sY  !#'   !   )   r$rceZdZdZ ddZddZddZddZddZddZ d dd Z e dd Z d dd Z e d dd Ze d dd Z d d!dZe d d"dZ d# d$dZy)%DetectionDataseta Contains information about a detection dataset. Handles lazy image loading and annotation retrieval, dataset splitting, conversions into multiple formats. Attributes: classes: List containing dataset class names. images: Accepts a list of image paths, or dictionaries of loaded cv2 images with paths as keys. If you pass a list of paths, the dataset will lazily load images on demand, which is much more memory-efficient. annotations: Dictionary mapping image path to annotations. The dictionary keys match match the keys in `images` or entries in the list of image paths. c||_t|t|k7r td||_|jrkt j |j}|jj D]/}|j||j|jt<1ttj||_ i|_y)N?The keys of the images and annotations dictionaries must match.)classesset ValueErrorrnparrayvaluesclass_iddatar listdictfromkeys image_paths_images_in_memory)r!r8imagesr np_classes annotations r"__init__zDetectionDataset.__init__Js  v;#k* *Q ' <<$,,/J"..557  &&2=G"++>JOO$9:   f 56CEr$c|jr|j|Stj|}|td||Sz!Assumes that image is in dataset.z Could not read image from path: rDcv2imreadr:r! image_pathimages r" _get_imagezDetectionDataset._get_imageeG  ! !))*5 5 :& =? |LM M r$cZt|jxst|jSrlenrDrCr s r"r#zDetectionDataset.__len__n#4))*Cc$2B2B.CCr$cj|j|}|j|}|j|}|||fSz Returns: The image path, image data, and its corresponding annotation at index i. rCrQrr!irOrPrGs r" __getitem__zDetectionDataset.__getitem__q? %%a(  +%%j1 5*,,r$c#^Ktt|D]}||\}}}|||fywz Iterate over the images and annotations in the dataset. Yields: Tuples containing the image path, image data, and its annotation. NrangerUrZs r"__iter__zDetectionDataset.__iter__|s=s4y! 0A,0G )JzeZ/ / 0+-ct|tsyt|jt|jk7ry|j|jk7ry|j s |j rYt jt|j jt|j jsy|j|jk7ryyNFT) isinstancer5r9r8rCrDr; array_equalr@r=rr!others r"__eq__zDetectionDataset.__eq__s%!12 t|| EMM 2 2   u00 0  ! !U%<%<>>T++2245U,,3356   u00 0r$Nct|j|||\}}|jr;|Dcic]}||j|}}|Dcic]}||j|}}n|}|}|Dcic]}||j|} }|Dcic]}||j|} }t |j || } t |j || } | | fScc}wcc}wcc}wcc}w)a0 Splits the dataset into two parts (training and testing) using the provided split_ratio. Args: split_ratio: The ratio of the training set to the entire dataset. random_state: The seed for the random number generator. This is used for reproducibility. shuffle: Whether to shuffle the data before splitting. Returns: A tuple containing the training and testing datasets. Examples: ```pycon >>> import numpy as np >>> import supervision as sv >>> ds = sv.DetectionDataset( ... classes=['dog', 'person'], ... images={ ... 'img1.jpg': np.zeros((100, 100, 3), dtype=np.uint8), ... 'img2.jpg': np.zeros((100, 100, 3), dtype=np.uint8), ... }, ... annotations={ ... 'img1.jpg': sv.Detections(xyxy=np.array([[10, 10, 20, 20]])), ... 'img2.jpg': sv.Detections(xyxy=np.array([[30, 30, 40, 40]])), ... } ... ) >>> train_ds, test_ds = ds.split(split_ratio=0.5, random_state=42) >>> len(train_ds), len(test_ds) (1, 1) ``` r? train_ratior'r(r8rEr)rrCrDrr5r8 r!r&r'r( train_paths test_pathspath train_input test_inputtrain_annotationstest_annotations train_dataset test_datasets r"r)zDetectionDataset.splitsV#3!!#% #  Z  ! !JUV$4!7!7!==VKVIST$ 6 6t <<TJT%K#JFQRdT4#3#3D#99RREOPTD$"2"24"88PP(LL) (LL( l**%WTSPC C,C  C%c2d d}d d}t|Dcgc] }|| c}}t|Dcgc] }|| c}}|s |s tdi}|D]}|j|jt t j d|D}t tj|} t|t| k7rt|} td| d| }t|Dcgc]}|jc}} i} |D]}| j|j |D]=}t|j| } |jD]}t!| | | | |<?|| |xs|| Scc}wcc}wcc}w) a Merge a list of `DetectionDataset` objects into a single `DetectionDataset` object. This method takes a list of `DetectionDataset` objects and combines their respective fields (`classes`, `images`, `annotations`) into a single `DetectionDataset` object. Args: dataset_list: A list of `DetectionDataset` objects to merge. Returns: A single `DetectionDataset` object containing the merged data from the input list. Examples: ```pycon >>> import numpy as np >>> import supervision as sv >>> ds_1 = sv.DetectionDataset( ... classes=['dog', 'person'], ... images={'img1.jpg': np.zeros((100, 100, 3), dtype=np.uint8)}, ... annotations={'img1.jpg': sv.Detections.empty()} ... ) >>> len(ds_1) 1 >>> ds_1.classes ['dog', 'person'] >>> ds_2 = sv.DetectionDataset( ... classes=['cat'], ... images={'img2.jpg': np.zeros((100, 100, 3), dtype=np.uint8)}, ... annotations={'img2.jpg': sv.Detections.empty()} ... ) >>> len(ds_2) 1 >>> ds_2.classes ['cat'] >>> ds_merged = sv.DetectionDataset.merge([ds_1, ds_2]) >>> len(ds_merged) 2 >>> ds_merged.classes ['cat', 'dog', 'person'] ``` cft|jdkDxst|jdk(SNrrTdatasets r" is_in_memoryz,DetectionDataset.merge..is_in_memorys.w001A5VW=P=P9QUV9V Vr$c2t|jdk(Sr|)rUrDr}s r"is_lazyz'DetectionDataset.merge..is_lazysw001Q6 6r$z>Merging lazy and in-memory DetectionDatasets is not supported.c34K|]}|jywr)rC).0r~s r" z)DetectionDataset.merge..)sP 3 3Psz Image paths z are not unique across datasets.) class_lists)source_classestarget_classes)source_to_target_mapping detectionsrn)r~r5r+r0)allr:updaterDr@r from_iterablerArBrUrrr8rrrCr)cls dataset_listrrr~ all_in_memoryall_lazyimages_in_memoryrCimage_paths_unique duplicatesr8rclass_index_mappingrOs r"mergezDetectionDataset.mergesb W 7,Ow\'2OP  EW(EFXP # ?G  # #G$=$= > ?   P<P P "$-- "<= { s#56 6(5Jzl*JK ) #8DEWE  # 4G K  w22 3 4# G";&w# &11  *A-@*:6+ J'   #2{#  OPE,FsF F9Fc |r t|||rt|jdd|D]\}}}t|j} tj j || d} t|j} t||j| |j|||} t| d5} | j| dddyy#1swYxYw)a Exports the dataset to PASCAL VOC format. This method saves the images and their corresponding annotations in PASCAL VOC format. Args: images_directory_path: The path to the directory where the images should be saved. If not provided, images will not be saved. annotations_directory_path: The path to the directory where the annotations in PASCAL VOC format should be saved. If not provided, annotations will not be saved. min_image_area_percentage: The minimum percentage of detection area relative to the image area for a detection to be included. Argument is used only for segmentation datasets. max_image_area_percentage: The maximum percentage of detection area relative to the image area for a detection to be included. Argument is used only for segmentation datasets. approximation_percentage: The percentage of polygon points to be removed from the input polygon, in the range [0, 1). Argument is used only for segmentation datasets. r~images_directory_pathT)parentsexist_okz.xml)rr8filename image_shapemin_image_area_percentagemax_image_area_percentageapproximation_percentagewN) rr mkdirstemosrrjoinnamerr8shapeopenwrite)r!rannotations_directory_pathrrrrOrPrannotation_nameannotations_path image_namepascal_voc_xmlfs r" as_pascal_voczDetectionDataset.as_pascal_vocJs> ! &;  & + , 2 24$ 2 O26 ,. E;"&z"2"7"7#%77<<.?2C40H$ "*-22 !9* LL' % .G.G-E"*C0,AGGN+,,! , &$,,s 6CC cBt|||\}}}t|||S)a Creates a Dataset instance from PASCAL VOC formatted data. Args: images_directory_path: Path to the directory containing the images. annotations_directory_path: Path to the directory containing the PASCAL VOC XML annotations. force_masks: If True, forces masks to be loaded for all annotations, regardless of whether they are present. Returns: A DetectionDataset instance containing the loaded images and annotations. Examples: ```python import roboflow from roboflow import Roboflow import supervision as sv roboflow.login() rf = Roboflow() project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID) dataset = project.version(PROJECT_VERSION).download("voc") ds = sv.DetectionDataset.from_pascal_voc( images_directory_path=f"{dataset.location}/train/images", annotations_directory_path=f"{dataset.location}/train/labels" ) ds.classes # ['dog', 'person'] ``` )rr force_masksrn)rr5)rrrrr8rCrs r"from_pascal_vocz DetectionDataset.from_pascal_vocs6X-H"7'A#- )k  K[  r$cFt|||||\}}}t|||S)a6 Creates a Dataset instance from YOLO formatted data. Args: images_directory_path: The path to the directory containing the images. annotations_directory_path: The path to the directory containing the YOLO annotation files. data_yaml_path: The path to the data YAML file containing class information. force_masks: If True, forces masks to be loaded for all annotations, regardless of whether they are present. is_obb: If True, loads the annotations in OBB format. OBB annotations are defined as `[class_id, x, y, x, y, x, y, x, y]`, where pairs of [x, y] are box corners. Returns: A DetectionDataset instance containing the loaded images and annotations. Examples: ```python import roboflow from roboflow import Roboflow import supervision as sv roboflow.login() rf = Roboflow() project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID) dataset = project.version(PROJECT_VERSION).download("yolov5") ds = sv.DetectionDataset.from_yolo( images_directory_path=f"{dataset.location}/train/images", annotations_directory_path=f"{dataset.location}/train/labels", data_yaml_path=f"{dataset.location}/data.yaml" ) ds.classes # ['dog', 'person'] ``` )rrdata_yaml_pathris_obbrn)rr5) rrrrrrr8rCrs r" from_yolozDetectionDataset.from_yolos<h-B"7'A)# - )k K[  r$c|r+|dk7s |dk7s|dk7rddl}|jdtd| t|||t |||||| |t ||j yy) a Exports the dataset to YOLO format. This method saves the images and their corresponding annotations in YOLO format. Args: images_directory_path: The path to the directory where the images should be saved. If not provided, images will not be saved. annotations_directory_path: The path to the directory where the annotations in YOLO format should be saved. If not provided, annotations will not be saved. data_yaml_path: The path where the data.yaml file should be saved. If not provided, the file will not be saved. min_image_area_percentage: The minimum percentage of detection area relative to the image area for a detection to be included. Argument is used only for segmentation datasets. max_image_area_percentage: The maximum percentage of detection area relative to the image area for a detection to be included. Argument is used only for segmentation datasets. approximation_percentage: The percentage of polygon points to be removed from the input polygon, in the range [0, 1). This is useful for simplifying the annotations. Argument is used only for segmentation datasets. is_obb: If True, exports annotations in OBB format (`class_id x1 y1 x2 y2 x3 y3 x4 y4`) using the oriented corners stored in `detections.data["xyxyxyxy"]`. Mirrors `from_yolo(..., is_obb=True)`. Masks are ignored when `is_obb=True`. ?rNz`min_image_area_percentage`, `max_image_area_percentage`, and `approximation_percentage` have no effect when `is_obb=True`; OBB annotations use corner coordinates directly.) stacklevelr)r~rrrrr)rr8)warningswarn UserWarningrrrr8) r!rrrrrrrrs r"as_yolozDetectionDataset.as_yolosV  % ,(C/'3.  MMC   ! , 4I  & 1 !+E*C*C)A    % .$,, O &r$cBt|||\}}}t|||S)a Creates a Dataset instance from COCO formatted data. Args: images_directory_path: The path to the directory containing the images. annotations_path: The path to the json annotation files. force_masks: If True, forces masks to be loaded for all annotations, regardless of whether they are present. Returns: A DetectionDataset instance containing the loaded images and annotations. Examples: ```python import roboflow from roboflow import Roboflow import supervision as sv roboflow.login() rf = Roboflow() project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID) dataset = project.version(PROJECT_VERSION).download("coco") ds = sv.DetectionDataset.from_coco( images_directory_path=f"{dataset.location}/train", annotations_path=f"{dataset.location}/train/_annotations.coco.json", ) ds.classes # ['dog', 'person'] ``` )rrrrn)r r5)rrrrr8rErs r" from_cocozDetectionDataset.from_cocoAs0T(="7-#( $  KXXr$c P| t|||t|||||||S||fS)u Exports the dataset to COCO format. This method saves the images and their corresponding annotations in COCO format. !!! tip The format of the mask is determined automatically based on its structure: - If a mask contains multiple disconnected components or holes, it will be saved using the Run-Length Encoding (RLE) format for efficient storage and processing. - If a mask consists of a single, contiguous region without any holes, it will be encoded as a polygon, preserving the outline of the object. This automatic selection ensures that the masks are stored in the most appropriate and space-efficient format, complying with COCO dataset standards. Args: images_directory_path: The path to the directory where the images should be saved. If not provided, images will not be saved. annotations_path: The path to COCO annotation file. min_image_area_percentage: The minimum percentage of detection area relative to the image area for a detection to be included. Argument is used only for segmentation datasets. max_image_area_percentage: The maximum percentage of detection area relative to the image area for a detection to be included. Argument is used only for segmentation datasets. approximation_percentage: The percentage of polygon points to be removed from the input polygon, in the range [0, 1). This is useful for simplifying the annotations. Argument is used only for segmentation datasets. starting_image_id: First image id to assign in the exported file. Defaults to ``1``. Override when exporting multiple splits into a coordinated COCO collection so ids remain unique across the set (see example below). starting_annotation_id: First annotation id to assign in the exported file. Defaults to ``1``. Override for the same multi-split reason as ``starting_image_id``. Returns: A ``(next_image_id, next_annotation_id)`` tuple containing the first unused ids after this export. Feed them straight back into ``starting_image_id`` and ``starting_annotation_id`` on the next split so ids stay globally unique. When ``annotations_path`` is ``None`` (images-only export) the starting ids are returned unchanged so chaining still composes. Example: ```python # Exporting train, valid, and test splits with non-colliding ids # so the three annotation files can later be merged into one COCO. next_image_id, next_annotation_id = train_ds.as_coco( images_directory_path="out/train/images", annotations_path="out/train/annotations.json", ) next_image_id, next_annotation_id = valid_ds.as_coco( images_directory_path="out/valid/images", annotations_path="out/valid/annotations.json", starting_image_id=next_image_id, starting_annotation_id=next_annotation_id, ) _, _ = test_ds.as_coco( images_directory_path="out/test/images", annotations_path="out/test/annotations.json", starting_image_id=next_image_id, starting_annotation_id=next_annotation_id, ) # return value not needed — no further split ``` r)r~annotation_pathrrrstarting_image_idstarting_annotation_id)rr )r!rrrrrrrs r"as_cocozDetectionDataset.as_cocorsQf ! , 4I   '( 0*C*C)A"3'= !"888r$)r8 list[str]rE,list[str] | dict[str, npt.NDArray[np.uint8]]rzdict[str, Detections]r+NonerOstrr+znpt.NDArray[np.uint8]r*)r[r,r+z-tuple[str, npt.NDArray[np.uint8], Detections])r+z7Iterator[tuple[str, npt.NDArray[np.uint8], Detections]]riobjectr+r0r-)r&r.r'r/r(r0r+z)tuple[DetectionDataset, DetectionDataset])rzlist[DetectionDataset]r+r5)NNrrr) r str | Nonerrrr.rr.rr.r+r)F)rrrrrr0r+r5)FF) rrrrrrrr0rr0r+r5)NNNrrrF)rrrrrrrr.rr.rr.rr0r+r)rrrrrr0r+r5)NNrrrr)rrrrrr.rr.rr.rr,rr,r+ztuple[int, int])r1r2r3__doc__rHrQr#r\rbrjr) classmethodrrrrrrrrr$r"r5r58s"FF=F+ F  F6D - 00!#' G+G+!G+ G+ 3 G+Ra a J-115+.+.*- 7,)7,%/7,$) 7, $) 7, #( 7, 7,r " 3 "3 %(3  3  3 3 j " < "< %(<  <  <  <  < < @-115%)+.+.*-GP)GP%/GP# GP $) GP $) GP#(GPGP GPR " .Y".Y.Y .Y  .Y.Yd-1'++.+.*-!"&'a9)a9%a9$) a9 $) a9 #( a9a9!$a9 a9r$r5ceZdZdZ d dZd dZddZddZ ddZddZ d dd Z dd Z e dd Z y)ClassificationDatasetag Contains information about a classification dataset, handles lazy image loading, dataset splitting. Attributes: classes: List containing dataset class names. images: List of image paths or dictionary mapping image name to image data. annotations: Dictionary mapping image name to annotations. c||_t|t|k7r td||_t t j ||_i|_t|t r||_tdyy)Nr7zPassing a `Dict[str, np.ndarray]` into `ClassificationDataset` is deprecated and will be removed in a future release. Use a list of paths `List[str]` instead.) r8r9r:rr@rArBrCrDrfr)r!r8rErs r"rHzClassificationDataset.__init__sz  v;#k* *Q '  f 56CE fd #%+D " 7  $r$c|jr|j|Stj|}|td||SrJrKrNs r"rQz ClassificationDataset._get_imagerRr$cZt|jxst|jSrrTr s r"r#zClassificationDataset.__len__rVr$cj|j|}|j|}|j|}|||fSrXrYrZs r"r\z!ClassificationDataset.__getitem__ r]r$c#^Ktt|D]}||\}}}|||fywr_r`rZs r"rbzClassificationDataset.__iter__s=s4y! 0A,0G )JzeZ/ / 0rcct|tsyt|jt|jk7ry|j|jk7ry|j s |j rYt jt|j jt|j jsy|j|jk7ryyre) rfrr9r8rCrDr;rgr@r=rrhs r"rjzClassificationDataset.__eq__"s%!67 t|| EMM 2 2   u00 0  ! !U%<%<>>T++2245U,,3356   u00 0r$Nct|j|||\}}|jr;|Dcic]}||j|}}|Dcic]}||j|}}n|}|}|Dcic]}||j|} }|Dcic]}||j|} }t |j || } t |j || } | | fScc}wcc}wcc}wcc}w)a" Splits the dataset into two parts (training and testing) using the provided split_ratio. Args: split_ratio: The ratio of the training set to the entire dataset. random_state: The seed for the random number generator. This is used for reproducibility. shuffle: Whether to shuffle the data before splitting. Returns: A tuple containing the training and testing datasets. Examples: ```pycon >>> import numpy as np >>> import supervision as sv >>> cd = sv.ClassificationDataset( ... classes=['cat', 'dog'], ... images={ ... 'img1.jpg': np.zeros((100, 100, 3), dtype=np.uint8), ... 'img2.jpg': np.zeros((100, 100, 3), dtype=np.uint8), ... }, ... annotations={ ... 'img1.jpg': sv.Classifications(class_id=np.array([0])), ... 'img2.jpg': sv.Classifications(class_id=np.array([1])), ... } ... ) >>> train_cd, test_cd = cd.split(split_ratio=0.5, random_state=42) >>> len(train_cd), len(test_cd) (1, 1) ``` rlrn)rrCrDrrr8ros r"r)zClassificationDataset.split8sT#3!!#% #  Z  ! !JUV$4!7!7!==VKVIST$ 6 6t <<TJT%K#JFQRdT4#3#3D#99RREOPTD$"2"24"88PP-LL) -LL( l**'WTSPryctj|d|jD]7}tjtjj ||d9|D]\}}}t |j }|j|jdn|jddd}|j|}tjj |||}tj||y)z Saves the dataset as a multi-class folder structure. Args: root_directory_path: The path to the directory where the dataset will be saved. T)rNrr) rmakedirsr8rrrr r confidencer> get_top_krLimwrite)r!root_directory_path class_nameimage_save_pathrPrGrr>s r"as_folder_structurez)ClassificationDataset.as_folder_structures '$7,, VJ KK %8*EPT U V37 0 .OUJo.33J((0##A&))!,Q/2  h/J ggll+> JWO KK / 0r$c tj|}tt|}g}i}|D]}|j |}tjtj j ||D]`}ttj j |||}|j|ttj|g||<b||||S)a Load data from a multiclass folder structure into a ClassificationDataset. Args: root_directory_path: The path to the dataset directory. Returns: The dataset. Examples: ```python import roboflow from roboflow import Roboflow import supervision as sv roboflow.login() rf = Roboflow() project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID) dataset = project.version(PROJECT_VERSION).download("folder") cd = sv.ClassificationDataset.from_folder_structure( root_directory_path=f"{dataset.location}/train" ) ``` )r>rn) rlistdirsortedr9indexrrrrappendr r;r<) rrr8rCrrr>rPrOs r"from_folder_structurez+ClassificationDataset.from_folder_structures8**01W&  ! J}}Z0HBGGLL1Dj$QR  .A:u!UV "":.*9XXxj1+ J'  #  r$)r8rrErrzdict[str, Classifications]r+rrr*)r[r,r+z2tuple[str, npt.NDArray[np.uint8], Classifications])r+zrs" #$! ;4 267  #  [ 9{[ 9| r Kr  r r$