UhepddlmZddlmZmZddlmZmZmZm Z ddl Z ddl m Z mZmZddlmZmZmZmZmZddlmZmZmZmZmZmZmZmZmZm Z m!Z!dd l"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+e*rdd lm,Z,e'rddl-Z-e(rdd lm.Z.e)rdd l/m0Z1n dd l2m0Z1ndZ.e+jfe4Z5eddddddddddddddejlfdee7dee8dee7dee e8e9e8fdee e8e9e8fdee7dee:dee7deedee7deededdee e;e%fdeefdZd'e9d!d#e?e:fd(Z@d)e e jd!fd*e:d#e9e e jd!ffd+ZBGd,d-ed./ZCe&Gd0d1e ZDGd2d3ZEy)5)Iterable) lru_cachepartial)AnyOptional TypedDictUnionN)BaseImageProcessor BatchFeature get_size_dict)convert_to_rgbget_resize_output_image_sizeget_size_with_aspect_ratiogroup_images_by_shapereorder_images) ChannelDimension ImageInput ImageTypeSizeDictget_image_size#get_image_size_for_max_height_widthget_image_typeinfer_channel_dimension_formatmake_flat_list_of_imagesvalidate_kwargsvalidate_preprocess_arguments)Unpack) TensorTypeauto_docstringis_torch_availableis_torchvision_availableis_torchvision_v2_availableis_vision_availablelogging)PILImageResampling)pil_torch_interpolation_mapping) functional maxsize do_rescalerescale_factor do_normalize image_mean image_stddo_padsize_divisibilitydo_center_crop crop_size do_resizesizeresampler&return_tensors data_formatct|||||||||| | |  | | dk7r td| tjk7r tdy)z Checks validity of typically used arguments in an `ImageProcessorFast` `preprocess` method. Raises `ValueError` if arguments incompatibility is caught. ) r,r-r.r/r0r1r2r3r4r5r6r7Nptz6Only returning PyTorch tensors is currently supported.z6Only channel first data format is currently supported.)r ValueErrorrFIRST)r,r-r.r/r0r1r2r3r4r5r6r7r8r9s z/var/www/catia.catastroantioquia-mas.com/valormas/lib/python3.12/site-packages/transformers/image_processing_utils_fast.py"validate_fast_preprocess_argumentsr?Isk*"%!+%  !n&<QRR&,,,QRR-tensor torch.Tensoraxisreturncn||jS |j|S#t$r|cYSwxYw)zF Squeezes a tensor, but only if the axis specified has dim 1. )rC)squeezer<)rArCs r> safe_squeezerGts@ |~~~~4~((  s & 44valuescJt|Dcgc] }t|c}Scc}w)zO Return the maximum value across all indices of an iterable of values. )zipmax)rHvalues_is r>max_across_indicesrMs +.v, 7hCM 77 7s imagescbt|Dcgc]}|jc}\}}}||fScc}w)zH Get the maximum height and width across all images in a batch. )rMshape)rNimg_ max_height max_widths r>get_max_height_widthrUs5 22O3992OPAz9  ""3Ps,image patch_sizecg}t|tj\}}td||D]9}td||D]'}|dd|||z|||zf}|j |);|S)a6 Divides an image into patches of a specified size. Args: image (`Union[np.array, "torch.Tensor"]`): The input image. patch_size (`int`): The size of each patch. Returns: list: A list of Union[np.array, "torch.Tensor"] representing the patches. ) channel_dimrN)rrr=rangeappend)rVrWpatchesheightwidthijpatchs r>divide_to_patchesrbsG"56F6L6LMMFE 1fj )"q%, "A!QZ/Q^1CCDE NN5 ! "" Nr@cfeZdZUeeed<eeeefed<eeed<ee ded<eeed<eeeefed<eeed<ee ee fed <eeed <ee e e e fed <ee e e e fed <eeed <ee ee fed<ee ed<ee ee fed<eded<y)DefaultFastImageProcessorKwargsr5r6default_to_squarer&F.InterpolationModer7r3r4r,r-r.r/r0do_convert_rgbr8r9input_data_format torch.devicedeviceN)__name__ __module__ __qualname__rbool__annotations__dictstrintr floatlistrrr@r>rdrds~ 4S> ""~%uHIJJTN"S#X''U3:.//4. ud5k1233eT%[0122TN"U3 ?344*++c+;&; <== ^ $$r@rdF)totalceZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZdZej"ZdZdZdgZeZdZdeeddffd Z d6dd d ed d d edd f dZdd dedd fdZdd de ee!efde ee!efdd fdZ"e#d d7de$ede$e ee%efde$e ee%efde$ede$ede$dde&fdZ'dd dededede ee%efde ee%efdd fdZ(dd d e)e*e+fdd fd Z,de-de-fd!Z.de)fd"Z/de-de-fd#Z0 d8de-d$e$ed%e$e e*efde$ddd f d&Z1 d8de-d$e$ed%e$e e*efde$dde%d f d'Z2 d7d e$ed(e$ed)e$ede$e ee%efde$e ee%efd*e$ede)fd+Z3 d9de$ede$ede$ede$e ee&efde$e ee&efd,e$ed e$ed-e$ed(e$ed.e$e d/d0e$e e*e4fd*e$efd1Z5de-deede6fd2Z7e8de-deede6fd3Z9de%d d,ed ed e$d d-ed(edededede$e ee%efde$e ee%efd0e$e e*e4fde6fd4Z:fd5Z;xZt|jjj|_y)Nr6rer6rer4 param_namerv)super__init__filter_out_unused_kwargspopr6r rer4 valid_kwargsrpkeyssetattrgetattrru_valid_kwargs_names)selfr{r6r4keykwarg __class__s r>rzBaseImageProcessorFast.__init__s "6"..v6zz&$)), tvzzBUW[WmWm7n o JJ{DNN; MVMby[Ihl$$4499; =CJJsD)E c5)c74d#;<  =$((9(9(I(I(N(N(P#Q r@rVrBr6 interpolationrg antialiasc ||ntjj}|jr?|jr3t |j dd|j|j}n|jr(t||jdtj}n|jr?|jr3t|j dd|j|j}n@|jr%|jr|j|jf}ntd|dtj ||||S)a@ Resize an image to `(size["height"], size["width"])`. Args: image (`torch.Tensor`): Image to resize. size (`SizeDict`): Dictionary in the format `{"height": int, "width": int}` specifying the size of the output image. interpolation (`InterpolationMode`, *optional*, defaults to `InterpolationMode.BILINEAR`): `InterpolationMode` filter to use when resizing the image e.g. `InterpolationMode.BICUBIC`. Returns: `torch.Tensor`: The resized image. NF)r6rerizjSize must contain 'height' and 'width' keys, or 'max_height' and 'max_width', or 'shortest_edge' key. Got .)rr)FInterpolationModeBILINEAR shortest_edge longest_edgerr6rrr=rSrTrr]r^r<resize)rrVr6rrr{new_sizes r>rzBaseImageProcessorFast.resizes,*7)B H[H[HdHd   $"3"32 RS!""!!H   3''"'"2"8"8 H __:5::<;Ldoo_c_m_mnH [[TZZ TZZ0H6 xxx}PYZZr@scalec ||zS)a? Rescale an image by a scale factor. image = image * scale. Args: image (`torch.Tensor`): Image to rescale. scale (`float`): The scaling factor to rescale pixel values by. Returns: `torch.Tensor`: The rescaled image. rv)rrVrr{s r>rescalezBaseImageProcessorFast.rescales$u}r@meanstdc 0tj|||S)a Normalize an image. image = (image - image_mean) / image_std. Args: image (`torch.Tensor`): Image to normalize. mean (`torch.Tensor`, `float` or `Iterable[float]`): Image mean to use for normalization. std (`torch.Tensor`, `float` or `Iterable[float]`): Image standard deviation to use for normalization. Returns: `torch.Tensor`: The normalized image. )r normalize)rrVrrr{s r>rz BaseImageProcessorFast.normalize0s*{{5$,,r@r)r*r.r/r0r,r-rkrjc|r>|r!_fuse_mean_std_and_rescale_factorz8BaseImageProcessorFast._fuse_mean_std_and_rescale_factorGsO ,j@C.DXYJ Yv>#BVWIJ9j00r@rNc|j||||||j\}}}|r3|j|jtj ||}|S|r|j ||}|S)z/ Rescale and normalize images. )r.r/r0r,r-rk)dtype)rrkrtorfloat32r)rrNr,r-r.r/r0s r>rescale_and_normalizez,BaseImageProcessorFast.rescale_and_normalizeXs-1,R,R%!!)== -S- ) Iz ^^FIIEMMI$BJPYZF \\&.9F r@c |j |jtd|jt j ||d|dfS)a Center crop an image to `(size["height"], size["width"])`. If the input size is smaller than `crop_size` along any edge, the image is padded with 0's and then center cropped. Args: image (`"torch.Tensor"`): Image to center crop. size (`Dict[str, int]`): Size of the output image. Returns: `torch.Tensor`: The center cropped image. z=The size dictionary must have keys 'height' and 'width'. Got r]r^)r]r^r<rr center_crop)rrVr6r{s r>rz"BaseImageProcessorFast.center_croptsS& ;; $**"4\]a]f]f]h\ijk k}}UT(^T']$CDDr@ct|S)a' Converts an image to RGB format. Only converts if the image is of type PIL.Image.Image, otherwise returns the image as is. Args: image (ImageInput): The image to convert. Returns: ImageInput: The converted image. )r)rrVs r>rz%BaseImageProcessorFast.convert_to_rgbse$$r@c|j|S|jD]1}||vstjd|d|j|3|S)zJ Filter out the unused kwargs from the kwargs dictionary. z!This processor does not use the `z ` parameter. It will be ignored.) unused_kwargslogger warning_oncer)rr{ kwarg_names r>rz/BaseImageProcessorFast.filter_out_unused_kwargss^    %M,, 'JV###&G |Ss$tu :& ' r@ct|S)z Prepare the images structure for processing. Args: images (`ImageInput`): The input images to process. Returns: `ImageInput`: The images with a valid nesting. )r)rrNs r>_prepare_images_structurez0BaseImageProcessorFast._prepare_images_structures(//r@rhric&t|}|tjtjtjfvrt d||r|j |}|tjk(rtj|}n6|tjk(r#tj|j}| t|}|tjk(r!|jdddj}||j!|}|S)NzUnsupported input image type rr )rrPILTORCHNUMPYr<rr pil_to_tensorr from_numpy contiguousrrLASTpermuter)rrVrhrirk image_types r>_process_imagez%BaseImageProcessorFast._process_images$E* immY__iooN Nu E   0 5 5 5MM!Q*557E  HHV$E r@c|j|}t|j|||}g}|D]}|j|||S)z: Prepare the input images for processing. )rhrirk)rrrr[)rrNrhrirkprocess_image_fnprocessed_imagesrVs r>_prepare_input_imagesz,BaseImageProcessorFast._prepare_input_imagessd//7"   )/   =E  # #$4U$; < = r@r4rer9c :|i}|td it||}|td it|d}t|tr t |}t|tr t |}|t j }||d<||d<||d<||d<||d<||d<|S) z Update kwargs that need further processing before being validated Can be overridden by subclasses to customize the processing of kwargs. r}r4r~r6rer/r0r9rv)rr isinstancerutuplerr=)rr6r4rer/r0r9r{s r>_further_process_kwargsz.BaseImageProcessorFast._further_process_kwargss >F  \mIZ[\D   T={#STI j$ 'z*J i &i(I  *00Kv'{&7"#)|'{ +} r@r5r3r7rfr8c  2t||||||||| | | |  y)z@ validate the kwargs for the preprocess method. ) r,r-r.r/r0r5r6r3r4r7r8r9N)r?)rr,r-r.r/r0r5r6r3r4r7r8r9r{s r>_validate_preprocess_kwargsz2BaseImageProcessorFast._validate_preprocess_kwargss0& +!)%!))# r@c.|j|g|i|SN) preprocess)rrNargsr{s r>__call__zBaseImageProcessorFast.__call__8stv7777r@c Zt|j|j|jD]}|j|t ||d!|j d}|j d}|j d}|j ||||}|jd i|}|jd i||j d}t|ttfr t|n||d<|j d|j d |j|g|i|S) N)captured_kwargsvalid_processor_keysrhrirk)rNrhrirkr7rrer9rv)rrr setdefaultrrrrrrrsr&r' _preprocess) rrNrr{rrhrirkr7s r>rz!BaseImageProcessorFast.preprocess;s7  DLdLde22 KJ   j'$ D*I J K $45"JJ':;H%++.L]fl,  .--77 )((262::j) :DHsTfNg9h +H 5nv   &' =!t8888r@c t|\}}i}|jD] \}}|r|j|||}|||<"t||}t|\}}i}|jD]4\}}|r|j ||}|j |||| | | }|||<6t||}| rt j|dn|}td|i| S)N)rVr6rrdimrz)data tensor_type) ritemsrrrrrstackr )rrNr5r6rr3r4r,r-r.r/r0r8r{grouped_imagesgrouped_images_indexresized_images_groupedrPstacked_imagesresized_imagesprocessed_images_groupedrs r>rz"BaseImageProcessorFast._preprocesscs"0EV/L,,!#%3%9%9%; ; !E>!%>\i!j,: "5 ) ;((>@TU0E^/T,,#% %3%9%9%; = !E>!%!1!1.)!L!77 NL*V_N/= $U + =**BDXYCQ5;;'7Q?Wg.2B!CQ_``r@clt|}|jdd|jdd|S)N_valid_processor_keysr)rto_dictr)r encoder_dictrs r>rzBaseImageProcessorFast.to_dicts7w( 0$7.5r@)NT)NNNNNN)NNN) NNNNNNNNNNNN)=rlrmrnr7r/r0r6rer4r5r3r,r-r.rhr8rr=r9rirkmodel_input_namesrdrrrrrrorrtrr rrrrrurrrrqrrrsrrrrrrrrrrr rr rrr __classcell__)rs@r>ryrys2HJI DIINJNLNN"((K F'(2LMR89R R804 /[/[/[- /[  /[ /[b  (--E8E?*+-5(5/) * -  -.r(,:>9=%)*.+/1tn1U5$u+#5671E%e"456 1 TN 1 ! 1(1 11     %e,- U +, 8EE38nE  E.%% % t 00 0&*.DH+/  ! $E#/?*?$@A  (   J*.DH+/   ! $E#/?*?$@A  (  n   4$((,,0:>9=26"x "H%"$D> " U5$u+#567 " E%e"456 "./" "L&**.'+;?:>$(#')-(,QU;?26  TN  !  tn  U5%,#678  E%u"567  D>  x   !  H%  5!LMN  !sJ!78  ./  D8z8FCbe%9jv%9%9N)a^$)a)a )a  56 )a  )a)a)a)a)aU5$u+#567)aE%e"456)a!sJ!78)a )aVr@ryc&eZdZddeeefdZy)SemanticSegmentationMixinN target_sizesc|j}|t|t|k7r tdg}tt|D]k}tj j j||jd||dd}|djd}|j|m|S|jd}t|jdDcgc]}|| }}|Scc}w)aD Converts the output of [`MobileNetV2ForSemanticSegmentation`] into semantic segmentation maps. Only supports PyTorch. Args: outputs ([`MobileNetV2ForSemanticSegmentation`]): Raw outputs of the model. target_sizes (`List[Tuple]` of length `batch_size`, *optional*): List of tuples corresponding to the requested final size (height, width) of each prediction. If unset, predictions will not be resized. Returns: semantic_segmentation: `List[torch.Tensor]` 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. zTMake sure that you pass in as many target sizes as the batch dimension of the logitsrrbilinearF)r6mode align_cornersr ) logitslenr<rZrnnr( interpolate unsqueezeargmaxr[rP) routputsrrsemantic_segmentationidxresized_logits semantic_mapr_s r>"post_process_semantic_segmentationz %,,\:  ;%$%+MMaM$8 !GLMbMhMhijMkGl$m!%:1%=$m !$m$$%ns# C3r)rlrmrnrrurrrvr@r>rrs(%QUV[Q\H](%r@rr)Fcollections.abcr functoolsrrtypingrrrr numpynpimage_processing_utilsr r r image_transformsrrrrr image_utilsrrrrrrrrrrrprocessing_utilsrutilsrr r!r"r#r$r%r&rr'torchvision.transforms.v2r(rtorchvision.transforms get_loggerrlrr=rortrursrrr?rGrMrrUarrayrbrdryrrvr@r>rs%(22SS    %/<"$=:&*#   H % 2!%&*#'6:59!'+%)$( $#/37;.>.D.D'S'SUO'S4.'Sud5k123 'S eT%[012 'S TN 'S }'STN'S!'S~'S 8 'S+,'SU3 ?34'S*+'S'ST  x}  8x}8c8#n!5#%*# >) *8; %.( )*0%iu%&T/TTn)%)%r@