ó
    qyüiõF  ã                   óô   • S SK r S SKJr  S SKrS SKJs  Js  Jr  SSK	J
r
  SSKJr  SSKJrJrJr  SSKJrJrJrJr  SSKJrJr  SS	KJrJr  \(       a  S
SKJr  S rS rS r S r!\ " S S\
5      5       r"S/r#g)é    N)ÚTYPE_CHECKINGé   )ÚTorchvisionBackend)ÚBatchFeature)Úcenter_to_corners_formatÚgroup_images_by_shapeÚreorder_images)ÚOPENAI_CLIP_MEANÚOPENAI_CLIP_STDÚPILImageResamplingÚSizeDict)ÚImagesKwargsÚUnpack)Ú
TensorTypeÚauto_docstringé   )ÚOwlv2ObjectDetectionOutputc                 ó,  • U R                  5       (       a@  U R                  [        R                  [        R                  4;   a  U $ U R                  5       $ U R                  [        R                  [        R                  4;   a  U $ U R                  5       $ )N)	Úis_floating_pointÚdtypeÚtorchÚfloat32Úfloat64ÚfloatÚint32Úint64Úint)Úts    Úm/home/mande/repo/quber/.venv/lib/python3.13/site-packages/transformers/models/owlv2/image_processing_owlv2.pyÚ_upcastr    '   sc   € à×Ñ×ÑØ—G‘G¤§¡¬u¯}©}Ð=Ó=ˆqÐLÀ1Ç7Á7Ã9ÐLà—G‘G¤§¡¬U¯[©[Ð9Ó9ˆqÐF¸q¿u¹u»wÐFó    c                 óf   • [        U 5      n U SS2S4   U SS2S4   -
  U SS2S4   U SS2S4   -
  -  $ )a“  
Computes the area of a set of bounding boxes, which are specified by its (x1, y1, x2, y2) coordinates.

Args:
    boxes (`torch.FloatTensor` of shape `(number_of_boxes, 4)`):
        Boxes for which the area will be computed. They are expected to be in (x1, y1, x2, y2) format with `0 <= x1
        < x2` and `0 <= y1 < y2`.
Returns:
    `torch.FloatTensor`: a tensor containing the area for each box.
Né   r   r   r   )r    )Úboxess    r   Úbox_arear%   /   sB   € ô �E‹N€EØ’!�Q�$‰K˜%¢ 1 ™+Ñ%¨%²°1°©+¸ºaÀ¸d¹Ñ*CÑDÐDr!   c                 óV  • [        U 5      n[        U5      n[        R                  " U S S 2S S S24   US S 2S S24   5      n[        R                  " U S S 2S SS 24   US S 2SS 24   5      nXT-
  R	                  SS9nUS S 2S S 2S4   US S 2S S 2S4   -  nUS S 2S 4   U-   U-
  nXx-  n	X˜4$ )Nr#   r   ©Úminr   )r%   r   Úmaxr(   Úclamp)
Úboxes1Úboxes2Úarea1Úarea2Úleft_topÚright_bottomÚwidth_heightÚinterÚunionÚious
             r   Úbox_iour5   >   sÄ   € Ü�VÓ€EÜ�VÓ€Eä�yŠy˜¢ 4¨¨!¨ Ñ,¨f²Q¸¸¸°U©mÓ<€HÜ—9’9˜V¢A t¨Q©R KÑ0°&º¸A¹B¸±-Ó@€Là Ñ+×2Ñ2°qÐ2Ð9€LØššA˜q˜Ñ! L²²A°q°Ñ$9Ñ9€Eà’!�T�'‰N˜UÑ" UÑ*€Eà
‰-€CØˆ:Ðr!   c                 ó(  • [        U[        [        45      (       aS  [        R                  " U Vs/ s H  o"S   PM	     sn5      n[        R                  " U Vs/ s H  o"S   PM	     sn5      nO>[        U[        R
                  5      (       a  UR                  S5      u  p4O[        S5      e[        R                  " X45      n[        R                  " XUXU/SS9nUR                  S5      R                  U R                  5      nX-  n U $ s  snf s  snf )aó  
Scale batch of bounding boxes to the target sizes.

Args:
    boxes (`torch.Tensor` of shape `(batch_size, num_boxes, 4)`):
        Bounding boxes to scale. Each box is expected to be in (x1, y1, x2, y2) format.
    target_sizes (`list[tuple[int, int]]` or `torch.Tensor` of shape `(batch_size, 2)`):
        Target sizes to scale the boxes to. Each target size is expected to be in (height, width) format.

Returns:
    `torch.Tensor` of shape `(batch_size, num_boxes, 4)`: Scaled bounding boxes.
r   r   z4`target_sizes` must be a list, tuple or torch.Tensor©Údim)Ú
isinstanceÚlistÚtupler   ÚtensorÚTensorÚunbindÚ	TypeErrorr)   ÚstackÚ	unsqueezeÚtoÚdevice)r$   Útarget_sizesÚiÚimage_heightÚimage_widthÚmax_sizeÚscale_factors          r   Ú_scale_boxesrJ   N   sß   € ô �,¤¤u ×.Ñ.Ü—|’|±<Ó$@²<¨a q¤T±<Ñ$@ÓAˆÜ—l’l±,Ó#?²,¨Q a¤D±,Ñ#?Ó@‰Ü	�L¤%§,¡,×	/Ñ	/Ø$0×$7Ñ$7¸Ó$:Ñ!ˆ�käÐNÓOÐOô �yŠy˜Ó3€Hä—;’; °HÐGÈQÑO€LØ×)Ñ)¨!Ó,×/Ñ/°·±Ó=€LØÑ €EØ€Lùò %AùÚ#?s   °D
ÁDc                   ó²  ^ • \ rS rSr\R
                  r\r\	r
SSS.rSrSrSrSrSrSrSrS/rSrSrS\\   4U 4S	 jjr  S'S
SS\S\\\   -  S-  4S jjrS(S jrS)SSS\SS4S jjr S)S\S   S\ S-  S\S\S   4S jjr!  S*SSS\"S\ SS4U 4S jjjr#S\S   S\ S\"SSS\ S\ S \S!\ S"\\\   -  S-  S#\\\   -  S-  S\ S-  S$\$\-  S-  S\%4S% jr&S&r'U =r($ )+ÚOwlv2ImageProcessorém   iÀ  )ÚheightÚwidthTNÚpixel_valuesgp?Úkwargsc                 ó\   >• SU;   a  UR                  S5      nX!S'   [        TU ]  " S0 UD6  g )NÚrescaleÚ
do_rescale© )ÚpopÚsuperÚ__init__)ÚselfrQ   Úrescale_valÚ	__class__s      €r   rX   ÚOwlv2ImageProcessor.__init__~   s3   ø€ ð ˜ÓØ Ÿ*™* YÓ/ˆKØ#.�<Ñ ä‰ÒÑ"˜6Ó"r!   Úoutputsr   Ú	thresholdrD   c                 ó°  • UR                   UR                  pT[        U5      nUb  [        U5      U:w  a  [        S5      e[        R
                  " USS9n[        R                  " UR                  5      nUR                  n	[        U5      nUb  [        XS5      n/ n
[        X‰U5       H*  u  p¼nX²:„  nX¾   nXÎ   nXÞ   nU
R                  X¼US.5        M,     U
$ )aÙ  
Converts the raw output of [`Owlv2ForObjectDetection`] into final bounding boxes in (top_left_x, top_left_y,
bottom_right_x, bottom_right_y) format.

Args:
    outputs ([`Owlv2ObjectDetectionOutput`]):
        Raw outputs of the model.
    threshold (`float`, *optional*, defaults to 0.1):
        Score threshold to keep object detection predictions.
    target_sizes (`torch.Tensor` or `list[tuple[int, int]]`, *optional*):
        Tensor of shape `(batch_size, 2)` or list of tuples (`tuple[int, int]`) containing the target size
        `(height, width)` of each image in the batch. If unset, predictions will not be resized.

Returns:
    `list[Dict]`: A list of dictionaries, each dictionary containing the following keys:
    - "scores": The confidence scores for each predicted box on the image.
    - "labels": Indexes of the classes predicted by the model on the image.
    - "boxes": Image bounding boxes in (top_left_x, top_left_y, bottom_right_x, bottom_right_y) format.
z9Make sure that you pass in as many target sizes as imageséÿÿÿÿr7   ©ÚscoresÚlabelsr$   )ÚlogitsÚ
pred_boxesÚlenÚ
ValueErrorr   r)   ÚsigmoidÚvaluesÚindicesr   rJ   ÚzipÚappend)rY   r]   r^   rD   Úbatch_logitsÚbatch_boxesÚ
batch_sizeÚbatch_class_logitsÚbatch_scoresÚbatch_labelsÚresultsrb   rc   r$   Úkeeps                  r   Úpost_process_object_detectionÚ1Owlv2ImageProcessor.post_process_object_detectionˆ   sß   € ð2 %,§N¡N°G×4FÑ4F�kÜ˜Ó&ˆ
àÑ#¬¨LÓ(9¸ZÓ(GÜÐXÓYÐYô #ŸYšY |¸Ñ<ÐÜ—}’}Ð%7×%>Ñ%>Ó?ˆØ)×1Ñ1ˆô /¨{Ó;ˆð Ñ#Ü& {ÓAˆKàˆÜ%(¨À[Ö%QÑ!ˆF˜EØÑ%ˆDØ‘\ˆFØ‘\ˆFØ‘KˆEØ�N‰N fÈÑOÖPñ &Rð ˆr!   c                 ó  • UR                   UR                  peUb#  [        U5      [        U5      :w  a  [        S5      eUb  UR                  S   S:w  a  [        S5      e[
        R                  " USS9n[
        R                  " UR                  5      n[        U5      nUS:  a†  [        UR                  S	   5       Hj  n	[
        R                  " X‰   * 5       HJ  n
X‰   U
   (       d  M  [        Xi   U
SS24   R                  S	5      Xi   5      S	   S	   nS
Xº'   SX‰   X³:„  '   ML     Ml     Ub  [        Xd5      n/ n[
        R                  " U5      n[        UR                  S	   5       HŸ  n	X‰   nUR!                  5       R#                  5       (       d  M,  SXîU:  '   [
        R                  " U5      S-   nXïS-  -
  US-  -  n[
        R$                  " USS5      nUXÙ'   XÙ   S	:„  nXÙ   U   nXi   U   nUR'                  USUS.5        M¡     U$ )a2  
Converts the output of [`Owlv2ForObjectDetection.image_guided_detection`] into the format expected by the COCO
api.

Args:
    outputs ([`Owlv2ImageGuidedObjectDetectionOutput`]):
        Raw outputs of the model.
    threshold (`float`, *optional*, defaults to 0.0):
        Minimum confidence threshold to use to filter out predicted boxes.
    nms_threshold (`float`, *optional*, defaults to 0.3):
        IoU threshold for non-maximum suppression of overlapping boxes.
    target_sizes (`torch.Tensor`, *optional*):
        Tensor of shape (batch_size, 2) where each entry is the (height, width) of the corresponding image in
        the batch. If set, predicted normalized bounding boxes are rescaled to the target sizes. If left to
        None, predictions will not be unnormalized.

Returns:
    `list[Dict]`: A list of dictionaries, each dictionary containing the scores, labels and boxes for an image
    in the batch as predicted by the model. All labels are set to None as
    `Owlv2ForObjectDetection.image_guided_detection` perform one-shot object detection.
NzTMake sure that you pass in as many target sizes as the batch dimension of the logitsr   r#   zTEach element of target_sizes must contain the size (h, w) of each image of the batchr`   r7   g      ð?r   g      ð¿ç        g�íµ ÷Æ°>çš™™™™™¹?gÍÌÌÌÌÌì?ra   )rd   Útarget_pred_boxesrf   rg   Úshaper   r)   rh   ri   r   ÚrangeÚargsortr5   rA   rJ   Ú
zeros_likeÚnonzeroÚnumelÚcliprl   )rY   r]   r^   Únms_thresholdrD   rd   Útarget_boxesÚprobsrb   ÚidxrE   Úiousrs   ÚalphasÚquery_scoresÚ	max_scoreÚquery_alphasÚmaskÚ
box_scoresr$   s                       r   Ú#post_process_image_guided_detectionÚ7Owlv2ImageProcessor.post_process_image_guided_detection½   s  € ð,  'Ÿ~™~¨w×/HÑ/H�àÑ#¬¨F«´s¸<Ó7HÓ(HÜÐsÓtÐtØÑ#¨×(:Ñ(:¸1Ñ(=ÀÓ(BÜÐsÓtÐtä—	’	˜& bÑ)ˆÜ—’˜uŸ|™|Ó,ˆô 0°Ó=ˆð ˜3ÓÜ˜\×/Ñ/°Ñ2Ö3�ÜŸš¨© |Ö4�AØ!™; qŸ>Ù ä" <Ñ#4°Qº°TÑ#:×#DÑ#DÀQÓ#GÈÑIZÓ[Ð\]Ñ^Ð_`Ña�DØ"�D‘GØ8;�F‘K Ñ 4Ó5ó 5ñ 4ð Ñ#Ü'¨ÓCˆLð ˆÜ×!Ò! &Ó)ˆä˜×+Ñ+¨AÑ.Ö/ˆCà!™;ˆLØ×'Ñ'Ó)×/Ñ/×1Ñ1Ùð 69ˆL¨	Ñ1Ñ2ô Ÿ	š	 ,Ó/°$Ñ6ˆIØ(¸©OÑ<ÀÈSÁÑQˆLÜ Ÿ:š: l°C¸Ó=ˆLØ&ˆF‰Kà‘; ‘?ˆDØ™ TÑ*ˆJØ Ñ% dÑ+ˆEØ�N‰N j¸DÈ5ÑQÖRñ' 0ð* ˆr!   Úimagesztorch.TensorÚconstant_valueÚreturnc                 ó‚   • UR                   SS u  p4[        X45      nXS-
  nXT-
  nSSXv4n[        R                  " XUS9n	U	$ )z,
Pad an image with zeros to the given size.
éþÿÿÿNr   )Úfill)r{   r)   ÚtvFÚpad)
rY   r�   r�   rN   rO   ÚsizeÚ
pad_bottomÚ	pad_rightÚpaddingÚpadded_images
             r   Ú_pad_imagesÚOwlv2ImageProcessor._pad_images
  sP   € ð Ÿ™ R SÐ)‰ˆÜ�6Ó!ˆØ‘]ˆ
Ø‘Lˆ	à�a˜Ð/ˆÜ—w’w˜v°^ÑDˆØÐr!   Údisable_groupingc                 ó�   • [        XS9u  pV0 nUR                  5        H  u  p‰U R                  U	US9n	X—U'   M     [        Xv5      n
U
$ )zx
Unlike the Base class `self.pad` where all images are padded to the maximum image size,
Owlv2 pads an image to square.
©rž   )r�   )r   Úitemsrœ   r	   )rY   r�   rž   r�   rQ   Úgrouped_imagesÚgrouped_images_indexÚprocessed_images_groupedr{   Ústacked_imagesÚprocessed_imagess              r   r–   ÚOwlv2ImageProcessor.pad  sg   € ô 0EÀVÑ/oÑ,ˆØ#%Ð Ø%3×%9Ñ%9Ö%;Ñ!ˆEØ!×-Ñ-ØØ-ð .ð ˆNð /= UÓ+ñ &<ô *Ð*BÓYÐàÐr!   Úimager—   Úanti_aliasingc                 ó†  >• UR                   UR                  4nUR                  n[        R                  " USS 5      R                  UR                  5      [        R                  " U5      R                  UR                  5      -  nU(       Ga#  Uc  US-
  S-  R                  SS9nO�[        R                  " U5      [        R                  " U5      -  n[        R                  " US:  5      (       a  [        S5      e[        R                  " US:„  US:*  -  5      (       a  [        R                  " S5        [        R                  " US:H  5      (       a  Un	O[S[        R                  " SU-  5      R                  5       -  S-   n
[         R"                  " XS   U
S   4UR%                  5       S	9n	OUn	[&        TU ]Q  X’S
S9$ )a  
Resize an image as per the original implementation.

Args:
    image (`Tensor`):
        Image to resize.
    size (`dict[str, int]`):
        Dictionary containing the height and width to resize the image to.
    anti_aliasing (`bool`, *optional*, defaults to `True`):
        Whether to apply anti-aliasing when downsampling the image.
    anti_aliasing_sigma (`float`, *optional*, defaults to `None`):
        Standard deviation for Gaussian kernel when downsampling the image. If `None`, it will be calculated
        automatically.
r#   Nr   r   r'   zFAnti-aliasing standard deviation must be greater than or equal to zerozWAnti-aliasing standard deviation greater than zero but not down-sampling along all axesr   )ÚsigmaF)r—   Ú	antialias)rN   rO   r{   r   r<   rB   rC   r*   Ú
atleast_1dÚ	ones_likeÚanyrg   ÚwarningsÚwarnÚceilr   r•   Úgaussian_blurÚtolistrW   Úresize)rY   r¨   r—   r©   Úanti_aliasing_sigmarQ   Úoutput_shapeÚinput_shapeÚfactorsÚfilteredÚkernel_sizesr[   s              €r   rµ   ÚOwlv2ImageProcessor.resize/  s„  ø€ ð, Ÿ™ T§Z¡ZÐ0ˆà—k‘kˆô —,’,˜{¨1¨2˜Ó/×2Ñ2°5·<±<Ó@Ä5Ç<Â<ÐP\ÓC]×C`ÑC`Ðaf×amÑamÓCnÑnˆçØ"Ñ*Ø(/°!©°qÑ'8×&?Ñ&?ÀAÐ&?Ð&FÑ#ä&+×&6Ò&6Ð7JÓ&KÌeÏoÊoÐ^eÓNfÑ&fÐ#Ü—9’9Ð0°1Ñ4×5Ñ5Ü$Ð%mÓnÐnÜ—Y’YÐ 3°aÑ 7¸GÀq¹LÑI×JÑJÜ—M’MØqôô �yŠyÐ,°Ñ1×2Ñ2Ø ‘à ¤5§:¢:¨aÐ2EÑ.EÓ#F×#JÑ#JÓ#LÑLÈqÑP�ä×,Ò,Ø¨™O¨\¸!©_Ð=ÐEX×E_ÑE_ÓEañ‘ð
 ˆHä‰w‰~˜h¸Uˆ~ÐCÐCr!   Ú	do_resizeÚresamplezPILImageResampling | NoneÚdo_padrT   Úrescale_factorÚdo_normalizeÚ
image_meanÚ	image_stdÚreturn_tensorsc           	      ó   • [        XS9u  pï0 nUR                  5        H  u  nnU R                  UXgSXš5      nUUU'   M!     [        UU5      nU(       a  U R	                  USUS9n[        UUS9u  pï0 nUR                  5        H$  u  nnU(       d  M  U R                  UX4S9nUUU'   M&     [        UU5      n[        UUS9u  pï0 nUR                  5        H  u  nnU R                  USXxXš5      nUUU'   M!     [        UU5      n[        SU0US9$ )Nr    Frx   )r�   rž   )r¨   r—   r¾   rP   )ÚdataÚtensor_type)r   r¡   Úrescale_and_normalizer	   r–   rµ   r   )rY   r�   r½   r—   r¾   r¿   rT   rÀ   rÁ   rÂ   rÃ   rž   rÄ   rQ   r¢   r£   r¤   r{   r¥   r¦   Úresized_images_groupedÚresized_stackÚresized_imagess                          r   Ú_preprocessÚOwlv2ImageProcessor._preprocesse  sb  € ô" 0EÀVÑ/oÑ,ˆØ#%Ð à%3×%9Ñ%9Ö%;Ñ!ˆE�>à!×7Ñ7Ø 
¸EÀ:óˆNð /=Ð$ UÓ+ñ &<ô *Ð*BÐDXÓYÐæØ#Ÿx™xÐ(8ÈÐ_o˜xÐpÐä/DØÐ/?ñ0
Ñ,ˆð "$ÐØ%3×%9Ñ%9Ö%;Ñ!ˆE�>ßˆyØ $§¡°.Àt Ð _�Ø0=Ð& uÓ-ñ &<ô (Ð(>Ð@TÓUˆô 0EÀ^ÐfvÑ/wÑ,ˆØ#%Ð Ø%3×%9Ñ%9Ö%;Ñ!ˆE�>à!×7Ñ7Ø  ~ÀZóˆNð /=Ð$ UÓ+ñ &<ô *Ð*BÐDXÓYÐä .Ð2BÐ!CÐQ_Ñ`Ð`r!   rU   )ry   N)rx   g333333Ó?N)rx   )TN))Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__r   ÚBILINEARr¾   r
   rÂ   r   rÃ   r—   Údefault_to_squareÚ	crop_sizer½   Údo_center_croprT   rÁ   Údo_convert_rgbÚmodel_input_namesrÀ   r¿   r   r   rX   r   r   r:   r;   ru   r�   rœ   Úboolr–   r   rµ   Ústrr   rÌ   Ú__static_attributes__Ú__classcell__)r[   s   @r   rL   rL   m   s	  ø† à!×*Ñ*€HØ!€JØ€IØ CÑ(€DØÐØ€IØ€IØ€NØ€JØ€LØ€NØ'Ð(ÐØ€NØ€Fð# ¨Ñ!5÷ #ð Ø8<ñ	3à-ð3ð ð3ð ! 4¨¡;Ñ.°Ñ5õ	3ôjKñZ .ð À%ð ÐR`õ ð" !$ñ	 à�^Ñ$ð ð  ™+ð ð ð	 ð 
ˆnÑ	õ ð8 #Ø ñ4Dàð4Dð ð4Dð ð	4Dð 
÷4Dð 4Dðl7aà�^Ñ$ð7að ð7að ð	7að
 .ð7að ð7að ð7að ð7að ð7að ˜D ™KÑ'¨$Ñ.ð7að ˜4 ™;Ñ&¨Ñ-ð7að  ™+ð7að ˜jÑ(¨4Ñ/ð7að 
÷7aò 7ar!   rL   )$r°   Útypingr   r   Ú$torchvision.transforms.v2.functionalÚ
transformsÚv2Ú
functionalr•   Úimage_processing_backendsr   Úimage_processing_utilsr   Úimage_transformsr   r   r	   Úimage_utilsr
   r   r   r   Úprocessing_utilsr   r   Úutilsr   r   Úmodeling_owlv2r   r    r%   r5   rJ   rL   Ú__all__rU   r!   r   Ú<module>ré      sy   ðó* Ý  ã ß 2Ó 2å ;Ý 2ß _Ñ _ß ZÓ Zß 4ß /ö Ý:òGòEòò ð> ônaÐ,ó naó ðnaðb	 !Ð
!�r!   