§
    ­¸j3º  ã                  ó–  — d dl mZ d dlZd dlmZ d dlmZ d dlmZm	Z	 d dl
Zd dlZd dlZerd dlmZ d dlmZ d dlmZmZmZ d d	lmZ d d
lmZ d dlmZ d dlmZmZmZm Z  d dl!m"Z" d dl#m$Z$m%Z% d dl&m'Z' d dl(m)Z)m*Z* d dl+m,Z,  e,¦   «         Z-ddgZ.dZ/ddgZ0h d£Z1 G d„ de2¦  «        Z3dld„Z4dmd „Z5dld!„Z6dnd&„Z7dod)„Z8dpd,„Z9dqd.„Z: ed/¬0¦  «         G d1„ d2¦  «        ¦   «         Z; G d3„ d4¦  «        Z<d/d5œdrd@„Z=dsdD„Z>dEddFœdtdN„Z?dudO„Z@dudP„ZAdvdR„ZB	 dwdxdV„ZCdydX„ZDdzd\„ZEdzd]„ZFd{d_„ZGd|dc„ZH G dd„ de¦  «        ZI G df„ dge¦  «        ZJd}dk„ZKdS )~é    )ÚannotationsN)Ú	dataclass)ÚPath)ÚTYPE_CHECKINGÚAny©Ú
Detections)ÚNDArray)ÚImageÚ	ImageDrawÚUnidentifiedImageError)ÚVisionDataset)Ú
MultiScale)Úresolve_keypoint_flip_pairs)ÚYoloKeypointSchemaÚ#_extract_yolo_class_names_from_dataÚ_load_yaml_mappingÚinfer_yolo_keypoint_schema)ÚCompose)Úmake_coco_transformsÚ"make_coco_transforms_square_div_64)Údecode_image)Úis_gpu_postprocessÚresolve_backend_for_build)Ú
get_loggerú	data.yamlzdata.yml)ÚvalidÚvalÚimagesÚlabels>	   ú.bmpú.dngú.jpgú.mpoú.pngú.tifú.jpegú.tiffú.webpc                  ó   — e Zd ZdZdS )ÚYoloSplitUnavailableErrorzFSignal that a requested YOLO split has no image directory to evaluate.N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__© ó    úd/root/private/project/pallet_detection_v2/.venv/lib/python3.11/site-packages/rfdetr/datasets/yolo.pyr+   r+   1   s   € € € € € ØPÐPÐPÐPr1   r+   Úvaluesú	list[str]ÚreturnúNDArray[np.float32]c           	     óX  — | \  }}}}t          j        t          |¦  «        t          |¦  «        dz  z
  t          |¦  «        t          |¦  «        dz  z
  t          |¦  «        t          |¦  «        dz  z   t          |¦  «        t          |¦  «        dz  z   gt           j        ¬¦  «        S )zDParse a YOLO center-width-height box into relative XYXY coordinates.é   ©Údtype)ÚnpÚarrayÚfloatÚfloat32)r3   Úx_centerÚy_centerÚwidthÚheights        r2   Ú_parse_yolo_boxrC   5   s™   € à(.Ñ%€Hˆh˜˜vÝŒ8å�(‰OŒO�e E™lœl¨QÑ.Ñ.Ý�(‰OŒO�e F™mœm¨aÑ/Ñ/Ý�(‰OŒO�e E™lœl¨QÑ.Ñ.Ý�(‰OŒO�e F™mœm¨aÑ/Ñ/ð		
õ Œjðñ ô ð r1   Úboxc                óº   — t          j        | d         | d         g| d         | d         g| d         | d         g| d         | d         ggt           j        ¬¦  «        S )z4Convert a relative XYXY box into a 4-corner polygon.r   é   r8   é   r9   )r;   r<   r>   )rD   s    r2   Ú_box_to_polygonrH   C   s`   € åŒ8Ø
ˆaŒ&�#�a”&Ð	˜C œF C¨¤FÐ+¨c°!¬f°c¸!´fÐ-=ÀÀAÄÈÈAÌÐ?OÐPÝŒjðñ ô ð r1   c                ój   — t          j        | t           j        ¬¦  «                             dd¦  «        S )z7Parse a flattened YOLO polygon into relative XY points.r9   éÿÿÿÿr8   )r;   r<   r>   Úreshape)r3   s    r2   Ú_parse_yolo_polygonrL   K   s)   € åŒ8�F¥"¤*Ð-Ñ-Ô-×5Ò5°b¸!Ñ<Ô<Ð<r1   ÚpolygonÚresolution_whútuple[int, int]úNDArray[np.bool_]c                ó  — |\  }}t          j        d||fd¦  «        }| j        dk    rEt          j        |¦  «                             d„ |                      ¦   «         D ¦   «         d¬¦  «         t          j        |t          ¬¦  «        S )zËRasterize a polygon into a dense boolean mask.

    TODO: remove once supervision ships a direct CompactMask.from_polygon factory;
    at that point the dense intermediate array is no longer needed.
    ÚLr   c                ó,   — g | ]}t          |¦  «        ‘ŒS r0   )Útuple)Ú.0Úpoints     r2   ú
<listcomp>z$_polygon_to_mask.<locals>.<listcomp>Y   s   € Ð%QÐ%QÐ%Q°u¥e¨E¡l¤lÐ%QÐ%QÐ%Qr1   rF   )Úfillr9   )
r   ÚnewÚsizer   ÚDrawrM   Útolistr;   r<   Úbool)rM   rN   rA   rB   Úmasks        r2   Ú_polygon_to_maskr_   P   sƒ   € ð "�M€Eˆ6ÝŒ9�S˜5 &˜/¨1Ñ-Ô-€DØ„|�aÒÐÝŒ�tÑÔ×$Ò$Ð%QÐ%QÀÇÂÑ@PÔ@PÐ%QÑ%QÔ%QÐXYÐ$ÑZÔZÐZÝŒ8�D¥Ð%Ñ%Ô%Ð%r1   Úpolygonsútuple[NDArray[np.float32], ...]c                ó°   ‡— t          | ¦  «        dk    r#‰\  }}t          j        d||ft          ¬¦  «        S t          j        ˆfd„| D ¦   «         ¦  «        S )záRasterize per-instance polygons into an ``(N, H, W)`` boolean array.

    TODO: remove once supervision ships a direct CompactMask.from_polygon factory;
    at that point the dense intermediate array is no longer needed.
    r   r9   c                ó0   •— g | ]}t          |‰¦  «        ‘ŒS r0   )r_   )rU   rM   rN   s     €r2   rW   z&_polygons_to_masks.<locals>.<listcomp>f   s$   ø€ ÐVÐVÐVÀ'Õ% g¨}Ñ=Ô=ÐVÐVÐVr1   )Úlenr;   Úzerosr]   Ústack)r`   rN   rA   rB   s    `  r2   Ú_polygons_to_masksrg   ]   s`   ø€ õ ˆ8�}„}˜ÒÐØ%‰ˆˆvÝŒx˜˜F EÐ*µ$Ð7Ñ7Ô7Ð7ÝŒ8ÐVÐVÐVÐVÈXÐVÑVÔVÑWÔWÐWr1   Úimages_directory_pathÚstrc                ór   — t          d„ t          | ¦  «                             ¦   «         D ¦   «         ¦  «        S )z(List YOLO image files in a stable order.c              3  óœ   K  — | ]G}|                      ¦   «         r1|j                             ¦   «         t          v ¯6t	          |¦  «        V — ŒHd S ©N)Úis_fileÚsuffixÚlowerÚYOLO_IMAGE_EXTENSIONSri   )rU   Úpaths     r2   ú	<genexpr>z)_list_yolo_image_paths.<locals>.<genexpr>k   s`   è è € ð ð àØ�<Š<‰>Œ>ðð #œk×/Ò/Ñ1Ô1Õ5JÐJÐJõ 	ˆD‰	Œ	àJÐJÐJÐJðð r1   )Úsortedr   Úiterdir)rh   s    r2   Ú_list_yolo_image_pathsru   i   sE   € åð ð åÐ.Ñ/Ô/×7Ò7Ñ9Ô9ðñ ô ñ ô ð r1   Ú	data_filec                ó^   — t          | ¦  «        }t          |¦  «        }t          ||¦  «        S )z0Read class names from a YOLO ``data.yaml`` file.)r   r   r   )rv   rq   Údatas      r2   Ú_extract_yolo_class_namesry   r   s*   € å�	‰?Œ?€DÝ˜dÑ#Ô#€DÝ.¨t°TÑ:Ô:Ð:r1   T)Úfrozenc                  ób   — e Zd ZU dZded<   ded<   ded<   ded<   d	ed
<   ded<   ded<   dd„ZdS )Ú_LazyYoloSampleaq  Lightweight 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.
    ri   Ú
image_pathÚintrA   rB   r6   ÚxyxyzNDArray[np.int64]Úclass_idra   r`   Ú	keypointsr5   r	   c                ó,  — ddl m} t          | j        ¦  «        dk    r |j        ¦   «         S t          | j        ¦  «        dk    r || j        | j        ¬¦  «        S t          | j        | j        | j	        f¦  «        } || j        | j        |¬¦  «        S )zFMaterialize the current sample as a supervision ``Detections`` object.r   r   )r€   r   )r€   r   r^   )
Úsupervisionr	   rd   r€   Úemptyr`   r   rg   rA   rB   )Úselfr	   r^   s      r2   Úto_detectionsz_LazyYoloSample.to_detectionsŠ   sŸ   € à*Ð*Ð*Ð*Ð*Ð*åˆtŒ}ÑÔ Ò"Ð"Ø#�:Ô#Ñ%Ô%Ð%ÝˆtŒ}ÑÔ Ò"Ð"à�: t¤}¸4¼9ÐEÑEÔEÐEõ " $¤-°$´*¸d¼kÐ1JÑKÔKˆØˆz 4¤=°t´yÀtÐLÑLÔLÐLr1   N)r5   r	   )r,   r-   r.   r/   Ú__annotations__r†   r0   r1   r2   r|   r|   y   s‡   € € € € € € ðð ð €O€O�OØ€J€J�JØ€K€K�KØÐÐÑØÐÐÑØ-Ð-Ð-Ñ-Ø"Ð"Ð"Ñ"ðMð Mð Mð Mð Mð Mr1   r|   c                  ó2   — e Zd ZdZdd„Zdd
„Zdd„Zdd„ZdS )Ú_LazyYoloDetectionDatasetzMLazy YOLO dataset that defers dense mask rasterization until ``__getitem__``.Úclassesr4   Úsamplesúlist[_LazyYoloSample]r5   ÚNonec                ó"   — || _         || _        d S rl   )rŠ   Ú_samples)r…   rŠ   r‹   s      r2   Ú__init__z"_LazyYoloDetectionDataset.__init__¡   s   € ØˆŒØˆŒˆˆr1   r~   c                ó*   — t          | j        ¦  «        S rl   )rd   r�   ©r…   s    r2   Ú__len__z!_LazyYoloDetectionDataset.__len__¥   s   € Ý�4”=Ñ!Ô!Ð!r1   Úidxú)tuple[str, NDArray[np.uint8], Detections]c                ó  — | j         |         }	 t          t          |j        ¦  «        ¦  «        \  }}n7# t          t
          t          f$ r}t          d|j        › �¦  «        |‚d }~ww xY w|j        ||                     ¦   «         fS )Nz Could not read image from path: )	r�   r   r   r}   ÚFileNotFoundErrorÚOSErrorr   Ú
ValueErrorr†   )r…   r”   ÚsampleÚ	rgb_imageÚ_Úexcs         r2   Ú__getitem__z%_LazyYoloDetectionDataset.__getitem__¨   s–   € Ø”˜sÔ#ˆð	^Ý'­¨VÔ->Ñ(?Ô(?Ñ@Ô@‰LˆI�q�qøÝ!¥7Õ,BÐCð 	^ð 	^ð 	^ÝÐSÀÔ@QÐSÐSÑTÔTÐZ]Ð]øøøøð	^øøøàÔ  )¨V×-AÒ-AÑ-CÔ-CÐCÐCs   �$4 ´A(ÁA#Á#A(r|   c                ó   — | j         |         S )zBReturn lightweight metadata without loading pixels or dense masks.)r�   )r…   r”   s     r2   Úget_image_infoz(_LazyYoloDetectionDataset.get_image_info°   s   € àŒ}˜SÔ!Ð!r1   N)rŠ   r4   r‹   rŒ   r5   r�   ©r5   r~   )r”   r~   r5   r•   )r”   r~   r5   r|   )r,   r-   r.   r/   r�   r“   rž   r    r0   r1   r2   r‰   r‰   ž   sn   € € € € € ØWÐWð ð  ð  ð  ð"ð "ð "ð "ðDð Dð Dð Dð"ð "ð "ð "ð "ð "r1   r‰   ©Úparse_polygonsÚline_numr~   Ú
label_pathr   Únum_classesrA   rB   r£   r]   ú;tuple[int, NDArray[np.float32], NDArray[np.float32] | None]c               óœ  — t          | ¦  «        dk     r3t          dt          |¦  «        ›d|› dt          | ¦  «        › d�¦  «        ‚t          | ¦  «        dk    rYt          | dd…         ¦  «        dz  d	k    r;t          d
t          |¦  «        ›d|› dt          | dd…         ¦  «        › d�¦  «        ‚	 t          | d	         ¦  «        }n?# t          $ r2}t          dt          |¦  «        ›d|› d| d	         ›d�¦  «        |‚d}~ww xY w|d	k     s||k    r/t          dt          |¦  «        ›d|› d|› d|› d|dz
  › d�¦  «        ‚t          | ¦  «        dk    r+t	          | dd…         ¦  «        }	|rt          |	¦  «        nd}
né	 t          | dd…         ¦  «        }n6# t          $ r)}t          d
t          |¦  «        ›d|› d�¦  «        |‚d}~ww xY wt          j        t          j	        |dd…d	f         ¦  «        t          j	        |dd…df         ¦  «        t          j
        |dd…d	f         ¦  «        t          j
        |dd…df         ¦  «        gt          j        ¬¦  «        }	|r|nd}
|	t          j        ||||gt          j        ¬¦  «        z  }|
€||dfS |
t          j        ||gt          j        ¬¦  «        z  }t          j        |dd…d	f         dt          |dz
  ¦  «        ¦  «        |dd…d	f<   t          j        |dd…df         dt          |dz
  ¦  «        ¦  «        |dd…df<   |||                     t          j        ¦  «        fS )aÍ  Parse 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.
    é   zMalformed label in ú	 at line uc   : expected 5 (bbox) fields or â‰¥ 7 fields for polygons (class_id + at least 3 (x, y) points), got ú.rF   Nr8   r   zMalformed polygon in z<: polygon coordinates must be paired (x, y) values, but got z coordinate values (odd count).zLabel 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.r9   ç        )rd   r™   ri   r~   rC   rH   rL   r;   r<   ÚminÚmaxr>   Úclipr=   Úastype)r3   r¤   r¥   r¦   rA   rB   r£   Úcidr�   rD   rM   Ú_raw_polygonÚxyxy_pxÚ
polygon_pxs                 r2   Ú_parse_yolo_label_linerµ   µ   s"  € õ< ˆ6�{„{�Q‚€ÝðI¥# j¡/¤/ð Ið I¸hð Ið Iå:=¸f¹+¼+ðIð Ið Iñ
ô 
ð 	
õ
 ˆ6�{„{�Q‚€�3˜v a b bœz™?œ?¨QÑ.°!Ò3Ð3ÝðH¥C¨
¡O¤Oð Hð HÀð Hð Hå˜6 ! " "œ:‘”ðHð Hð Hñ
ô 
ð 	
ð
Ý�&˜”)‰nŒnˆˆøÝð ð ð ÝØn•S˜‘_”_ÐnÐn¨hÐnÐnÈ6ÐRSÌ9ÐnÐnÐnñ
ô 
àð	øøøøðøøøð ˆQ‚w€w�#˜Ò$Ð$Ýð7•S˜‘_”_ð 7ð 7¨hð 7ð 7Øð7ð 7Ø?Jð7ð 7à#.°¡?ð7ð 7ð 7ñ
ô 
ð 	
õ
 ˆ6�{„{�aÒÐÝ˜f Q R RœjÑ)Ô)ˆàFTÐ.^­o¸cÑ.BÔ.BÐ.BÐZ^ˆˆð	Ý.¨v°a°b°b¬zÑ:Ô:ˆLˆLøÝð 	ð 	ð 	Ýð@­¨J©¬ð @ð @ÀHð @ð @ð @ñô ð ðøøøøð	øøøõ
 Œhå”�| A A A q DÔ)Ñ*Ô*Ý”�| A A A q DÔ)Ñ*Ô*Ý”�| A A A q DÔ)Ñ*Ô*Ý”�| A A A q DÔ)Ñ*Ô*ð	õ ”*ð
ñ 
ô 
ˆð #1Ð:�,�,°dˆØ•B”H˜e V¨U°FÐ;Å2Ä:ÐNÑNÔNÑN€GØ€Ø�G˜TÐ!Ð!Ø�2œ8 U¨F O½2¼:ÐFÑFÔFÑF€JÝ”w˜z¨!¨!¨!¨Q¨$Ô/°µe¸EÀA¹IÑ6FÔ6FÑGÔG€Jˆqˆqˆq�!ˆtÑÝ”w˜z¨!¨!¨!¨Q¨$Ô/°µe¸FÀQ¹JÑ6GÔ6GÑHÔH€Jˆqˆqˆq�!ˆtÑØ�˜×*Ò*­2¬:Ñ6Ô6Ð6Ð6s0   Â4C
 Ã

DÃ-DÄDÆF Æ
GÆ%$G	Ç	GÚnum_keypointsÚkeypoint_dimú4tuple[int, NDArray[np.float32], NDArray[np.float32]]c               ó–  — d||z  z   }t          | ¦  «        |k    r[t          | ¦  «        dk    r|dk    rdnd}	t          dt          |¦  «        ›d|› d|› d|› d	|› d
t          | ¦  «        › d|	› �¦  «        ‚t          | dd…         |||||d¬¦  «        \  }
}}	 t	          j        | dd…         t          j        ¬¦  «                             ||¦  «        }n6# t          $ r)}t          dt          |¦  «        ›d|› d�¦  «        |‚d}~ww xY wt	          j        |¦  «         	                    ¦   «         s#t          dt          |¦  «        ›d|› d�¦  «        ‚|dd…dd…f         }t	          j
        |dft          j        ¬¦  «        }|dk    rp|dd…df         }t	          j        |dk     |dk    z  ¦  «        r#t          dt          |¦  «        ›d|› d�¦  «        ‚t	          j        |dd|¬¦  «         ||dd…df<   nk|dd…df         dk     |dd…df         dk     z  }t	          j        |dd|¬¦  «         d||dd…f<   |dd…df         dk    |dd…df         dk    z   }d||df<   |dd…df         t          |¦  «        z  |dd…df<   |dd…df         t          |¦  «        z  |dd…df<   |dd…df         dk    }d||dd…f<   |
||fS )zNParse one Ultralytics YOLO pose row into pixel boxes and COCO-style keypoints.r©   r   z¨ 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.Ú zMalformed YOLO pose label in rª   z: expected z fields from kpt_shape=[z, z], got r«   NFr¢   r9   z,: could not parse keypoint values as floats.z: non-finite keypoint.r8   rG   r¬   g       @z/: keypoint visibility values must be in [0, 2].g      ð?)ÚoutrF   )rd   r™   ri   rµ   r;   Úasarrayr>   rK   ÚisfiniteÚallre   Úanyr¯   r=   )r3   r¤   r¥   r¦   rA   rB   r¶   r·   Úexpected_fieldsÚhintr±   r³   rœ   Úraw_keypointsr�   Úxyr�   Ú
visibilityÚ	absent_2dÚpresentÚabsents                        r2   Ú_parse_yolo_pose_label_linerÈ     sà  € ð ˜-¨,Ñ6Ñ6€OÝ
ˆ6�{„{�oÒ%Ð%õ
 �6‰{Œ{˜aÒÐ M°AÒ$5Ð$5ð@ð @ð ð 	õ ð(­C°
©O¬Oð (ð (Èð (ð (Ø'ð(ð (ØANð(ð (ØR^ð(ð (å�v‘;”;ð(ð (à!%ð(ð (ñ
ô 
ð 	
õ -Øˆr�ˆrŒ
ØØØØØØðñ ô �O€Cˆ�!ðÝœ
 6¨!¨"¨"¤:µR´ZÐ@Ñ@Ô@×HÒHÈÐXdÑeÔeˆˆøÝð ð ð Ýð9­C°
©O¬Oð 9ð 9Èð 9ð 9ð 9ñ
ô 
ð ð	øøøøðøøøõ Œ;�}Ñ%Ô%×)Ò)Ñ+Ô+ð wÝÐu½¸Z¹¼ÐuÐuÐU]ÐuÐuÐuÑvÔvÐvØ	�q�q�q˜"˜1˜"�uÔ	€Bå”˜-¨Ð+µ2´:Ð>Ñ>Ô>€IØ�qÒÐà" 1 1 1 a 4Ô(ˆ
ÝŒ6�: Ò#¨
°SÒ(8Ñ9Ñ:Ô:ð 	Ýð@µ°J±´ð @ð @ÈHð @ð @ð @ñô ð õ 	Œ��C˜ "Ð%Ñ%Ô%Ð%Ø$ˆ	�!�!�!�Q�$‰ˆð ˜˜˜˜1˜”X ’^¨¨1¨1¨1¨a¨4¬°3ªÑ7ˆ	Ý
Œ��C˜ "Ð%Ñ%Ô%Ð%àˆˆ9�a�a�aˆ<ÑØ˜˜˜˜1˜”X ’_¨¨A¨A¨A¨q¨D¬°SªÑ9Ð:ˆØ #ˆ	�'˜1�*Ñà˜˜˜˜A˜”h¥ u¡¤Ñ-€Iˆaˆaˆa�ˆd�OØ˜˜˜˜A˜”h¥ v¡¤Ñ.€Iˆaˆaˆa�ˆd�Oà�q�q�q˜!�tŒ_ Ò#€FØ€Iˆf�b�q�bˆjÑØ�˜Ð"Ð"s   Â<C Ã
D
Ã!$DÄD
F)Úinclude_keypointsÚkeypoint_schemaÚ
img_folderÚ	lb_folderÚinclude_polygonsrÉ   rÊ   úYoloKeypointSchema | Noneú'tuple[list[str], list[_LazyYoloSample]]c               óÈ  — |r|rt          d¦  «        ‚|r6|pt          |¦  «        }|j        }t          |j        d¬¦  «        }|j        }nt          |¦  «        }d}d}g }	t          | ¦  «        D �]n}
t          |¦  «        t          |
¦  «        j	        › d�z  }t          j        |
¦  «        5 }|j        \  }}ddd¦  «         n# 1 swxY w Y   g }g }g }g }|                     ¦   «         �r|                     d¬¦  «        5 }d„ |D ¦   «         }ddd¦  «         n# 1 swxY w Y   t          |¦  «        D ]Ë\  }}|                     ¦   «         }|rCt!          ||d	z   |t#          |¦  «        ||||¬
¦  «        \  }}}d}|                     |¦  «         n*t'          ||d	z   |t#          |¦  «        |||¬¦  «        \  }}}|                     |¦  «         |                     |¦  «         |r|�|                     |¦  «         ŒÌ|	                     t)          |
||t+          j        |t*          j        ¬¦  «                             dd¦  «        t+          j        |t*          j        ¬¦  «        t5          |¦  «        |r3t+          j        |¦  «                             t*          j        d¬¦  «        n"t+          j        d|dft*          j        ¬¦  «        ¬¦  «        ¦  «         �Œp||	fS )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.r   ©Údefaultz.txtNzutf-8)Úencodingc                ó^   — g | ]*}|                      ¦   «         ¯|                      ¦   «         ‘Œ+S r0   )Ústrip)rU   Úlines     r2   rW   z'_build_yolo_samples.<locals>.<listcomp>�  s-   € ÐIÐIÐI¨$¸D¿JºJ¹L¼LÐI˜Ÿš™œÐIÐIÐIr1   rF   )r¶   r·   r¢   r9   rJ   é   F)ÚcopyrG   )r}   rA   rB   r   r€   r`   r�   )r™   r   Úclass_namesr®   Únum_keypoints_per_classr·   ry   ru   r   Ústemr   ÚopenrZ   ÚexistsÚ	enumerateÚsplitrÈ   rd   Úappendrµ   r|   r;   r<   r>   rK   Úint64rT   rf   r°   re   )rË   rÌ   rv   rÍ   rÉ   rÊ   rŠ   r¶   r·   r‹   r}   r¥   ÚimagerA   rB   r   r€   r`   r�   ÚhandleÚlinesÚir×   r3   r±   r³   Úkeypoints_pxr´   s                               r2   Ú_build_yolo_samplesrè   _  s¸  € ðL ð eÐ-ð eÝÐcÑdÔdÐdØð Ø)ÐRÕ-GÈ	Ñ-RÔ-RˆØ!Ô-ˆÝ˜OÔCÈQÐOÑOÔOˆØ&Ô3ˆˆå+¨IÑ6Ô6ˆØˆØˆØ%'€Gå,¨ZÑ8Ô8ð 8
ñ 8
ˆ
Ý˜)‘_”_­$¨zÑ*:Ô*:Ô*?Ð'EÐ'EÐ'EÑEˆ
ÝŒZ˜
Ñ#Ô#ð 	' uØ!œJ‰MˆE�6ð	'ð 	'ð 	'ñ 	'ô 	'ð 	'ð 	'ð 	'ð 	'ð 	'ð 	'øøøð 	'ð 	'ð 	'ð 	'ð +-ˆØ ˆØ.0ˆØ/1ˆ	Ø×ÒÑÔñ 	0Ø—’¨'�Ñ2Ô2ð J°fØIÐI°&ÐIÑIÔI�ðJð Jð Jñ Jô Jð Jð Jð Jð Jð Jð Jøøøð Jð Jð Jð Jå$ UÑ+Ô+ð 0ð 0‘��4ØŸš™œ�Ø$ð Ý1LØØ˜A™Ø"Ý˜G™œØØØ&3Ø%1ð	2ñ 	2ô 	2Ñ.�C˜ ,ð "&�JØ×$Ò$ \Ñ2Ô2Ð2Ð2å/EØØ˜A™Ø"Ý˜G™œØØØ'7ð0ñ 0ô 0Ñ,�C˜ *ð —’ Ñ$Ô$Ð$Ø—’˜GÑ$Ô$Ð$Ø#ð 0¨
Ð(>Ø—O’O JÑ/Ô/Ð/øà�ŠÝØ%ØØÝ”X˜d­"¬*Ð5Ñ5Ô5×=Ò=¸bÀ!ÑDÔDÝœ (µ"´(Ð;Ñ;Ô;Ý˜x™œð !ðK•B”H˜YÑ'Ô'×.Ò.­r¬zÀÐ.ÑFÔFÐFåœ 1 m°QÐ"7½r¼zÐJÑJÔJðñ ô ñ	
ô 	
ð 	
ñ 	
ð  �GÐÐs$   Â.CÃC		ÃC		ÄDÄD 	Ä#D 	c                óP   — 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.
    F©rÍ   ©rŠ   r‹   ©rè   r‰   ©rË   rÌ   rv   rŠ   r‹   s        r2   Ú"_build_lazy_yolo_detection_datasetrî   Ï  s3   € õ$ +¨:°yÀ)Ð^cÐdÑdÔdÑ€GˆWÝ$¨W¸gÐFÑFÔFÐFr1   c                óP   — t          | ||d¬¦  «        \  }}t          ||¬¦  «        S )aå  Build 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.
    Trê   rë   rì   rí   s        r2   Ú%_build_lazy_yolo_segmentation_datasetrð   å  s3   € õ +¨:°yÀ)Ð^bÐcÑcÔcÑ€GˆWÝ$¨W¸gÐFÑFÔFÐFr1   r   c                óT   — t          | ||dd|¬¦  «        \  }}t          ||¬¦  «        S )zDBuild a YOLO pose dataset that stores keypoints without dense masks.FT)rÍ   rÉ   rÊ   rë   rì   )rË   rÌ   rv   rÊ   rŠ   r‹   s         r2   Ú!_build_lazy_yolo_keypoint_datasetrò   õ  sD   € õ +ØØØØØØ'ðñ ô Ñ€GˆWõ %¨W¸gÐFÑFÔFÐFr1   rŠ   Údatasetr   c           
     óV  — ddl m} g }g }g }t          | ¦  «        D ]>\  }}||ddœ}	|�t          |j        ¦  «        |	d<   g |	d<   |                     |	¦  «         Œ?t          |d¦  «        }
d}t          t          |¦  «        ¦  «        D �]p}|
rX| 	                    |¦  «        }|j
        }|j        |j        }}|j        }|j        }t          |j        ¦  «        dk    }|j        }ne||         \  }}}|j        dd	…         \  }}|j        }|j        }|j        du}t'          j        t          |¦  «        dd
ft&          j        ¬¦  «        }|                     |t-          |¦  «        t/          |¦  «        t/          |¦  «        dœ¦  «         t          t          |¦  «        ¦  «        D �]O}||         \  }}}}t1          |¦  «        t1          |¦  «        }}t1          ||z
  ¦  «        t1          ||z
  ¦  «        }}||t/          ||         ¦  «        ||||gt1          ||z  ¦  «        ddœ} |rg | d<   |�¯|t          |¦  «        k     r||         nt'          j        dt&          j        ¬¦  «        }!|!                     d¦  «                             t0          ¦  «                             ¦   «         | d<   t/          t'          j        |!dd…d	f         dk    ¦  «        ¦  «        | d<    |j        | ¦  «         |dz  }�ŒQ�Œrddi|||dœ}" |¦   «         }#|"|#_        |#                     ¦   «          |#S )am  Build 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   )ÚCOCOÚnone)ÚidÚnameÚsupercategoryNr�   Úskeletonr    r8   rG   r9   )r÷   Ú	file_namerB   rA   )r÷   Úimage_idÚcategory_idÚbboxÚareaÚiscrowdÚsegmentation)r   rG   rJ   r¶   rF   ÚdescriptionzRF-DETR YOLO dataset)Úinfor   r   Ú
categories)Úpycocotools.cocorõ   rß   ÚlistÚkeypoint_namesrá   ÚhasattrÚrangerd   r    r}   rB   rA   r   r€   r`   r�   Úshaper^   r;   re   r>   ri   r~   r=   rK   r°   r\   Úcount_nonzeroró   ÚcreateIndex)$rŠ   ró   rÊ   rõ   r   r   r  r”   Ú
class_nameÚcategoryÚuse_lazy_pathÚann_idÚimg_idrš   r}   rB   rA   r   r€   Ú	has_masksr�   Úimage_arrayÚ
detectionsræ   Úx1Úy1Úx2Úy2Úbbox_xÚbbox_yÚbbox_wÚbbox_hÚannÚkeypoints_iÚcoco_datasetÚcocos$                                       r2   Ú_build_coco_api_from_samplesr!    sk  € ð &Ð%Ð%Ð%Ð%Ð%à#%€FØ(*€KØ')€JÝ$ WÑ-Ô-ð $ð $‰ˆˆZØ zÀFÐKÐKˆØÐ&Ý$(¨Ô)GÑ$HÔ$HˆH�[Ñ!Ø#%ˆH�ZÑ Ø×Ò˜(Ñ#Ô#Ð#Ð#å˜GÐ%5Ñ6Ô6€MØ€FÝ�˜G™œÑ%Ô%ð 'ñ 'ˆØð 	FØ×+Ò+¨FÑ3Ô3ˆFØÔ*ˆJØ"œM¨6¬<�EˆFØ”;ˆDØ”ˆHÝ˜FœOÑ,Ô,¨qÒ0ˆIØÔ(ˆIˆIà29¸&´/Ñ/ˆJ˜ ZØ'Ô-¨b¨q¨bÔ1‰MˆF�EØ”?ˆDØ!Ô*ˆHØ"œ¨tÐ3ˆIÝœ¥# d¡)¤)¨Q°Ð!2½"¼*ÐEÑEÔEˆIà�Š˜Vµ#°j±/´/ÍSÐQWÉ[Ì[ÕcfÐglÑcmÔcmÐnÐnÑoÔoÐoå•s˜4‘y”yÑ!Ô!ð 	ñ 	ˆAØ! !œW‰NˆB��B˜Ý" 2™YœY­¨b©	¬	�FˆFÝ" 2¨¡7™^œ^­U°2¸±7©^¬^�FˆFàØ"Ý" 8¨A¤;Ñ/Ô/Ø ¨°Ð8Ý˜f v™oÑ.Ô.Øðð ˆCð ð )à&(��NÑ#ØÐ*Ø./µ#°i±.´.Ò.@Ð.@˜i¨œl˜lÅbÄhÈvÕ]_Ô]gÐFhÑFhÔFh�Ø#.×#6Ò#6°rÑ#:Ô#:×#AÒ#AÅ%Ñ#HÔ#H×#OÒ#OÑ#QÔ#Q��KÑ Ý'*­2Ô+;¸KÈÈÈÈ1ÈÔ<MÐPQÒ<QÑ+RÔ+RÑ'SÔ'S��OÑ$ØˆKÔ˜sÑ#Ô#Ð#Ø�a‰KˆF‰Fñ)	ð. Ð 6Ð7ØØ"Ø ð	ð €Lð ˆ4‰6Œ6€DØ€D„LØ×ÒÑÔÐØ€Kr1   Údataset_dirc                ó’  ‡ — t          ˆ fd„t          D ¦   «         ¦  «        }t          j                             t          j                             ‰ d¦  «        ¦  «        }t          ˆ fd„t          D ¦   «         ¦  «        }|o|}t          ˆ fd„t          D ¦   «         d¦  «        }d|g}t          ˆ fd„|D ¦   «         ¦  «        }|o|o|S )uQ  Checks if the specified dataset directory is in yolo format.

    We accept a dataset to be in yolo format if the following conditions are met:
    - The dataset_dir contains a data.yaml or data.yml file
    - The dataset_dir contains "train" and either "valid" or "val" subdirectories,
      each containing "images" and "labels" subdirectories
    - The "test" subdirectory is optional

    .. note::
        This is a coarse filesystem pre-check and intentionally does **not**
        consult ``data.yaml`` split path keys.  Actual split directories are
        resolved by :func:`_resolve_yolo_split_dirs`, which reads the YAML
        first and falls back to the filesystem convention.  When both ``valid/``
        and ``val/`` exist but YAML declares the non-priority one, the two
        functions may pick different directories â€” this is by design; the
        validity gate is a cheap early filter only.  When ``valid/`` exists,
        it takes precedence over ``val/``.

    Returns:
        ``True`` if the directory satisfies all YOLO format requirements,
        ``False`` otherwise.
    c              3  ó’   •K  — | ]A}t           j                             t           j                             ‰|¦  «        ¦  «        V — ŒBd S rl   ©Úosrq   rÞ   Újoin)rU   Ú	yaml_filer"  s     €r2   rr   z(is_valid_yolo_dataset.<locals>.<genexpr>o  sR   øè è € ð &ð &ØAJ�Œ�Š•r”w—|’| K°Ñ;Ô;Ñ<Ô<ð&ð &ð &ð &ð &ð &r1   Útrainc              3  ó’   •K  — | ]A}t           j                             t           j                             ‰|¦  «        ¦  «        V — ŒBd S rl   r%  ©rU   Údr"  s     €r2   rr   z(is_valid_yolo_dataset.<locals>.<genexpr>s  sA   øè è € Ð]Ð]À1•"”'—.’.¥¤§¢¨k¸1Ñ!=Ô!=Ñ>Ô>Ð]Ð]Ð]Ð]Ð]Ð]r1   c              3  ó–   •K  — | ]C}t           j                             t           j                             ‰|¦  «        ¦  «        ¯?|V — ŒDd S rl   r%  r+  s     €r2   rr   z(is_valid_yolo_dataset.<locals>.<genexpr>w  sG   øè è € ÐYÐYˆq­B¬G¯NªN½2¼7¿<º<ÈÐUVÑ;WÔ;WÑ,XÔ,XÐYˆÐYÐYÐYÐYÐYÐYr1   r   c           	   3  ó¨   •K  — | ]L}t           D ]B}t          j                             t          j                             ‰||¦  «        ¦  «        V — ŒCŒMd S rl   )ÚREQUIRED_DATA_SUBDIRSr&  rq   rÞ   r'  )rU   Ú	split_dirÚdata_subdirr"  s      €r2   rr   z(is_valid_yolo_dataset.<locals>.<genexpr>{  sn   øè è € ð )ð )àÝ0ð)ð )ð õ 	Œ�Š•r”w—|’| K°¸KÑHÔHÑIÔIð)ð )ð )ð )ð )ð )ð )r1   )	r¿   ÚREQUIRED_YOLO_YAML_FILESr&  rq   rÞ   r'  Ú_VALID_VAL_DIR_NAMESÚnextr¾   )r"  Úcontains_required_yolo_yamlÚ	has_trainÚhas_valÚcontains_required_split_dirsÚval_dir_nameÚactive_splitsÚcontains_required_data_subdirss   `       r2   Úis_valid_yolo_datasetr<  X  s  ø€ õ. #&ð &ð &ð &ð &ÝNfð&ñ &ô &ñ #ô #Ðõ ”—’�rœwŸ|š|¨K¸ÑAÔAÑBÔB€IÝÐ]Ð]Ð]Ð]ÕH\Ð]Ñ]Ô]Ñ]Ô]€GØ#,Ð#8°Ð åØYÐYÐYÐYÕ(ÐYÑYÔYØñô €Lð ˜lÐ+€MÝ%(ð )ð )ð )ð )à&ð)ñ )ô )ñ &ô &Ð"ð
 'ÐjÐ+GÐjÐLjÐjr1   Úrootrà   útuple[Path, Path] | Nonec                ó,  — t          |¦  «        }|                     d¦  «        r#t          |                     dd¦  «        ¦  «        n| }|                     ¦   «         s| |z  }|                     |¦  «        }|€|dk    r|                     d¦  «        }|€dS ||z  }	 |                     ¦   «                              |                      ¦   «         ¦  «         n# t          $ r Y dS w xY w|j        }|                     ¦   «         }|rUd|v rQ| 	                    d¦  «        }	t          g |d|	…         ¢d‘||	dz   d…         ¢R Ž }
|
                     ¦   «         r||
fS n8|r6|dz  }|dz  }|                     ¦   «         r|                     ¦   «         r||fS dS )	aè  Parse ``data_file`` and resolve image/label dirs for ``split``.

    Returns ``None`` when the YAML declares no usable path for the requested
    split, the resolved path does not exist on disk, or a path traversal is
    detected.

    Raises:
        OSError: File I/O failure reading ``data_file``.
        ValueError: Unexpected value type inside the YAML mapping.
        TypeError: Unexpected type inside the YAML mapping.
        yaml.YAMLError: Malformed YAML content.

    Args:
        root: Dataset root directory.
        data_file: Path to ``data.yaml`` or ``data.yml``.
        split: One of ``"train"``, ``"val"``, or ``"test"``.

    Returns:
        ``(images_dir, labels_dir)`` on success, or ``None`` to signal fallback.
    rq   rº   Nr   r   r   r    rF   )
r   Úgetr   Úis_absoluteÚresolveÚrelative_tor™   ÚpartsÚis_dirÚindex)r=  rv   rà   rx   Ú	yaml_baseÚraw_pathÚsplit_imagesrD  rE  r”   Úsplit_labelsÚ
sub_imagesÚ
sub_labelss                r2   Ú_parse_yaml_split_dirsrM  ƒ  sÜ  € õ* ˜iÑ(Ô(€DØ.2¯hªh°vÑ.>Ô.>ÐH•�T—X’X˜f bÑ)Ô)Ñ*Ô*Ð*ÀD€IØ× Ò Ñ"Ô"ð %Ø˜9Ñ$ˆ	àŸ8š8 E™?œ?€HØÐ˜E UšN˜NØ—8’8˜GÑ$Ô$ˆàÐØˆtà˜xÑ'€LðØ×ÒÑÔ×*Ò*¨4¯<ª<©>¬>Ñ:Ô:Ð:Ð:øÝð ð ð Øˆtˆtðøøøð Ô€EØ× Ò Ñ"Ô"€FØð 	*�(˜eÐ#Ð#Ø�kŠk˜(Ñ#Ô#ˆÝÐF˜U 4 C 4œ[ÐF¨(ÐF°U¸3À¹7¸9¸9Ô5EÐFÐFÐFˆØ×ÒÑ Ô ð 	.Ø Ð-Ð-ð	.à	ð *Ø! HÑ,ˆ
Ø! HÑ,ˆ
Ø×ÒÑÔð 	* :×#4Ò#4Ñ#6Ô#6ð 	*Ø˜zÐ)Ð)Øˆ4s   Â9C Ã
C'Ã&C'c                óH  — |                      ¦   «         sdS 	 t          | ||¦  «        S # t          $ r Y nmt          t          f$ r'}t
                               d|||¦  «         Y d}~n;d}~wt          j        $ r&}t
                               d||¦  «         Y d}~nd}~ww xY wdS )aç  Try to resolve image and label dirs for ``split`` from ``data_file``.

    Returns ``None`` when the YAML file is absent, declares no usable path for
    the requested split, or the resolved path does not exist on disk.

    Args:
        root: Dataset root directory.
        data_file: Path to ``data.yaml`` or ``data.yml``.
        split: One of ``"train"``, ``"val"``, or ``"test"``.

    Returns:
        ``(images_dir, labels_dir)`` on success, or ``None`` to signal fallback.
    Nue   Could not resolve YAML split path for %r in %s: %s â€” falling back to Roboflow directory convention.uS   Failed to parse YAML file %s: %s â€” falling back to Roboflow directory convention.)	rÞ   rM  r˜   r™   Ú	TypeErrorÚloggerÚwarningÚyamlÚ	YAMLError)r=  rv   rà   r�   s       r2   Ú_resolve_split_from_yamlrT  »  s  € ð ×ÒÑÔð Øˆtð
Ý% d¨I°uÑ=Ô=Ð=øÝð ð ð ØˆÝ�	Ð"ð 
ð 
ð 
Ý�ŠØsØØØñ		
ô 	
ð 	
ð 	
ð 	
ð 	
ð 	
ð 	
øøøøõ Œ>ð 
ð 
ð 
Ý�ŠØaØØñ	
ô 	
ð 	
ð 	
ð 	
ð 	
ð 	
ð 	
øøøøð
øøøð ˆ4s&   ˜) ©
BµBÁA'Á'BÁ9BÂBútuple[Path, Path]c                ót  — |dk    rŒ|                      ¦   «         rx	 t          |¦  «                             d¦  «        }n*# t          t          t
          t          j        f$ r d}Y nw xY w|�(t          | ||¦  «        }|€t	          d|› d�¦  «        ‚|S t          | ||¦  «        }|�|S ddddœ}|                     ||¦  «        }| |z  dz  }| |z  d	z  }|d
k    r\|                      ¦   «         sHt          D ]@}	| |	z  dz  }
| |	z  d	z  }|
 
                    ¦   «         r| 
                    ¦   «         r|
|fc S ŒA||fS )a’  Resolve image and label directories for a YOLO dataset split.

    Supports both Roboflow (``valid/``) and Ultralytics (``val/``, paths in
    ``data.yaml``) layouts.  When the YAML file declares ``train``/``val``/
    ``test`` path keys the function uses those; otherwise it falls back to the
    existing Roboflow convention with an additional check for ``val/`` when
    ``valid/`` is absent.

    When ``split`` is ``"val"``, the function first queries the YAML for a
    ``"val"`` key and, if absent, retries with a ``"valid"`` key before falling
    back to the filesystem convention.

    Labels are derived from the resolved images path by replacing the
    ``"images"`` segment with ``"labels"`` anywhere in the path, mirroring the
    Ultralytics ``img2label_paths`` convention.  This handles both
    trailing-images (``val/images``) and intermediate-images
    (``images/val2017``) layouts.

    Args:
        root: Dataset root directory.
        data_file: Path to ``data.yaml`` or ``data.yml``.
        split: One of ``"train"``, ``"val"``, or ``"test"``.

    Returns:
        ``(images_dir, labels_dir)`` as resolved :class:`~pathlib.Path` objects.
    ÚtestNzYOLO test split declared in z could not be resolvedr)  r   )r)  r   rW  r   r    r   )rÞ   r   r@  r˜   r™   rO  rR  rS  rT  r3  rE  )r=  rv   rà   Údeclared_test_pathÚresultÚroboflow_mapÚmappedÚimg_dirÚlb_dirÚaltÚ	candidateÚcandidate_labelss               r2   Ú_resolve_yolo_split_dirsra  ß  s’  € ð6 �‚€˜9×+Ò+Ñ-Ô-€ð	&Ý!3°IÑ!>Ô!>×!BÒ!BÀ6Ñ!JÔ!JÐÐøÝ�¥Yµ´Ð?ð 	&ð 	&ð 	&Ø!%ÐÐÐð	&øøøàÐ)Ý-¨d°I¸uÑEÔEˆFØˆ~Ý Ð!aÀ	Ð!aÐ!aÐ!aÑbÔbÐbØˆMå% d¨I°uÑ=Ô=€FØÐØˆà$¨W¸fÐEÐE€LØ×Ò˜e UÑ+Ô+€FØ�V‰m˜hÑ&€GØ�F‰]˜XÑ%€Fà�‚~€~˜gŸnšnÑ.Ô.€~Ý'ð 	3ð 	3ˆCØ˜s™
 XÑ-ˆIØ# c™z¨HÑ4ÐØ×ÒÑ!Ô!ð 3Ð&6×&=Ò&=Ñ&?Ô&?ð 3Ø Ð"2Ð2Ð2Ð2Ð2øà�Fˆ?Ðs   œ"? ¿$A&Á%A&Ú
images_dirÚ
labels_dirr�   c                óJ  — |                       ¦   «         s8|                      ¦   «         rt          d| › �¦  «        ‚t          d| › �¦  «        ‚|                      ¦   «         st          d|› �¦  «        ‚t	          t          | ¦  «        ¦  «        }|st          d| › �¦  «        ‚dS )a  Validate the filesystem contract for a YOLO test split.

    A missing image directory means that the split is unavailable and may be
    replaced with validation data.  Once the image directory exists, an empty
    image directory or missing labels directory is invalid test data and must
    propagate as an error instead of being relabeled as validation data.  An
    existing labels directory may contain omitted or empty label files for
    legitimate background images.

    Args:
        images_dir: Resolved directory containing test images.
        labels_dir: Resolved directory containing test labels.

    Raises:
        YoloSplitUnavailableError: If the test image directory is absent.
        ValueError: If the test images or labels directory is unusable.
    z2YOLO test images directory is an invalid symlink: z&YOLO test images directory not found: z&YOLO test labels directory not found: z9YOLO test images directory contains no supported images: N)rE  Ú
is_symlinkr™   r+   ru   ri   )rb  rc  Úimage_pathss      r2   Ú_validate_yolo_test_splitrg    sÊ   € ð$ ×ÒÑÔð _Ø× Ò Ñ"Ô"ð 	`ÝÐ^ÐR\Ð^Ð^Ñ_Ô_Ð_Ý'Ð(]ÐQ[Ð(]Ð(]Ñ^Ô^Ð^Ø×ÒÑÔð PÝÐNÀ*ÐNÐNÑOÔOÐOå(­¨Z©¬Ñ9Ô9€KØð cÝÐaÐU_ÐaÐaÑbÔbÐbðcð cr1   c                  ó$   — e Zd ZdZddd	„Zdd„ZdS )ÚConvertYoloa–  Converts 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]
    Fr   Úinclude_masksr]   rÉ   r¶   r~   c                ó0   — || _         || _        || _        d S rl   ©rj  rÉ   r¶   )r…   rj  rÉ   r¶   s       r2   r�   zConvertYolo.__init__W  s    € Ø*ˆÔØ!2ˆÔØ*ˆÔÐÐr1   rã   úImage.ImageÚtargetúdict[str, Any]r5   ú+tuple[Image.Image, dict[str, torch.Tensor]]c                ó˜  — |j         \  }}|d         }t          j        |g¦  «        }|d         }t          |¦  «        dk    rmt          j        |j        ¦  «                             t          j        ¦  «        }t          j        |j        ¦  «                             t          j	        ¦  «        }n@t          j
        dt          j        ¬¦  «        }t          j
        dt          j	        ¬¦  «        }|dd…ddd…f                              d|¬	¦  «         |dd…d
dd…f                              d|¬	¦  «         |dd…df         |dd…d
f         k    |dd…df         |dd…df         k    z  }	||	         }||	         }i }
||
d<   ||
d<   ||
d<   |dd…df         |dd…d
f         z
  |dd…df         |dd…df         z
  z  }||
d<   t          j
        |j        d         ft          j	        ¬¦  «        }||
d<   | j        rÍ|j        �ƒt          j         |j        ¦  «        dk    rft          j        |j        |	                     ¦   «                              ¦   «                  ¦  «                             t          j        ¦  «        }||
d<   n&t          j
        d||ft          j        ¬¦  «        |
d<   |
d                              ¦   «         |
d<   | j        r�|                     d¦  «        }|€4t          j
        |	j        d         | j        dft          j        ¬¦  «        }n:t          j        |t          j        ¬¦  «                             d| j        d¦  «        }||	         |
d<   t          j        t3          |¦  «        t3          |¦  «        g¦  «        |
d<   t          j        t3          |¦  «        t3          |¦  «        g¦  «        |
d<   ||
fS )zßConvert 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)
        rü   r  r   )r   rØ   r9   )r   Nr8   )r­   r®   rF   rG   Úboxesr    rÿ   r   Úmasksr�   rJ   Ú	orig_sizerZ   )rZ   ÚtorchÚtensorrd   Ú
from_numpyr   Útor>   r€   râ   re   Úclamp_r
  rj  r^   r;   ÚcpuÚnumpyÚuint8r]   rÉ   r@  r¶   Ú	as_tensorrK   r~   )r…   rã   rn  ÚwÚhrü   r  rr  rŠ   ÚkeepÚ
target_outrÿ   r   rs  rÂ   r�   s                   r2   Ú__call__zConvertYolo.__call__\  s�  € ð Œz‰ˆˆ1à˜*Ô%ˆÝ”<  
Ñ+Ô+ˆà˜LÔ)ˆ
åˆz‰?Œ?˜QÒÐÝÔ$ Z¤_Ñ5Ô5×8Ò8½¼ÑGÔGˆEÝÔ& zÔ':Ñ;Ô;×>Ò>½u¼{ÑKÔKˆGˆGå”K ­e¬mÐ<Ñ<Ô<ˆEÝ”k $­e¬kÐ:Ñ:Ô:ˆGð 	ˆaˆaˆa���A�ˆgŒ×Ò !¨ÐÑ+Ô+Ð+Øˆaˆaˆa���A�ˆgŒ×Ò !¨ÐÑ+Ô+Ð+à�a�a�a˜�d”˜e A A A q DœkÒ)¨e°A°A°A°q°D¬k¸EÀ!À!À!ÀQÀ$¼KÒ.GÑHˆØ�d”ˆØ˜$”-ˆà.0ˆ
Ø#ˆ
�7ÑØ&ˆ
�8ÑØ!)ˆ
�:Ñð �a�a�a˜�d”˜e A A A q DœkÑ)¨e°A°A°A°q°D¬k¸EÀ!À!À!ÀQÀ$¼KÑ.GÑHˆØ!ˆ
�6Ñå”+˜wœ}¨QÔ/Ð1½¼ÐEÑEÔEˆØ 'ˆ
�9ÑàÔð 	=ØŒÐ*­r¬w°z´Ñ/GÔ/GÈ!Ò/KÐ/KÝÔ(¨¬¸¿º¹¼×9IÒ9IÑ9KÔ9KÔ)LÑMÔM×PÒPÕQVÔQ\Ñ]Ô]�Ø&+�
˜7Ñ#Ð#å&+¤k°1°a¸°)Å5Ä;Ð&OÑ&OÔ&O�
˜7Ñ#à",¨WÔ"5×":Ò":Ñ"<Ô"<ˆJ�wÑàÔ!ð 	6Ø"ŸJšJ {Ñ3Ô3ˆMØÐ$å!œK¨¬°A¬¸Ô8JÈAÐ(NÕV[ÔVcÐdÑdÔd�	�	å!œO¨MÅÄÐOÑOÔO×WÒWÐXZÐ\`Ô\nÐpqÑrÔr�	Ø&/°¤oˆJ�{Ñ#å"'¤/µ3°q±6´6½3¸q¹6¼6Ð2BÑ"CÔ"Cˆ
�;ÑÝ"œ_­c°!©f¬fµc¸!±f´fÐ-=Ñ>Ô>ˆ
�6Ñà�jÐ Ð r1   N)FFr   )rj  r]   rÉ   r]   r¶   r~   )rã   rm  rn  ro  r5   rp  )r,   r-   r.   r/   r�   r‚  r0   r1   r2   ri  ri  6  sR   € € € € € ðð ð@+ð +ð +ð +ð +ð
A!ð A!ð A!ð A!ð A!ð A!r1   ri  c                  ó>   ‡ — e Zd ZdZ	 	 	 	 ddˆ fd„Zdd„Zdd„Zˆ xZS )ÚYoloDetectionuž  YOLO 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.
    NFrË   ri   rÌ   rv   Ú
transformsúCompose | Nonerj  r]   rÉ   rÛ   úlist[int] | Nonec                óz  •— |r|rt          d¦  «        ‚t          ¦   «                              |¦  «         || _        || _        || _        |  |rI	 t          |¦  «        | _        n:# t          t           t          f$ r}t          d|›d�¦  «        |‚d }~ww xY wd | _        t          |pg d¬¦  «        | _        | j        �%t          | j        j        | j        ¬¦  «        | _        t          ||| j        ¬¦  «        | _        | j        �t          |||| j        ¦  «        | _        n/|rt#          |||¦  «        | _        nt%          |||¦  «        | _        | j        j        | _        t)          t+          t-          | j        ¦  «        ¦  «        ¦  «        | _        t1          | j        | j        | j        ¦  «        | _        d S )NrÑ   z6YOLO keypoint training requires kpt_shape metadata in r«   r   rÒ   rl  )r™   Úsuperr�   Ú_transformsrj  rÉ   r   rÊ   r—   r˜   r®   r¶   rÛ   ri  Úpreparerò   Ú
sv_datasetrð   rî   rŠ   r  r	  rd   Úidsr!  r   )
r…   rË   rÌ   rv   r…  rj  rÉ   rÛ   r�   Ú	__class__s
            €r2   r�   zYoloDetection.__init__¸  så  ø€ ð ð 	iÐ.ð 	iÝÐgÑhÔhÐhÝ‰Œ×Ò˜Ñ$Ô$Ð$Ø%ˆÔØ*ˆÔØ!2ˆÔØÐ7Øð 	(ðsÝ'AÀ)Ñ'LÔ'L�Ô$Ð$øÝ%¥zµ7Ð;ð sð sð sÝ Ð!hÐZcÐ!hÐ!hÐ!hÑiÔiÐorÐrøøøøðsøøøð $(ˆDÔ Ý Ð!8Ð!>¸BÈÐJÑJÔJˆÔØÔÐ+Ý!$ TÔ%9Ô%QÐ[_Ô[mÐ!nÑ!nÔ!nˆDÔÝ"Ø'Ø/ØÔ,ð
ñ 
ô 
ˆŒð ÔÐ+Ý?ØØØØÔ$ñ	ô ˆDŒOˆOð ð 	cÝCÀJÐPYÐ[dÑeÔeˆDŒOˆOå@ÀÈYÐXaÑbÔbˆDŒOà”Ô.ˆŒÝ��c $¤/Ñ2Ô2Ñ3Ô3Ñ4Ô4ˆŒõ 1°´¸t¼ÐPTÔPdÑeÔeˆŒ	ˆ	ˆ	s   ÁA% Á%BÁ<BÂBr5   r~   c                ó*   — t          | j        ¦  «        S rl   )rd   rŒ  r’   s    r2   r“   zYoloDetection.__len__ì  s   € Ý�4”?Ñ#Ô#Ð#r1   r”   ú8tuple[Image.Image | torch.Tensor, dict[str, Any] | None]c                ó6  — | j         |         }| j        |         \  }}}t          j        |¦  «        }||dœ}| j        r"| j                             |¦  «        j        |d<   |                      ||¦  «        \  }}	| j        �|                      ||	¦  «        S ||	fS )N)rü   r  r�   )	r�  rŒ  r   Ú	fromarrayrÉ   r    r�   r‹  rŠ  )
r…   r”   rü   r}   r›   r  Úimgrn  Úprepared_imageÚprepared_targets
             r2   rž   zYoloDetection.__getitem__ï  s§   € Ø”8˜C”=ˆØ,0¬O¸CÔ,@Ñ)ˆ
�I˜zåŒo˜iÑ(Ô(ˆà.6ÀjÐ!QÐ!QˆØÔ!ð 	PØ"&¤/×"@Ò"@ÀÑ"EÔ"EÔ"OˆF�;ÑØ*.¯,ª,°s¸FÑ*CÔ*CÑ'ˆ˜àÔÐ'Ø×#Ò# N°OÑDÔDÐDà˜Ð.Ð.r1   )NFFN)rË   ri   rÌ   ri   rv   ri   r…  r†  rj  r]   rÉ   r]   rÛ   r‡  r¡   )r”   r~   r5   r�  )r,   r-   r.   r/   r�   r“   rž   Ú__classcell__)rŽ  s   @r2   r„  r„     sŠ   ø€ € € € € ðð ð8 &*Ø#Ø"'Ø48ð2fð 2fð 2fð 2fð 2fð 2fð 2fðh$ð $ð $ð $ð/ð /ð /ð /ð /ð /ð /ð /r1   r„  Ú	image_setÚargsÚ
resolutionc                ó  ‡— t          |j        ¦  «        Š‰                     ¦   «         st          d‰› �¦  «        ‚t	          ˆfd„t
          D ¦   «         ‰dz  ¦  «        }|                      d¦  «        d         }t          ‰||¦  «        \  }}|dk    rt          ||¦  «         |j	        }|j
        }t          j        |j        ¦  «        }	|j        }
|j        }|j        }t#          |dd¦  «        }t#          |d	d
¦  «        }t#          |dd¦  «        }t#          |dg ¦  «        }t%          ||¬¦  «        }t'          t#          |dd¦  «        ¦  «        }t)          |¦  «        }|r@	 t+          |¦  «         n/# t          t,          t.          f$ r}t-          d¦  «        |‚d}~ww xY w|rnt1          t3          |¦  «        t3          |¦  «        t3          |¦  «        t5          | ||	t          j        u|
|	t          j        u||||||¬¦  «        |||¬¦  «        }nmt1          t3          |¦  «        t3          |¦  «        t3          |¦  «        t;          | ||	t          j        u|
|	t          j        u||||||¬¦  «        |||¬¦  «        }|S )a¿  Build a YOLO-format dataset from Roboflow or Ultralytics directory layouts.

    Supports both Roboflow (``train/valid/test``) and Ultralytics (``train/val/test``,
    with ``data.yaml`` path keys) directory structures.  Split directories are resolved
    via :func:`_resolve_yolo_split_dirs`.

    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``, ``segmentation_head``,
            ``multi_scale``, ``expanded_scales``,
            ``patch_size``, and ``num_windows`` are required. ``aug_config``,
            ``scale_jitter``, keypoint fields, and ``augmentation_backend`` are
            optional and retain documented safe defaults.
        resolution: Target square resolution in pixels.

    Returns:
        A :class:`YoloDetection` dataset instance ready for use with a DataLoader.

    Raises:
        AttributeError: If a required dataset or transform option is absent.
        FileNotFoundError: If the configured dataset root does not exist.
        ValueError: If keypoint training lacks a valid keypoint schema.
    zYOLO dataset root not found: c              3  óP   •K  — | ] }‰|z                        ¦   «         ¯‰|z  V — Œ!d S rl   )rÞ   )rU   Úfr=  s     €r2   rr   z+build_roboflow_from_yolo.<locals>.<genexpr>  s<   øè è € ÐXÐX 1ÀTÈAÁX×DUÒDUÑDWÔDWÐX�d˜Q‘hÐXÐXÐXÐXÐXÐXr1   r   rœ   r   rW  Ú
aug_configNÚscale_jitterTÚuse_grouppose_keypointsFrÛ   )rÉ   Úaugmentation_backendrz  zeYOLO keypoint training requires an Ultralytics pose data.yaml/data.yml with valid kpt_shape metadata.)	Úmulti_scaleÚexpanded_scalesÚskip_random_resizeÚ
patch_sizeÚnum_windowsr�  rž  Úgpu_postprocessÚkeypoint_flip_pairs)rË   rÌ   rv   r…  rj  rÉ   rÛ   )r   r"  rÞ   r—   r4  r2  rà   ra  rg  Úsquare_resize_div_64Úsegmentation_headr   Ú
from_valuer¡  r¢  r¤  r¥  Úgetattrr   r   r   r   r™   r˜   r„  ri   r   ÚOFFÚ
PER_SAMPLEr   )r—  r˜  r™  rv   Ú	split_keyrË   rÌ   r¨  rj  r¡  r¢  r¤  r¥  r�  rž  rÉ   rÛ   r§  Úresolved_augmentation_backendr¦  r�   ró   r=  s                         @r2   Úbuild_roboflow_from_yolor°     sÜ  ø€ õ4 �Ô Ñ!Ô!€DØ�;Š;‰=Œ=ð HÝÐ FÀÐ FÐ FÑGÔGÐGõ ÐXÐXÐXÐXÕ(@ÐXÑXÔXÐZ^ÐalÑZlÑmÔm€IØ—’ Ñ$Ô$ QÔ'€IÝ4°T¸9ÀiÑPÔPÑ€J�	Ø�FÒÐÝ! *¨iÑ8Ô8Ð8àÔ4ÐØÔ*€MÝÔ'¨Ô(8Ñ9Ô9€KØÔ*€OØ”€JØÔ"€KÝ˜˜|¨TÑ2Ô2€JÝ˜4 °Ñ6Ô6€LÝ Ð&?ÀÑGÔGÐÝ% dÐ,EÀrÑJÔJÐÝ5°dÐN_Ð`Ñ`Ô`ÐÝ$=½gÀdÐLbÐdiÑ>jÔ>jÑ$kÔ$kÐ!Ý(Ð)FÑGÔG€Oàð ð	Ý& yÑ1Ô1Ð1Ð1øÝ!¥:­wÐ7ð 	ð 	ð 	ÝØwñô àðøøøøð	øøøð
 ð +
ÝÝ˜:‘”Ý˜)‘n”nÝ˜)‘n”nÝ9ØØØ'­z¬~Ð=Ø /Ø#.µjÔ6KÐ#KØ%Ø'Ø%Ø)Ø /Ø$7ðñ ô ð (Ø/Ø$;ð'
ñ 
ô 
ˆˆõ,  Ý˜:‘”Ý˜)‘n”nÝ˜)‘n”nÝ+ØØØ'­z¬~Ð=Ø /Ø#.µjÔ6KÐ#KØ%Ø'Ø%Ø)Ø /Ø$7ðñ ô ð (Ø/Ø$;ð'
ñ 
ô 
ˆð* €Ns   Å&E6 Å6F"ÆFÆF")r3   r4   r5   r6   )rD   r6   r5   r6   )rM   r6   rN   rO   r5   rP   )r`   ra   rN   rO   r5   rP   )rh   ri   r5   r4   )rv   ri   r5   r4   )r3   r4   r¤   r~   r¥   r   r¦   r~   rA   r~   rB   r~   r£   r]   r5   r§   )r3   r4   r¤   r~   r¥   r   r¦   r~   rA   r~   rB   r~   r¶   r~   r·   r~   r5   r¸   )rË   ri   rÌ   ri   rv   ri   rÍ   r]   rÉ   r]   rÊ   rÎ   r5   rÏ   )rË   ri   rÌ   ri   rv   ri   r5   r‰   )
rË   ri   rÌ   ri   rv   ri   rÊ   r   r5   r‰   rl   )rŠ   r4   ró   r   rÊ   rÎ   r5   r   )r"  ri   r5   r]   )r=  r   rv   r   rà   ri   r5   r>  )r=  r   rv   r   rà   ri   r5   rU  )rb  r   rc  r   r5   r�   )r—  ri   r˜  r   r™  r~   r5   r„  )LÚ
__future__r   r&  Údataclassesr   Úpathlibr   Útypingr   r   r{  r;   ru  rR  rƒ   r	   Únumpy.typingr
   ÚPILr   r   r   Útorchvision.datasetsr   Úrfdetr.configr   Úrfdetr.datasets._aug_utilsr   Ú rfdetr.datasets._keypoint_schemar   r   r   r   Úrfdetr.datasets._torchvisionr   Úrfdetr.datasets.cocor   r   Úrfdetr.datasets.io_utilsr   Ú!rfdetr.datasets.kornia_transformsr   r   Úrfdetr.utilities.loggerr   rP  r2  r3  r/  rp   r—   r+   rC   rH   rL   r_   rg   ru   ry   r|   r‰   rµ   rÈ   rè   rî   rð   rò   r!  r<  rM  rT  ra  rg  ri  r„  r°  r0   r1   r2   ú<module>rÀ     sï  ðð #Ð "Ð "Ð "Ð "Ð "à 	€	€	€	Ø !Ð !Ð !Ð !Ð !Ð !Ø Ð Ð Ð Ð Ð Ø %Ð %Ð %Ð %Ð %Ð %Ð %Ð %à Ð Ð Ð Ø €€€Ø €€€àð 'Ø&Ð&Ð&Ð&Ð&Ð&Ø  Ð  Ð  Ð  Ð  Ð  Ø 8Ð 8Ð 8Ð 8Ð 8Ð 8Ð 8Ð 8Ð 8Ð 8Ø .Ð .Ð .Ð .Ð .Ð .à $Ð $Ð $Ð $Ð $Ð $Ø BÐ BÐ BÐ BÐ BÐ Bðð ð ð ð ð ð ð ð ð ð ð ð 1Ð 0Ð 0Ð 0Ð 0Ð 0ðð ð ð ð ð ð ð ð 2Ð 1Ð 1Ð 1Ð 1Ð 1Ø [Ð [Ð [Ð [Ð [Ð [Ð [Ð [Ø .Ð .Ð .Ð .Ð .Ð .à	ˆ‰Œ€à'¨Ð4Ð Ø'Ð Ø! 8Ð,Ð ØcÐcÐcÐ ðQð Qð Qð Qð QÐ 1ñ Qô Qð Qðð ð ð ðð ð ð ð=ð =ð =ð =ð

&ð 
&ð 
&ð 
&ð	Xð 	Xð 	Xð 	Xðð ð ð ð;ð ;ð ;ð ;ð €�$ÐÑÔð!Mð !Mð !Mð !Mð !Mñ !Mô !Mñ Ôð!MðH"ð "ð "ð "ð "ñ "ô "ð "ð>  ðX7ð X7ð X7ð X7ð X7ð X7ðvL#ð L#ð L#ð L#ðj $Ø15ðmð mð mð mð mð mð`Gð Gð Gð Gð,Gð Gð Gð Gð Gð Gð Gð Gð* 26ðNð Nð Nð Nð Nðb(kð (kð (kð (kðV5ð 5ð 5ð 5ðp!ð !ð !ð !ðH6ð 6ð 6ð 6ðrcð cð cð cð<g!ð g!ð g!ð g!ð g!ñ g!ô g!ð g!ðT]/ð ]/ð ]/ð ]/ð ]/�Mñ ]/ô ]/ð ]/ð@gð gð gð gð gð gr1   