Zj{SrSSKrSSKJr SSKJr SSKJr SSKJ r J r J r SSK r SSKrSSKJr SSKJr SSKJr S S KJr S S KJrJr S S KJrJr S S KJrJ r J!r!J"r"J#r#J$r$ S SK%J&r&J'r' S SK(J)r)J*r*J+r+ \+"5(aSSK,r,"SS\&SS9r-\*"SS\55r.SSS\/S\04Sjr1S3Sjr2S4Sjr3S\4\0S\0S\04S jr5S5S!\0S"\0S#\/S$\0S-S%\4\0S-S&\6\4\4\0\4\044 S'jjr7S(r8S)\0S&\Rr4S*jr:S6S+jr;S7S!\0S,\RrS-\6\0\04S&\Rr4S.jjr\ 4S&\Rr4S0jr?S8S1jr@S9S2jrAS/rBg):zImage processor class for SAM.N)Iterable)deepcopy)product)AnyOptionalUnion) functional) batched_nms)TorchvisionBackend) BatchFeature get_size_dict)group_images_by_shapereorder_images)IMAGENET_DEFAULT_MEANIMAGENET_DEFAULT_STDChannelDimension ImageInputPILImageResamplingSizeDict) ImagesKwargsUnpack) TensorTypeauto_docstringis_vision_availablecB\rSrSr%Sr\\\4\S'\\\4\S'Sr g)SamImageProcessorKwargs/a> mask_size (`dict[str, int]`, *optional*): The size `{"longest_edge": int}` to resize the segmentation maps to. mask_pad_size (`dict[str, int]`, *optional*): The size `{"height": int, "width": int}` to pad the segmentation maps to. Must be larger than any segmentation map size provided for preprocessing. mask_size mask_pad_sizeN) __name__ __module__ __qualname____firstlineno____doc__dictstrint__annotations____static_attributes__r!}/root/GenerationalWealth/GenerationalWealth/venv/lib/python3.13/site-packages/transformers/models/sam/image_processing_sam.pyrr/s%CH~S>!r,rF)totalc#^\rSrSr\r\Rr\ r \ r SS0r SS0rSrSrSrSrSrSSS.rSSS.rS\\4U4Sjjr\S5S \S \S -S\\S \4U4S jjj5rS6S\\\-\\\4-\ -S -S\\\-\\\4-\ -S -S \4U4Sjjjr!S\"\\4S\4Sjr#S5SSS\ SSS S4U4Sjjjr$S5S \S \S -S\%S\&S\\'-S -S\(\S4S -S \4Sjjr)S \*SS\%S\ SSS \%S!\ S"\%S#\+S$\%S%\+\*\+-S -S&\+\*\+-S -S'\%S -S(\ S -S)\%S -S \"\*S\*\"\\444S*jr,S7SS+S,\S-\+S.\S -S/\*\S -S\-S4 S0jjr.S8S1jr/S9S2jr0S3r1S4r2U=r3$):SamImageProcessor< longest_edgeiTheightwidthkwargsc &>[TU]"S0UD6 g)Nr!)super__init__)selfr7 __class__s r-r:SamImageProcessor.__init__Ls "6"r,Nimagessegmentation_mapsreturnc &>[TU]"X40UD6$)zX segmentation_maps (`ImageInput`, *optional*): The segmentation maps to preprocess. )r9 preprocess)r;r>r?r7r<s r-rBSamImageProcessor.preprocessOsw!&FvFFr,rr c >[TU]"S0UD6nUb([U[5(d[S0[ USS9D6nUb([U[5(d[S0[ USS9D6nXS'X#S'U$)z Update kwargs that need further processing before being validated Can be overridden by subclasses to customize the processing of kwargs. r) param_namer r!)r9_standardize_kwargs isinstancerr)r;rr r7r<s r-rF%SamImageProcessor._standardize_kwargs\sx,6v6  Ix)H)H T={#STI  $Z x-P-P$`}]'_`M'{"/ r, old_shapecxUup4US-[X45- nX5-XE-pv[US-5n[US-5nXg4$)zG Compute the output size given input size and target long side length. ??)maxr))r;rIr2oldholdwscalenewhnewws r-_get_preprocess_shape'SamImageProcessor._get_preprocess_shapeqsK s"S_4\4UR(d[SUR535eURSSnUR XRR5upg[ TU]"U4[XgS9US.UD6$)aE Resize an image to `(size["height"], size["width"])`. Args: image (`torch.Tensor`): Image to resize. size (`SizeDict`): Dictionary in the format `{"longest_edge": int}` specifying the size of the output image. The longest edge of the image will be resized to the specified size, while the other edge will be resized to maintain the aspect ratio. resample (`PILImageResampling | tvF.InterpolationMode | int | None`, *optional*): Resampling filter to use when resizing the image. Returns: `torch.Tensor`: The resized image. z?The `size` dictionary must contain the key `longest_edge`. Got Nr4)rWrX)r2 ValueErrorkeysshaperSr9resizer) r;rUrWrXr7 input_size output_height output_widthr<s r-r^SamImageProcessor.resize|s.  ^_c_h_h_j^klm m[[% &*&@&@M^M^&_# w~   JU] ag  r,do_convert_rgbinput_data_formatreturn_tensorsdevicez torch.devicec xURXXFS9nUVs/sHoRSSPM n nUR5n UR"U40U D6upU U U S.n UbURUSS[R S9nUR5nUR SS[RURS5URS 5S .5 UR"SS U0UD6unnUVs/sH1nURS 5R[R5PM3 snU S '[XS9$s snfs snf)z Preprocess image-like inputs. )r>rcrdrfrZN) pixel_valuesoriginal_sizesreshaped_input_sizesF)r>expected_ndimsrcrdrr ) do_normalize do_rescalerXrWpad_sizer>rlabels)data tensor_typer!)_prepare_image_like_inputsr]copy _preprocessrFIRSTupdaterNEARESTpopsqueezetotorchint64r )r;r>r?rcrdrerfr7rUri images_kwargsrhrjrqprocessed_segmentation_mapssegmentation_maps_kwargs_ms r-_preprocess_image_like_inputs/SamImageProcessor._preprocess_image_like_inputssa00L]1 9??u++bc*? -1-=-=f-V -V* (,$8   (*.*I*I( $"2"8"8 +J+ '(.{{} $ $ + +$)"' 2 : :488E 8 < <_ M  .2-=-=.2.6N. * 'E``D_qaiilooekk:D_`DNBBA@<as D2+8D7 do_resizedo_center_crop crop_sizernrescale_factorrm image_mean image_stddo_padrodisable_groupingc [XS9unn0nUR5H"unnU(aURUX4S9nUUU'M$ [UU5nUVs/sHnURSSPM nn[UUS9unn0nUR5H8unnU(aUR UU5nUR UXxXU 5nUUU'M: [UU5nU (aURUXS9nUU4$s snf)N)r)rUrWrXrZ)ror)ritemsr^rr] center_croprescale_and_normalizepad)r;r>rrWrXrrrnrrmrrrrorr7grouped_imagesgrouped_images_indexresized_images_groupedr]stacked_imagesresized_imagesrUrjprocessed_images_groupedprocessed_imagess r-ruSamImageProcessor._preprocesss-&0EV/o,,!#%3%9%9%; !E>!%>!`,: "5 )&<((>@TU>LMnU BC 0nM0E^fv/w,,#% %3%9%9%; !E>!%!1!1.)!L!77 LV_N/= $U +&<**BDXY #xx(88xo !555' NsC2z+np.ndarray | PIL.Image.Image | torch.Tensor crop_n_layers overlap_ratiopoints_per_cropcrop_n_points_downscale_factorcURU5n[UUUUUU5uppUc[R"S5nUR U5nUR U5nU R U5n XX4$)an Generates a list of crop boxes of different sizes. Each layer has (2**i)**2 boxes for the ith layer. Args: image (`torch.Tensor`): Input original image target_size (`int`): Target size of the resized image crop_n_layers (`int`, *optional*, defaults to 0): If >0, mask prediction will be run again on crops of the image. Sets the number of layers to run, where each layer has 2**i_layer number of image crops. overlap_ratio (`float`, *optional*, defaults to 512/1500): Sets the degree to which crops overlap. In the first crop layer, crops will overlap by this fraction of the image length. Later layers with more crops scale down this overlap. points_per_crop (`int`, *optional*, defaults to 32): Number of points to sample from each crop. crop_n_points_downscale_factor (`list[int]`, *optional*, defaults to 1): The number of points-per-side sampled in layer n is scaled down by crop_n_points_downscale_factor**n. device (`torch.device`, *optional*, defaults to None): Device to use for the computation. If None, cpu will be used. cpu) process_image_generate_crop_boxesr|rfr{) r;rU target_sizerrrrrf crop_boxescropped_images input_labelss r-generate_crop_boxes%SamImageProcessor.generate_crop_boxess>""5)DX      * E A ^ >\\%(F]]6* ),,V4#v. NHHr,c tUupURSS5nURSS5nURSURS:wa [S5eURUR:waUR UR5nURSn [ R "U [ RURS9n US:aXU:-n US:a[XU5n XU:-n X,nXnX:n[U5n[XSSX/5)n XnXnXn[XX5n[U5nXU4$)a[ Filters the predicted masks by selecting only the ones that meets several criteria. The first criterion being that the iou scores needs to be greater than `pred_iou_thresh`. The second criterion is that the stability score needs to be greater than `stability_score_thresh`. The method also converts the predicted masks to bounding boxes and pad the predicted masks if necessary. Args: masks (`torch.Tensor`): Input masks. iou_scores (`torch.Tensor`): List of IoU scores. original_size (`tuple[int,int]`): Size of the original image. cropped_box_image (`torch.Tensor`): The cropped image. pred_iou_thresh (`float`, *optional*, defaults to 0.88): The threshold for the iou scores. stability_score_thresh (`float`, *optional*, defaults to 0.95): The threshold for the stability score. mask_threshold (`float`, *optional*, defaults to 0): The threshold for the predicted masks. stability_score_offset (`float`, *optional*, defaults to 1): The offset for the stability score used in the `_compute_stability_score` method. rz3masks and iou_scores must have the same batch size.dtyperf) flattenr]r[rfr{r|onesbool_compute_stability_score_batched_mask_to_box_is_box_near_crop_edge _pad_masks _mask_to_rle)r;masks iou_scores original_sizecropped_box_imagepred_iou_threshstability_score_threshmask_thresholdstability_score_offsetoriginal_heightoriginal_width batch_size keep_maskstability_scoresscoresconverted_boxess r- filter_masksSamImageProcessor.filter_masks-sVF+8'''1-  a# ;;q>Z--a0 0RS S <<:,, ,#u||4J[[^ JJzELLQ S !/%ABI "C '7Oef !8N%NOI& &.u5+ A~0W  " )45_UU#o--r,cUc UROUnUSUS4n[U[R[R 45(aUR 5n[U[R[R 45(aUR 5n/n[U5Hup[X[R 5(a[R"X5X'O,[X[R5(d [S5e[R"XUSSS9n U SSX9S 2SX9S 24n [R"XSSS9n U(aX:n URU 5 M U$) a Remove padding and upscale masks to the original image size. Args: masks (`Union[List[torch.Tensor], List[np.ndarray]]`): Batched masks from the mask_decoder in (batch_size, num_channels, height, width) format. original_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`): The original sizes of each image before it was resized to the model's expected input shape, in (height, width) format. reshaped_input_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`): The size of each image as it is fed to the model, in (height, width) format. Used to remove padding. mask_threshold (`float`, *optional*, defaults to 0.0): The threshold to use for binarizing the masks. binarize (`bool`, *optional*, defaults to `True`): Whether to binarize the masks. pad_size (`int`, *optional*, defaults to `self.pad_size`): The target size the images were padded to before being passed to the model. If None, the target size is assumed to be the processor's `pad_size`. Returns: (`torch.Tensor`): Batched masks in batch_size, num_channels, height, width) format, where (height, width) is given by original_size. Nr5r6zIInput masks should be a list of `torch.tensors` or a list of `np.ndarray`bilinearF)mode align_corners.rr) rorGr|Tensornpndarraytolist enumerate from_numpy TypeErrorF interpolateappend) r;rrirjrbinarizerotarget_image_size output_masksirinterpolated_masks r-post_process_masks$SamImageProcessor.post_process_masks{s]>%-$44==(%h/'1BC nu||RZZ&@ A A+224N *U\\2::,F G G#7#>#>#@  ). 9 A%(BJJ// ++EH5%,,77 kll ! eh8IPZjo p  1#7S9M9PQR9S7SUqWkWnopWqUq2q r  ! .?U_ot u $5$F!    1 2!:r,c[XX45$)a Post processes mask that are generated by calling the Non Maximum Suppression algorithm on the predicted masks. Args: all_masks (`torch.Tensor`): List of all predicted segmentation masks all_scores (`torch.Tensor`): List of all predicted iou scores all_boxes (`torch.Tensor`): List of all bounding boxes of the predicted masks crops_nms_thresh (`float`): Threshold for NMS (Non Maximum Suppression) algorithm. )!_post_process_for_mask_generation)r; all_masks all_scores all_boxescrops_nms_threshs r- post_process_for_mask_generation2SamImageProcessor.post_process_for_mask_generations1 ddr,r!N)NN)rg? rN)g)\(?gffffff?rr)rTN)4r"r#r$r%r valid_kwargsrBILINEARrXrrrrrWrrrnrmrcrror rr:rrr rBr)rr'r(rrFtuplerSr^rrrrrlistfloatrurrrrrr+ __classcell__)r<s@r-r0r0<sy*L!**H&J$I D !D%IIJLN F.H"S1M#(?!@#04 G G&, G01 G  G GMQPT#&c3h7(BTIXc]*T#s(^;hFM  * uS#X c OS    L     L590C0C&,0C 0C , 0C j(4/ 0Cc>)*T10C 0Cd-6^$-6-6 -6 L -6  -6-6-6-6-6DK'$.-64;&--6t -6T/-6+-6" tN#T%S/%:: ;#-6f)&(;<+//I</I /I  /I t /I)-S D(8/I(/In# L.f3jeer,r0rrVrrc XU-:RS[RS9RS[RS9nXU- :RS[RS9RS[RS9nX4- nU$)Nr)sumr|int16int32)rrr intersectionsunionsrs r-rrs #99 :??%++?VZZ[]ejepepZq(>>? D DRu{{ D [ _ _`bjojuju _ vF$- r,c.[R"U5S:Xa2[R"/URSSQSP7SUR06$URnUSSup#[R "USS9upEU[R "X$RS9SSS24-n[R "USS9upuXbU)--n[R"USS9up[R "USS9upU [R "X9RS9SSS24-n [R "U SS9upXU )--n [R"U SS9upX:Xx:-n [R"XX/SS9nX)RS5-nUR"/USSQSP76nU$) a  Computes the bounding boxes around the given input masks. The bounding boxes are in the XYXY format which corresponds the following required indices: - LEFT: left hand side of the bounding box - TOP: top of the bounding box - RIGHT: right of the bounding box - BOTTOM: bottom of the bounding box Return [0,0,0,0] for an empty mask. For input shape channel_1 x channel_2 x ... x height x width, the output shape is channel_1 x channel_2 x ... x 4. Args: - masks (`torch.Tensor` of shape `(batch, nb_mask, height, width)`) rNrZrfrdimrf) r|numelzerosr]rfrMarangeminstack unsqueezereshape)rr]r5r6 in_heightrin_height_coords bottom_edges top_edgesin_widthin_width_coords right_edges left_edges empty_filterouts r-rrs" {{5Q{{EEKK,EaE EE KKE"#JMF99U+LI 5<<?O?O#PQUWXQX#YYii 0b9OL'YJ*??99-26LI))Er*KHeOO!LTSTW!UUOYYB7NK%((;;OIIo26MJ ,1IJL ++zkHb QC ))"- -C ++ %uSbz %1 %C Jr,cN[R"U[RURS9n[R"U[RURS9nUupg n[R"XgXg//URS9n [ UR 5S:XaU RS5n X -R5n[R"XSSS24USS9n [R"XSSS24USS9n [R"X)5n [R"U SS9$) zNFilter masks at the edge of a crop, but not at the edge of the original image.rrr rNr)atolrtolr) r| as_tensorrrftensorlenr]risclose logical_andany) boxescrop_boxorig_boxr crop_box_torchorig_box_torchlefttoproffsetnear_crop_edgenear_image_edges r-rrs__XU[[VN__XU[[VNODq! \\Dt125<< HF 5;;1!!!$ ^ " " $E]]5q*ASTUNmmE$'+BTUVO&&~7GHN 99^ ++r,r orig_height orig_widthcUupEpgUS:XaUS:Xa Xc:XaXr:XaU$X6U- - X'U- - pXHU- XYU- 4n [RRRX SS9$)Nr)value)r|nnr r) rrrrrrrightbottompad_xpad_yrs r-rrso'Du qySAX%"5&:O . |0L5 sCK 0C 88   " "5Q " 77r,rrrrrr@cn[U[5(a [S5eURSSn/n[ US-5H-n[ XEU-- 5n UR [U 55 M/ [X#U5up[XX{X5up[R"U 5n U R5n [R"U 5nURS5RSSSS5n[R"U 5n [R "USS2SS2SS2S4[R"S9nXX4$) a Generates a list of crop boxes of different sizes. Each layer has (2**i)**2 boxes for the ith layer. Args: image (`torch.Tensor`): Image to generate crops for. target_size (`int`): Size of the smallest crop. crop_n_layers (`int`, *optional*): If `crops_n_layers>0`, mask prediction will be run again on crops of the image. Sets the number of layers to run, where each layer has 2**i_layer number of image crops. overlap_ratio (`int`, *optional*): Sets the degree to which crops overlap. In the first crop layer, crops will overlap by this fraction of the image length. Later layers with more crops scale down this overlap. points_per_crop (`int`, *optional*): Number of points to sample per crop. crop_n_points_downscale_factor (`int`, *optional*): The number of points-per-side sampled in layer n is scaled down by crop_n_points_downscale_factor**n. z.Only one image is allowed for crop generation.rZNrrrkr r)rGrr[r]ranger)r_build_point_grid_generate_per_layer_crops_generate_crop_imagesr|rrrrpermute ones_liker})rUrrrrrr points_gridrn_pointsr layer_idxsrpoint_grid_per_croprs r-rrs8%IJJKK$MK =1$ %!*KLM,X67&7}UbcJ*?;K+'Nj)J!!#Jkk"56O%//2::1aAFO[[0N???1aA:#>ekkRL  DDr,c //pCUupV[XV5nURSSXe/5 URS5 [U5GHnSUS--n [X-SU - -5n [[R "XS- -U-U - 55n [[R "XS- -U-U - 55n [U 5V s/sHn [X- U -5PM nn [U 5V s/sHn [X- U -5PM nn [ X5HKunnUU[UU -U5[UU -U5/nURU5 URUS-5 MM GM" X44$s sn fs sn f)aU Generates 2 ** (layers idx + 1) crops for each crop_n_layers. Crops are in the XYWH format : The XYWH format consists of the following required indices: - X: X coordinate of the top left of the bounding box - Y: Y coordinate of the top left of the bounding box - W: width of the bounding box - H: height of the bounding box rrkr)rrr'r)mathceilr)rrrrr/ im_heightim_width short_sidei_layern_crops_per_sideoverlap crop_width crop_heightr crop_box_x0 crop_box_y0rrboxs r-r)r)Ns  'IY)Jq!X12a'1-m0A8H4HIJG!/C$Dx$OSc#cde $))W10D%E %QUe$efg @EFV@WX@W1sJ0A56@W XAFGWAXYAXAsK1Q67AX Y :ID#c$"3X>C+DUW`@abC   c "   gk *;(  !!YYs E*,E/ n_per_sidecSSU-- n[R"USU- U5n[R"USSS24US45n[R"USS2S4SU45n[R"X4/SS9R SS5nU$)z;Generates a 2D grid of points evenly spaced in [0,1]x[0,1].rrkNrr)r|linspacetilerr)r?rpoints_one_sidepoints_xpoints_ypointss r-r(r(ps !j. !FnnVQZDOzz/$'2ZODHzz/!T'2Q ODH [[(-2 6 > >r1 EF Mr,cN/n/n[U5HupU uppUSS2X2X24nURU5 URSSn[R"U5R SS9R S5nX#U U-n[UUU5nURU5 M Xx4$)z Takes as an input bounding boxes that are used to crop the image. Based in the crops, the corresponding points are also passed. NrZ)r)dimsr)rrr]r|rflipr_normalize_coordinates)rrUr-r/rrrdrtotal_points_per_croprrrrr"r# cropped_imcropped_im_size points_scalerFnormalized_pointss r-r*r*zsN , #+ 51cj$*45 j)$**23/||O499t9DNNqQ ]+l:2; V$$%67-  00r,coordsrcBUupEUS-[XE5- nXF-XV-p[US-5n[US-5n[U5R5nU(aUR SSS5nUSX- -US'USXt- -US'U(aUR SS5nU$)zw Expects a numpy array of length 2 in the final dimension. Requires the original image size in (height, width) format. rKrLrrk).r).rr)rMr)rrr) rrPris_bounding_box old_height old_widthrP new_height new_widths r-rJrJs*J # J : :E&. 0A IO$IZ#%&J f  # # %FAq)F^y'<=F6NF^z'>?F6NA& Mr,rlecUSup[R"X-[S9nSnSnUSHnXSXDU-&XF- nU(+nM URX!5nUR SS5$)z/Compute a binary mask from an uncompressed RLE.rWrrFcountsr)r|emptyrr transpose)rWr5r6maskidxparitycounts r- _rle_to_maskr`srKMF ;;v~T 2D C FX"(S;  << &D >>!Q r,c[UR5U[R"URS5US9nXnUVs/sHoPUPM nnX$nUVs/sHn[ U5PM nnXqX4$s snfs snf)a Perform NMS (Non Maximum Suppression) on the outputs. Args: rle_masks (`torch.Tensor`): binary masks in the RLE format iou_scores (`torch.Tensor` of shape (nb_masks, 1)): iou_scores predicted by the model mask_boxes (`torch.Tensor`): The bounding boxes corresponding to segmentation masks amg_crops_nms_thresh (`float`, *optional*, defaults to 0.7): NMS threshold. r)rridxs iou_threshold)r rr|rr]r`) rle_masksr mask_boxesamg_crops_nms_thresh keep_by_nmsrrWrs r-rrs  [[))!, -* K(J'23{!1{I3(J*3 4)3\# )E 4 i 33 4 4s A7A<c~URupnURSSS5RS5nUSS2SS24USS2SS24- nUR5n/n[ U5HnXUSS2S4U:HS4S-n[ U5S:Xa>XS4S:XaUR X#/X#-/S.5 OUR X#/SX#-/S.5 McUSSUSS- n XS4S:Xa/OS/n XSR5/U R5-X#-USR5- /-- n UR X#/U S.5 M U$)zV Encodes masks the run-length encoding (RLE), in the format expected by pycoco tools. rrkrNr)rWrY) r]r+rnonzeror'rritemr) input_maskrr5r6diffchange_indicesr rcur_idxsbtw_idxsrYs r-rrsr !+ 0 0J##Aq!,44Q7J ae z!SbS&1 1D\\^N C : !A"6!";Q">?!C x=A Q$1$ VO?OPQ VO6>?RST AB<(3B-/!Q$'1,1#A;##%&)::fnxXZ|O`O`Ob>b=ccc VOv>? Jr,)rrV)g4@)rrrrr)F)gffffff?)rkrV)Cr&r2collections.abcrrtr itertoolsrtypingrrrnumpyrr|torch.nnr rtorchvision.ops.boxesr torchvision.transforms.v2tvFimage_processing_backendsr image_processing_utilsr rimage_transformsrr image_utilsrrrrrrprocessing_utilsrrutilsrrrPILrr0rr)rrrrrrrr)rr(r*rJr'r(r`rr__all__r!r,r-rs% $'' $-7;AE5DD "l% "Ae*AeAeH NEcf.b,$8S 888%"$78 2E2E2E 2E 4Z 2E %)I$4 2E 4S ?DI %&2Ej"D#%,,_c14]b#ll;@c? \\8  d38n    4:>  r,