sgRodZddlZddlZddlmZddlmZmZmZm Z m Z m Z m Z m Z mZddlZddlmZmZmZddlmZmZmZmZmZmZmZmZmZddlm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/dd l0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:e7r ddl;Z;dd l;mZ?ddl@Z?e:jeBZCe"je"jfZFdJd e eGeGffd ZH dJd ejdeGdeGde eeJe$fd e eGeGff dZK dKd ejdeeGe eGeGfe eGfde eGde eeJe$fd e eGeGff dZLd efdZMdJdejde eGd ejfdZNdede eGeGfd efdZOde ed e efdZP dJde ejde eeJe$fd e eGfdZQ dJd ejd!e eGeGfde eeJe$fd ejfd"ZRd#eGd$eGd ejfd%ZS dLd&eTde ee$eJffd'ZUd(ejd ejfd)ZV dMd ejd*ed+eeJejfd,eTdee$eJfd ef d-ZX dNd(ejd.e d/e fd0ZYd1ejd/e eGeGfd2eGd ejfd3ZZd4ejd e ejejffd5Z[ dOd6ejd(ejd7ejd8e eGeGfd/e eGeGfd9ed efd:Z\d;e&jfdeeJefde&f d?Z_d@Z`dAZadBZbdPdCZc dQdDe^dEe^dFe e eGd/e eGeGffdGZdGdHdIeZedIgZfy)RzImage processor class for DETR.N) defaultdict) AnyCallableDictIterableListOptionalSetTupleUnion)BaseImageProcessor BatchFeature get_size_dict) PaddingModecenter_to_corners_formatcorners_to_center_format id_to_rgbpadrescaleresize rgb_to_idto_channel_dimension_format)IMAGENET_DEFAULT_MEANIMAGENET_DEFAULT_STDAnnotationFormatAnnotationTypeChannelDimension ImageInputPILImageResamplingget_image_sizeinfer_channel_dimension_formatis_scaled_imagemake_list_of_imagesto_numpy_array valid_imagesvalidate_annotationsvalidate_kwargsvalidate_preprocess_arguments) TensorTypeis_flax_available is_jax_tensoris_scipy_availableis_tf_available is_tf_tensoris_torch_availableis_torch_tensoris_vision_availablelogging)nnreturnc|\}}d}|Stt||f}tt||f}||z |z|kDr||z|z }tt |}||kr||k(s ||kr ||k(r||} }|| fS||kr0|} ||t||z|z }|| fSt||z|z }|| fS|}||t||z|z } || fSt||z|z } || fS)aC Computes the output image size given the input image size and the desired output size. Args: image_size (`Tuple[int, int]`): The input image size. size (`int`): The desired output size. max_size (`int`, *optional*): The maximum allowed output size. N)floatminmaxintround) image_sizesizemax_sizeheightwidthraw_sizemin_original_sizemax_original_sizeohows a/var/www/html/venv/lib/python3.12/site-packages/transformers/models/detr/image_processing_detr.pyget_size_with_aspect_ratiorGXsFMFEH!#vuo"67!#vuo"67 0 04 7( B"336GGHuX'D%FdNETMB 8O    H$8X&./B 8OTF]U*+B 8O   H$8X%./B 8OTE\F*+B 8O input_image max_height max_widthinput_data_formatct||}|\}}||z }||z }t||} t|| z} t|| z} | | fS)a Computes the output image size given the input image and the maximum allowed height and width. Keep aspect ratio. Important, even if image_height < max_height and image_width < max_width, the image will be resized to at least one of the edges be equal to max_height or max_width. For example: - input_size: (100, 200), max_height: 50, max_width: 50 -> output_size: (25, 50) - input_size: (100, 200), max_height: 200, max_width: 500 -> output_size: (200, 400) Args: input_image (`np.ndarray`): The image to resize. max_height (`int`): The maximum allowed height. max_width (`int`): The maximum allowed width. input_data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format of the input image. If not provided, it will be inferred from the input image. )r!r8r:) rIrJrKrLr<r?r@ height_scale width_scale min_scale new_height new_widths rF#get_image_size_for_max_height_widthrSsc2 ->?JMFE&Le#KL+.IVi'(JEI%&I y  rHr=r>cdt||}t|ttfr|St |||S)a Computes the output image size given the input image size and the desired output size. If the desired output size is a tuple or list, the output image size is returned as is. If the desired output size is an integer, the output image size is computed by keeping the aspect ratio of the input image size. Args: input_image (`np.ndarray`): The image to resize. size (`int` or `Tuple[int, int]` or `List[int]`): The desired output size. max_size (`int`, *optional*): The maximum allowed output size. input_data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format of the input image. If not provided, it will be inferred from the input image. )r! isinstancelisttuplerG)rIr=r>rLr<s rFget_resize_output_image_sizerXs3* ->?J$u & %j$ AArHcft|tjrtjSt rt |rddl}|jStrt|rddl }|jStrt|rddlm}|jSt!dt#|)z Returns a function that converts a numpy array to the framework of the input array. Args: arr (`np.ndarray`): The array to convert. rNzCannot convert arrays of type )rUnpndarrayarrayr.r/ tensorflowconvert_to_tensorr0r1torchtensorr+r, jax.numpynumpy ValueErrortype)arrtfr_jnps rFget_numpy_to_framework_fnrhs#rzz"xx\#.### 4||}S1yy 5d3i[A BBrHreaxiscn||jS |j|S#t$r|cYSwxYw)zF Squeezes an array, but only if the axis specified has dim 1. ri)squeezerc)reris rF safe_squeezerms? |{{}{{{%%  s & 44 annotationr<c|\}}i}|jD]N\}}|dk(r?|}t|}|tj||||gtjz}|||<J|||<P|S)Nboxesdtype)itemsrrZasarrayfloat32)rnr< image_height image_widthnorm_annotationkeyvaluerps rFnormalize_annotationr{s *L+O &&() U '>E,U3E RZZlK V^`^h^hi iE#(OC #(OC ) rHvaluescJt|Dcgc] }t|c}Scc}w)zO Return the maximum value across all indices of an iterable of values. )zipr9)r|values_is rFmax_across_indicesrs +.v, 7hCM 77 7s imagescJ|t|d}|tjk(r+t|Dcgc]}|jc}\}}}||fS|tj k(r+t|Dcgc]}|jc}\}}}||fSt d|cc}wcc}w)zH Get the maximum height and width across all images in a batch. rz"Invalid channel dimension format: )r"rFIRSTrshapeLASTrc)rrLimg_rJrKs rFget_max_height_widthrs  :6!9E,222#5F6SSsyy6S#T :y  "" .33 3#5F6SSsyy6S#T Iq  ""=>O=PQRR 7T6Ss B+B image output_sizect||\}}tj|tj}d|d|d|f<|S)a Make a pixel mask for the image, where 1 indicates a valid pixel and 0 indicates padding. Args: image (`np.ndarray`): Image to make the pixel mask for. output_size (`Tuple[int, int]`): Output size of the mask.  channel_dimrqN)r!rZzerosint64)rrrL input_height input_widthmasks rFmake_pixel_maskr sF!/uBS TL+ 88Krxx 0D()D,  $% KrHr?r@c ddlm}g}|D]}|j|||}|j |}t |j dkr|d}tj|tj}tj|d}|j||rtj|d}|Stjd||ftj}|S#t$r tdwxYw) a1 Convert a COCO polygon annotation to a mask. Args: segmentations (`List[List[float]]`): List of polygons, each polygon represented by a list of x-y coordinates. height (`int`): Height of the mask. width (`int`): Width of the mask. rrz1Pycocotools is not installed in your environment.r ).Nrqrk) pycocotoolsr ImportError frPyObjectsdecodelenrrZrtuint8anyappendstackr) segmentationsr?r@ coco_maskmaskspolygonsrlesrs rFconvert_coco_poly_to_maskr sO1 E!$$Xvu=% tzz?Q  ?Dzz$bhh/vvd# T Q' L!VU+288< L# OMNNOs C$$C9return_segmentation_masksct||\}}|d}tj|gtj}|d}|Dcgc]}d|vs |ddk(s|}}|Dcgc]}|d } }tj| tj} tj|Dcgc]}|d c}tj} tj|Dcgc] }d|vr|dndc}tj} |Dcgc]}|d  } }tj| tjj d d } | d d d d fxx| d d d d fz cc<| d d dd d fj d|| d d dd d f<| d d dd d fj d|| d d dd d f<| d d df| d d dfkD| d d d f| d d dfkDz} i}||d<| | |d<| | |d<| | |d<| | |d<tjt|t|gtj|d<|rld|dvre|Dcgc]}|d }}tj|tj}|| }|jd}|r|j dn|}||d<|r'|Dcgc]}|d }}t|||}|| |d<|Scc}wcc}wcc}wcc}wcc}wcc}wcc}w)zM Convert the target in COCO format into the format expected by DETR. rimage_idrq annotationsiscrowdr category_idareabboxNr)r8r9rr class_labelsrp orig_size keypoints)rr segmentationr) r!rZrtrrureshapeclipr:rr)rtargetrrLrvrwrrobjclassesrrrpkeep new_targetr num_keypointssegmentation_masksrs rF!prepare_coco_detection_annotationrCs!/uBS TL+j!Hzz8*BHH5H'K"-]3#1EY[\I\3]K]-89cs=!9G9jj1G ::k:ss6{:"** MDjj{[I,<#i.!C[ceckcklG$/ 0SS[ 0E 0 JJuBJJ / 7 7A >E !QR%LE!RaR%L L1add7^((QK(@E!QTT'N1add7^((QL(AE!QTT'N !Q$K%1+ %%1+ad *C DDJ%Jz!(J~+JwdJv#DMJy jj#l*;S=M)NVXV^V^_J{{k!n41<=#S%= =JJy ; dO !* 2?I%%g.Y "+ ; =HIcc.1II)*Js0KK! K' K$K) K. K35 K8rc||jdk(rtjdS|jdd\}}tjd|tj }tjd|tj }tj ||d\}}|tj|dz}|j|jdd jd }tjj|tj|t }|jd }|j|jdd jd }|tj|dz}|j|jdd jd } tjj|tj|t }|jd } | j| jdd jd } tj|| || gd S)a Compute the bounding boxes around the provided panoptic segmentation masks. Args: masks: masks in format `[number_masks, height, width]` where N is the number of masks Returns: boxes: bounding boxes in format `[number_masks, 4]` in xyxy format r)rrNrqij)indexingrkrrgחA) fill_valuer)r=rZrrarangerumeshgrid expand_dimsrr9mar\boolfilledr8r) rhwyxx_maskx_maxx_miny_masky_maxy_mins rFmasks_to_boxesrs zzQxx ;;rs DAq !Qbjj)A !Qbjj)A ;;q!d +DAq R^^AA. .F NN6<<?B / 3 3B 7E  F288E#>!? @A HHH $E MM%++a." - 1 1" 5E R^^AA. .F NN6<<?B / 3 3B 7E  F288E#>!? @A HHH $E MM%++a." - 1 1" 5E 88UE5%0! 44rHr masks_path return_masksczt||\}}tj||dz }i}tjd|vr|dn|dgtj |d<tj||gtj |d<tj||gtj |d<d|vrktjt jj|tj} t| } tj|dD cgc]} | d c} } | | d d d d fk(} | jtj} |r| |d <t| |d <tj|dD cgc]} | d  c} tj |d <tj|dD cgc]} | d c} tj |d<tj|dD cgc]} | d c} tj|d<|Scc} wcc} wcc} wcc} w)z6 Prepare a coco panoptic annotation for DETR. r file_nameridrqr=r segments_infoNrrprrrr)r!pathlibPathrZrtrPILImageopenuint32rr\astyperrru) rrrrrLrvrwannotation_pathrr segment_infoidss rF prepare_coco_panoptic_annotationrs!/uBS TL+ll:. 1DDOJZZzV?S );Y_`dYe(fnpnvnvwJz\;$?rxxPJv jj, )DBHHUJ{&  399>>/:"))L% hhvo?VW| T*WXQd]++ RXX& "'Jw ,U3 7%'XX=CO=T U\\- ( U]_]e]e& >"!# 9?9P Q\) $ QY[YaYa! 9 ZZ6<_6M Nl\& ! NVXV`V` 6 !X V R Os H) H. H3 H8 input_size target_sizec|\}}|\}}tjj|jddd} | jddk(r(t j ||ft j} n!| jdj||} |r'|jD]} | D] } | d| | | k(<t| } t| ||ftj} | S)Nrrrrqresample)scipyspecialsoftmax transposerrZrrargmaxrr|rrr NEAREST) rrrstuff_equiv_classes deduplicaterrfinal_hfinal_wm_idequiveq_idseg_imgs rFget_segmentation_imagers DAq"GW == A!6 ;D zz"~xxAbhh/{{2&&q!,(//1 /E /&+AhTU]# / /oGWw0;M;U;UVG NrHr n_classesc|\}}|jtj}|j||d}t |}t |Dcgc]}||k(j }}|Scc}w)Nr )rrZrrrrangesum) rrrrr np_seg_imgrirs rF get_mask_arearsi"GW)J##GWa8J Z D',Y'7 8!TQYOO  8D 8 K 9sA.logitsctjj|d}|jdd}t j ||d}|j d|j d}}||fS)NrrkT)keepdims)rrrrrZtake_along_axisrl)rprobslabelsscoress rF%score_labels_from_class_probabilitiesrsf MM ! !&r ! 2E \\"t\ ,F   vB 7F^^B');FF 6>rH out_logitsrpprocessed_size is_thing_mapc t|\}}||jddz k7||kDz} || } || } t|| } t| t| k7r t d|| } t | dddf|t j} t| d} | j\}}}| j|d} tt}t| D]\}}||r ||j|!t| |||d}t| |t| }| j!d kDrt#j$|Dcgc]}|d k c}t& }|j)r| |} | |} | |} t| ||f||d}t||t| }t#j$|Dcgc]}|d k c}t& }|j)rxn%t#j*d t"j, } tt/| |Dcgc]\}\}}|||t1||d }}}}~ t3j45}t6j8j;|j=|d|j?|d}ddd|Scc}wcc}wcc}}}w#1swYSxYw)a Converts the output of [`DetrForSegmentation`] into panoptic segmentation predictions for a single sample. Args: out_logits (`torch.Tensor`): The logits for this sample. masks (`torch.Tensor`): The predicted segmentation masks for this sample. boxes (`torch.Tensor`): The prediced bounding boxes for this sample. The boxes are in the normalized format `(center_x, center_y, width, height)` and values between `[0, 1]`, relative to the size the image (disregarding padding). processed_size (`Tuple[int, int]`): The processed size of the image `(height, width)`, as returned by the preprocessing step i.e. the size after data augmentation but before batching. target_size (`Tuple[int, int]`): The target size of the image, `(height, width)` corresponding to the requested final size of the prediction. is_thing_map (`Dict`): A dictionary mapping class indices to a boolean value indicating whether the class is a thing or not. threshold (`float`, *optional*, defaults to 0.85): The threshold used to binarize the segmentation masks. rr&Not as many boxes as there are classesNrT)r)rrrrq)rrristhingrrPNGformat png_stringr) rrrrrcrr BILINEARrmrrrV enumeraterrrr=rZr\rronesrr~r:ioBytesIOrr fromarraysavegetvalue)r rrpr rr  thresholdrrr cur_scores cur_classes cur_boxes cur_masksbrrrklabelrrafiltered_smallrcatrout predictionss rFpost_process_panoptic_sampler*s@;:FNFF j&&r*Q. .6I3E FDJ,K(t5I 9~[))ABBd IyD)>DVD_D_`IY*IooGAq!!!!R(I%d+k*15E"  & - -a 01%Y M`nrsG Nc*o NDA4"8a16"8E  "!>/2I#^O4J%~o6K,YA M`nrsG +ZQDXXt&z$resize_annotation.._s!Y 658eFm+Ys$&r=rprqrrNrr) rWr~rsrZrtrur\rr)rnrrrrratios ratio_height ratio_widthnew_annotationryrzrp scaled_boxesr scaled_arearrs rFresize_annotationr9Is?,YSi=XY YF &L+N(N6 &&(( U '>E 2::{L+Wc.dlnlvlv#wwL&2N7 # F]D+ "<=K%0N6 " G^!T'NEHHW\]tfT;J]^ELL,E!Q$K)+E&+N7 # F]%0N6 ""'N3 %(( ^s.D ct|r|j}|j}tjdg|dgg}tj |dd|ddk7ddz}|dddxx|dddzcc<t |S)a Converts given binary mask of shape `(height, width)` to the run-length encoding (RLE) format. Args: mask (`torch.Tensor` or `numpy.array`): A binary mask tensor of shape `(height, width)` where 0 denotes background and 1 denotes the target segment_id or class_id. Returns: `List`: Run-length encoded list of the binary mask. Refer to COCO API for more information about the RLE format. rrNrr)r1rbflattenrZ concatenatewhererV)rpixelsrunss rFbinary_mask_to_rler@}stzz| \\^F ^^aS&1#. /F 88F12J&"+- .q 1A 5DAJ$ss)J :rHctj|}g}|D]8}tj||k(dd}t|}|j |:|S)a Converts given segmentation map of shape `(height, width)` to the run-length encoding (RLE) format. Args: segmentation (`torch.Tensor` or `numpy.array`): A segmentation map of shape `(height, width)` where each value denotes a segment or class id. Returns: `List[List]`: A list of lists, where each list is the run-length encoding of a segment / class id. rr)r_uniquer=r@r)r segment_idsrun_length_encodingsidxrrles rFconvert_segmentation_to_rlerGs^,,|,K){{<3.15 &##C() rHc|jd|jdcxk(r|jdk(stdtd|j|||kDz}||||||fS)a  Binarize the given masks using `object_mask_threshold`, it returns the associated values of `masks`, `scores` and `labels`. Args: masks (`torch.Tensor`): A tensor of shape `(num_queries, height, width)`. scores (`torch.Tensor`): A tensor of shape `(num_queries)`. labels (`torch.Tensor`): A tensor of shape `(num_queries)`. object_mask_threshold (`float`): A number between 0 and 1 used to binarize the masks. Raises: `ValueError`: Raised when the first dimension doesn't match in all input tensors. Returns: `Tuple[`torch.Tensor`, `torch.Tensor`, `torch.Tensor`]`: The `masks`, `scores` and `labels` without the region < `object_mask_threshold`. rz1mask, scores and labels must have the same shape!)rrcne)rrrobject_mask_threshold num_labelsto_keeps rFremove_low_and_no_objectsrMsy( KKNfll1o @a @LMM ALMMii #v0E'EFG >6'?F7O ;;rHc||k(}|j}|||k\j}|dkDxr|dkD}|r||z } | j|kDsd}||fS)NrF)ritem) mask_labels mask_probsr#mask_thresholdoverlap_mask_area_thresholdmask_k mask_k_area original_area mask_exists area_ratios rFcheck_segment_validityrYsr A F**,K ]n499;M/7ma&7K =0  #>>K  rHrRrSlabel_ids_to_fusec||jdn|d}||jdn|d}tj||ftj|j} g} |5t j j|jd|ddd}d} ||jdddz}|jd} i} t|jdD]}}||j}||v}t| ||||\}}|s/|| vr| |} n| dz } | | |<t||jd }| j| |||d |sy| | |<| | fS) NrrrrrdevicebilinearFr=mode align_cornersr)rlabel_id was_fusedscore)rr_rint32r]r4 functional interpolate unsqueezeviewrrrOrYr;r)rQ pred_scores pred_labelsrRrSrZrr?r@rsegmentscurrent_segment_idrPstuff_memory_listr# pred_class should_fuserWrT segment_scores rFcompute_segmentsrss%0$7Z  a [^F#.#6J  Q KNE;;ekk*J[J[\LH]]..   #+JV[/  +""2q!,,J##A&K)+ ;$$Q' (C ^((*  $55 5 Q8S  V ..%6z%B""a'"$6L !+a."5"5"7;M OO, *!,*  0B!*-7C:  !!rHc(eZdZdZddgZej ddejddddddddf de e efde d e e e fd ed e d e e efd e de eeefde eeefdee de dee e e fddffd Zede e efffd Z d?dej,de deede dee e ej0fdee e efde fdZejddfdej,d e e e fd edeedee e efdej,f dZej8fd ede fdZ d@dej,d edee e efdee e efdej,f d Zd!e d"ee e fde fd#Z d!e d$ee e fd%ee e fde fd&Z! dAdej,d'ee e fd!ee e efd(e ee"efdeedee e efd)e dej,fd*Z# dBd+eej,d,ee e$ee$fd(e ee"efd-e d.ee e e%fdeedee e efd)e dee e e fde&fd/Z'dddddddddddddddejPddfd+e)d,ee e$ee$fde dee e ej0fdee d ee e e fd ee d ee e efd ee dee dee eeefdee eeefdee dee e efd.ee e%e fde e efdee e efdee e e fde&f&d0Z*d1Z+dCd2Z,dDd3Z-dEd4Z. dFd5ed6e e%eeffd7Z/dGd6eee e ffd8Z0 dHd5ed9ed:ed6eeee e fd;ee dee f d<Z1 dId5ed9ed:ed=ee2e d6eeee e fdee f d>Z3xZ4S)JDetrImageProcessora Constructs a Detr image processor. Args: format (`str`, *optional*, defaults to `"coco_detection"`): Data format of the annotations. One of "coco_detection" or "coco_panoptic". do_resize (`bool`, *optional*, defaults to `True`): Controls whether to resize the image's `(height, width)` dimensions to the specified `size`. Can be overridden by the `do_resize` parameter in the `preprocess` method. size (`Dict[str, int]` *optional*, defaults to `{"shortest_edge": 800, "longest_edge": 1333}`): Size of the image's `(height, width)` dimensions after resizing. Can be overridden by the `size` parameter in the `preprocess` method. Available options are: - `{"height": int, "width": int}`: The image will be resized to the exact size `(height, width)`. Do NOT keep the aspect ratio. - `{"shortest_edge": int, "longest_edge": int}`: The image will be resized to a maximum size respecting the aspect ratio and keeping the shortest edge less or equal to `shortest_edge` and the longest edge less or equal to `longest_edge`. - `{"max_height": int, "max_width": int}`: The image will be resized to the maximum size respecting the aspect ratio and keeping the height less or equal to `max_height` and the width less or equal to `max_width`. resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BILINEAR`): Resampling filter to use if resizing the image. do_rescale (`bool`, *optional*, defaults to `True`): Controls whether to rescale the image by the specified scale `rescale_factor`. Can be overridden by the `do_rescale` parameter in the `preprocess` method. rescale_factor (`int` or `float`, *optional*, defaults to `1/255`): Scale factor to use if rescaling the image. Can be overridden by the `rescale_factor` parameter in the `preprocess` method. do_normalize (`bool`, *optional*, defaults to True): Controls whether to normalize the image. Can be overridden by the `do_normalize` parameter in the `preprocess` method. image_mean (`float` or `List[float]`, *optional*, defaults to `IMAGENET_DEFAULT_MEAN`): Mean values to use when normalizing the image. Can be a single value or a list of values, one for each channel. Can be overridden by the `image_mean` parameter in the `preprocess` method. image_std (`float` or `List[float]`, *optional*, defaults to `IMAGENET_DEFAULT_STD`): Standard deviation values to use when normalizing the image. Can be a single value or a list of values, one for each channel. Can be overridden by the `image_std` parameter in the `preprocess` method. do_convert_annotations (`bool`, *optional*, defaults to `True`): Controls whether to convert the annotations to the format expected by the DETR model. Converts the bounding boxes to the format `(center_x, center_y, width, height)` and in the range `[0, 1]`. Can be overridden by the `do_convert_annotations` parameter in the `preprocess` method. do_pad (`bool`, *optional*, defaults to `True`): Controls whether to pad the image. Can be overridden by the `do_pad` parameter in the `preprocess` method. If `True`, padding will be applied to the bottom and right of the image with zeros. If `pad_size` is provided, the image will be padded to the specified dimensions. Otherwise, the image will be padded to the maximum height and width of the batch. pad_size (`Dict[str, int]`, *optional*): The size `{"height": int, "width" int}` to pad the images to. Must be larger than any image size provided for preprocessing. If `pad_size` is not provided, images will be padded to the largest height and width in the batch. pixel_values pixel_maskTNgp?r do_resizer=r do_rescalerescale_factor do_normalize image_mean image_stddo_convert_annotationsdo_padpad_sizer5c  d| vr| jd} d| vr'tjd| jd}n|dnd}||nddd}t||d}| |} t |d i| ||_||_||_||_ ||_ ||_ ||_ | |_ ||nt|_| | nt |_| |_| |_gd |_y) Npad_and_return_pixel_maskr>vThe `max_size` parameter is deprecated and will be removed in v4.26. Please specify in `size['longest_edge'] instead`.i5i ) shortest_edge longest_edgeFr>default_to_square)rrrrrxr=rryrzr{r~r|r}rrrreturn_tensors data_formatrL)poplogger warning_oncersuper__init__rrxr=rryrzr{r~rr|rr}rr_valid_processor_keys)selfrrxr=rryrzr{r|r}r~rrkwargsr> __class__s rFrzDetrImageProcessor.__init__Js '& 0ZZ ;*DY&/&;AU   & "rHimage_processor_dictc |j}d|vr|jd|d<d|vr|jd|d<t| |fi|S)a Overrides the `from_dict` method from the base class to make sure parameters are updated if image processor is created using from_dict and kwargs e.g. `DetrImageProcessor.from_pretrained(checkpoint, size=600, max_size=800)` r>r)copyrr from_dict)clsrrrs rFrzDetrImageProcessor.from_dictsd 488:  /5zz*/E  , && 0@F Kf@g !< =w !5@@@rHrrrrrLc||n |j}|tjk(r|dn|}t||||}|S|tjk(r|dn|}t |||||}|St d|d)zD Prepare an annotation for feeding into DETR model. FrLT)rrrLzFormat z is not supported.)rrCOCO_DETECTIONr COCO_PANOPTICrrc)rrrrrrrLs rFprepare_annotationz%DetrImageProcessor.prepare_annotations"-4;; %44 41J1RXq %6v8L]F '55 50I0QWp %5%6"3 F wvh.@AB BrHrc vd|vr'tjd|jd}nd}t||d}d|vrd|vrt ||d|d|}nNd |vrd |vrt ||d |d |}n0d |vrd |vr |d |d f}nt d |jdt|f||||d|}|S)a Resize the image to the given size. Size can be `min_size` (scalar) or `(height, width)` tuple. If size is an int, smaller edge of the image will be matched to this number. Args: image (`np.ndarray`): Image to resize. size (`Dict[str, int]`): Size of the image's `(height, width)` dimensions after resizing. Available options are: - `{"height": int, "width": int}`: The image will be resized to the exact size `(height, width)`. Do NOT keep the aspect ratio. - `{"shortest_edge": int, "longest_edge": int}`: The image will be resized to a maximum size respecting the aspect ratio and keeping the shortest edge less or equal to `shortest_edge` and the longest edge less or equal to `longest_edge`. - `{"max_height": int, "max_width": int}`: The image will be resized to the maximum size respecting the aspect ratio and keeping the height less or equal to `max_height` and the width less or equal to `max_width`. resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BILINEAR`): Resampling filter to use if resizing the image. data_format (`str` or `ChannelDimension`, *optional*): The channel dimension format for the output image. If unset, the channel dimension format of the input image is used. input_data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format of the input image. If not provided, it will be inferred. r>rNFrrrrrJrKr?r@z\Size must contain 'height' and 'width' keys or 'shortest_edge' and 'longest_edge' keys. Got .)r=rrrL) rrrrrXrSrckeysr) rrr=rrrLrr>new_sizes rFrzDetrImageProcessor.resizesD     D zz*-HHTHN d "~'=3tO,d>.BVgHT !kT&9:tL)4 +/ +L+   .  % %&7 8 9 . $ eXijE"'D %4^L  "Wi(IS Z^D(N8 $(s C( C-c . d|vr&tjd|jd}d}d|vr&tjd|jd}| |jn|}| |jn|}t ||d}| |j n|}| |jn|}| |jn| } | |jn| } | |jn| } | |jn| } | |jn| } | |jn|}| |jn|}| |jn|}t!|}t#|s t%dt'|j)|j* t-|| | | | ||| |t/|t0r|g}|;t3|t3|k7r$t%d t3|d t3|d t5|}|t7|t8||K|t4j:k(r8t/|t<j>t@fst%dtC|d|Dcgc] }tE|}}tG|dr|rtjd|tI|d}|Wg}g}tK||D]>\}}|jM||||||}|jO||jO|@|}|}~~|r|gg}}tK||D]f\}}tQ||}|jS|||||}|jU||tQ||}|jO||jO|h|}|}~~n"|Dcgc]}|jS||||}}|r!|Dcgc]}|jW|| |}}| r"|Dcgc]}|jY|| | |}}| r:|8tK||Dcgc]!\}}|j[|tQ||#}}}|r|j]||d||| ||} | S|Dcgc]}t_|||}}tad|i|} ||Dcgc]}ta||c}| d<| Scc}wcc}wcc}wcc}wcc}}wcc}wcc}w)at Preprocess an image or a batch of images so that it can be used by the model. Args: images (`ImageInput`): Image or batch of images to preprocess. Expects a single or batch of images with pixel values ranging from 0 to 255. If passing in images with pixel values between 0 and 1, set `do_rescale=False`. annotations (`AnnotationType` or `List[AnnotationType]`, *optional*): List of annotations associated with the image or batch of images. If annotation is for object detection, the annotations should be a dictionary with the following keys: - "image_id" (`int`): The image id. - "annotations" (`List[Dict]`): List of annotations for an image. Each annotation should be a dictionary. An image can have no annotations, in which case the list should be empty. If annotation is for segmentation, the annotations should be a dictionary with the following keys: - "image_id" (`int`): The image id. - "segments_info" (`List[Dict]`): List of segments for an image. Each segment should be a dictionary. An image can have no segments, in which case the list should be empty. - "file_name" (`str`): The file name of the image. return_segmentation_masks (`bool`, *optional*, defaults to self.return_segmentation_masks): Whether to return segmentation masks. masks_path (`str` or `pathlib.Path`, *optional*): Path to the directory containing the segmentation masks. do_resize (`bool`, *optional*, defaults to self.do_resize): Whether to resize the image. size (`Dict[str, int]`, *optional*, defaults to self.size): Size of the image's `(height, width)` dimensions after resizing. Available options are: - `{"height": int, "width": int}`: The image will be resized to the exact size `(height, width)`. Do NOT keep the aspect ratio. - `{"shortest_edge": int, "longest_edge": int}`: The image will be resized to a maximum size respecting the aspect ratio and keeping the shortest edge less or equal to `shortest_edge` and the longest edge less or equal to `longest_edge`. - `{"max_height": int, "max_width": int}`: The image will be resized to the maximum size respecting the aspect ratio and keeping the height less or equal to `max_height` and the width less or equal to `max_width`. resample (`PILImageResampling`, *optional*, defaults to self.resample): Resampling filter to use when resizing the image. do_rescale (`bool`, *optional*, defaults to self.do_rescale): Whether to rescale the image. rescale_factor (`float`, *optional*, defaults to self.rescale_factor): Rescale factor to use when rescaling the image. do_normalize (`bool`, *optional*, defaults to self.do_normalize): Whether to normalize the image. do_convert_annotations (`bool`, *optional*, defaults to self.do_convert_annotations): Whether to convert the annotations to the format expected by the model. Converts the bounding boxes from the format `(top_left_x, top_left_y, width, height)` to `(center_x, center_y, width, height)` and in relative coordinates. image_mean (`float` or `List[float]`, *optional*, defaults to self.image_mean): Mean to use when normalizing the image. image_std (`float` or `List[float]`, *optional*, defaults to self.image_std): Standard deviation to use when normalizing the image. do_pad (`bool`, *optional*, defaults to self.do_pad): Whether to pad the image. If `True`, padding will be applied to the bottom and right of the image with zeros. If `pad_size` is provided, the image will be padded to the specified dimensions. Otherwise, the image will be padded to the maximum height and width of the batch. format (`str` or `AnnotationFormat`, *optional*, defaults to self.format): Format of the annotations. return_tensors (`str` or `TensorType`, *optional*, defaults to self.return_tensors): Type of tensors to return. If `None`, will return the list of images. data_format (`ChannelDimension` or `str`, *optional*, defaults to `ChannelDimension.FIRST`): The channel dimension format for the output image. Can be one of: - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format. - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format. - Unset: Use the channel dimension format of the input image. input_data_format (`ChannelDimension` or `str`, *optional*): The channel dimension format for the input image. If unset, the channel dimension format is inferred from the input image. Can be one of: - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format. - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format. - `"none"` or `ChannelDimension.NONE`: image in (height, width) format. pad_size (`Dict[str, int]`, *optional*): The size `{"height": int, "width" int}` to pad the images to. Must be larger than any image size provided for preprocessing. If `pad_size` is not provided, images will be padded to the largest height and width in the batch. rzuThe `pad_and_return_pixel_mask` argument is deprecated and will be removed in a future version, use `do_pad` instead.Nr>zrThe `max_size` argument is deprecated and will be removed in a future version, use `size['longest_edge']` instead.F)r=r>rzkInvalid image type. Must be of type PIL.Image.Image, numpy.ndarray, torch.Tensor, tf.Tensor or jax.ndarray.)captured_kwargsvalid_processor_keys)ryrzr{r|r}rxr=rzThe number of images (z) and annotations (z) do not match.zxThe path to the directory containing the mask PNG files should be provided as a `pathlib.Path` or string object, but is z instead.rzIt looks like you are trying to rescale already rescaled images. If the input images have pixel values between 0 and 1, set `do_rescale=False` to avoid rescaling them again.)rrrL)r=r>rrL)r=rrLrT)rrrrLrrr)input_channel_dimrvrrr)1rrrrxr=rrryrzr{r|r}r~rrrr$r&rcr(rrr)rUdictrrr'SUPPORTED_ANNOTATION_FORMATSrrrstrrdr%r#r"r~rrr!rr9r normalizer{rrr)!rrrrrrxr=rryrzr{r~r|r}rrrrrLrrr>rprepared_imagesprepared_annotationsrresized_imagesresized_annotationsr resized_imageresized_annotationrnrs! rF preprocesszDetrImageProcessor.preprocesssB '& 0   ( ZZ ;0F,,N,8,@t((l (2(:T__ &/&7DNNY +A+ID ' 'Oe !'F$,$44==( &F$V,F#:   DLfLfg &!)%!   "z+t'D&-K  "s6{c+6F'F(V 5H[IYHZZij "&)  " )E{ S  "*888zGLL#+>?<<@vay I   " O#% !$V[!9 4 v00.G)&7 1 &&u-$++F3 4%F.K!5 &68" 3%(%= CME6 .u6G HI$(KKD8hbs%0%M*.)?)? >-IZ+[*&#))-8'../AB C(1 "$7"(KKD8WhKi lrschdll5.L]l^sFs oufkuj)O`aF "k&=*-[&)A%J))*nUL]6^_K !XX'"&'"34-!& N*$,E;RcdF*/GUcdN&[f,MWLH,x(w=b t $ ,s*?Q3)Q8 Q=0R!&R+R Rc rtjd|j|j}}t |t |k7r t d|j ddk7r t dtjj|d}|dddfjd\}}t|}|jd\} } tj| | | | gd j|j } || dddddfz}t#|||D cgc] \} } }| | |d }} } }|Scc}} } w) aY Converts the raw output of [`DetrForObjectDetection`] into final bounding boxes in (top_left_x, top_left_y, bottom_right_x, bottom_right_y) format. Only supports PyTorch. Args: outputs ([`DetrObjectDetectionOutput`]): Raw outputs of the model. target_sizes (`torch.Tensor` of shape `(batch_size, 2)`): Tensor containing the size (height, width) of each image of the batch. For evaluation, this must be the original image size (before any data augmentation). For visualization, this should be the image size after data augment, but before padding. 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. z`post_process` is deprecated and will be removed in v5 of Transformers, please use `post_process_object_detection` instead, with `threshold=0.` for equivalent results.TMake sure that you pass in as many target sizes as the batch dimension of the logitsrrzTEach element of target_sizes must contain the size (h, w) of each image of the batchr.Ndimrrrp)rrr pred_boxesrrcrr4rgrr9runbindr_rtor]r~)routputs target_sizesr out_bboxprobrrrpimg_himg_w scale_fctr0lr"resultss rF post_processzDetrImageProcessor.post_processs5  d '~~w/A/AH z?c,/ /st t   a A %st t}}$$Z4c3B3h++B/)2#**1- uKKue DetrImageProcessor.post_process_segmentation..to_tuple!+#u% ))+, ,rHNr^r`)rrr)rrr pred_masksrr~rr9rIr4rgrhrlsigmoidr)rrrrrRr  raw_masks empty_labelpredsr cur_logitsr!r=r cur_labelsrr)s rFpost_process_segmentationz,DetrImageProcessor.post_process_segmentations."  5 !(0B0BI  &&r*Q.  - ,/z9l+S & 'J 4%/%7%7%;%?%?%C "J ==-i1GHD#D)J#D)J!$I 11)AtG2Dhtn[e1fnnopqI"**,~=BI%/:PYZK LL % & rHctjdt|t|k7r td|j ddj \}}|j jd}tjj|||fdd}|j|kDj}tt|||D]\} \} } } | d| d}} | d d d | d |fjd|| d <tjj|| d j!t#| j d j%|| d <|S) a Converts the output of [`DetrForSegmentation`] into actual instance segmentation predictions. Only supports PyTorch. Args: results (`List[Dict]`): Results list obtained by [`~DetrImageProcessor.post_process`], to which "masks" results will be added. outputs ([`DetrSegmentationOutput`]): Raw outputs of the model. orig_target_sizes (`torch.Tensor` of shape `(batch_size, 2)`): Tensor containing the size (h, w) of each image of the batch. For evaluation, this must be the original image size (before any data augmentation). max_target_sizes (`torch.Tensor` of shape `(batch_size, 2)`): Tensor containing the maximum size (h, w) of each image of the batch. For evaluation, this must be the original image size (before any data augmentation). threshold (`float`, *optional*, defaults to 0.5): Threshold to use when turning the predicted masks into binary values. Returns: `List[Dict]`: A list of dictionaries, each dictionary containing the scores, labels, boxes and masks for an image in the batch as predicted by the model. z`post_process_instance` is deprecated and will be removed in v5 of Transformers, please use `post_process_instance_segmentation`.zBMake sure to pass in as many orig_target_sizes as max_target_sizesrrr^Fr_rNrnearest)r=r`)rrrrcr9rrrlr4rgrhrrrr~rir7rWbyte)rrrorig_target_sizesmax_target_sizesrmax_hmax_w outputs_masksrcur_masktttrrs rFpost_process_instancez(DetrImageProcessor.post_process_instance5su,  5  !S)9%: :ab b'++A.q188: u**2215  11 Zu2 '..09<AAC $-c-AQSd.e$f  A !RQ415E"*1fuffuf+<"="G"G"JGAJw "$--";"; 7#))+% 2D9#<#df AJw  rHc | !"#tjd||}t|t|k7r td|t dDcic]}||dk }}|j |j |j} }}t|t|cxk(rt|k(stdtd|jddz } g} d "t||| ||D]\} } }}!| jdjd\}}|j| ||kDz}||}||}| |} tjj| dddf"|d j!d} t#||}| jd d\#t|t|k7r td | j%d} t'd t)|D];\}}||j+r |j+j-|=d !"#fd }|| |d\}}|j/dkDr t1j2t)|Dcgc] \}}||dkc}}t0j4|j6}|j9j+r||}||}| |} || |\}}nn1t1j:dt0j<|j6}g}t)|D]1\}}||j+}|j-|||||d3~t?j@5}|jC|d|jE|d}ddd| j-| Scc}wcc}}w#1swY*xYw)a Converts the output of [`DetrForSegmentation`] into actual panoptic predictions. Only supports PyTorch. Args: outputs ([`DetrSegmentationOutput`]): Raw outputs of the model. processed_sizes (`torch.Tensor` of shape `(batch_size, 2)` or `List[Tuple]` of length `batch_size`): Torch Tensor (or list) containing the size (h, w) of each image of the batch, i.e. the size after data augmentation but before batching. target_sizes (`torch.Tensor` of shape `(batch_size, 2)` or `List[Tuple]` of length `batch_size`, *optional*): Torch Tensor (or list) corresponding to the requested final size `(height, width)` of each prediction. If left to None, it will default to the `processed_sizes`. is_thing_map (`torch.Tensor` of shape `(batch_size, 2)`, *optional*): Dictionary mapping class indices to either True or False, depending on whether or not they are a thing. If not set, defaults to the `is_thing_map` of COCO panoptic. threshold (`float`, *optional*, defaults to 0.85): Threshold to use to filter out queries. Returns: `List[Dict]`: A list of dictionaries, each dictionary containing a PNG string and segments_info values for an image in the batch as predicted by the model. z`post_process_panoptic is deprecated and will be removed in v5 of Transformers, please use `post_process_panoptic_segmentation`.Nz.to_tuplerrHr^rrr cgSr.rrrHrFz:DetrImageProcessor.post_process_panoptic..sbrHcp|jddjd}|jddk(r3tj ftj |j }n!|jdj }|rO jD]<}t|dkDs|D]&}|j|j||d(>\}}tjjt!|j j#j%}|j'||ft(j*}tj,tj.j1|j3} | j||d} | j%} tj4t7| }g} t9t|D]>} | j;|j| j=j?@| |fS)Nrrrr\)r=rr ) rrrr_rlongr]rrjr|r masked_fill_eqrrrrrrbrr r ByteTensor ByteStorage from_buffertobytes from_numpyrrrrrO)rrdeduprrrrrrrrrrrrrrs rF get_ids_areaz>DetrImageProcessor.post_process_panoptic..get_ids_areasq!,44R8::b>Q& ;;1vUZZ TD;;r?//15D!4!;!;!=Lu:>).L $ 1 1$''%.%( KLL $,K#8 ))--i !Q8K8K8M8S8S8U.VW!..w.@K]KeKe.f"--e.?.?.K.KGOOL].^_ '__WgqA '--/ '' *(=>s6{+9AKK  0 5 5 789W}$rHT)rrrr\rrrrF)#rrrrcrrrrrr~rr9rIr4rgrhrlrr;rrrOrnumelr_ as_tensorrr]rrrrrrr)$rrprocessed_sizesrr rrr r raw_boxesrrrr!r r=rrrr#r$rrrcr&rr%r'r(r)rrrrrs$ @@@@@rFpost_process_panopticz(DetrImageProcessor.post_process_panopticcs,  5   *L  3|#4 4[\ \  05c ;1AqBwJ;L;+2>>7;M;MwOaOayI :#i.EC 4EEp Fp !&&r*Q.  - DG  9o|D V & ?J 9dK&0%7%7%;%?%?%C "J ==-i1GHD#D)J#D)J!$I 11)AtG2Dhtn[e1fnnopqI04AI??23'DAq9~Z0 !IJJ"))!,I"-j"9 %j1 @5#EJJL1' 5< (4Y (K g#ZZJDUDUV M!$ m1 m((*$$A,s:K\_ij%kl m ] S /-0\\^m\  ] LL %mV &n M<^I& ] ]s N'(N, "'N22N; rrc|j|j}}|"t|t|k7r tdtj j |d}|dddfjd\}}t|} |t|trMtj|D cgc]} | d c} } tj|D cgc]} | d c} } n|jd\} } tj| | | | gdj| j } | | dddddfz} g}t#||| D]3\}}}|||kD}|||kD}|||kD}|j%|||d5|Scc} wcc} w) a Converts the raw output of [`DetrForObjectDetection`] into final bounding boxes in (top_left_x, top_left_y, bottom_right_x, bottom_right_y) format. Only supports PyTorch. Args: outputs ([`DetrObjectDetectionOutput`]): Raw outputs of the model. threshold (`float`, *optional*): 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 scores, labels and boxes for an image in the batch as predicted by the model. Nrr.rrrr)rrrrcr4rgrr9rrUrr_Tensorrrrr]r~r)rrrrr rrrrrprrrrrr0rr"rer$boxs rFpost_process_object_detectionz0DetrImageProcessor.post_process_object_detections& '~~w/A/AH  #:#l"33 j}}$$Z4c3B3h++B/)2  #,- L%Aqad%AB L%Aqad%AB+2215 u UE5%$@aHKKELLYIIaqj11E6651 MGAq!a)m$Ea)m$EA M"C NNeusK L  M &B%As ( F Fcn|j}|j}|jddddf}|j}t j d||}|j d}||t|k7r tdg} t|D]a} tjj|| jd|| dd } | djd} | j| c| S|jd } t| j dD cgc]} | |  } } | Scc} w) a0 Converts the output of [`DetrForSegmentation`] into semantic segmentation maps. Only supports PyTorch. Args: outputs ([`DetrForSegmentation`]): Raw outputs of the model. target_sizes (`List[Tuple[int, int]]`, *optional*): A 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[torch.Tensor]`: A list of length `batch_size`, where each item is a semantic segmentation map of shape (height, width) corresponding to the target_sizes entry (if `target_sizes` is specified). Each entry of each `torch.Tensor` correspond to a semantic class id. rr.Nzbqc, bqhw -> bchwrrr^Fr_r)rrrrr_einsumrrrcrr4rgrhrirr)rrrclass_queries_logitsmasks_queries_logits masks_classes masks_probsr batch_sizesemantic_segmentationrEresized_logits semantic_maprs rF"post_process_semantic_segmentationz5DetrImageProcessor.post_process_semantic_segmentation"sj '~~&11-444 %,,\:  ;%$%1$7$7A$7$> !GLMbMhMhijMkGl$m!%:1%=$m !$m$$%ns" D2rRrSreturn_coco_annotationc |j}|j}|jd} |jddz } |j} tj j |djd\} } g}t| D]}t| || || ||| \}}}|jddkrH|||n|jdd\}}tj||fdz }|j|gdy|||nd}t|||||g|\}}|r t|}|j||d|S)a Converts the output of [`DetrForSegmentation`] into instance segmentation predictions. Only supports PyTorch. Args: outputs ([`DetrForSegmentation`]): Raw outputs of the model. threshold (`float`, *optional*, defaults to 0.5): The probability score threshold to keep predicted instance masks. mask_threshold (`float`, *optional*, defaults to 0.5): Threshold to use when turning the predicted masks into binary values. overlap_mask_area_threshold (`float`, *optional*, defaults to 0.8): The overlap mask area threshold to merge or discard small disconnected parts within each binary instance mask. target_sizes (`List[Tuple]`, *optional*): List of length (batch_size), where each list item (`Tuple[int, int]]`) corresponds to the requested final size (height, width) of each prediction. If unset, predictions will not be resized. return_coco_annotation (`bool`, *optional*): Defaults to `False`. If set to `True`, segmentation maps are returned in COCO run-length encoding (RLE) format. Returns: `List[Dict]`: A list of dictionaries, one per image, each dictionary containing two keys: - **segmentation** -- A tensor of shape `(height, width)` where each pixel represents a `segment_id` or `List[List]` run-length encoding (RLE) of the segmentation map if return_coco_annotation is set to `True`. Set to `None` if no mask if found above `threshold`. - **segments_info** -- A dictionary that contains additional information on each segment. - **id** -- An integer representing the `segment_id`. - **label_id** -- An integer representing the label / semantic class id corresponding to `segment_id`. - **score** -- Prediction score of segment with `segment_id`. rrrrNrrrQrkrlrRrSrZr)rrrrr4rgrr9rrMr_rrrsrG)rrrrRrSrr&rrr!rKrQrkrlrrmask_probs_itempred_scores_itempred_labels_itemr?r@rrrms rF"post_process_instance_segmentationz5DetrImageProcessor.post_process_instance_segmentationRsL '~~&11)//2 )//3a7 )113 $&==#8#89MSU#8#V#Z#Z[]#^ [02z" VAB[1 {1~{1~y*C ?O-/? $$Q'1,3?3K QQ`QfQfghgiQj ${{FE?;a?  rRS.:-E,q/4K%5*,,-,G"$'& "L(&:<H NNL8T U9 V:rHrZc |tjdt}|j}|j}|j d} |j ddz } |j } tjj|djd\} } g}t| D]}t| || || ||| \}}}|j ddkrH|||n|j dd\}}tj||fdz }|j|gdy|||nd}t!|||||||\}}|j||d|S) ae Converts the output of [`DetrForSegmentation`] into image panoptic segmentation predictions. Only supports PyTorch. Args: outputs ([`DetrForSegmentation`]): The outputs from [`DetrForSegmentation`]. threshold (`float`, *optional*, defaults to 0.5): The probability score threshold to keep predicted instance masks. mask_threshold (`float`, *optional*, defaults to 0.5): Threshold to use when turning the predicted masks into binary values. overlap_mask_area_threshold (`float`, *optional*, defaults to 0.8): The overlap mask area threshold to merge or discard small disconnected parts within each binary instance mask. label_ids_to_fuse (`Set[int]`, *optional*): The labels in this state will have all their instances be fused together. For instance we could say there can only be one sky in an image, but several persons, so the label ID for sky would be in that set, but not the one for person. target_sizes (`List[Tuple]`, *optional*): List of length (batch_size), where each list item (`Tuple[int, int]]`) corresponds to the requested final size (height, width) of each prediction in batch. If unset, predictions will not be resized. Returns: `List[Dict]`: A list of dictionaries, one per image, each dictionary containing two keys: - **segmentation** -- a tensor of shape `(height, width)` where each pixel represents a `segment_id` or `None` if no mask if found above `threshold`. If `target_sizes` is specified, segmentation is resized to the corresponding `target_sizes` entry. - **segments_info** -- A dictionary that contains additional information on each segment. - **id** -- an integer representing the `segment_id`. - **label_id** -- An integer representing the label / semantic class id corresponding to `segment_id`. - **was_fused** -- a boolean, `True` if `label_id` was in `label_ids_to_fuse`, `False` otherwise. Multiple instances of the same class / label were fused and assigned a single `segment_id`. - **score** -- Prediction score of segment with `segment_id`. Nz5`label_ids_to_fuse` unset. No instance will be fused.rrrrr(r))rrsetrrrrr4rgrr9rrMr_rrrs)rrrrRrSrZrrrr!rKrQrkrlrrr*r+r,r?r@rrrms rF"post_process_panoptic_segmentationz5DetrImageProcessor.post_process_panoptic_segmentationsV  $    W X # &~~&11)//2 )//3a7 )113 $&==#8#89MSU#8#V#Z#Z[]#^ [02z" VAB[1 {1~{1~y*C ?O-/? $$Q'1,3?3K QQ`QfQfghgiQj ${{FE?;a?  rRS.:-E,q/4K%5*,,-,G"3'& "L( NNL8T U1 V2rH)NNNNNN)NrNNT)NrTNNNTN)g?r+)r+)NN333333?)r+Nr.)r+r+皙?NF)r+r+r3NN)5__name__ __module__ __qualname____doc__model_input_namesrrr rr rrrr:r7rr r classmethodrrrZr[rrrrrrr9rr r{rrrrr*rrrrrrrrrrr%r-r r0 __classcell__)rs@rFrurus2h(60@/N/N#'9'B'B,3!04/315-1D c++,D D 38n D % D  D c5j)D D %e,-D U +,D !)D D 4S>*D  D L AT#s(^ A A".2*.9=DHzz)*  $(  U3 #456 $E#/?*?$@A H(:'B'B26DH BzzB38nB% B ./ B $E#/?*?$@A B BR(:'A'A g % g  g$?CDH lzzlleC)9$9:; l $E#/?*?$@A l  l8GtGsCxGUYG)) S/)!c? ) )^049:26DH"(zz(38_(T#s(^, ( uhuo56 ( ./ ($E#/?*?$@A(( (HNR9:"&;?26DH"-1SRZZ SeND4H$HIJSuhuo56 S  S !sJ!78 S./S$E#/?*?$@ASS4S>*S SpNR*.9=$()-%)6:'+15:>9=!%9=;?4D4J4JDH-1)GGeND4H$HIJG$( G U3 #456 G D> GtCH~&GTNG!sEz!23GtnG!)GU5$u+#567GE%e"456GG s$4456!G"!z3!78#G$3 001%G&$E#/?*?$@A'G(4S>*)G, -GV'R*Z+\GV_c3"'3=B:tTY{CZ=[3j-%USVX[S[_H]-%f #-08<16QQ Q &+ Q tE#s(O45 Q!)Q dQn #-0048<VV V &+ V $CH- VtE#s(O45V dVrHrur.r1)FN)TNr)r2)r+r3)r+r3NN)gr7rr collectionsrtypingrrrrrr r r r rbrZimage_processing_utilsrrrimage_transformsrrrrrrrrr image_utilsrrrrrrr r!r"r#r$r%r&r'r(r)utilsr*r+r,r-r.r/r0r1r2r3r_r4r scipy.specialr scipy.stats get_loggerr4rrrrr:rGr[rrSrXrhrmr{rrrrrrrrrrrrr*rr7r9r@rGrMrYrsru__all__rrHrFrEs3& #SSSUU   $      H % 0 ? ?AQA_A_`$5c?$VAE ! ! ! ! c+;&; <= !  38_ !L#@D BB U38_d3i/ 0BsmB c+;&; <= B  38_ B8ChC0 bjj    T uS#X 4 8x}8c8[_#  #19%EU@U:V1W# #Y#(rv ::$)#s(OHPQVWZ\lWlQmHnZZ&SL',@D 9 $9 &6&; <= 9x5"**55L6: & ::& &c7<<'(& & -s23 &  &T`e ::#(7<22::E#s(OPSXZXbXb"**rzzSUS]S]G]A^R R ::R ::R#s(O R sCx R  R Rr#5#=#= 0S#X0S#X0sCx0 0 ! 0h. *<8, ),,0#'9" 9" "' 9"  C) 9"sCx9"xi+iX' rH