U PhT @szdZddlmZddlZddlmZmZddlmZm Z m Z m Z m Z ddl mZmZddlZddlZddlmZmZddlmZdd lmZdd lmZmZmZdd lmZm Z m!Z!dd l"m#Z#dd l$m%Z%dddddddgZ&edZ'd)ddddddddddZ(d*dddddddd!d"d#dZ)Gd$ddeeZ*Gd%ddeZ+Gd&dde+eZ,Gd'dde*e+Z-Gd(dde+Z.dS)+z: A collection of generic interfaces for MONAI transforms. ) annotationsN)ABCabstractmethod)Callable GeneratorHashableIterableMapping)AnyTypeVar)config transforms)KeysCollection) MetaTensor) LazyTraitRandomizableTrait ThreadUnsafe)MAX_SEED ensure_tuplefirst)TransformBackends) MONAIEnvVarsrapply_transform Randomizable LazyTransformRandomizableTransform Transform MapTransform ReturnTypeFzCallable[..., ReturnType]r bool bool | Nonez dict | Nonez bool | str) transformdataunpack_parameterslazy overrides logger_namereturncCshddlm}||||||}t|trJ|rJt|trB||d|iS||St|tr`|||dS||S)a% Perform a transform 'transform' on 'data', according to the other parameters specified. If `data` is a tuple and `unpack_parameters` is True, each parameter of `data` is unpacked as arguments to `transform`. Otherwise `data` is considered as single argument to `transform`. If 'lazy' is True, this method first checks whether it can execute this method lazily. If it can't, it will ensure that all pending lazy transforms on 'data' are applied before applying this 'transform' to it. If 'lazy' is True, and 'overrides' are provided, those overrides will be applied to the pending operations on 'data'. See ``Compose`` for more details on lazy resampling, which is an experimental feature for 1.2. Please note, this class is function is designed to be called by ``apply_transform``. In general, you should not need to make specific use of it unless you are implementing pipeline execution mechanisms. Args: transform: a callable to be used to transform `data`. data: the tensorlike or dictionary of tensorlikes to be executed on unpack_parameters: whether to unpack parameters for `transform`. Defaults to False. lazy: whether to enable lazy evaluation for lazy transforms. If False, transforms will be carried out on a transform by transform basis. If True, all lazy transforms will be executed by accumulating changes and resampling as few times as possible. See the :ref:`Lazy Resampling topic for more information about lazy resampling. overrides: this optional parameter allows you to specify a dictionary of parameters that should be overridden when executing a pipeline. These each parameter that is compatible with a given transform is then applied to that transform before it is executed. Note that overrides are currently only applied when :ref:`Lazy Resampling` is enabled for the pipeline or a given transform. If lazy is False they are ignored. Currently supported args are: {``"mode"``, ``"padding_mode"``, ``"dtype"``, ``"align_corners"``, ``"resample_mode"``, ``device``}. logger_name: this optional parameter allows you to specify a logger by name for logging of pipeline execution. Setting this to False disables logging. Setting it to True enables logging to the default loggers. Setting a string overrides the logger name to which logging is performed. Returns: ReturnType: The return type of `transform`. r)!apply_pending_transforms_in_orderr$r$) monai.transforms.lazy.functionalr( isinstancetupler)r!r"r#r$r%r&r(r-O/home/dell461/cl/sdc2/HISourceFinder-master-l/src/monai/transforms/transform.py_apply_transform.s -  r/Tzlist[ReturnType] | ReturnType)r!r" map_items unpack_items log_statsr$r%r'c sXzBt|ttfr0|r0fdd|DWSt|WStk rR}ztr`dk r2ttjj s2tt rtj j j dddntj j j dddtj}|dtjdt|ttfr|d}dd d fd d } t|tr(|D]\} } | | | dqn | |dtd|W5d}~XYnXdS)a Transform `data` with `transform`. If `data` is a list or tuple and `map_data` is True, each item of `data` will be transformed and this method returns a list of outcomes. otherwise transform will be applied once with `data` as the argument. Args: transform: a callable to be used to transform `data`. data: an object to be transformed. map_items: whether to apply transform to each item in `data`, if `data` is a list or tuple. Defaults to True. unpack_items: whether to unpack parameters using `*`. Defaults to False. log_stats: log errors when they occur in the processing pipeline. By default, this is set to False, which disables the logger for processing pipeline errors. Setting it to None or True will enable logging to the default logger name. Setting it to a string specifies the logger to which errors should be logged. lazy: whether to execute in lazy mode or not. See the :ref:`Lazy Resampling topic for more information about lazy resampling. Defaults to None. overrides: optional overrides to apply to transform parameters. This parameter is ignored unless transforms are being executed lazily. See the :ref:`Lazy Resampling topic for more details and examples of its usage. Raises: Exception: When ``transform`` raises an exception. Returns: Union[List[ReturnType], ReturnType]: The return type of `transform` or a list thereof. c sg|]}t|qSr-)r/).0item)r$r2r%r!r1r-r. sz#apply_transform..F) data_shape value_rangename)r6r7z === Transform input info -- z ===rDataz str | None)prefixcs6t|tjtjfr$|dd|dn|d|ddS)NT)imgr6r7r:)r; data_valuer:)r+npndarraytorchTensorr"r:) datastatsr-r. _log_statssz#apply_transform.._log_statsrAr"zapplying transform N)r9)r+listr,r/ Exceptionrdebugr composeComposestrZutilityarray DataStatslogging getLoggerZ _logger_nameerrortype__name__dictitems RuntimeError) r!r"r0r1r2r$r%eloggerrCkvr-)rBr$r2r%r!r1r.res*%    c@sHeZdZUdZejZded<ddddddd Z d d d d dZ dS)ra7 An interface for handling random state locally, currently based on a class variable `R`, which is an instance of `np.random.RandomState`. This provides the flexibility of component-specific determinism without affecting the global states. It is recommended to use this API with :py:class:`monai.data.DataLoader` for deterministic behaviour of the preprocessing pipelines. This API is not thread-safe. Additionally, deepcopying instance of this class often causes insufficient randomness as the random states will be duplicated. znp.random.RandomStateRNz int | Noneznp.random.RandomState | None)seedstater'cCs|dk r>t|ttjfs t|n|}|t}tj||_|S|dk rtt|tjjsjt dt |j d||_|Stj|_|S)a Set the random state locally, to control the randomness, the derived classes should use :py:attr:`self.R` instead of `np.random` to introduce random factors. Args: seed: set the random state with an integer seed. state: set the random state with a `np.random.RandomState` object. Raises: TypeError: When ``state`` is not an ``Optional[np.random.RandomState]``. Returns: a Randomizable instance. Nz5state must be None or a np.random.RandomState but is .) r+intr=integeridrrandom RandomStaterY TypeErrorrPrQ)selfrZr[_seedr-r-r.set_random_states zRandomizable.set_random_stater Noner"r'cCstd|jjddS)a Within this method, :py:attr:`self.R` should be used, instead of `np.random`, to introduce random factors. all :py:attr:`self.R` calls happen here so that we have a better chance to identify errors of sync the random state. This method can generate the random factors based on properties of the input data. Raises: NotImplementedError: When the subclass does not override this method. Subclass  must implement this method.NNotImplementedError __class__rQrcr"r-r-r. randomizes zRandomizable.randomize)NN) rQ __module__ __qualname____doc__r=r`rarY__annotations__rernr-r-r-r.rs   c@s0eZdZUdZgZded<eddddZdS) ra: An abstract class of a ``Transform``. A transform is callable that processes ``data``. It could be stateful and may modify ``data`` in place, the implementation should be aware of: #. thread safety when mutating its own states. When used from a multi-process context, transform's instance variables are read-only. thread-unsafe transforms should inherit :py:class:`monai.transforms.ThreadUnsafe`. #. ``data`` content unused by this transform may still be used in the subsequent transforms in a composed transform. #. storing too much information in ``data`` may cause some memory issue or IPC sync issue, especially in the multi-processing environment of PyTorch DataLoader. See Also :py:class:`monai.transforms.Compose` zlist[TransformBackends]backendr rDcCstd|jjddS)a ``data`` is an element which often comes from an iteration over an iterable, such as :py:class:`torch.utils.data.Dataset`. This method should return an updated version of ``data``. To simplify the input validations, most of the transforms assume that - ``data`` is a Numpy ndarray, PyTorch Tensor or string, - the data shape can be: #. string data without shape, `LoadImage` transform expects file paths, #. most of the pre-/post-processing transforms expect: ``(num_channels, spatial_dim_1[, spatial_dim_2, ...])``, except for example: `AddChannel` expects (spatial_dim_1[, spatial_dim_2, ...]) - the channel dimension is often not omitted even if number of channels is one. This method can optionally take additional arguments to help execute transformation operation. Raises: NotImplementedError: When the subclass does not override this method. rhriNrjrmr-r-r.__call__ szTransform.__call__N)rQrorprqrsrrrrtr-r-r-r.rs  c@sLeZdZdZd ddddZeddZejddd dZed d Zd S)rz An implementation of functionality for lazy transforms that can be subclassed by array and dictionary transforms to simplify implementation of new lazy transforms. Fr r)cCs.|dk r$t|ts$tdt|||_dSNz#lazy must be a bool but is of type r+rrbrP_lazyrcr$r-r-r.__init__)s zLazyTransform.__init__cCs|jS)N)rwrcr-r-r.r$/szLazyTransform.lazycCs.|dk r$t|ts$tdt|||_dSrurvrxr-r-r.r$3s cCsdS)NFr-rzr-r-r.requires_current_data:sz#LazyTransform.requires_current_dataN)F) rQrorprqrypropertyr$setterr{r-r-r-r.r#s c@s2eZdZdZddddddZd d d d d ZdS)rag An interface for handling random state locally, currently based on a class variable `R`, which is an instance of `np.random.RandomState`. This class introduces a randomized flag `_do_transform`, is mainly for randomized data augmentation transforms. For example: .. code-block:: python from monai.transforms import RandomizableTransform class RandShiftIntensity100(RandomizableTransform): def randomize(self): super().randomize(None) self._offset = self.R.uniform(low=0, high=100) def __call__(self, img): self.randomize() if not self._do_transform: return img return img + self._offset transform = RandShiftIntensity() transform.set_random_state(seed=0) print(transform(10)) ?Tfloatr)prob do_transformcCs||_tt|dd|_dS)Ngr~) _do_transformminmaxr)rcrrr-r-r.ry[szRandomizableTransform.__init__r rfrgcCs|j|jk|_dS)a^ Within this method, :py:attr:`self.R` should be used, instead of `np.random`, to introduce random factors. all :py:attr:`self.R` calls happen here so that we have a better chance to identify errors of sync the random state. This method can generate the random factors based on properties of the input data. N)rYrandrrrmr-r-r.rn_s zRandomizableTransform.randomizeN)r~T)rQrorprqryrnr-r-r-r.r?scsheZdZdZddZdddddfd d Zd d Zed dZddddddZ ddddZ Z S)raV A subclass of :py:class:`monai.transforms.Transform` with an assumption that the ``data`` input of ``self.__call__`` is a MutableMapping such as ``dict``. The ``keys`` parameter will be used to get and set the actual data item to transform. That is, the callable of this transform should follow the pattern: .. code-block:: python def __call__(self, data): for key in self.keys: if key in data: # update output data with some_transform_function(data[key]). else: # raise exception unless allow_missing_keys==True. return data Raises: ValueError: When ``keys`` is an empty iterable. TypeError: When ``keys`` type is not in ``Union[Hashable, Iterable[Hashable]]``. cOsBtjr8t|jtjd|_t|dr8t|jtj j |_t |S)Npostinverse) r USE_META_DICTr attach_hookrtr call_updatehasattrrInvertibleTransforminverse_updater__new__)clsargskwargsr-r-r.rs  zMapTransform.__new__Frrrf)keysallow_missing_keysr'csXtt||_||_|js(td|jD]$}t|ts.tdt |j dq.dS)Nzkeys must be non empty.z:keys must be one of (Hashable, Iterable[Hashable]) but is r\) superryrrr ValueErrorr+rrbrPrQ)rcrrkeyrlr-r.rys    zMapTransform.__init__cCst|tttfs|Sd}t|tr.|gd}}|r@t|dtsP|rL|dS|Sdd|D}t|D]@\}}|D]2}t||tsqrtj||t|tj d||<qrqf|r|dS|S)z This function is to be called after every `self.__call__(data)`, update `data[key_transforms]` and `data[key_meta_dict]` using the content from MetaTensor `data[key]`, for MetaTensor backward compatibility 0.9.0. FTrcSsg|] }t|qSr-)rR)r3xr-r-r.r5sz,MapTransform.call_update..)t) r+rEr,r enumeraterr sync_meta_infoInvertD)rcr"is_dictZlist_didxZdict_irWr-r-r.rs  "zMapTransform.call_updatecCstd|jjddS)a ``data`` often comes from an iteration over an iterable, such as :py:class:`torch.utils.data.Dataset`. To simplify the input validations, this method assumes: - ``data`` is a Python dictionary, - ``data[key]`` is a Numpy ndarray, PyTorch Tensor or string, where ``key`` is an element of ``self.keys``, the data shape can be: #. string data without shape, `LoadImaged` transform expects file paths, #. most of the pre-/post-processing transforms expect: ``(num_channels, spatial_dim_1[, spatial_dim_2, ...])``, except for example: `AddChanneld` expects (spatial_dim_1[, spatial_dim_2, ...]) - the channel dimension is often not omitted even if number of channels is one. Raises: NotImplementedError: When the subclass does not override this method. returns: An updated dictionary version of ``data`` by applying the transform. rhriNrjrmr-r-r.rtszMapTransform.__call__zMapping[Hashable, Any]zIterable | Noner)r"extra_iterablesr'cgsv|pdgt|jg}t|jf|D]J^}}||krP|rH|ft|n|Vq&|js&td|d|jjdq&dS)a[ Iterate across keys and optionally extra iterables. If key is missing, exception is raised if `allow_missing_keys==False` (default). If `allow_missing_keys==True`, key is skipped. Args: data: data that the transform will be applied to extra_iterables: anything else to be iterated through NzKey `z` of transform `z8` was missing in the data and allow_missing_keys==False.)lenrzipr,rKeyErrorrlrQ)rcr"rZex_itersrZ _ex_itersr-r-r. key_iterators zMapTransform.key_iteratorzdict[Hashable, Any]rDcCst||dS)z Get the first available key of `self.keys` in the input `data` dictionary. If no available key, return an empty tuple `()`. Args: data: data that the transform will be applied to. r-)rrrmr-r-r. first_keys zMapTransform.first_key)F) rQrorprqrryrrrtrr __classcell__r-r-rr.rks   )FFNF)TFFNN)/rq __future__rrMabcrrcollections.abcrrrrr typingr r numpyr=r?monair r monai.configrmonai.data.meta_tensorrmonai.transforms.traitsrrr monai.utilsrrrmonai.utils.enumsrmonai.utils.miscr__all__rr/rrrrrrr-r-r-r. sN      :I=8,