hSrSSKJr SSKrSSKrSSKJr SSKJrJ r SSK J r J r J r SSKrSSKrSSKJrJr SS KJr SS KJrJr SS KJrJrJrJr SS KJr SS K J!r!J"r"J#r# /SQr$Sr%Sr&\ \S4r'\(\'r)Sr*Sr+SS1r,SS1r-1Skr.S1r/S1r0SS1r1S1r2S1r3S1r4S1r5"SS\5r6"SS\6\5r7"S S!\65r8"S"S#\65r9"S$S%\95r:"S&S'\65r;"S(S)\65r<"S*S+\75r="S,S-\65r>g).aModule for composing multiple transforms into augmentation pipelines. This module provides classes for combining multiple transformations into cohesive augmentation pipelines. It includes various composition strategies such as sequential application, random selection, and conditional application of transforms. These composition classes handle the coordination between different transforms, ensuring proper data flow and maintaining consistent behavior across the augmentation pipeline. ) annotationsN) defaultdict)IteratorSequence)AnyUnioncast) BboxParams BboxProcessor)HubMixin)KeypointParamsKeypointsProcessor)SERIALIZABLE_REGISTRY Serializableget_shortest_class_fullnameinstantiate_nonserializable)BasicTransform) DataProcessor format_args get_shape) BaseComposer ComposerOneOf OneOrOther RandomOrder ReplayComposeSelectiveChannelTransform SequentialSomeOfr) imagemaskmasksbboxes keypointsvolumevolumesmask3dmasks3d)r#r$r)r*r"imagesr#>r$r+r*r(r%r&r'r(r)r*c~\rSrSr%SrSrS\S'SrS\S'SrS \S 'S"S#S jjr S$S jr S%S jr S&Sjr S'Sjr S(SjrS)SjrS*SjrS+SjrS,SjrS-Sjr\S.Sj5r\S/Sj5r\4S0Sjjr\S-Sj5r\S1Sj5rS2SjrS2SjrS3SjrS4SjrS5S6Sjjr S7S jr!S!r"g)8rKaBase class for composing multiple transforms together. This class serves as a foundation for creating compositions of transforms in the Albumentations library. It provides basic functionality for managing a sequence of transforms and applying them to data. Attributes: transforms (List[TransformType]): A list of transforms to be applied. p (float): Probability of applying the compose. Should be in the range [0, 1]. replay_mode (bool): If True, the compose is in replay mode. _additional_targets (Dict[str, str]): Additional targets for transforms. _available_keys (Set[str]): Set of available keys for data. processors (Dict[str, Union[BboxProcessor, KeypointsProcessor]]): Processors for specific data types. Args: transforms (TransformsSeqType): A sequence of transforms to compose. p (float): Probability of applying the compose. Raises: ValueError: If an invalid additional target is specified. Note: - Subclasses should implement the __call__ method to define how the composition is applied to data. - The class supports serialization and deserialization of transforms. - It provides methods for adding targets, setting deterministic behavior, and checking data validity post-transform. Nz dict[int, BasicTransform] | None_transforms_dictz tuple[DataProcessor, ...] | Nonecheck_each_transformTbool main_composec :[U[[45(a[R"SSS9 U/nXlX lSUl0Ul[5Ul 0Ul UR5 URU5 URU5 XPlg)Nz`transforms is single transform, but a sequence is expected! Transform will be wrapped into list.r! stacklevelF) isinstancerrwarningswarn transformsp replay_mode_additional_targetsset_available_keys processors _set_keysset_mask_interpolationset_random_seedsave_applied_params)selfr8r9mask_interpolationseedrBkwargss Y/var/www/fran/franai/venv/lib/python3.13/site-packages/albumentations/core/composition.py__init__BaseCompose.__init__ns j;"? @ @ MMr %J$ 35 ),IK  ##$67 T"#6 cSU;ag[US5(aUUR(aCUSRURRURR 545 gggg)z2Track transform parameters if tracking is enabled.applied_transformsparamsN)hasattrrMappend __class____name__copy)rC transformdatas rG_track_transform_params#BaseCompose._track_transform_paramss_ 4 'GIx,H,HYM]M] % & - -y/B/B/K/KYM]M]MbMbMd.e fN^,H 'rJcXlX lURH1n[U[[ 45(dM UR X5 M3 g)zSet random state directly from generators. Args: random_generator (np.random.Generator): numpy random generator to use py_random (random.Random): python random generator to use N)random_generator py_randomr8r5rrset_random_state)rCrXrYrSs rGrZBaseCompose.set_random_states@!1"I)nk%BCC**+;G)rJcXl[RRU5Ul[R "U5UlURH1n[U[[45(dM URU5 M3 g)zNSet random state from seed. Args: seed (int | None): Random seed to use N) rEnprandom default_rngrXRandomrYr8r5rrrA)rCrErSs rGrABaseCompose.set_random_seeds^ " 5 5d ;t,I)nk%BCC))$/)rJcFXlURUR5 g)zSet interpolation mode for mask resizing operations. Args: mask_interpolation (int | None): OpenCV interpolation flag to use for mask transforms. If None, default interpolation for masks will be used. N)rD!_set_mask_interpolation_recursiver8)rCrDs rGr@"BaseCompose.set_mask_interpolations#5 ..t?rJcUHn[U[5(a5[US5(a"URbURUlMIMKMM[U[5(dMdUR UR5 M g)NrD)r5rrNrDrr@rCr8rSs rGrc-BaseCompose._set_mask_interpolation_recursivesk#I)^449&:;;@W@W@c373J3JI0Ad;I{33001H1HI $rJc,[UR5$N)iterr8rCs rG__iter__BaseCompose.__iter__sDOO$$rJc,[UR5$ri)lenr8rks rG__len__BaseCompose.__len__s4??##rJc[e)aApply transforms. Args: *args (Any): Positional arguments are not supported. **data (Any): Named parameters with data to transform. Returns: dict[str, Any]: Transformed data. Raises: NotImplementedError: This method must be implemented by subclasses. )NotImplementedError)rCargsrTs rG__call__BaseCompose.__call__s "!rJc URU$rir8)rCitems rG __getitem__BaseCompose.__getitem__st$$rJc"UR5$ri) indented_reprrks rG__repr__BaseCompose.__repr__s!!##rJcUR$)ztGet additional targets dictionary. Returns: dict[str, str]: Dictionary containing additional targets mapping. )r;rks rGadditional_targetsBaseCompose.additional_targetss'''rJcUR$)zaGet set of available keys. Returns: set[str]: Set of string keys available for transforms. )r=rks rGavailable_keysBaseCompose.available_keyss###rJcUR5R5VVs0sH'up#URS5(aMUS:XaM%X#_M) nnnURRS-nUR HJnUS- n[ US5(aURU[-5O [U5nUSU-U-S-- nML USSU[- --S[U5S 3-- nU$s snnf) zGet an indented string representation of the composition. Args: indent (int): Indentation level. Default: REPR_INDENT_STEP. Returns: str: Formatted string representation with proper indentation. __r8z([ r} ,z], )) to_dict_privateitems startswithrPrQr8rNr}REPR_INDENT_STEPreprr)rCindentkvrt repr_stringtt_reprs rGr}BaseCompose.indented_reprs"&!5!5!7!=!=!?q!? UYHZ^_co^o!?qnn--4 A 4 KCJ1oC^C^Q__V.>%>?dhijdkF 3<&036 6K! tcV.>%>??C TXHYGZZ[B\\\ rsC*C* C*c[U5$)z[Get the full qualified name of the class. Returns: str: The shortest class fullname. )rclss rGget_class_fullnameBaseCompose.get_class_fullnames+3//rJcg)zmCheck if the class is serializable. Returns: bool: True if the class is serializable, False otherwise. Trs rGis_serializableBaseCompose.is_serializablesrJcUR5URURVs/sHoR5PM snS.$s snf)Convert the composition to a dictionary for serialization. Returns: dict[str, Any]: Dictionary representation of the composition. )__class_fullname__r9r8)rr9r8rrCrs rGrBaseCompose.to_dict_privatesD#'"9"9";8<H1,,.H  IsAcUR5[U5SURVs/sHoR5PM snS.$s snf)Get a dictionary representation with object IDs for replay mode. Returns: dict[str, Any]: Dictionary with composition data and object IDs. N)ridrMr8)rrr8get_dict_with_idrs rGrBaseCompose.get_dict_with_id)sG#'"9"9";T(9=IA--/I   JsA c U(aUR5HIup#X R;dMX0RU:wdM*[SUSURUSU35e URRU5 URHnUR U5 M UR R5HnUR U5 M UR5 g)zAdd additional targets to all transforms. Args: additional_targets (dict[str, str] | None): Dict of name -> type mapping for additional targets. If None, no additional targets will be added. z4Trying to overwrite existed additional targets. Key=z Exists=z New value: N) rr; ValueErrorupdater8 add_targetsr>valuesr?)rCrrrrprocs rGrBaseCompose.add_targets7s *002000Q:R:RST:U5U$ c$*B*B1*E)FlSTRUW3  $ $ + +,> ?__ 01%..0  !341 rJcDURRURR55 URH`nURRUR 5 [ US5(dM;URRUR5 Mb UR(aURRS/5 URR5HnURUR;a#[R"SURS3SS9 URRUR5 URR(dMURRURR5 M gg)zSet _available_keystargets_as_paramslabelszGot processor for z!, but no transform to process it.r!r3N)r=rr;keysr8rrNrr>rdefault_data_namer6r7 data_fieldsrM label_fields)rCrrs rGr?BaseCompose._set_keysMs1 ##D$<$<$A$A$CDA  ' '(8(8 9q-..$$++A,?,?@! ??  ' ' 3..0))1E1EEMM,T-C-C,DDef#$$$++D,<,<=;;+++((// 0H0HI1 rJcLURHnURX5 M g)zSet deterministic mode for all transforms. Args: flag (bool): Whether to enable deterministic mode. save_key (str): Key to save replay parameters. Default: "replay". N)r8set_deterministic)rCflagsave_keyrs rGrBaseCompose.set_deterministic`s A   /!rJc:UR(a[U5nURHnnUR5HWupEXCR;d0X@R;dM%URUUR;dMDUR XR5X'MY Mp U$)zCheck and filter data after transformation. Args: data (dict[str, Any]): Dictionary containing transformed data Returns: dict[str, Any]: Filtered data dictionary )r/rrrr;filter)rCrTshaper data_name data_values rGcheck_data_post_transform%BaseCompose.check_data_post_transformks  $ $dOE11-1ZZ\)I $4$44!%=%== 44Y?4CSCSS*.++j*H .:2 rJ) r;r=rDr9r>rYrXr:rBrEr8)NNF) r8TransformsSeqTyper9floatrD int | NonerErrBr0rFr)rS TransformTyperTdict[str, Any]returnNone)rXznp.random.GeneratorrYz random.Randomrr)rErrr)rDrrrr8rrr)rzIterator[TransformType])rint)rtrrTrrr)ryrrr)rstr)rzdict[str, str])rzset[str])rrrrrr0rr)rdict[str, str] | Nonerrrr)replay)rr0rrrrrTrrr)#rQ __module__ __qualname____firstlineno____doc__r.__annotations__r/r1rHrUrZrAr@rcrlrprurzr~propertyrrrr} classmethodrrrrrr?rr__static_attributes__rrJrGrrKsC<:>6==A:AL$ *.$) 7%7 7' 7  7 " 778g H-H!H  H( 0 @J%$" %$(($$+;&00    ,J& 0rJc8^\rSrSrSrS&S'U4Sjjjr\S(Sj5r\RS)Sj5rS*Sjr S+Sjr S+S jr S*S jr SS .S,S jjr S-S jrS.SjrS/SjrS.SjrS.SjrS.SjrS.SjrS0SjrS1U4SjjrS1U4Sjjr\S2Sj5r\S3Sj5r\S2Sj5r\S4Sj5r\S5Sj5rS6SjrS7SjrS8Sjr S7Sjr!S9S jr"\S:S!j5r#\S:S"j5r$\S:S#j5r%\S:S$j5r&S%r'U=r($);riaCompose multiple transforms together and apply them sequentially to input data. This class allows you to chain multiple image augmentation transforms and apply them in a specified order. It also handles bounding box and keypoint transformations if the appropriate parameters are provided. Args: transforms (list[BasicTransform | BaseCompose]): A list of transforms to apply. bbox_params (dict[str, Any] | BboxParams | None): Parameters for bounding box transforms. Can be a dict of params or a BboxParams object. Default is None. keypoint_params (dict[str, Any] | KeypointParams | None): Parameters for keypoint transforms. Can be a dict of params or a KeypointParams object. Default is None. additional_targets (dict[str, str] | None): A dictionary mapping additional target names to their types. For example, {'image2': 'image'}. Default is None. p (float): Probability of applying all transforms. Should be in range [0, 1]. Default is 1.0. is_check_shapes (bool): If True, checks consistency of shapes for image/mask/masks on each call. Disable only if you are sure about your data consistency. Default is True. strict (bool): If True, enables strict mode which: 1. Validates that all input keys are known/expected 2. Validates that no transforms have invalid arguments 3. Raises ValueError if any validation fails If False, these validations are skipped. Default is False. mask_interpolation (int | None): Interpolation method for mask transforms. When defined, it overrides the interpolation method specified in individual transforms. Default is None. seed (int | None): Controls reproducibility of random augmentations. Compose uses its own internal random state, completely independent from global random seeds. When seed is set (int): - Creates a fixed internal random state - Two Compose instances with the same seed and transforms will produce identical sequences of augmentations - Each call to the same Compose instance still produces random augmentations, but these sequences are reproducible between different Compose instances - Example: transform1 = A.Compose([...], seed=137) and transform2 = A.Compose([...], seed=137) will produce identical sequences When seed is None (default): - Generates a new internal random state on each Compose creation - Different Compose instances will produce different sequences of augmentations - Example: transform = A.Compose([...]) # random results Important: Setting random seeds outside of Compose (like np.random.seed() or random.seed()) has no effect on augmentations as Compose uses its own internal random state. save_applied_params (bool): If True, saves the applied parameters of each transform. Default is False. You will need to use the `applied_transforms` key in the output dictionary to access the parameters. Example: >>> import albumentations as A >>> transform = A.Compose([ ... A.RandomCrop(width=256, height=256), ... A.HorizontalFlip(p=0.5), ... A.RandomBrightnessContrast(p=0.2), ... ], seed=137) >>> transformed = transform(image=image) Note: - The class checks the validity of input data and shapes if is_check_args and is_check_shapes are True. - When bbox_params or keypoint_params are provided, it sets up the corresponding processors. - The transform can handle additional targets specified in the additional_targets dictionary. - When strict mode is enabled, it performs additional validation to ensure data and transform configuration correctness. Fc >[TU]UUUU U S9 U(a^[U[5(a [ S 0UD6n O%[U[5(aUn O Sn [ U 5e[ U 5URS'U(a^[U[5(a [S 0UD6n O%[U[5(aUn O Sn [ U 5e[U 5URS'URR5HnURUR5 M URU5 UR(dURR[ 5 SUlXplX`l[)SURR555UlUR-UR5 UR/UR5 XlSUlSUlg) N)r8r9rDrErBz@unknown format of bbox_params, please use `dict` or `BboxParams`r%zHunknown format of keypoint_params, please use `dict` or `KeypointParams`r&Tc3b# UH%n[URSS5(dM!Uv M' g7f)r/FN)getattrrM).0rs rG #Compose.__init__..s'* 5TNdfk9lDD5s / /Fr)superrHr5dictr rr r>rrrensure_transforms_validr8rr=rAVAILABLE_KEYS is_check_argsstrictis_check_shapestupler/_set_check_args_for_transforms_set_processors_for_transformsrB_images_was_list_masks_was_list)rCr8 bbox_paramskeypoint_paramsrr9rrrDrErBb_paramsmsgk_paramsrrPs rGrHCompose.__init__s !1 3   +t,,%4 4K44&X o%(5h(?DOOH % /400)U(aUR5 Xlgri)_validate_strictr)rCvalues rGrr s   ! ! # rJcL^SU4SjjmURH nT"U5 M g)zOValidate that no transforms have invalid arguments when strict mode is enabled.c,>[US5(aQUR(a@SSRUR5SURR3n[ U5e[ U[5(aURH nT"U5 M gg)N invalid_argsz Argument(s) 'z, z' are not valid for transform ) rNrjoinrPrQrr5rr8)rSmessagercheck_transforms rGr1Compose._validate_strict..check_transformsy.11i6L6L#DIIi.D.D$E#FG33<3F3F3O3O2PR!)))[11"--A#A&.2rJN)rSrrrrx)rCrSrs @rGrCompose._validate_stricts  'I I &)rJcUHzn[U[5(a0[US5(aURUR5 MFMH[U[ 5(dM_UR UR5 M| g)Nset_processors)r5rrNrr>rrr8rfs rGr&Compose._set_processors_for_transforms&s_#I)^449&677,,T__=8I{3333I4H4HI $rJcUH|n[U[5(a=URUR5 URUlUR Ul[U[ 5(dMlUR5 M~ gri)r5rrr8r/r>rdisable_check_args_privaterfs rGr&Compose._set_check_args_for_transforms.s`#I)[1133I4H4HI151J1J .'+ $)W--446 $rJc.SUlSUlSUlg)zDisable argument checking for transforms. This method disables strict mode and argument checking for all transforms in the composition. FN)rrr1rks rGr "Compose.disable_check_args_private7s # !rJ force_applycU(a Sn[U5e[U[[45(d Sn[ U5eUR (aUR (a/US'U=(d' URR5UR:nU(dU$URU5 URH-nU"S0UD6nURXc5 URU5nM/ URU5$)akApply transformations to data. Args: *args (Any): Positional arguments are not supported. force_apply (bool): Whether to apply transforms regardless of probability. Default: False. **data (Any): Dict with data to transform. Returns: dict[str, Any]: Dictionary with transformed data. Raises: KeyError: If positional arguments are provided. zXYou have to pass data to augmentations as named arguments, for example: aug(image=image)z&force_apply must have bool or int typerLr)KeyErrorr5r0r TypeErrorrBr1rYr^r9 preprocessr8rUr postprocess)rCrrtrTr need_to_runrs rGruCompose.__call__@s lC3- +c{33:CC.   # #(9(9)+D% &!ET^^%:%:%r*r(r!) rrr;get_get_data_shapeCHECKED_VOLUMECHECKED_MASK3DrO_check_shape_consistencyr_validate_data_preprocess_processors_preprocess_arrays)rCrTshapes volume_shapesrr internal_namers rGrCompose.preprocesshs   FM)-% $ 8 8 < r#BSrWZ^rWrrrJcUR(dgURR5HnURU5 M URR5HnUR U5 M g)z.Run preprocessors if this is the main compose.N)r1r>rensure_data_validr)rCrT processors rGrCompose._preprocess_processorssX  //1I  ' ' -2//1I   &2rJcHURU5 URU5 g)zJConvert lists to numpy arrays for images and masks, and ensure contiguity.N)_preprocess_images_preprocess_masksrCrTs rGr Compose._preprocess_arrayss % t$rJcSU;ag[US[[45(a/SUlUS(dg[R "US5US'gSUlg)z$Convert image lists to numpy arrays.r+NTF)r5listrrr]stackr5s rGr3Compose._preprocess_imagessR 4   d8ntUm 4 4$(D !>XXd8n5DN$)D !rJcSU;ag[US[[45(a/SUlUS(dg[R "US5US'gSUlg)z#Convert mask lists to numpy arrays.r$NTF)r5r8rrr]r9r5s rGr4Compose._preprocess_maskssR $   d7mdE] 3 3#'D =HHT']3DM#(D rJc,UR(aURR5HnURU5 M SU;a"UR(a[ US5US'SU;a"UR (a[ US5US'U$)zApply post-processing to data after all transforms have been applied. Args: data (dict[str, Any]): Data after transformation. Returns: dict[str, Any]: Post-processed data. r+r$)r1r>rrrr8r)rCrTr9s rGrCompose.postprocesssz   __++- d#.4D$9$9!%d8n!5X$4#7#7 $T'] 3W  rJch>[TU]5nURRS5nURRS5nUR U(aUR R5OSU(aUR R5OSUR URS.5 U$)rr%r&N)rrrr)rrr>rrrMrrrC dictionarybbox_processorkeypoints_processorrPs rGrCompose.to_dict_privatesW,. ,,X6"oo11+>JX~44DDF^bTg$7$>$>$N$N$Pmq&*&=&=#'#7#7   rJcj>[TU]5nURRS5nURRS5nUR U(aUR R 5OSU(aUR R 5OSURSURS.5 U$)rr%r&N)rrrrMr) rrr>rrrMrrrr@s rGrCompose.get_dict_with_idsW-/ ,,X6"oo11+>JX~44DDF^bTg$7$>$>$N$N$Pmq&*&=&=#'#7#7   rJcz[U[R5(d[US35eURSS$)N must be numpy array typer!r5r]ndarrayrrrrTs rG_check_single_dataCompose._check_single_datas6$ ++yk)BCD Dzz"1~rJc[U[R5(a-URS;a[ US35eUR SS$[U[ [45(afU(dg[SU55(d[ SUS35e[S U55(a[ S US 35eUS R SS $[ US35e)aCheck masks data format and return shape. Args: data_name (str): Name of the data field being checked data (Any): Input data in one of these formats: - List of numpy arrays, each of shape (H, W) or (H, W, C) - Numpy array of shape (N, H, W) or (N, H, W, C) - Empty list for cases where no masks are present Returns: tuple[int, int] | None: (height, width) of the first mask, or None if masks list is empty Raises: TypeError: If data format is invalid )rr as numpy array must be 3D or 4Dr rNc3V# UHn[U[R5v M! g7fri)r5r]rJrms rGr,Compose._check_masks_data..%s?$Qz!RZZ00$s')zAll elements in z must be numpy arraysc3># UHoRS;v M g7f)>r!rN)ndimrQs rGrrS's6A66'sz All masks in z must be 2D or 3D numpy arraysrr!z; must be either a numpy array or a sequence of numpy arrays) r5r]rJrUrrr8rallanyrKs rG_check_masks_dataCompose._check_masks_data s" dBJJ ' 'yy&9+-M NOO::a? " dT5M * *?$???"29+=R STT6666- {:X YZZ7==!$ $9+%`abbrJcH[U[R5(a-URS;a[ US35eUR SS$[U[ 5(a"[US[R5(d[ US35eUSR SS$) avCheck multi-image data format and return shape. Args: data_name (str): Name of the data field being checked data (Any): Input data in one of these formats: - List-like of numpy arrays - Numpy array of shape (N, H, W, C) or (N, H, W) Returns: tuple[int, int]: (height, width) of the first image Raises: TypeError: If data format is invalid rrrOr rrz7 must be either a numpy array or a list of numpy arraysNr!)r5r]rJrUrrrrKs rG_check_multi_dataCompose._check_multi_data-s dBJJ ' 'yy&9+-M NOO::a? "$))DGRZZ1P1Pyk)`ab bAw}}Ra  rJcU[;aURS5c [S5eU[;aURS5c [S5egg)Nr%z6bbox_params must be specified for bbox transformationsr&z?keypoints_params must be specified for keypoint transformations)CHECK_BBOX_PARAMrrCHECK_KEYPOINTS_PARAM)internal_data_namer>s rG_check_bbox_keypoint_params#Compose._check_bbox_keypoint_paramsFsQ !1 1jnnX6N6VUV V !6 6:>>+;V;^^_ _<_ 6rJc|U(a5U(a-URUS5[U5:wa [S5eggg)NrzHeight and Width of image, mask or masks should be equal. You can disable shapes check by setting a parameter is_check_shapes=False of Compose class (do it only if you are sure about your data consistency).)countror)r!rs rG _check_shapesCompose._check_shapesMs; v&,,vay*AS[*P0 +Qv?rJc /n/nUR5GHWupEURRXD5nU[;aM[ U[ R 5(d[US35eURURSS5 MxUcM}[ U[ R [45(dMURX`R5 URXFU5nUcMU[[-;a+URUSS5 URUSS5 GMUS;a+URUSS5 URUSS5 GMCURUSS5 GMZ UR!X#5 g)NrHr!r r>r*r(r)rr;rCHECKED_SINGLEr5r]rJrrOrr8rbr>rrrr)rCrFr!r"rrTr#rs rGr'Compose._check_argsVsQ %||~OI 4488NM.!$ 33#yk1J$KLL djj!n-|dRZZ$677  , ,]OO L((4HE} ?? eAaj)$$U2AY/"88 eAaj)$$U1QZ0 eBQi(= .@ %%fr*r(rHr must be 4D or 5D array)rXr5r]rJrrUrr\)rCrr#rTrs rGrpCompose._get_multi_data_shapes G #**9;E =4 3e 3 2 2dBJJ//9+-F GHHyy&9+-D EFF:: %%i66rJcURXR5 UR(a5U(a-URUS5[U5:wa [ S5eggg)zCheck consistency of shapes.rzDepth, Height and Width of volume, mask3d, volumes and masks3d should be equal. You can disable shapes check by setting is_check_shapes=False.N)rfrreror)rCr!r"s rGr Compose._check_shape_consistencysb 6#7#78   Mm6I6I-XYJZ6[_bcp_q6qQ 7rM rJc\URS;a[US35eURSS$)Nr[ must be 3D or 4D arrayrrUrrrKs rGrmCompose._check_volume_datas1 99F "yk)@AB Bzz"1~rJc\URS;a[US35eURSS$)Nrurwr rr}rKs rG_check_volumes_dataCompose._check_volumes_datas1 99F "yk)@AB Bzz!ArJc\URS;a[US35eURSS$)z:Check single volumetric mask data format and return shape.r[r|Nrr}rKs rGrnCompose._check_mask3d_datas3 99F "yk)@AB Bzz"1~rJc\URS;a[US35eURSS$)z=Check multiple volumetric masks data format and return shape.)rrvrwr rr}rKs rG_check_masks3d_dataCompose._check_masks3d_datas3 99F "yk)@AB Bzz!ArJ) rrrr/rrr1rBr) NNN?TFNNF)r8rr"dict[str, Any] | BboxParams | Noner&dict[str, Any] | KeypointParams | Nonerrr9rrr0rr0rDrrErrBr0r)rr0rrrrrtrrr0rTrrr)rTrrr)rTrrr)r,rrr0rr)rrrTrrztuple[int, int])rrrTrrztuple[int, int] | None)rarr>rrr)r!list[tuple[int, ...]]rr0rr)rFrrr)rrr#rrTrrztuple[int, ...] | None)rrrT np.ndarrayrztuple[int, ...])r!rr"rrr)rrrTrrztuple[int, int, int]))rQrrrrrHrrsetterrrrr rurrr&rr r3r4rrr staticmethodrLrXr\rbrfr'rrlrprrmrrnrr __classcell__rPs@rGrrs?H;?BF48 $)-$)=%%=%8=%@ =% 2 =%  =%=%=%'=%=%"=%=%~ ]]'"J7"8=&&P &D %s'% * ).(* ccB!!0`` $=L( 7    rJrcF^\rSrSrSrSS U4SjjjrSS.S SjjrSrU=r$) ria[Select one of transforms to apply. Selected transform will be called with `force_apply=True`. Transforms probabilities will be normalized to one 1, so in this case transforms probabilities works as weights. Args: transforms (list): list of transformations to compose. p (float): probability of applying selected transform. Default: 0.5. c>[TU]XS9 URVs/sHo3RPM nn[ U5nUVs/sHo3U- PM snUlgs snfs snfN)r8r9)rrHr8r9sum transforms_ps)rCr8r9rrsrPs rGrHOneOf.__init__sX J4&*oo6oo 6  -:;]!e];7;s AAFr cUR(aURH nU"S0UD6nM U$UR(aU(d(URR 5UR :aaUR R[UR5URS9nURUnU"SSS0UD6nURXC5 U$)a{Apply the OneOf composition to the input data. Args: *args (Any): Positional arguments are not supported. force_apply (bool): Whether to apply transforms regardless of probability. Default: False. **data (Any): Dict with data to transform. Returns: dict[str, Any]: Dictionary with transformed data. Raises: KeyError: If positional arguments are provided. )r9rTr) r:r8rrYr^r9rXchoicerorU)rCrrtrTridxs rGruOneOf.__call__s   __y4y%K   ;$..2G2G2IDFF2R,,33C4HDL^L^3_C$A...D  ( ( 1 rJ)r?r8rr9rr rQrrrrrHrurrrs@rGrrs!<< 8=rJrc`^\rSrSrSrS S U4SjjjrSS.S SjjrS SjrSU4SjjrS r U=r $)r iaSelects exactly `n` transforms from the given list and applies them. The selection of which `n` transforms to apply is done **uniformly at random** from the provided list. Each transform in the list has an equal chance of being selected. Once the `n` transforms are selected, each one is applied **based on its individual probability** `p`. Args: transforms (list[BasicTransform | BaseCompose]): A list of transforms to choose from. n (int): The exact number of transforms to select and potentially apply. If `replace=False` and `n` is greater than the number of available transforms, `n` will be capped at the number of transforms. replace (bool): Whether to sample transforms with replacement. If True, the same transform can be selected multiple times (up to `n` times). Default is False. p (float): The probability that this `SomeOf` composition will be applied. If applied, it will select `n` transforms and attempt to apply them. Default is 1.0. Note: - The overall probability `p` of the `SomeOf` block determines if *any* selection and application occurs. - The individual probability `p` of each transform inside the list determines if that specific transform runs *if it is selected*. - If `replace` is True, the same transform might be selected multiple times, and its individual probability `p` will be checked each time it's encountered. Example: >>> import albumentations as A >>> transform = A.SomeOf([ ... A.HorizontalFlip(p=0.5), # 50% chance to apply if selected ... A.VerticalFlip(p=0.8), # 80% chance to apply if selected ... A.RandomRotate90(p=1.0), # 100% chance to apply if selected ... ], n=2, replace=False, p=1.0) # Always select 2 transforms uniformly # In each call, 2 transforms out of 3 are chosen uniformly. # For example, if HFlip and VFlip are chosen: # - HFlip runs if random() < 0.5 # - VFlip runs if random() < 0.8 # If VFlip and Rotate90 are chosen: # - VFlip runs if random() < 0.8 # - Rotate90 runs if random() < 1.0 (always) Fc>[TU]X5 X lU(d[U[UR5:aB[UR5Ul[ R "SURS3[SS9 X0lg)Nz=`n` is greater than number of transforms. `n` will be set to .r!r3) rrHnror8r6r7 UserWarningreplacerCr8rrr9rPs rGrHSomeOf.__init__(se '1s4??33)DF MMOPTPVPVxWXY   rJr cxUR(a.URHnU"S0UD6nURU5nM U$URR 5UR :aRUR 5nUH<nURUnU"S0UD6nURXC5 URU5nM> U$)aPApply n randomly selected transforms from the list of transforms. Args: *arg (Any): Positional arguments are not supported. force_apply (bool): Whether to apply transforms regardless of probability. Default: False. **data (Any): Dict with data to transform. Returns: dict[str, Any]: Dictionary with transformed data. r)r:r8rrYr^r9_get_idxrU)rCrargrTrindices_to_consideris rGruSomeOf.__call__4s   __y4y55d;%K >> "TVV +"&--/ (OOA&y4y,,Q555d; )  rJcURR[UR5URUR S9nUR 5 U$N)sizer)rXrror8rrsort)rCrs rGrSomeOf._get_idxQsG##**  LL+    rJct>[TU]5nURURURS.5 U$)zConvert the SomeOf composition to a dictionary for serialization. Returns: dict[str, Any]: Dictionary representation of the composition. rr)rrrrrrCrArPs rGrSomeOf.to_dict_private[s3W,. 4<<@ArJrr Fr r8rrrrr0r9r)rrrr0rTrrrrznp.ndarray[np.int_]r) rQrrrrrHrurrrrrs@rGr r s,,\  7<:  rJr c>^\rSrSrSrSSU4SjjjrSSjrSrU=r$) rigaApply a random subset of transforms from the given list in a random order. Selects exactly `n` transforms uniformly at random from the list, and then applies the selected transforms in a random order. Each selected transform is applied based on its individual probability `p`. Attributes: transforms (TransformsSeqType): A list of transformations to choose from. n (int): The number of transforms to apply. If `n` is greater than the number of available transforms and `replace` is False, `n` will be set to the number of available transforms. replace (bool): Whether to sample transforms with replacement. If True, the same transform can be selected multiple times. Default is False. p (float): Probability of applying the selected transforms. Should be in the range [0, 1]. Default is 1.0. Example: >>> import albumentations as A >>> transform = A.RandomOrder([ ... A.HorizontalFlip(p=0.5), ... A.VerticalFlip(p=1.0), ... A.RandomBrightnessContrast(p=0.8), ... ], n=2, replace=False, p=1.0) >>> # This will uniformly select 2 transforms and apply them in a random order, >>> # respecting their individual probabilities (0.5, 1.0, 0.8). Note: - Inherits from SomeOf, but overrides `_get_idx` to ensure random order without sorting. - Selection is uniform; application depends on individual transform probabilities. c">[TU]XX4S9 g)N)r8rrr9rrHrs rGrHRandomOrder.__init__s JWJrJcURR[UR5URUR S9$r)rXrror8rrrks rGrRandomOrder._get_idxs<$$++  LL,  rJrrrr) rQrrrrrHrrrrs@rGrrgs<KK  rJrc\^\rSrSrSrSS U4SjjjrSS.S SjjrSrU=r$) rizdSelect one or another transform to apply. Selected transform will be called with `force_apply=True`.c>UcUbUc Sn[U5eX/n[TU] X45 [UR5[ :wa[ R"SSS9 gg)Nz>You must set both first and second or set transforms argument.z'Length of transforms is not equal to 2.r!r3)rrrHror8NUM_ONEOF_TRANSFORMSr6r7)rCfirstsecondr8r9rrPs rGrHOneOrOther.__init__s^  }V o%J ' t #7 7 MMCPQ R 8rJFr c,UR(a.URHnU"S0UD6nURXC5 M U$URR 5UR :aURS"SSS0UD6$URS"SSS0UD6$)aAApply one or another transform to the input data. Args: *args (Any): Positional arguments are not supported. force_apply (bool): Whether to apply transforms regardless of probability. Default: False. **data (Any): Dict with data to transform. Returns: dict[str, Any]: Dictionary with transformed data. rrTr)r:r8rUrYr^r9rCrrtrTrs rGruOneOrOther.__call__s   __y4y,,Q5%K >> "TVV +??1%?$?$? ?r"[TU]X5 X lgri)rrHchannels)rCr8rr9rPs rGrH"SelectiveChannelTransform.__init__s ' rJFr cU(d(URR5UR:aUSnUSS2SS2UR4n[R "U5nUR HnU"US9SnURXv5 M [R"U5nUR5n [URU5HupXSS2SS2U 4'M [R "U 5US'U$)aCApply transforms to specific channels of the image. Args: *args (Any): Positional arguments are not supported. force_apply (bool): Whether to apply transforms regardless of probability. Default: False. **data (Any): Dict with data to transform. Returns: dict[str, Any]: Dictionary with transformed data. r"N)r") rYr^r9rr]ascontiguousarrayr8rUcv2splitrRzip) rCrrtrTr"selected_channels sub_imagertransformed_channels output_imgrchannels rGru"SelectiveChannelTransform.__call__s $..//1DFF:ME %aDMM&9 : ,,->?I__I.w7 ,,Q:%$'99Y#7 J #DMM3G H (/1a9%!I00[TU]XX4XV5 URSUS9 XplURR U5 g)NTr)rrHrrr=add) rCr8rrrr9rrrPs rGrHReplayCompose.__init__sC /WXj th7    *rJFr c>[[5X0R'[TU]"SSU0UD6nUR 5nUR XTUR5 URU5 XTUR'U$)abApply transforms and record parameters for future replay. Args: *args (Any): Positional arguments are not supported. force_apply (bool): Whether to apply transforms regardless of probability. Default: False. **kwargs (Any): Dict with data to transform. Returns: dict[str, Any]: Dictionary with transformed data and replay information. rr)rrrrrurfill_with_params fill_applied)rCrrtrFresult serializedrPs rGruReplayCompose.__call__sq!,D 1}}!DkDVD**,  j*?@ *% *t}} rJc @[RU5nU"SSS0UD6$)a Replay previously saved augmentations. Args: saved_augmentations (dict[str, Any]): Previously saved augmentation parameters. **kwargs (Any): Dict with data to transform. Returns: dict[str, Any]: Dictionary with transformed data using saved parameters. rTr)r_restore_for_replay)saved_augmentationsrFaugss rGrReplayCompose.replay1s(001DE////rJcUSnUSn[X5nU(aUnOrUSnUR5VVs0sHupxUS;dM Xx_M n nn[Un SU ;a*U SV s/sHn [R XS9PM sn U S'U "S 0U D6n[ SU5n[ U[5(aX5lSUl X%l U$s snnfs sn f) aArgs: transform_dict (dict[str, Any]): A dictionary that contains transform data. lambda_transforms (dict): A dictionary that contains lambda transforms, that is instances of the Lambda class. This dictionary is required when you are restoring a pipeline that contains lambda transforms. Keys in that dictionary should be named same as `name` arguments in respective lambda transforms from a serialized pipeline. appliedrMr)rrrMr8)lambda_transformsrTr) rrrrrr r5rrMr:applied_in_replay) transform_dictrrrMlmbdrSnamerrrtrrs rGr!ReplayCompose._restore_for_replay@s!+)*>M I!"67D%3%9%9%;t%;TQqHs?sDAD%;Dt'-Ct#",/&/"55a5]/&\" d I)95 i 0 0%  $ &-#u&s CC'CcURURS55nX1S'US URS/5HnURXB5 M g)zFill serialized transform data with parameters for replay. Args: serialized (dict[str, Any]): Serialized transform data. all_params (Any): Parameters to fill in. rrMr8N)rr)rCr all_paramsrMrSs rGrReplayCompose.fill_with_paramsesN t 45%8 t # b9I  ! !) 8:rJcSU;a6USVs/sHo RU5PM nn[U5US'US$URS5SLUS'US$s snf)zSet 'applied' flag for transforms based on parameters. Args: serialized (dict[str, Any]): Serialized transform data. Returns: bool: True if any transform was applied, False otherwise. r8rrMN)rrWr)rCrrrs rGrReplayCompose.fill_appliedssv : %5? 5MN5M((+5MGN$'LJy !)$$%/NN8$[TU]5nURSUR05 U$)zConvert the ReplayCompose to a dictionary for serialization. Returns: dict[str, Any]: Dictionary representation of the composition. r)rrrrrs rGrReplayCompose.to_dict_privates/W,. :t}}56rJr)NNNrTr)r8rrrrrrrr9rrr0rr)rtrrr0rFrrr)rrrFrrrri)rrrzdict[str, Any] | Nonerr)rrrrrr)rrrr0r)rQrrrrrHrurrrrrrrrrs@rGrrs(;?BF48 $  +% +8 +@ + 2 +  + + + +8=( 0 048"&"0" ""H 9%"  rJrcF^\rSrSrSrSS U4SjjjrSS.S SjjrSrU=r$) riaSequentially applies all transforms to targets. Note: This transform is not intended to be a replacement for `Compose`. Instead, it should be used inside `Compose` the same way `OneOf` or `OneOrOther` are used. For instance, you can combine `OneOf` with `Sequential` to create an augmentation pipeline that contains multiple sequences of augmentations and applies one randomly chose sequence to input data (see the `Example` section for an example definition of such pipeline). Example: >>> import albumentations as A >>> transform = A.Compose([ >>> A.OneOf([ >>> A.Sequential([ >>> A.HorizontalFlip(p=0.5), >>> A.ShiftScaleRotate(p=0.5), >>> ]), >>> A.Sequential([ >>> A.VerticalFlip(p=0.5), >>> A.RandomBrightnessContrast(p=0.5), >>> ]), >>> ], p=1) >>> ]) c >[TU]XS9 grr)rCr8r9rPs rGrHSequential.__init__s J4rJFr cUR(d/U(d(URR5UR:a=URH-nU"S0UD6nUR XC5 UR U5nM/ U$)a9Apply all transforms in sequential order. Args: *args (Any): Positional arguments are not supported. force_apply (bool): Whether to apply transforms regardless of probability. Default: False. **data (Any): Dict with data to transform. Returns: dict[str, Any]: Dictionary with transformed data. r)r:rYr^r9r8rUrrs rGruSequential.__call__se   {dnn.C.C.E.N__y4y,,Q555d;% rJrrrrrrs@rGrrs!2558=rJr)?r __future__rr^r6 collectionsrcollections.abcrrtypingrrr rnumpyr] bbox_utilsr r hub_mixinr keypoints_utilsrr serializationrrrrtransforms_interfacerutilsrrr__all__rrrr8rrr*r+riror_r` VOLUME_KEYSrCHECKED_VOLUMESrCHECKED_MASKS3Drrrr rrrrrrrJrGr sO# #.## 1? 188 nm34 'l  x 6"9 :$ # ++t,tn H k8H V)K)Xk[k\* &* Z(=(=V: :zQGQh..rJ