U hZ~ @sddlmZddlZddlZddlmZmZddlmZm Z m Z m Z m Z m Z ddlZddlZddlmZddlmZddlmZmZdd lmZdd lmZmZdd lmZmZm Z m!Z!dd l"m#Z#dd l$m%Z%m&Z&m'Z'ddddddddddddg Z(dZ)dZ*e e#dfZ+e e+Z,dZ-dZ.dZ/dZ0dZ1d Z2d!Z3dd"d#d$d%Z4Gd&ddeZ5Gd'dde5eZ6Gd(dde5Z7Gd)dde5Z8Gd*d+d+e8Z9Gd,dde5Z:Gd-dde5Z;Gd.dde6Zd?d@ZdS)BraBase 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. applied_in_replay (bool): Indicates if the compose was applied during replay. _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_composer#floatr-pcCsZt|ttfr"tjddd|g}||_||_d|_d|_i|_ t |_ i|_ | dS)Nz`transforms is single transform, but a sequence is expected! Transform will be wrapped into list.r% stacklevelF)r0rrwarningswarnr-r> replay_modeapplied_in_replay_additional_targetsset_available_keys processors _set_keysselfr-r>r6r6r7__init__iszBaseCompose.__init__zIterator[TransformType]r.cCs t|jSr/)iterr-rKr6r6r7__iter__{szBaseCompose.__iter__intcCs t|jSr/)lenr-rOr6r6r7__len__~szBaseCompose.__len__rdict[str, Any])argsdatar.cOstdSr/)NotImplementedError)rKrUrVr6r6r7__call__szBaseCompose.__call__r")itemr.cCs |j|Sr/)r-)rKrYr6r6r7 __getitem__szBaseCompose.__getitem__strcCs|Sr/) indented_reprrOr6r6r7__repr__szBaseCompose.__repr__zdict[str, str]cCs|jSr/)rErOr6r6r7additional_targetsszBaseCompose.additional_targetszset[str]cCs|jSr/)rGrOr6r6r7available_keysszBaseCompose.available_keys)indentr.cCsdd|D}|jjd}|jD]@}|d7}t|drL||tnt|}|d||d7}q(|dd|tdt |d 7}|S) NcSs(i|] \}}|ds|dks||qS)__r-) startswith.0kvr6r6r7 s  z-BaseCompose.indented_repr..z([ r\ ,z], )) to_dict_privateitems __class____name__r-hasattrr\REPR_INDENT_STEPreprr)rKr`rUZ repr_stringtZt_reprr6r6r7r\s   $zBaseCompose.indented_reprcCst|Sr/)rclsr6r6r7get_class_fullnameszBaseCompose.get_class_fullnamecCsdS)NTr6rtr6r6r7is_serializableszBaseCompose.is_serializablecCs||jdd|jDdS)NcSsg|] }|qSr6)rlrdrsr6r6r7 sz/BaseCompose.to_dict_private..)__class_fullname__r>r-)rvr>r-rOr6r6r7rlszBaseCompose.to_dict_privatecCs"|t|ddd|jDdS)NcSsg|] }|qSr6)get_dict_with_idrxr6r6r7rysz0BaseCompose.get_dict_with_id..)rzr3paramsr-)rvr3r-rOr6r6r7r{s zBaseCompose.get_dict_with_iddict[str, str] | NoneNone)r^r.cCs|r|D]@\}}||jkr ||j|kr td|d|j|d|q |j||jD]}||q`|jD]}||qz|dS)Nz4Trying to overwrite existed additional targets. Key=z Exists=z New value: ) rmrE ValueErrorr1r- add_targetsrHvaluesrI)rKr^rerfrsprocr6r6r7rs    zBaseCompose.add_targetscCs|j|j|jD]*}|j|jt|dr|j|jq|jr|jdg|j D]N}|j |jkrt j d|j ddd|j|j |jjrb|j|jjqbdS)zSet _available_keystargets_as_paramslabelszGot processor for z!, but no transform to process it.r%r?N)rGr1rEkeysr-r_rprrHrZdefault_data_namerArB data_fieldsr|Z label_fields)rKrsrr6r6r7rIs     zBaseCompose._set_keysreplay)flagsave_keyr.cCs|jD]}|||qdSr/)r-set_deterministic)rKrrrsr6r6r7rs zBaseCompose.set_deterministicrVr.cCsd|jr`t|d}|jD]F}|D]<}||jksH||jkr |j||jkr ||||||<q q|S)Nr&)r9rrrEfilter)rKrVZ image_shaper data_namer6r6r7check_data_post_transforms   z%BaseCompose.check_data_post_transform)r)ro __module__ __qualname____doc__r8__annotations__r9r;rLrPrSrXrZr]propertyr^r_rqr\ classmethodrvrwrlr{rrIrrr6r6r6r7rFs2     c sTeZdZdZd?ddd d d d d d d d fdd ZdddddZdddddZddddZdddd dddddZd ddd!d"d#Z ddd$d%d&Z ddd$d'd(Z ddfd)d* Z ddfd+d, Z ed dd-d.d/d0Zed dd-d.d1d2Zed dd-d.d3d4Zed ddd5d6d7Zed8d dd9d:d;Zddd<d=d>ZZS)@raCompose transforms and handle all transformations regarding bounding boxes Args: transforms (list): list of transformations to compose. bbox_params (BboxParams): Parameters for bounding boxes transforms keypoint_params (KeypointParams): Parameters for keypoints transforms additional_targets (dict): Dict with keys - new target name, values - old target name. ex: {'image2': 'image'} p (float): probability of applying all list of transforms. Default: 1.0. is_check_shapes (bool): If True shapes consistency of images/mask/masks would be checked on each call. If you would like to disable this check - pass False (do it only if you are sure in your data consistency). strict (bool): If True, unknown keys will raise an error. If False, unknown keys will be ignored. Default: True. return_params (bool): if True returns params of each applied transform save_key (str): key to save applied params, default is 'applied_params' N?TFapplied_paramsr#"dict[str, Any] | BboxParams | None&dict[str, Any] | KeypointParams | Noner}r<r:r[) r- bbox_paramskeypoint_paramsr^r>is_check_shapesstrict return_paramsrc sNt|||rRt|tr(tf|} nt|tr8|} n d} t| t| |jd<|rt|trltf|} nt|tr||} n d} t| t | |jd<|j D]} | |j q| ||j s|jtd|_||_||_tdd|j D|_||j ||_|r>| |_|j| t|j |_|jd| d||j dS) Nz@unknown format of bbox_params, please use `dict` or `BboxParams`r)zHunknown format of keypoint_params, please use `dict` or `KeypointParams`r*Tcss |]}t|jddr|VqdS)r9FN)getattrr|)rdrr6r6r7 %sz#Compose.__init__..r)superrLr0dictrrrrHrrrZensure_transforms_validr-rrGr1AVAILABLE_KEYS is_check_argsrrtupler9_set_check_args_for_transformsrraddr2r8r_set_processors_for_transforms)rKr-rrr^r>rrrrZb_paramsmsgZk_paramsrrnr6r7rLsH             zCompose.__init__r~r,cCsF|D]<}t|tr*t|dr@||jqt|tr||jqdS)Nset_processors)r0rrprrHrrr-rKr-r5r6r6r7r4s    z&Compose._set_processors_for_transformscCsF|D]<}t|tr.||j|j|_|j|_t|tr|qdSr/)r0rrr-r9rHrdisable_check_args_privaterr6r6r7r<s   z&Compose._set_check_args_for_transformsrMcCsd|_d|_d|_dS)NF)rrr;rOr6r6r7rEsz"Compose.disable_check_args_private force_applyrrTrUrrVr.cOs|rd}t|t|ttfs*d}t||jrB|jrBt||j<|pRt |j k}|s\|S| ||j D]}|f|}| |}ql||S)NzXYou have to pass data to augmentations as named arguments, for example: aug(image=image)z&force_apply must have bool or int type)KeyErrorr0r:rQ TypeErrorrr;rrrandomr> preprocessr-r postprocess)rKrrUrVrZ need_to_runrsr6r6r7rXJs       zCompose.__call__zdict[int, dict[str, Any]])r|rVr.cKsZ|jdkrtd|||D]*\}}|j|}|j|f|}||}q$||S)z[Run transforms with given parameters. Available only for Compose with `return_params=True`.NzJ`run_with_params` is not available for Compose with `return_params=False`.)r8 RuntimeErrorrrmZapply_with_paramsrr)rKr|rVZtr_idparamtrr6r6r7run_with_paramsbs    zCompose.run_with_paramsrcCs|jr>|D]2}||jkr |tkr |tkr d|d}t|q |jrP|jf||jr|j D]}| |q`|j D]}| |qzdS)NzKey z is not in available keys.) rrG MASK_KEYS IMAGE_KEYSrr _check_argsr;rHrZensure_data_validr)rKrVrrr>r6r6r7rps    zCompose.preprocesscCs$|jr |jD]}||q|Sr/)r;rHrr)rKrVr>r6r6r7r~s zCompose.postprocesscsZt}|jd}|jd}||r4|jnd|rD|jnd|j|jd|S)Nr)r*)rrr^r)rrlrHgetr1r|r^rrK dictionaryZbbox_processorZkeypoints_processorrr6r7rls   zCompose.to_dict_privatecs\t}|jd}|jd}||r4|jnd|rD|jnd|jd|jd|S)Nr)r*)rrr^r|r) rr{rHrr1r|rlr^rrrr6r7r{s    zCompose.get_dict_with_idztuple[int, int])rrVr.cCs(t|tjst|d|jddS)Nz must be numpy array typer%)r0npndarrayrshaperrVr6r6r7_check_single_datas zCompose._check_single_datacCst|tjrJ|jdkr$t|d|jtkr<|jddS|jddSt|trtdd|Dsvtd|d t d d|Drtd |d |d jddSt|ddS)N)z must be a 3D or 4D numpy arrayr rr%css|]}t|tjVqdSr/)r0rrrdmr6r6r7rsz,Compose._check_masks_data..zAll elements in z must be numpy arrayscss|]}|jdkVqdS))r%rN)ndimrr6r6r7rsz All masks in z must be 2D or 3D numpy arraysrz; must be either a numpy array or a sequence of numpy arrays) r0rrrrr rrallanyrr6r6r7_check_masks_datas  & zCompose._check_masks_datacCs:t|trt|dtjs(t|d|djddS)Nrz must be list of numpy arraysr%)r0rrrrrrr6r6r7_check_multi_dataszCompose._check_multi_data)internal_data_namerHr.cCs@|tkr|ddkrtd|tkr<|ddkrt||dd|jD}t|fdd|D|_dS)NcSsg|] }|jqSr6r>rxr6r6r7rysz"OneOf.__init__..csg|] }|qSr6r6rxsr6r7rys)rrLr-sum transforms_ps)rKr-r>rrrr7rLszOneOf.__init__Frrr:rTrcOsn|jr |jD]}|f|}q |S|jrj|s8t|jkrjtjt|j|jd}|j|}|fddi|}|S)NrrT)rCr-rrr>r choicerR)rKrrUrVrsidxr6r6r7rXs   zOneOf.__call__)rrorrrrLrXrr6r6rr7rs csheZdZdZddddddfd d Zd d d dd ddddZddddZddfdd ZZS)raSelect N transforms to apply. Selected transforms 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. n (int): number of transforms to apply. replace (bool): Whether the sampled transforms are with or without replacement. Default: True. p (float): probability of applying selected transform. Default: 1. Tr r#rQr:r<r-nreplacer>cst||||_|sL|t|jkrLt|j|_tjd|jdtdd||_dd|jD}t |fdd|D|_ dS)Nz=`n` is greater than number of transforms. `n` will be set to .r%r?cSsg|] }|jqSr6rrxr6r6r7rysz#SomeOf.__init__..csg|] }|qSr6r6rxrr6r7rys) rrLrrRr-rArB UserWarningrrr)rKr-rrr>rrrr7rL s  zSomeOf.__init__FrrrT)argrrVr.cOsz|jr*|jD]}|f|}||}q |S|jrv|sBt|jkrv|D]*}|j|}|fddi|}||}qJ|SNrT)rCr-rrrr>_get_idx)rKrrrVrsir6r6r7rXs      zSomeOf.__call__np.ndarray[np.int_]rMcCs*tjt|j|j|j|jd}||SN)sizerr>)r rrRr-rrrsort)rKrr6r6r7r&szSomeOf._get_idxcs"t}||j|jd|S)N)rr)rrlr1rrrKrrr6r7rl+s zSomeOf.to_dict_private)Tr ) rorrrrLrXrrlrr6r6rr7rs  cs<eZdZdZddddddfd d Zd d d dZZS) RandomOrderaSelect N transforms to apply. Selected transforms will be called in random order with `force_apply=True`. Transforms probabilities will be normalized to one 1, so in this case transforms probabilities works as weights. This transform is like SomeOf, but transforms are called with random order. It will not replay random order in ReplayCompose. Args: transforms (list): list of transformations to compose. n (int): number of transforms to apply. replace (bool): Whether the sampled transforms are with or without replacement. Default: False. p (float): probability of applying selected transform. Default: 1. Fr r#rQr:r<rcst||||dSr/rrL)rKr-rrr>rr6r7rL?szRandomOrder.__init__rrMcCstjt|j|j|j|jdSr)r rrRr-rrrrOr6r6r7rBszRandomOrder._get_idx)Fr )rorrrrLrrr6r6rr7r1s rcsHeZdZdZddddddfdd Zd d d d d ddddZZS)rzdSelect one or another transform to apply. Selected transform will be called with `force_apply=True`.NrzTransformType | NonezTransformsSeqType | Noner<)firstsecondr-r>csZ|dkr,|dks|dkr$d}t|||g}t||t|jtkrVtjddddS)Nz>You must set both first and second or set transforms argument.z'Length of transforms is not equal to 2.r%r?)rrrLrRr-NUM_ONEOF_TRANSFORMSrArB)rKrrr-r>rrr6r7rLIszOneOrOther.__init__Frrr:rTrcOs^|jr |jD]}|f|}q |St|jkrF|jdfddi|S|jdfddi|S)NrrT)rCr-rr>rKrrUrVrsr6r6r7rXYs  zOneOrOther.__call__)NNNrrr6r6rr7rFscsHeZdZdZddddddfd d Zd d d dd ddddZZS)r$acA transformation class to apply specified transforms to selected channels of an image. This class extends BaseCompose to allow selective application of transformations to specified image channels. It extracts the selected channels, applies the transformations, and then reinserts the transformed channels back into their original positions in the image. Parameters: transforms (TransformsSeqType): A sequence of transformations (from Albumentations) to be applied to the specified channels. channels (Sequence[int]): A sequence of integers specifying the indices of the channels to which the transforms should be applied. p (float): Probability that the transform will be applied; the default is 1.0 (always apply). Methods: __call__(*args, **kwargs): Applies the transforms to the image according to the specified channels. The input data should include 'image' key with the image array. Returns: dict[str, Any]: The transformed data dictionary, which includes the transformed 'image' key. rr r%rr#z Sequence[int]r<r~)r-channelsr>r.cst||||_dSr/)rrLr)rKr-rr>rr6r7rL}sz"SelectiveChannelTransform.__init__Frrr:rTrc Os|st|jkr|d}|dddd|jf}t|}|jD]}||dd}qBt|}|} t |j|D]\} } | | dddd| f<qtt| |d<|S)Nr&)r&) rr>rrZascontiguousarrayr-cv2splitcopyzip) rKrrUrVr&Zselected_channelsZ sub_imagersZtransformed_channelsZ output_imgrZchannelr6r6r7rXs   z"SelectiveChannelTransform.__call__)rrrr6r6rr7r$es  c seZdZd(ddddd d d d fd d Zdddd dddfddZeddddddZed)ddddddZddddd d!Zdd d"d#d$Z dd%fd&d' Z Z S)*r NrTrr#rrr}r<r:r[)r-rrr^r>rrcs:t|||||||jd|d||_|j|dS)NTr)rrLrrrGr)rKr-rrr^r>rrrr6r7rLs zReplayCompose.__init__FrrrT)rUrrr.csVtt||j<tjfd|i|}|}||||j|||||j<|S)Nr)rrrrrXr{fill_with_params fill_applied)rKrrUrr4 serializedrr6r7rXs  zReplayCompose.__call__)saved_augmentationsrr.cKst|}|fddi|Srr _restore_for_replay)rrZaugsr6r6r7rs zReplayCompose.replayzdict[str, Any] | Noner")transform_dictlambda_transformsr.c s|d}|d}t|}|r$|}nN|d}dd|D}t|}d|krhfdd|dD|d<|f|}tt|}t|tr||_d |_||_|S) aArgs: 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. appliedr|rzcSsi|]\}}|dkr||qS))rzrr|r6rcr6r6r7rgsz5ReplayCompose._restore_for_replay..r-csg|]}tj|dqS)rrrxrr6r7rysz5ReplayCompose._restore_for_replay..T) rrmrr rr0r|rCrD) rrrr|Zlmbdr5namerUrur6rr7rs&       z!ReplayCompose._restore_for_replayr~)r all_paramsr.cCs@||d}||d<|d=|dgD]}|||q*dS)Nr3r|r-)rr)rKrr r|r5r6r6r7rs zReplayCompose.fill_with_params)rr.csFd|kr,fdd|dD}t||d<n|ddk |d<|dS)Nr-csg|]}|qSr6)rrxrOr6r7rysz.ReplayCompose.fill_applied..rr|)rr)rKrrr6rOr7rs zReplayCompose.fill_appliedrMcst}|d|ji|S)Nr)rrlr1rrrr6r7rls zReplayCompose.to_dict_private)NNNrTr)N) rorrrLrXrrrrrrlrr6r6rr7r s   #csDeZdZdZddddfdd Zdd d d d d d ddZZS)r!aSequentially 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) >>> ]) rr#r<r=cst||dSr/rrJrr6r7rL szSequential.__init__Frrr:rTrcOs<|js|st|jkr8|jD]}|f|}||}q|Sr/)rCrr>r-rrr6r6r7rXs    zSequential.__call__)rrr6r6rr7r!s)> __future__rrrA collectionsrrtypingrrrrr r rZnumpyrZalbumentationsr Zalbumentations.core.typesr Z bbox_utilsrrZ hub_mixinrZkeypoints_utilsrrZ serializationrrrrZtransforms_interfacerutilsrrr__all__rrqr"r#rrrrrrrr2rrrrrrr$r r!r6r6r6r7sd        "z46W