^jWBddlmZddlZddlmZddlmZddlmZm Z ddl Z ddl Z erddl mZddlmZmZddlmZdd lmZmZmZmZdd lmZmZmZd d gZd dgZddgZhdZ d/dZ!d0dZ"d/dZ#d1dZ$d2dZ%d3dZ&d4dZ'edGddZ(GddZ)dd d5d Z* d6d!Z+d"dd# d7d$Z,d8d%Z-d8d&Z. d9d'Z/ d: d;d(Z0d) annotationsN) dataclass)Path) TYPE_CHECKINGAny Detections)Image ImageDraw) VisionDataset)YoloKeypointSchema#_extract_yolo_class_names_from_data_load_yaml_mappinginfer_yolo_keypoint_schema)%_resolve_runtime_augmentation_backendmake_coco_transforms"make_coco_transforms_square_div_64 data.yamlzdata.ymltrainvalidimageslabels> .bmp.dng.jpg.mpo.png.tif.jpeg.tiff.webpc "|\}}}}tjt|t|dz z t|t|dz z t|t|dz zt|t|dz zgtjS)zDParse a YOLO center-width-height box into relative XYXY coordinates.dtype)nparrayfloatfloat32)valuesx_centery_centerwidthheights _/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/rfdetr/datasets/yolo.py_parse_yolo_boxr0(s(.%Hhv 88 (OeElQ. . (OeFma/ / (OeElQ. . (OeFma/ /  jj ctj|d|dg|d|dg|d|dg|d|dggtjS)z4Convert a relative XYXY box into a 4-corner polygon.rr#r$)r&r'r))boxs r/_box_to_polygonr66sZ 88 a&#a& CFCF+c!fc!f-=AA?OPjj r1cltj|tjjddS)z7Parse a flattened YOLO polygon into relative XY points.r$r#)r&r'r)reshape)r*s r/_parse_yolo_polygonr:>s$ 88F"** - 5 5b! <z)_list_yolo_image_paths..^s:  <<>dkk//15JJ D sAA)sortedriterdir)images_directory_paths r/_list_yolo_image_pathsr]\s+ ./779 r1cFt|}t|}t||S)z0Read class names from a YOLO ``data.yaml`` file.)rrr) data_filerXdatas r/_extract_yolo_class_namesraes"  ?D d #D .tT ::r1T)frozenc`eZdZUdZded<ded<ded<ded<ded <d ed <ded <dd Zy)_LazyYoloSampleaqLightweight per-image YOLO metadata with polygons kept lazy until fetch time. Note: ``frozen=True`` prevents field *reassignment* but does NOT prevent in-place mutation of ``np.ndarray`` fields (e.g. ``sample.xyxy[0] = 999.0`` would silently succeed). This is safe across DataLoader workers because each worker receives a pickled copy of the dataset. rV image_pathintr-r. np.ndarrayxyxyclass_idtuple[np.ndarray, ...]rM keypointscbddlm}t|jdk(r|jSt|j dk(r||j|j St|j |j|jf}||j|j |S)zFMaterialize the current sample as a supervision ``Detections`` object.rr)rirh)rirhrF) supervisionr rJriemptyrMrhrNr-r.)selfr rFs r/ to_detectionsz_LazyYoloSample.to_detections}s* t}}  "#:##% % t}}  "t}}499E E"$--$**dkk1JK4==tyytLLr1N)returnz 'Detections')__name__ __module__ __qualname____doc____annotations__rpr1r/rdrdls6O J K $$Mr1rdc0eZdZdZddZddZd dZd dZy) _LazyYoloDetectionDatasetzMLazy YOLO dataset that defers dense mask rasterization until ``__getitem__``.c ||_||_yrQ)classes_samples)ror{sampless r/__init__z"_LazyYoloDetectionDataset.__init__s  r1c,t|jSrQ)rJr|ros r/__len__z!_LazyYoloDetectionDataset.__len__s4==!!r1c|j|} tj|j5}t j |j d}ddd|j|jfS#1swY&xYw#tttjf$r}td|j|d}~wwxYw)NRGBz Could not read image from path: ) r|r openrer&r'convertFileNotFoundErrorOSErrorUnidentifiedImageError ValueErrorrp)roidxsampleimage rgb_imageexcs r/ __getitem__z%_LazyYoloDetectionDataset.__getitem__ss# ^F--. ;%HHU]]5%9:  ;  )V-A-A-CCC  ; ;!7E,H,HI ^?@Q@Q?RSTZ] ] ^s.B%A:B:B?BC$B==Cc |j|S)zBReturn lightweight metadata without loading pixels or dense masks.)r|)rors r/get_image_infoz(_LazyYoloDetectionDataset.get_image_infos}}S!!r1N)r{ list[str]r}zlist[_LazyYoloSample]rqNonerqrf)rrfrqz$tuple[str, np.ndarray, 'Detections'])rrfrqrd)rrrsrtrur~rrrrwr1r/ryrysW "D"r1ryparse_polygonsc t|dkr'tdt|d|dt|dt|dkDr>t|dddzd k7r*td t|d|d t|ddd  t|d }|d ks||k\r'td t|d|d|d|d|dz d t|dk(rt |dd} |r t | nd} n t |dd} tjtj| ddd ftj| dddftj| ddd ftj| dddfgtj} |r| nd} | tj||||gtjz} | || dfS| tj||gtjz} tj| ddd fdt|dz | ddd f<tj| dddfdt|dz | dddf<|| | jtjfS#t$r'}td t|d|d|d d|d}~wwxYw#t$r!}td t|d|d|d}~wwxYw)aParse one YOLO label line and return ``(class_id, xyxy_px, polygon_px)``. Args: values: Whitespace-split fields from the label line. line_num: 1-based line number (for error messages). label_path: Path to the label file (for error messages). num_classes: Total number of classes in the dataset (used for range check). width: Image width in pixels. height: Image height in pixels. parse_polygons: When ``False`` the pixel-space polygon array is not computed or returned (``polygon_px`` will be ``None``). Set to ``False`` on the detection-only path to avoid allocating polygon arrays that would immediately be discarded. Returns: Tuple of ``(class_id, xyxy_px, polygon_px)`` where coordinates are in pixel space. ``polygon_px`` is ``None`` when ``parse_polygons=False``. Raises: ValueError: If the line is malformed or the class ID is out of range. zMalformed label in at line uc: expected 5 (bbox) fields or ≥ 7 fields for polygons (class_id + at least 3 (x, y) points), got .r3Nr#rzMalformed polygon in z<: polygon coordinates must be paired (x, y) values, but got z coordinate values (odd count).zLabel z line z: invalid class ID z (must be an integer).z : class ID z" is out of range for dataset with u classes (valid range 0–z).z.: could not parse coordinate values as floats.r$)rJrrVrfr0r6r:r&r'minmaxr)clipr(astype)r*line_num label_path num_classesr-r.rcidrr5rA _raw_polygonxyxy_px polygon_pxs r/_parse_yolo_label_liners< 6{Q!#j/!4IhZH::=f+a I   6{Q3vabz?Q.!3#C O#6izJ6!":''F H  &)n Qw#$S_'vhZ8u>{mL##.?"32 7   6{afQRj)=K_S%9QU .vabz:L hh|AqD)*|AqD)*|AqD)*|AqD)*   ** #1,dBHHeVUF;2::NNGGT!!288UFO2::FFJwwz!Q$/eEAI6FGJq!twwz!Q$/eFQJ6GHJq!t **2::6 66Y S_'vhZ7J6RS9-Wm n  * 'J':)H:N?@  s0I5/J(5 J%>"J  J%( K1K  Kcd||zz}t||k7rIt|dk(r|dkDrdnd} tdt|d|d|d|d |d t|d | t|d d|||||d \} } } t j |dd tj j||} t j| jstdt|d|d| d d d df}t j|dftj }|dk(re| d d df}t j|dk|dkDzrtdt|d|dt j|dd|||d d df<n\|d d dfdk|d d dfdkz}t j|dd|d||d d f<|d d dfdk(|d d dfdk(z}d||df<|d d dft|z|d d df<|d d dft|z|d d df<|d d dfdk}d||d df<| | |fS#t$r!}tdt|d|d|d }~wwxYw)zNParse one Ultralytics YOLO pose row into pixel boxes and COCO-style keypoints.rrz This looks like a detection-only label row (5 fields). Check whether the dataset mixes detection and pose annotations or whether the kpt_shape in data.yaml is correct.zMalformed YOLO pose label in rz : expected z fields from kpt_shape=[z, z], got rNFrr$z,: could not parse keypoint values as floats.z: non-finite keypoint.r#r4rg@z/: keypoint visibility values must be in [0, 2].g?)outr3)rJrrVrr&asarrayr)r9isfiniteallrKanyrr()r*rrrr-r. num_keypoints keypoint_dimexpected_fieldshintrr_ raw_keypointsrxyrk visibility absent_2dpresentabsents r/_parse_yolo_pose_label_liners-,66O 6{o% 6{aMA$5 @ +C O+>izR'((@rR^Q_`v;-q (  -r  OC! 6!":RZZ@HHXde  ;;} % ) ) +8Z8K9U]T^^tuvv q"1"u B-+2::>Iq"1a4( 66:# S(89 :/J/B)H:V@@  C"%$ !Q$ 1X^1a437  C"%9a<1X_AqDS9: # '1*Ahu-IadOAhv.IadO q!t_ #FIfbqbj  ""M +C O+>izR9 9  s:8H:: I$II$F)include_keypointskeypoint_schemac|r |r td|r?|xs t|}|j}t|jd}|j }nt |}d}d}g} t|D]I} t|t| jdz } tj| 5} | j\} }dddg}g}g}g}| jr| jd5}|Dcgc]#}|js|j%}}dddtD]\}}|j!}|r7t#||dz| t%| || \}}}d}|j'|n"t)||dz| t%| | \}}}|j'||j'||s||j'|| j't+|  t-j.|t,j0 j3d d t-j.|t,j4 t7||r4t-j8|j;t,j0dn't-j<d|dft,j0 L|| fS#1swYxYwcc}w#1swYxYw)u>Build the class list and sample list shared by both YOLO builder functions. Iterates over every image in ``img_folder``, reads image dimensions via PIL (header-only, no full decode), and parses the matching ``.txt`` label file when present. Images without a label file are included as *background* samples with empty detections. Args: img_folder: Path to the directory containing images. lb_folder: Path to the directory containing YOLO ``.txt`` label files. data_file: Path to the ``data.yaml`` / ``data.yml`` file with class names. include_polygons: When ``True`` polygon coordinates are stored in each :class:`_LazyYoloSample` (segmentation path). When ``False`` polygon coordinates returned by :func:`_parse_yolo_label_line` are discarded and ``polygons=()`` is stored instead (detection-only path). Mutually exclusive with ``include_keypoints``. include_keypoints: When ``True`` keypoint coordinates are stored in each :class:`_LazyYoloSample` (pose path). Mutually exclusive with ``include_polygons``; raises :class:`ValueError` when both are ``True``. keypoint_schema: Keypoint schema describing class names, per-class keypoint counts, OKS sigmas, keypoint names, flip index, and keypoint dimensionality. When ``None`` and ``include_keypoints=True`` the schema is auto-inferred from ``data_file`` via :func:`infer_yolo_keypoint_schema`. Returns: A ``(classes, samples)`` tuple where ``classes`` is the ordered list of class names and ``samples`` is a list of :class:`_LazyYoloSample` objects. Examples: >>> # Used internally by _build_lazy_yolo_detection_dataset and >>> # _build_lazy_yolo_segmentation_dataset — not part of the public API. >>> pass HYOLO segmentation masks and keypoints cannot be loaded at the same time.rdefaultz.txtNzutf-8)encodingr3)rrrr$r8F)copyr4)rer-r.rhrirMrk)rr class_namesrnum_keypoints_per_classrrar]rstemr rr?existsstrip enumeratesplitrrJappendrrdr&r'r)r9int64rCrLrrK) img_folder lb_folderr_include_polygonsrrr{rrr}rerrr-r.rhrirMrkhandlelinelinesir*rr keypoints_pxrs r/_build_yolo_samplesrSsL-cdd)R-G -R!--OCCQO &33 +I6  %'G,Z88 )_$z*:*?*?)@'EE ZZ # 'u!JJME6 '"$ %'&(    '2 Jf28I$DJJLII J$U+ 04$1LA"G &3%1 2.C,"&J$$\2/EA"G '70,C*$ G$# (>OOJ/9 0<  %XXd"**5==b!D("((;x!HHY'..rzz.F1mQ"7rzzJ  U8 t G q ' 'J J Js0*J>-K2K K K>K KK c@t|||d\}}t||S)u~Build a YOLO detection dataset that stores bounding boxes lazily. Unlike :func:`_build_lazy_yolo_segmentation_dataset`, this function does not store polygon coordinates or dense masks — only ``xyxy`` boxes are retained, keeping peak memory proportional to the number of annotations. Images without a matching ``.txt`` label file are included as *background* samples with empty detections, so datasets that mix labelled and unlabelled images are handled correctly. Args: img_folder: Path to the directory containing images. lb_folder: Path to the directory containing YOLO ``.txt`` label files. data_file: Path to the ``data.yaml`` / ``data.yml`` file with class names. Returns: A :class:`_LazyYoloDetectionDataset` whose ``__getitem__`` loads pixel data on demand and returns ``sv.Detections`` without mask information. Frr{r}rryrrr_r{r}s r/"_build_lazy_yolo_detection_datasetrs'$+:y)^cdGW $Wg FFr1c@t|||d\}}t||S)aBuild a YOLO dataset that stores polygons and rasterizes masks on demand. Args: img_folder: Path to the directory containing images. lb_folder: Path to the directory containing YOLO ``.txt`` label files. data_file: Path to the ``data.yaml`` / ``data.yml`` file with class names. Returns: A :class:`_LazyYoloDetectionDataset` whose ``__getitem__`` loads pixel data on demand and rasterizes polygon masks into dense boolean tensors. Trrrrs r/%_build_lazy_yolo_segmentation_datasetrs'+:y)^bcGW $Wg FFr1cDt|||dd|\}}t||S)zDBuild a YOLO pose dataset that stores keypoints without dense masks.FT)rrrrr)rrr_rr{r}s r/!_build_lazy_yolo_keypoint_datasetrs4+' GW %Wg FFr1c ddlm}g}g}g}t|D];\}}||dd} |t|j| d<g| d<|j | =t |d} d} tt|D]N} | rr|j| } | j}| j| j}}| j}| j}t| jdkD}| j }nr|| \}}}|j"dd \}}|j}|j}|j$du}t'j(t|dd ft&j* }|j | t-|t/|t/|d tt|D]}||\}}}}t1|t1|}}t1||z t1||z }}| | t/||||||gt1||zdd } |rg| d<||t|kr||n$t'j(dt&j* }!|!j3dj5t0j7| d<t/t'j8|!ddd fdkD| d<|j | | dz } Qddi|||d}"|}#|"|#_|#j=|#S)amBuild an in-memory ``pycocotools.COCO`` object from YOLO lazy samples. Args: classes: Ordered class names where index is the YOLO class ID. dataset: Lazy YOLO backend exposing ``__len__`` and either ``get_image_info(idx)`` or ``__getitem__(idx)``. Returns: Initialized ``pycocotools.COCO`` object with ``dataset`` and indexes. r)COCOnone)idname supercategoryNrkskeletonrr#r4r$)r file_namer.r-)rimage_id category_idbboxareaiscrowd segmentation)rr4r8rr3 descriptionzRF-DETR YOLO dataset)inforr categories)pycocotools.cocorrlistkeypoint_namesrhasattrrangerJrrer.r-rhrirMrkshaperFr&rKr)rVrfr(r9rrB count_nonzerodataset createIndex)$r{rrrrrrr class_namecategory use_lazy_pathann_idimg_idrrer.r-rhri has_masksrk image_array detectionsrx1y1x2y2bbox_xbbox_ybbox_wbbox_hann keypoints_i coco_datasetcocos$ r/_build_coco_api_from_samplesrs&#%F(*K')J$W-$ZzFK  &$()G)G$HH[ !#%HZ (# $G%56M FG %' ++F3F**J"MM6<.Vs2&AJrww||K;<&AA c3K|]A}tjjtjj|CywrQr)rW split_dirrs r/rYz(is_valid_yolo_dataset..Ys2'AJrww||K;<'rc 3K|]M}tD]B}tjjtjj ||DOywrQ)REQUIRED_DATA_SUBDIRSrrXrr)rWr data_subdirrs r/rYz(is_valid_yolo_dataset..\sL) 0)  rww||KKHI)I)sAA)rREQUIRED_YOLO_YAML_FILESrREQUIRED_SPLIT_DIRS)rcontains_required_yolo_yamlcontains_required_split_dirscontains_required_data_subdirss` r/is_valid_yolo_datasetr!Lse#&&Nf&#$''Na'$ &)),)&" ' j+G jLjjr1c"eZdZdZdddZddZy) ConvertYoloaConverts supervision Detections to the target dict format expected by RF-DETR. Args: include_masks: whether to include segmentation masks. include_keypoints: whether to include pose keypoints. num_keypoints: Number of keypoints per instance when keypoints are enabled. Examples: >>> import numpy as np >>> from supervision import Detections >>> from PIL import Image >>> # Create a sample image and target >>> image = Image.new("RGB", (100, 100)) >>> detections = Detections( ... xyxy=np.array([[10, 20, 30, 40]]), ... class_id=np.array([0]) ... ) >>> target = {"image_id": 0, "detections": detections} >>> # Create converter >>> converter = ConvertYolo(include_masks=False) >>> # Call converter >>> img, result = converter(image, target) >>> sorted(result.keys()) ['area', 'boxes', 'image_id', 'iscrowd', 'labels', 'orig_size', 'size'] >>> result["boxes"].shape torch.Size([1, 4]) >>> result["labels"].tolist() [0] >>> result["image_id"].tolist() [0] c.||_||_||_yrQ include_masksrr)ror&rrs r/r~zConvertYolo.__init__s*!2*r1c|j\}}|d}tj|g}|d}t|dkDrytj|j j tj}tj|jj tj}nJtjdtj}tjdtj}|dddddfjd| |ddd ddfjd| |ddd f|ddd fkD|dddf|dddfkDz} || }|| }i} || d <|| d <|| d<|ddd f|ddd fz |dddf|dddfz z} | | d<tj|jdftj} | | d<|jr|jtj|jdkDratj|j| j!j#j tj$} | | d<n+tjd||ftj$| d<| dj'| d<|j(r|j+d}|@tj| jd|j,d ftj}n@tj.|tjj1d|j,d }|| | d<tj.t3|t3|g| d<tj.t3|t3|g| d<|| fS)zConvert image and YOLO detections to RF-DETR format. Args: image: PIL Image target: dict with 'image_id' and 'detections' Returns: tuple of (image, target_dict) rrr)rrr$)rNr#)rrr3r4boxesrrrmasksrkr8 orig_sizer?)r?torchtensorrJ from_numpyrhtor)rirrKclamp_rr&rFr&cpunumpyuint8rDrgetr as_tensorr9rf)rortargetwhrrr(r{keep target_outrrr)rrks r/__call__zConvertYolo.__call__s8zz1*%<< +L) z?Q $$Z__588GE&&z':':;>>u{{KGKKemm 6j  r1N)FFr)r&rDrrDrrf)rz Image.Imager5dictrqrC)rrrsrtrur~r:rwr1r/r#r#ds@+ A!r1r#cTeZdZdZ d dfd ZddZddZxZS) YoloDetectionuYOLO format dataset with lazy image loading and optional mask support. Both detection (``include_masks=False``) and segmentation (``include_masks=True``) paths use a lazy backend: image pixels are loaded on demand inside ``__getitem__`` rather than at construction time, which keeps peak RAM proportional to the number of annotations rather than to ``N × H × W``. Images without a matching ``.txt`` label file are treated as *background* images and produce empty detections. This ensures that datasets containing a mix of annotated and unannotated images are handled correctly in both single-GPU and multi-GPU training. This class provides a VisionDataset interface compatible with RF-DETR training, matching the API of CocoDetection. Args: img_folder: Path to the directory containing images lb_folder: Path to the directory containing YOLO annotation .txt files data_file: Path to data.yaml file containing class names and dataset info transforms: Optional transforms to apply to images and targets include_masks: Whether to load segmentation masks (for YOLO segmentation format). When True polygons are parsed and rasterized on demand; when False only bounding-box coordinates are stored. include_keypoints: Whether to load Ultralytics YOLO pose keypoints. num_keypoints_per_class: Optional keypoint schema used by RF-DETR. c\|r |r tdtt||||_||_||_|r t||_nd|_t|xsgd|_ |j0t|jj|j|_ t|||j|_|rt!||||j|_n'|rt%||||_nt'||||_|j"j(|_t+t-t/|j"|_t3|j(|j"|j|_y#tttf$r}td|d|d}~wwxYw)Nrz6YOLO keypoint training requires kpt_shape metadata in rrrr%)rsuperr=r~ _transformsr&rrrrrrrrr#preparer sv_datasetrrr{rrrJidsrr ) rorrr_ transformsr&rrr __class__s r/r~zYoloDetection.__init__s .gh h mT+J7%*!2  s'A)'L$$(D  !8!>BJ    +!$T%9%9%Q%Q[_[m[m!nD "'/,,  ?$$ DO CJPY[deDO@YXabDO.. c$//2341tPTPdPde 9&z7; s #YZcYffg!hiorr ssFF+F&&F+c,t|jSrQ)rJrBrs r/rzYoloDetection.__len__s4??##r1cV|j|}|j|\}}}tj|}||d}|jr(|jj |j |d<|j||\}}|j|j||\}}||fS)N)rrrk) rCrBr fromarrayrrrkrAr@)rorrrerrimgr5s r/rzYoloDetection.__getitem__s88C=,0OOC,@) Izooi(&jA  ! !"&//"@"@"E"O"OF; ll3/ V    '**37KCF{r1)NFFN) rrVrrVr_rVr&rDrrDrzlist[int] | Noner)rrf)rrrsrtrur~rr __classcell__)rEs@r/r=r=sg8#"'48/f/f/f /f  /f /f"2/fb$r1r=ct|jjs Jdddz dz dz dz fdz dz dz dz fdz dz dz dz fd}tfd tDd z }||j d d \}}t |d d}t |dd}t |dd} t |dd} t |dd} t |dd} t |dd} t |dd}t |dd}t |dg}|rt |dgxsgnd}tt |dd}|dk7}|r t||rCtt|t|t|t||| | | | | ||| |||}|Stt|t|t|t||| | | | | ||| |||}|S#tttf$r}td|d}~wwxYw)aBuild a Roboflow YOLO-format dataset. This uses Roboflow's standard YOLO directory structure (train/valid/test folders with images/ and labels/ subdirectories). Args: image_set: Dataset split to load. One of ``"train"``, ``"val"``, or ``"test"``. args: Argument namespace. The following attributes are consumed: ``dataset_dir``, ``square_resize_div_64``, ``aug_config``, ``segmentation_head``, ``multi_scale``, ``expanded_scales``, ``do_random_resize_via_padding``, ``patch_size``, ``num_windows``. ``aug_config`` is forwarded to the transform builder; when ``None`` the builder falls back to the default :data:`~rfdetr.datasets.aug_configs.AUG_CONFIG`. resolution: Target square resolution in pixels. Returns: A :class:`YoloDetection` dataset instance ready for use with a DataLoader. zprovided Roboflow path z does not existrrrrtest)rvalrLc3PK|]}|z js|z ywrQ)r)rWfroots r/rYz+build_roboflow_from_yolo..Is$X1TAXDUDUDWdQhXs& &rrrsquare_resize_div_64Fsegmentation_head multi_scaleexpanded_scalesNdo_random_resize_via_padding patch_size num_windows aug_configuse_grouppose_keypointsrkeypoint_flip_pairsaugmentation_backendr0zeYOLO keypoint training requires an Ultralytics pose data.yaml/data.yml with valid kpt_shape metadata.)rSrTskip_random_resizerVrWrXgpu_postprocessrZ)rrr_rDr&rr)rrrnextrrgetattrrrrrrr=rVrr) image_setargs resolutionPATHSr_rrrQr&rSrTrUrVrWrXrrrZresolved_augmentation_backendr]rrrPs @r/build_roboflow_from_yolore+s&   !D ;;=I3D6II=.8+TG^h-FGw)4'>H+DE)4&=8+CD EX(@XZ^alZlmI!)//#"6q"9:J "4)?GD"5u=M$ u5Kd$5trpsu# !% & .  (4(!8,c = & X; $!M!M!MH""@ X7 X7X7X7 X7  X7  X7X7/X7vL# L#L#L# L#  L#  L#L#L#(L#j$15mmmm  m  m/m-m`G, G GGGG( G  G*26N N N/N Nbk0g!g!TZMZzbr1