o er@s dZddlmZmZmZddlZddlZddlZddl m Z ddl Z ddlmZddlmZddlmZdd lmZGd d d ejZGd d d eZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZ dS)a Augmenters that are based on applying convolution kernels to images. List of augmenters: * :class:`Convolve` * :class:`Sharpen` * :class:`Emboss` * :class:`EdgeDetect` * :class:`DirectedEdgeDetect` For MotionBlur, see ``blur.py``. )print_functiondivisionabsolute_importN)_normalize_cv2_input_arr_)meta) parameters)dtypescs8eZdZdZ   d fdd ZddZdd ZZS) Convolvea* Apply a convolution to input images. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: yes; tested * ``uint32``: no (1) * ``uint64``: no (2) * ``int8``: yes; tested (3) * ``int16``: yes; tested * ``int32``: no (2) * ``int64``: no (2) * ``float16``: yes; tested (4) * ``float32``: yes; tested * ``float64``: yes; tested * ``float128``: no (1) * ``bool``: yes; tested (4) - (1) rejected by ``cv2.filter2D()``. - (2) causes error: cv2.error: OpenCV(3.4.2) (...)/filter.cpp:4487: error: (-213:The function/feature is not implemented) Unsupported combination of source format (=1), and destination format (=1) in function 'getLinearFilter'. - (3) mapped internally to ``int16``. - (4) mapped internally to ``float32``. Parameters ---------- matrix : None or (H, W) ndarray or imgaug.parameters.StochasticParameter or callable, optional The weight matrix of the convolution kernel to apply. * If ``None``, the input images will not be changed. * If a 2D numpy array, that array will always be used for all images and channels as the kernel. * If a callable, that method will be called for each image via ``parameter(image, C, random_state)``. The function must either return a list of ``C`` matrices (i.e. one per channel) or a 2D numpy array (will be used for all channels) or a 3D ``HxWxC`` numpy array. If a list is returned, each entry may be ``None``, which will result in no changes to the respective channel. seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> matrix = np.array([[0, -1, 0], >>> [-1, 4, -1], >>> [0, -1, 0]]) >>> aug = iaa.Convolve(matrix=matrix) Convolves all input images with the kernel shown in the ``matrix`` variable. >>> def gen_matrix(image, nb_channels, random_state): >>> matrix_A = np.array([[0, -1, 0], >>> [-1, 4, -1], >>> [0, -1, 0]]) >>> matrix_B = np.array([[0, 1, 0], >>> [1, -4, 1], >>> [0, 1, 0]]) >>> if image.shape[0] % 2 == 0: >>> return [matrix_A] * nb_channels >>> else: >>> return [matrix_B] * nb_channels >>> aug = iaa.Convolve(matrix=gen_matrix) Convolves images that have an even height with matrix A and images having an odd height with matrix B. N deprecatedcstt|j||||d|durd|_d|_dSt|r4|jdks,Jd|j|jf||_d|_dSt |rA||_d|_dSt dt |f)N)seedname random_state deterministicNonerzNExpected convolution matrix to have exactly two dimensions, got %d (shape %s).constantfunctionzNExpected float, int, tuple/list with 2 entries or StochasticParameter. Got %s.) superr __init__matrix matrix_typeia is_np_arrayndimshapeZ is_callable Exceptiontype)selfrr rrr __class__OD:\Projects\ConvertPro\env\Lib\site-packages\imgaug/augmenters/convolutional.pyr{s0        zConvolve.__init__cCs|jdur|S|j}tj|gdgd|d|t|}t|D]\}}|j\} } } |jdkr2q"|j} |jj dvrD|j t j dd}n|jj dkrR|j t j dd}|jd kr]dg| } nl|jd kri|jg| } n`|jd kr|||| ||} t| r| jd krt | d t jfdd| f} t| tot| | k}t| o| jdko| jd | k}|s|sJdt| ft| r| d} ntd|}t| D]}| |durtt|d |fd| ||d |f<q| j dkr|dk}n | j dvrt|| }||j|<q"|S)N)boolZuint8Zuint16int8int16float16float32Zfloat64) Zuint32Zuint64Zuint128Zuint256Zint32Zint64Zint128Zint256Zfloat96Zfloat128Zfloat256)allowedZ disallowedZ augmenterr)r#r&F)copyr$rrrr.rzCallable provided to Convole must return either a list of 2D matrices (one per image channel) or a 2D numpy array or a 3D numpy array where the last dimension's size matches the number of image channels. Got type %s.)rrrzInvalid matrix typer#?)r$r&) imagesiadtZ gate_dtypesZ duplicatelen enumeratersizedtyperZastypenpr'r%rrrrrZtileZnewaxis isinstancelistrZ transposersmxrangecv2Zfilter2DrZrestore_dtypes_)rbatchrparentshooksr-Zrssiimage_height_width nb_channelsZ input_dtypeZmatricesZ is_valid_listZis_valid_arrayZ image_augZchannelr!r!r"_augment_batch_sz                         zConvolve._augment_batch_cCs |j|jgS)z=See :func:`~imgaug.augmenters.meta.Augmenter.get_parameters`.)rr)rr!r!r"get_parameterss zConvolve.get_parameters)NNNr r )__name__ __module__ __qualname____doc__rrArB __classcell__r!r!rr"r !sYWr c(eZdZdZ   dfdd ZZS) Sharpena Sharpen images and alpha-blend the result with the original input images. **Supported dtypes**: See :class:`~imgaug.augmenters.convolutional.Convolve`. Parameters ---------- alpha : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Blending factor of the sharpened image. At ``0.0``, only the original image is visible, at ``1.0`` only its sharpened version is visible. * If a number, exactly that value will always be used. * If a tuple ``(a, b)``, a random value will be sampled from the interval ``[a, b]`` per image. * If a list, a random value will be sampled from that list per image. * If a ``StochasticParameter``, a value will be sampled from that parameter per image. lightness : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Lightness/brightness of the sharped image. Sane values are somewhere in the interval ``[0.5, 2.0]``. The value ``0.0`` results in an edge map. Values higher than ``1.0`` create bright images. Default value is ``1.0``. * If a number, exactly that value will always be used. * If a tuple ``(a, b)``, a random value will be sampled from the interval ``[a, b]`` per image. * If a list, a random value will be sampled from that list per image. * If a ``StochasticParameter``, a value will be sampled from that parameter per image. seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.Sharpen(alpha=(0.0, 1.0)) Sharpens input images and blends the sharpened image with the input image using a random blending factor between ``0%`` and ``100%`` (uniformly sampled). >>> aug = iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0)) Sharpens input images with a variable `lightness` sampled uniformly from the interval ``[0.75, 2.0]`` and with a fully random blending factor (as in the above example). g?g?g333333?Nr c Ptj|ddddd}tj|ddddd}t||} tt|j| ||||ddS)Nalphar?TZ value_rangeZtuple_to_uniformZlist_to_choice lightnessrNrr rrr)iaphandle_continuous_param_SharpeningMatrixGeneratorrrIr) rrNrRr rrr alpha_paramZlightness_param matrix_genrr!r"r6   zSharpen.__init__)rJrLNNr r rCrDrErFrrGr!r!rr"rIs DrIc@eZdZddZddZdS)rWcC||_||_dSN)rNrR)rrNrRr!r!r"rI z#_SharpeningMatrixGenerator.__init__c Cs|jj|d}d|krdksnJd|f|jj|d}tjgdgdgdgtjd}tjgdd d |d ggdgtjd}d ||||}|g|S) NrrrP>> import imgaug.augmenters as iaa >>> aug = iaa.Emboss(alpha=(0.0, 1.0), strength=(0.5, 1.5)) Emboss an image with a strength sampled uniformly from the interval ``[0.5, 1.5]`` and alpha-blend the result with the original input image using a random blending factor between ``0%`` and ``100%``. rKrPg?rPNr c rM)NrNrOTrQstrengthrSrT)rUrV_EmbossMatrixGeneratorrror) rrNrrr rrrrXZstrength_paramrYrr!r"rrZzEmboss.__init__)rprqNNr r r[r!r!rr"rods @roc@r\)rscCr]r^)rNrr)rrNrrr!r!r"rr_z_EmbossMatrixGenerator.__init__c Cs|jj|d}d|krdksnJd|f|jj|d}tjgdgdgdgtjd}tjd|d|dgd|d d|gdd|d |ggtjd}d ||||}|g|S) Nr`rrPrarbrcrdr+r)rNrfrrr3rgr') rrhr@rriZstrength_samplerjrkrr!r!r"rls4  z_EmbossMatrixGenerator.__call__Nrmr!r!r!r"rsrnrscs(eZdZdZ   dfdd ZZS) EdgeDetecta Generate a black & white edge image and alpha-blend it with the input image. **Supported dtypes**: See :class:`~imgaug.augmenters.convolutional.Convolve`. Parameters ---------- alpha : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Blending factor of the edge image. At ``0.0``, only the original image is visible, at ``1.0`` only the edge image is visible. * If a number, exactly that value will always be used. * If a tuple ``(a, b)``, a random value will be sampled from the interval ``[a, b]`` per image. * If a list, a random value will be sampled from that list per image. * If a ``StochasticParameter``, a value will be sampled from that parameter per image. seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.EdgeDetect(alpha=(0.0, 1.0)) Detect edges in an image, mark them as black (non-edge) and white (edges) and alpha-blend the result with the original input image using a random blending factor between ``0%`` and ``100%``. rKg?Nr cs:tj|ddddd}t|}tt|j|||||ddS)NrNrOTrQrT)rUrV_EdgeDetectMatrixGeneratorrrtr)rrNr rrrrXrYrr!r"rs  zEdgeDetect.__init__)ruNNr r r[r!r!rr"rts 0rtc@r\)rvcCs ||_dSr^)rN)rrNr!r!r"rs z#_EdgeDetectMatrixGenerator.__init__cCs|jj|d}d|krdksnJd|ftjgdgdgdgtjd}tjgdgdgdgtjd}d ||||}|g|S) Nr`rrPrarbrcrd)rrr)rNrfr3rgr')rrhr@rrirjrkrr!r!r"rls2  z#_EdgeDetectMatrixGenerator.__call__Nrmr!r!r!r"rvs rvcrH) DirectedEdgeDetecta) Detect edges from specified angles and alpha-blend with the input image. This augmenter first detects edges along a certain angle. Usually, edges are detected in x- or y-direction, while here the edge detection kernel is rotated to match a specified angle. The result of applying the kernel is a black (non-edges) and white (edges) image. That image is alpha-blended with the input image. **Supported dtypes**: See :class:`~imgaug.augmenters.convolutional.Convolve`. Parameters ---------- alpha : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Blending factor of the edge image. At ``0.0``, only the original image is visible, at ``1.0`` only the edge image is visible. * If a number, exactly that value will always be used. * If a tuple ``(a, b)``, a random value will be sampled from the interval ``[a, b]`` per image. * If a list, a random value will be sampled from that list per image. * If a ``StochasticParameter``, a value will be sampled from that parameter per image. direction : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Angle (in degrees) of edges to pronounce, where ``0`` represents ``0`` degrees and ``1.0`` represents 360 degrees (both clockwise, starting at the top). Default value is ``(0.0, 1.0)``, i.e. pick a random angle per image. * If a number, exactly that value will always be used. * If a tuple ``(a, b)``, a random value will be sampled from the interval ``[a, b]`` will be sampled per image. * If a list, then a random value will be sampled from that list per image. * If a ``StochasticParameter``, a value will be sampled from the parameter per image. seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.DirectedEdgeDetect(alpha=1.0, direction=0) Turn input images into edge images in which edges are detected from the top side of the image (i.e. the top sides of horizontal edges are part of the edge image, while vertical edges are ignored). >>> aug = iaa.DirectedEdgeDetect(alpha=1.0, direction=90/360) Same as before, but edges are detected from the right. Horizontal edges are now ignored. >>> aug = iaa.DirectedEdgeDetect(alpha=1.0, direction=(0.0, 1.0)) Same as before, but edges are detected from a random angle sampled uniformly from the interval ``[0deg, 360deg]``. >>> aug = iaa.DirectedEdgeDetect(alpha=(0.0, 0.3), direction=0) Similar to the previous examples, but here the edge image is alpha-blended with the input image. The result is a mixture between the edge image and the input image. The blending factor is randomly sampled between ``0%`` and ``30%``. rurpNr c sPtj|ddddd}tj|ddddd}t||} tt|j| ||||ddS)NrNrOTrQ directionrT)rUrV"_DirectedEdgeDetectMatrixGeneratorrrxr) rrNryr rrrrXZdirection_paramrYrr!r"rs   zDirectedEdgeDetect.__init__)rurpNNr r r[r!r!rr"rx5s Urxc@r\)rzcCr]r^)rNry)rrNryr!r!r"rr_z+_DirectedEdgeDetectMatrixGenerator.__init__cCs|jj|d}d|krdksnJd|f|jj|d}t|dd}t|}t|dtj}t|dtj} t || g} tj gdgdgdgtj d} t gd gd D].\}} || fd krt || g} t t| | } | d }d |d }|| | d |d f<qc| t| } | d} d | d<tj gdgdgdgtj d}d |||| }|g|S)Nr`rrPraihr,rbrd)r+rr)rrrr+)rrrc)rNrfryintr3Zdeg2radcospisinrgr' itertoolsproductZrad2degrZangle_between_vectorssum)rrhr@rriZdirection_sampledegZradxyZdirection_vectorrkZ cell_vectorZ distance_degZdistanceZ similarityrjrr!r!r"rls\     z+_DirectedEdgeDetectMatrixGenerator.__call__Nrmr!r!r!r"rzrnrz)!rF __future__rrrrnumpyr3r8Z six.movesmovesr6ZimgaugrZ imgaug.imgaugrrr rUr r.Z Augmenterr rIobjectrWrorsrtrvrxrzr!r!r!r"s*     QWS@ i