o &j@@sdZddlmZmZmZddlZddlZddlZddlZddl Z ddl Z ddl Z zddl m Z Wney?ddlm Z YnwddlZddlZddlZddlZddlmZddlZddlZdZejejeZ ej!e dZ"ej!e dZ#ej!e dZ$ej!ejejed Z%e&ej'd Z(e&ej'd Z)e&ej'd Z*d Z+ddddej,ej-ej.ej/gZ0Gddde1Z2e3dfddZ4dddZ5Gddde6Z7ddZ8ddZ9dd Z:d!d"Z;d#d$Zd)d*Z?d+d,Z@d-d.ZAd/d0ZBd1d2ZCd3d4ZDd5d6ZEdd7d8ZFe7d9d:d;ZGe7d<d=d>ZHe7d?ddAdBZIe7d?dCdDZJe7dEddFdGZKe7dHdIdJZLe7dKddMdNZMe7dOdPdQZNdRdSZOdTdUZPddVdWZQddXdYZRddZd[ZSdd\d]ZTdd^d_ZUdd`daZVddbdcZWdddeZXdfdgZYddjdkZZddldmZ[dndoZ\ddpdqZ]  ddtduZ^ w ddxdyZ_  dd{d|Z` } sdd~dZa w sdddZbdddZcdddZde+fddZedddZfddZgddZhddZiGddde6ZjGdddejZkGdddejZlddZmgdZnenD]\ZoZpZqemeoepeqereo<qdS)z5Collection of basic functions used throughout imgaug.)print_functiondivisionabsolute_importN)IterableALLz quokka.jpgzquokka_annotations.jsonzquokka_depth_map_halfres.pngzDejaVuSans.ttffloatintZuint matplotlibnearestlinearareacubicc@eZdZdZdS)DeprecationWarningzWarning for deprecated calls. Since python 2.7 DeprecatedWarning is silent by default. So we define our own DeprecatedWarning here so that it is not silent by default. N__name__ __module__ __qualname____doc__rrN/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/imgaug/imgaug.pyr<rcCsddl}|j|||ddS)aGenerate a a warning with stacktrace. Parameters ---------- msg : str The message of the warning. category : class The class of the warning to produce. stacklevel : int, optional How many steps above this function to "jump" in the stacktrace when displaying file and line number of the error message. Usually ``2``. rNcategory stacklevel)warningswarn)msgrrrrrrrEsrcCst|t|ddS)aGenerate a non-silent deprecation warning with stacktrace. The used warning is ``imgaug.imgaug.DeprecationWarning``. Parameters ---------- msg : str The message of the warning. stacklevel : int, optional How many steps above this function to "jump" in the stacktrace when displaying file and line number of the error message. Usually ``2`` rN)rr)rrrrrwarn_deprecatedZsrc@s&eZdZdZ  dddZddZdS) deprecatedaDecorator to mark deprecated functions with warning. Adapted from . Parameters ---------- alt_func : None or str, optional If given, tell user what function to use instead. behavior : {'warn', 'raise'}, optional Behavior during call to deprecated function: ``warn`` means that the user is warned that the function is deprecated; ``raise`` means that an error is raised. removed_version : None or str, optional The package version in which the deprecated function will be removed. comment : None or str, optional An optional comment that will be appended to the warning message. NrcC||_||_||_||_dSN)alt_funcbehaviorremoved_versioncomment)selfr#r$r%r&rrr__init__ zdeprecated.__init__csd}jdur djf}d}jdurdjf}d}jdur1tjdkr1djdf}ddd|||fDtfd d }d }|jdurY||_|S|d |j|_|S) NzUse ``%s`` instead.z!It will be removed in version %s.rz%s.z.  cSsg|]}|dur|qSr"r).0Zsubmsgrrr s z'deprecated.__call__..csddl}t|dr|d}n|d}d|vs d|vr,d|djjjf}ndjf}|dddd }jd krKt |d d n jd krTt ||i|S)Nrgetfullargspecr'clsz!Method ``%s.%s()`` is deprecated.z Function ``%s()`` is deprecated.r*z```r)rraise) inspecthasattrr- getargspec __class__rrstripreplacer$rr)argskwargsr2 arg_namesZmain_msgrZaddendumfuncr'rrwrappeds"   z$deprecated.__call__..wrappedz**Deprecated**. z ) r#r%r&lenr6join functoolswrapsr)r'r<Zalt_msgZrmv_msgZ comment_msgr=docrr;r__call__s,     zdeprecated.__call__)NrNN)rrrrr(rCrrrrr ms  r cC t|tjS)zCheck whether a variable is a numpy array. Parameters ---------- val The variable to check. Returns ------- bool ``True`` if the variable is a numpy array. Otherwise ``False``. ) isinstancenpZndarrayvalrrr is_np_array rIcCst|tjo t|S)zCheck whether a variable is a numpy scalar. Parameters ---------- val The variable to check. Returns ------- bool ``True`` if the variable is a numpy scalar. Otherwise ``False``. )rErFZgenericZisscalarrGrrr is_np_scalarsrKcCst|tjo t|t S)zCheck whether a variable is an ``int``. Parameters ---------- val The variable to check. Returns ------- bool ``True`` if the variable is an ``int``. Otherwise ``False``. )rEnumbersIntegralboolrGrrris_single_integerrOcCs"t|tjot| ot|t S)zCheck whether a variable is a ``float``. Parameters ---------- val The variable to check. Returns ------- bool ``True`` if the variable is a ``float``. Otherwise ``False``. )rErLRealrOrNrGrrris_single_floats  rRcCst|pt|S)zCheck whether a variable is a ``number``, i.e. an ``int`` or ``float``. Parameters ---------- val The variable to check. Returns ------- bool ``True`` if the variable is a ``number``. Otherwise ``False``. )rOrRrGrrris_single_numbersrScCs t|tS)z Checks whether a variable is iterable. Parameters ---------- val The variable to check. Returns ------- bool ``True`` if the variable is an iterable. Otherwise ``False``. )rErrGrrr is_iterable)s rTcCrD)zCheck whether a variable is a string. Parameters ---------- val The variable to check. Returns ------- bool ``True`` if the variable is a string. Otherwise ``False``. )rEsix string_typesrGrrr is_string< rWcCst|tdkS)zCheck whether a variable is a ``bool``. Parameters ---------- val The variable to check. Returns ------- bool ``True`` if the variable is a ``bool``. Otherwise ``False``. TtyperGrrris_single_boolMsr[cCt|o t|jjtjS)zCheck whether a variable is a numpy integer array. Parameters ---------- val The variable to check. Returns ------- bool ``True`` if the variable is a numpy integer array. Otherwise ``False``. )rI issubclassdtyperZrFintegerrGrrris_integer_array_rPr`cCr\)zCheck whether a variable is a numpy float array. Parameters ---------- val The variable to check. Returns ------- bool ``True`` if the variable is a numpy float array. Otherwise ``False``. )rIr]r^rZrFZfloatingrGrrris_float_arrayprPracCs.tjddkrtjddkrt|dSt|S)zCheck whether a variable is a callable, e.g. a function. Parameters ---------- val The variable to check. Returns ------- bool ``True`` if the variable is a callable. Otherwise ``False``. rr0rrC)sys version_infor3callablerGrrr is_callables rfcCrD)zCheck whether a variable is a generator. Parameters ---------- val The variable to check. Returns ------- bool ``True`` is the variable is a generator. Otherwise ``False``. )rEtypes GeneratorTyperGrrr is_generatorrXriccsRt|ttfs |VdS|D]}t|ttfr#t|D]}|Vqq|VqdS)a7Flatten arbitrarily nested lists/tuples. Code partially taken from https://stackoverflow.com/a/10824420. Parameters ---------- nested_iterable A ``list`` or ``tuple`` of arbitrarily nested values. Yields ------ any All values in `nested_iterable`, flattened. N)rElisttupleflatten)Znested_iterableijrrrrls  rlcCstdjjS)zReturn the name of the caller, e.g. a function. Returns ------- str The name of the caller as a string rb)rc _getframef_codeco_namerrrr caller_names rrcCs^|dus |dus Jd|dur#|dusJdt|ftd|}ddl}|j|dS)aSet the seed of imgaug's global RNG. The global RNG controls most of the "randomness" in imgaug. The global RNG is the default one used by all augmenters. Under special circumstances (e.g. when an augmenter is switched to deterministic mode), the global RNG is replaced with a local one. The state of that replacement may be dependent on the global RNG's state at the time of creating the child RNG. .. note:: This function is not yet marked as deprecated, but might be in the future. The preferred way to seed `imgaug` is via :func:`~imgaug.random.seed`. Parameters ---------- entropy : int The seed value to use. seedval : None or int, optional Deprecated since 0.4.0. NzKExpected argument 'entropy' or 'seedval' to be not-None, but bothwere None.zArgument 'seedval' is the outdated name for 'entropy'. Hence, if it is provided, 'entropy' must be None. Got 'entropy' value of type %s.z9Parameter 'seedval' is deprecated. Use 'entropy' instead.r)rZr imgaug.randomrandomseed)ZentropyZseedvalimgaugrrrrus ruz!imgaug.random.normalize_generatorcCddl}|j|S)aNormalize various inputs to a numpy random generator. Parameters ---------- random_state : None or int or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.bit_generator.SeedSequence or numpy.random.RandomState See :func:`~imgaug.random.normalize_generator`. Returns ------- numpy.random.Generator or numpy.random.RandomState In numpy <=1.16 a ``RandomState``, in 1.17+ a ``Generator`` (even if the input was a ``RandomState``). rN)rsrtZnormalize_generator_ random_statervrrrnormalize_random_state rzzimgaug.random.get_global_rngcCsddl}|jS)zGet or create the current global RNG of imgaug. Note that the first call to this function will create a global RNG. Returns ------- imgaug.random.RNG The global RNG to use. rN)rsrtZget_global_rngrvrrrcurrent_random_states r}z!imgaug.random.convert_seed_to_rngFcCs8ddl}|dur|r|jjS|jjS|j|S)aaCreate a new numpy random number generator. Parameters ---------- seed : None or int, optional The seed value to use. If ``None`` and `fully_random` is ``False``, the seed will be derived from the global RNG. If `fully_random` is ``True``, the seed will be provided by the OS. fully_random : bool, optional Whether the seed will be provided by the OS. Returns ------- numpy.random.Generator or numpy.random.RandomState In numpy <=1.16 a ``RandomState``, in 1.17+ a ``Generator``. Both are initialized with the provided seed. rN)rsrtRNGZcreate_fully_randomZcreate_pseudo_random_)ruZ fully_randomrvrrrnew_random_state!s    rcCsddl}|jdS)zCreate a dummy random state using a seed of ``1``. Returns ------- imgaug.random.RNG The new random state. rNrb)rsrtr~r|rrrdummy_random_state@s rz.imgaug.random.copy_generator_unless_global_rngcCs$ddl}|r |j|S|j|S)aCopy an existing numpy (random number) generator. Parameters ---------- random_state : numpy.random.Generator or numpy.random.RandomState The generator to copy. force_copy : bool, optional If ``True``, this function will always create a copy of every random state. If ``False``, it will not copy numpy's default random state, but all other random states. Returns ------- rs_copy : numpy.random.RandomState The copied random state. rN)rsrtZcopy_generatorZ©_generator_unless_global_generator)ryZ force_copyrvrrrcopy_random_stateNs  rzimgaug.random.derive_generator_cCrw)aDerive a child numpy random generator from another one. Parameters ---------- random_state : numpy.random.Generator or numpy.random.RandomState The generator from which to derive a new child generator. Returns ------- numpy.random.Generator or numpy.random.RandomState In numpy <=1.16 a ``RandomState``, in 1.17+ a ``Generator``. In both cases a derived child generator. rN)rsrtZderive_generator_rxrrrderive_random_statehr{rz imgaug.random.derive_generators_rbcCsddl}|jj||dS)a*Derive child numpy random generators from another one. Parameters ---------- random_state : numpy.random.Generator or numpy.random.RandomState The generator from which to derive new child generators. n : int, optional Number of child generators to derive. Returns ------- list of numpy.random.Generator or list of numpy.random.RandomState In numpy <=1.16 a ``list`` of ``RandomState`` s, in 1.17+ a ``list`` of ``Generator`` s. In both cases lists of derived child generators. rN)n)rsrtZderive_generators_)ryrrvrrrderive_random_states|srz imgaug.random.advance_generator_cCsddl}|j|dS)zAdvance a numpy random generator's internal state. Parameters ---------- random_state : numpy.random.Generator or numpy.random.RandomState Generator of which to advance the internal state. rN)rsrtZadvance_generator_rxrrrforward_random_states rcCsddlm}m}|dkr|ddddd}|St|tr3t|dkr3||d|d|d|d d}|St||r<|}|St||rdt|jdksLJd |jddd ks]Jd |jf|jd}|Std t |f)aGenerate a normalized rectangle for the standard quokka image. Parameters ---------- extract : 'square' or tuple of number or imgaug.augmentables.bbs.BoundingBox or imgaug.augmentables.bbs.BoundingBoxesOnImage Unnormalized representation of the image subarea to be extracted. * If ``str`` ``square``, then a squared area ``(x: 0 to max 643, y: 0 to max 643)`` will be extracted from the image. * If a ``tuple``, then expected to contain four ``number`` s denoting ``(x1, y1, x2, y2)``. * If a :class:`~imgaug.augmentables.bbs.BoundingBox`, then that bounding box's area will be extracted from the image. * If a :class:`~imgaug.augmentables.bbs.BoundingBoxesOnImage`, then expected to contain exactly one bounding box and a shape matching the full image dimensions (i.e. ``(643, 960, *)``). Then the one bounding box will be used similar to ``BoundingBox`` above. Returns ------- imgaug.augmentables.bbs.BoundingBox Normalized representation of the area to extract from the standard quokka image. r BoundingBoxBoundingBoxesOnImagesquarex1y1x2y2rbrr0zXProvided BoundingBoxesOnImage instance may currently only contain a single bounding box.rzXExpected BoundingBoxesOnImage instance on an image of shape (643, 960, ?). Got shape %s.zrExpected 'square' or tuple of four entries or BoundingBox or BoundingBoxesOnImage for parameter 'extract', got %s.) imgaug.augmentables.bbsrrrErkr>bounding_boxesshape ExceptionrZ)extractrrbbrrr_quokka_normalize_extracts8    rcCst|r|j}t|r|j}t|}|dur t|St|trt|dvs(Jt|dvs0Jt|dkrGt|dkrG|d|dksFJn t|dkrT||dtdd|ddD}|suJdtd d|ddDft |ddD])\}}||dur|||<q}t ||r||||<q}t t |||||<q}t|St |st|rt|||f}t|Std t|f) aCompute the intended new shape of an image-like array after resizing. Parameters ---------- from_shape : tuple or ndarray Old shape of the array. Usually expected to be a ``tuple`` of form ``(H, W)`` or ``(H, W, C)`` or alternatively an array with two or three dimensions. to_shape : None or tuple of ints or tuple of floats or int or float or ndarray New shape of the array. * If ``None``, then `from_shape` will be used as the new shape. * If an ``int`` ``V``, then the new shape will be ``(V, V, [C])``, where ``C`` will be added if it is part of `from_shape`. * If a ``float`` ``V``, then the new shape will be ``(H*V, W*V, [C])``, where ``H`` and ``W`` are the old height/width. * If a ``tuple`` ``(H', W', [C'])`` of ints, then ``H'`` and ``W'`` will be used as the new height and width. * If a ``tuple`` ``(H', W', [C'])`` of floats (except ``C``), then ``H'`` and ``W'`` will be used as the new height and width. * If a numpy array, then the array's shape will be used. Returns ------- tuple of int New shape. Nrr0r0rcSsg|] }|dup t|qSr"rSr+vrrrr, z*_compute_resized_shape..rzOExpected the first two entries in to_shape to be None or numbers, got types %s.cSg|]}t|qSrrYrrrrr,zrExpected to_shape to be None or ndarray or tuple of floats or tuple of ints or single int or single float, got %s.)rIrrjrErkr>appendallstr enumeraterOrrFroundrR_compute_resized_shaperrZ)Z from_shapeZto_shapeZto_shape_computedZis_to_s_valid_valuesrmZ from_shape_irrrrsR!      rcCsRtjtdd}|durt|}||}|dur't|j|}t||dd}|S)aReturn an image of a quokka as a numpy array. Parameters ---------- size : None or float or tuple of int, optional Size of the output image. Input into :func:`~imgaug.imgaug.imresize_single_image`. Usually expected to be a ``tuple`` ``(H, W)``, where ``H`` is the desired height and ``W`` is the width. If ``None``, then the image will not be resized. extract : None or 'square' or tuple of number or imgaug.augmentables.bbs.BoundingBox or imgaug.augmentables.bbs.BoundingBoxesOnImage Subarea of the quokka image to extract: * If ``None``, then the whole image will be used. * If ``str`` ``square``, then a squared area ``(x: 0 to max 643, y: 0 to max 643)`` will be extracted from the image. * If a ``tuple``, then expected to contain four ``number`` s denoting ``(x1, y1, x2, y2)``. * If a :class:`~imgaug.augmentables.bbs.BoundingBox`, then that bounding box's area will be extracted from the image. * If a :class:`~imgaug.augmentables.bbs.BoundingBoxesOnImage`, then expected to contain exactly one bounding box and a shape matching the full image dimensions (i.e. ``(643, 960, *)``). Then the one bounding box will be used similar to ``BoundingBox`` above. Returns ------- (H,W,3) ndarray The image array of dtype ``uint8``. RGBZpilmodeNrr)imageioimread QUOKKA_FPrextract_from_imagerrimresize_single_image)sizerimgr shape_resizedrrrquokka%s"  rcCs t|ddS)aReturn an (square) image of a quokka as a numpy array. Parameters ---------- size : None or float or tuple of int, optional Size of the output image. Input into :func:`~imgaug.imgaug.imresize_single_image`. Usually expected to be a ``tuple`` ``(H, W)``, where ``H`` is the desired height and ``W`` is the width. If ``None``, then the image will not be resized. Returns ------- (H,W,3) ndarray The image array of dtype ``uint8``. r)rr)rrrrr quokka_squareQrJrcCsddlm}tjtdd}t|ddd}|dur!t|}||}|dur,|jdd }t |j|}t||dd }|d }| t j d }d |}|||jdd d dS)aReturn a heatmap (here: depth map) for the standard example quokka image. Parameters ---------- size : None or float or tuple of int, optional See :func:`~imgaug.imgaug.quokka`. extract : None or 'square' or tuple of number or imgaug.augmentables.bbs.BoundingBox or imgaug.augmentables.bbs.BoundingBoxesOnImage See :func:`~imgaug.imgaug.quokka`. Returns ------- imgaug.augmentables.heatmaps.HeatmapsOnImage Depth map as an heatmap object. Values close to ``0.0`` denote objects that are close to the camera. Values close to ``1.0`` denote objects that are furthest away (among all shown objects). r)HeatmapsOnImagerrrr  interpolationNr).rgo@rbr0r) Zimgaug.augmentables.heatmapsrrrQUOKKA_DEPTH_MAP_HALFRES_FPrrrrrastyperFfloat32)rrrrrrZimg_0to1rrrquokka_heatmapes   rcCs8ddlm}ttd }t|}Wdn1swYg}g}|dddD]}|d}|d} |||| q,tjd tj d } t j j t |t || jd \} } d | | | df<|durot|} | | } || | jdd dd }|durt| j|}||dd }t|dd d|_|S)aReturn a segmentation map for the standard example quokka image. Parameters ---------- size : None or float or tuple of int, optional See :func:`~imgaug.imgaug.quokka`. extract : None or 'square' or tuple of number or imgaug.augmentables.bbs.BoundingBox or imgaug.augmentables.bbs.BoundingBoxesOnImage See :func:`~imgaug.imgaug.quokka`. Returns ------- imgaug.augmentables.segmaps.SegmentationMapsOnImage Segmentation map object. r)SegmentationMapsOnImagerNpolygons keypointsxy)rrrbr^rrbrr)Zimgaug.augmentables.segmapsropenQUOKKA_ANNOTATIONS_FPjsonloadrrFzerosint32skimageZdrawZpolygonarrayrrrrresizerk)rrrf json_dictxxyykp_dictrrZimg_segZrrccrZsegmaprrrrquokka_segmentation_maps2        rcCsddlm}m}d\}}|durt|}|j}|j}ttd }t |}Wdn1s/wYg} |dD]} | || d|| d|d q:|durZ|j |j d f} nd } || | d } |durpt | |} | | } | S) aIReturn example keypoints on the standard example quokke image. The keypoints cover the eyes, ears, nose and paws. Parameters ---------- size : None or float or tuple of int or tuple of float, optional Size of the output image on which the keypoints are placed. If ``None``, then the keypoints are not projected to any new size (positions on the original image are used). ``float`` s lead to relative size changes, ``int`` s to absolute sizes in pixels. extract : None or 'square' or tuple of number or imgaug.augmentables.bbs.BoundingBox or imgaug.augmentables.bbs.BoundingBoxesOnImage Subarea to extract from the image. See :func:`~imgaug.imgaug.quokka`. Returns ------- imgaug.augmentables.kps.KeypointsOnImage Example keypoints on the quokka image. r)KeypointKeypointsOnImagerrNrrrrrrr0rrr0r)Zimgaug.augmentables.kpsrrrrrrrrrrheightwidthron)rrrrlefttop bb_extractrrrrrZkpsoirrrrquokka_keypointss(   $   rc Csddlm}m}d\}}|durt|}|j}|j}ttd }t |}Wdn1s/wYg} |dD]} | || d|| d|| d || d |d q:|durd|j |j d f} nd } || | d} |durzt | |} | | } | S)aVReturn example bounding boxes on the standard example quokke image. Currently only a single bounding box is returned that covers the quokka. Parameters ---------- size : None or float or tuple of int or tuple of float, optional Size of the output image on which the BBs are placed. If ``None``, then the BBs are not projected to any new size (positions on the original image are used). ``float`` s lead to relative size changes, ``int`` s to absolute sizes in pixels. extract : None or 'square' or tuple of number or imgaug.augmentables.bbs.BoundingBox or imgaug.augmentables.bbs.BoundingBoxesOnImage Subarea to extract from the image. See :func:`~imgaug.imgaug.quokka`. Returns ------- imgaug.augmentables.bbs.BoundingBoxesOnImage Example BBs on the quokka image. rrrNrrrrrrrr0rr)rrrrrrrrrrrrrrr)rrrrrrrrrZbbsZbb_dictrZbbsoirrrrquokka_bounding_boxess6          rc sddlm}m}d\|durt|}|j|jttd }t |}Wdn1s/wYg}|dD]}| |fdd|d Dq:|durZ|j |j d f} nd } ||| d } |durpt | |} | | } | S) aY Returns example polygons on the standard example quokke image. The result contains one polygon, covering the quokka's outline. Parameters ---------- size : None or float or tuple of int or tuple of float, optional Size of the output image on which the polygons are placed. If ``None``, then the polygons are not projected to any new size (positions on the original image are used). ``float`` s lead to relative size changes, ``int`` s to absolute sizes in pixels. extract : None or 'square' or tuple of number or imgaug.augmentables.bbs.BoundingBox or imgaug.augmentables.bbs.BoundingBoxesOnImage Subarea to extract from the image. See :func:`~imgaug.imgaug.quokka`. Returns ------- imgaug.augmentables.polys.PolygonsOnImage Example polygons on the quokka image. r)PolygonPolygonsOnImagerNrrcs$g|]}|d|dfqSrr)r+pointrrrrr,Gsz#quokka_polygons..rr0rr)Zimgaug.augmentables.polysrrrrrrrrrrrrrr) rrrrrrrrZ poly_jsonrZpsoirrrrquokka_polygons#s0      rcCsptj|}tj|}|dkr||nt|d}|dkr#||nt|d}ttt||ddS)aCalculcate the angle in radians between vectors `v1` and `v2`. From http://stackoverflow.com/questions/2827393/angles-between-two-n-dimensional-vectors-in-python Parameters ---------- v1 : (N,) ndarray First vector. v2 : (N,) ndarray Second vector. Returns ------- float Angle in radians. Examples -------- >>> angle_between_vectors(np.float32([1, 0, 0]), np.float32([0, 1, 0])) 1.570796... >>> angle_between_vectors(np.float32([1, 0, 0]), np.float32([1, 0, 0])) 0.0 >>> angle_between_vectors(np.float32([1, 0, 0]), np.float32([-1, 0, 0])) 3.141592... rgg?)rFZlinalgZnormrZarccosZclipdot)Zv1Zv2Zlength1Zlength2Zv1_unitZv2_unitrrrangle_between_vectorsVs rcCsdd}|||f||f} |||f||f} | d| d| d| d} | d| d| d| d} | d| d| d| d} | dkrV| | }| | }||fSdS)aCompute the intersection point of two lines. Taken from https://stackoverflow.com/a/20679579 . Parameters ---------- x1 : number x coordinate of the first point on line 1. (The lines extends beyond this point.) y1 : number y coordinate of the first point on line 1. (The lines extends beyond this point.) x2 : number x coordinate of the second point on line 1. (The lines extends beyond this point.) y2 : number y coordinate of the second point on line 1. (The lines extends beyond this point.) x3 : number x coordinate of the first point on line 2. (The lines extends beyond this point.) y3 : number y coordinate of the first point on line 2. (The lines extends beyond this point.) x4 : number x coordinate of the second point on line 2. (The lines extends beyond this point.) y4 : number y coordinate of the second point on line 2. (The lines extends beyond this point.) Returns ------- tuple of number or bool The coordinate of the intersection point as a ``tuple`` ``(x, y)``. If the lines are parallel (no intersection point or an infinite number of them), the result is ``False``. cSsL|d|d}|d|d}|d|d|d|d}||| fS)Nrbrr)Zpoint1Zpoint2Zline_yZline_xZsloperrr _make_lines  z3compute_line_intersection_point.._make_linerrbrFr)rrrrZx3Zy3Zx4Zy4rline1line2DZDxZDyrrrrrcompute_line_intersection_points0   rrrc Csddlm}m}m}|jjdvsJd|jjf|j} |jtjkr(|tj }| |}| t |} | |} | j||f|t|| dt|} | jdsuz| jddWntyt} zd t| vrjt| } WYd } ~ nd } ~ ww| j| kr| | } | S) aDraw text on an image. This uses by default DejaVuSans as its font, which is included in this library. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: yes; not tested * ``float64``: no * ``float128``: no * ``bool``: no TODO check if other dtypes could be enabled Parameters ---------- img : (H,W,3) ndarray The image array to draw text on. Expected to be of dtype ``uint8`` or ``float32`` (expected value range is ``[0.0, 255.0]``). y : int x-coordinate of the top left corner of the text. x : int y- coordinate of the top left corner of the text. text : str The text to draw. color : iterable of int, optional Color of the text to draw. For RGB-images this is expected to be an RGB color. size : int, optional Font size of the text to draw. Returns ------- (H,W,3) ndarray Input image with text drawn on it. r)Image ImageDraw ImageFont)uint8rzSCan currently draw text only on images of dtype 'uint8' or 'float32'. Got dtype %s.)fillfontZ WRITEABLET)writez/cannot set WRITEABLE flag to True of this arrayN)ZPILrrrr^namerFrrrZ fromarrayZtruetypeDEFAULT_FONT_FPZDrawtextrkZasarrayflagsZsetflags ValueErrorrcopy)rrrrcolorrZ PIL_ImageZ PIL_ImageDrawZ PIL_ImageFont input_dtypercontextZimg_npexrrr draw_texts25           rcst|dkr|Strdkrtdftr fn)tdks/JdtftddDsIJdtddDtft|trqtd d |D}|d krgttt |d Sfd d|DS|j }|j dvsJdt|f|d}|d |d}}|j dkr|dnd}dd t rt t|nt rt t|n|krΈ|krt|Sd|fvrt|dgt|dd} tj| |jdStdd|j d dD} | r Jdtdd|Dfdus+tvs+JddddtDtfdurB|ks:|kr>tjn+tjn'dtjfvrNtjndtjfvrZtjndtjfvrftjntjd dlm} tjkr| j|gdgdddn | j|gd gd!dd|f} |dur| |f} tj| |jd} t|D]\}j}|j}|d"krÈ tj!d#n|d$krՈtjkrՈ tj"n |d%kr tj#|dur|d&krfd'dt$%|D}tj&|d(d)}n tj'fd*}|jjjjks Jd+jj|jjft|j dkr>|dur>|d kr>|ddddtj(f}|d"krH|d,k}n+|d$kratjkrad dlm} | )|tj*}n|d%krsd dlm} | )|tj+}|| |<q| S)-aB Resize each image in a list or array to a specified size. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: yes; tested * ``uint32``: no (1) * ``uint64``: no (2) * ``int8``: yes; tested (3) * ``int16``: yes; tested * ``int32``: limited; tested (4) * ``int64``: no (2) * ``float16``: yes; tested (5) * ``float32``: yes; tested * ``float64``: yes; tested * ``float128``: no (1) * ``bool``: yes; tested (6) - (1) rejected by ``cv2.imresize`` - (2) results too inaccurate - (3) mapped internally to ``int16`` when interpolation!="nearest" - (4) only supported for interpolation="nearest", other interpolations lead to cv2 error - (5) mapped internally to ``float32`` - (6) mapped internally to ``uint8`` Parameters ---------- images : (N,H,W,[C]) ndarray or list of (H,W,[C]) ndarray Array of the images to resize. Usually recommended to be of dtype ``uint8``. sizes : float or iterable of int or iterable of float The new size of the images, given either as a fraction (a single float) or as a ``(height, width)`` ``tuple`` of two integers or as a ``(height fraction, width fraction)`` ``tuple`` of two floats. interpolation : None or str or int, optional The interpolation to use during resize. If ``int``, then expected to be one of: * ``cv2.INTER_NEAREST`` (nearest neighbour interpolation) * ``cv2.INTER_LINEAR`` (linear interpolation) * ``cv2.INTER_AREA`` (area interpolation) * ``cv2.INTER_CUBIC`` (cubic interpolation) If ``str``, then expected to be one of: * ``nearest`` (identical to ``cv2.INTER_NEAREST``) * ``linear`` (identical to ``cv2.INTER_LINEAR``) * ``area`` (identical to ``cv2.INTER_AREA``) * ``cubic`` (identical to ``cv2.INTER_CUBIC``) If ``None``, the interpolation will be chosen automatically. For size increases, ``area`` interpolation will be picked and for size decreases, ``linear`` interpolation will be picked. Returns ------- (N,H',W',[C]) ndarray Array of the resized images. Examples -------- >>> import imgaug as ia >>> images = np.zeros((2, 8, 16, 3), dtype=np.uint8) >>> images_resized = ia.imresize_many_images(images, 2.0) >>> images_resized.shape (2, 16, 32, 3) Convert two RGB images of height ``8`` and width ``16`` to images of height ``2*8=16`` and width ``2*16=32``. >>> images_resized = ia.imresize_many_images(images, (2.0, 4.0)) >>> images_resized.shape (2, 16, 64, 3) Convert two RGB images of height ``8`` and width ``16`` to images of height ``2*8=16`` and width ``4*16=64``. >>> images_resized = ia.imresize_many_images(images, (16, 32)) >>> images_resized.shape (2, 16, 32, 3) Converts two RGB images of height ``8`` and width ``16`` to images of height ``16`` and width ``32``. rzLIf 'sizes' is given as a single number, it is expected to be >= 0, got %.8f.rzYIf 'sizes' is given as a tuple, it is expected be a tuple of two entries, got %d entries.cSg|] }t|o |dkqSrrr+rHrrrr,rz(imresize_many_images..z|If 'sizes' is given as a tuple, it is expected be a tuple of two ints or two floats, each >= 0, got types %s with values %s.cSrrrYrrrrr,rcSsh|]}|jqSrrr+imagerrr z'imresize_many_images..rbsizesrcs(g|]}t|tjdfddqS).r r.)imresize_many_imagesrFnewaxisr)rr rrr,s r0rz4Expected array of shape (N, H, W, [C]), got shape %sr0NrcSsg|]}|dkqSrr)r+axisrrrr,rzCannot resize images, because at least one image has a height and/or width and/or number of channels of zero. Observed shapes were: %s.cSsg|]}|jqSrrrrrrr,rz9Expected 'interpolation' to be None or one of %s. Got %s., cSrr)r)r+Zvalid_iprrrr,rr r r dtypes) rNruint16int8int16rfloat16rfloat64) uint32uint64uint128uint256int64int128int256float96float128float256allowedZ disallowed augmenter)rNrrrrrrr) rrrrrrrrrr r!rNrrrcs(g|]}tjd|ffdqS).r)cv2r)r+c) height_targetrinter width_targetrrr,s rrzkExpected cv2.resize() to keep the input dtype '%s', but got '%s'. This is an internal error. Please report.),r>rSrrrrErjr rFrrndimrRrrrrkrr^anyIMRESIZE_VALID_INTERPOLATIONSr?r& INTER_AREA INTER_LINEAR INTER_NEAREST INTER_CUBICr gate_dtypesrrrrrrsmxrangestackrr Zrestore_dtypes_rr)imagesr rZ nb_shapesr nb_imagesZ height_imageZ width_image nb_channelsZ shape_outZhas_zero_size_axesiadtZ result_shaperesultrmrZinput_dtype_nameZchannelsZ result_imgr)r(rr)rr r*rr s  ]                        r cCs4t|dr|j}t|dvsJdt||fdS)NrrzPExpected image with two or three dimensions, but got %d dimensions and shape %s.)r3rr>rrrr_assert_two_or_three_dims's  r?cCs~t|d}|jdkrd}|ddddtjf}t|tjddddddf||d}|r;|ddddddfS|dS)aUResize a single image. **Supported dtypes**: See :func:`~imgaug.imgaug.imresize_many_images`. Parameters ---------- image : (H,W,C) ndarray or (H,W) ndarray Array of the image to resize. Usually recommended to be of dtype ``uint8``. sizes : float or iterable of int or iterable of float See :func:`~imgaug.imgaug.imresize_many_images`. interpolation : None or str or int, optional See :func:`~imgaug.imgaug.imresize_many_images`. Returns ------- (H',W',C) ndarray or (H',W') ndarray The resized image. FrTNrrr )r?r.rFr r )rr rZ grayscalersrrrr/s  rconstantTc Cs2ddlm}ddlm}|jdkrt|S|j|gdgddd|dur-td |}t|t |o8|dk} t |oIt |d voId d |D} | sV| sVJd t |t |r^||g}t ||j krlt|dg}|j||d|d||d}|j} tjj|t|||d} |r| jj| jkr| | } | S)aP Resize an array by pooling values within blocks. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: yes; tested * ``uint32``: yes; tested (2) * ``uint64``: no (1) * ``int8``: yes; tested * ``int16``: yes; tested * ``int32``: yes; tested (2) * ``int64``: no (1) * ``float16``: yes; tested * ``float32``: yes; tested * ``float64``: yes; tested * ``float128``: yes; tested (2) * ``bool``: yes; tested - (1) results too inaccurate (at least when using np.average as func) - (2) Note that scikit-image documentation says that the wrapped pooling function converts inputs to ``float64``. Actual tests showed no indication of that happening (at least when using preserve_dtype=True). Parameters ---------- arr : (H,W) ndarray or (H,W,C) ndarray Image-like array to pool. Ideally of datatype ``float64``. block_size : int or tuple of int Spatial size of each group of values to pool, aka kernel size. * If a single ``int``, then a symmetric block of that size along height and width will be used. * If a ``tuple`` of two values, it is assumed to be the block size along height and width of the image-like, with pooling happening per channel. * If a ``tuple`` of three values, it is assumed to be the block size along height, width and channels. func : callable Function to apply to a given block in order to convert it to a single number, e.g. :func:`numpy.average`, :func:`numpy.min`, :func:`numpy.max`. pad_mode : str, optional Padding mode to use if the array cannot be divided by `block_size` without remainder. See :func:`~imgaug.imgaug.pad` for details. pad_cval : number, optional Value to use for padding if `mode` is ``constant``. See :func:`numpy.pad` for details. preserve_dtype : bool, optional Whether to convert the array back to the input datatype if it is changed away from that in the pooling process. cval : None or number, optional Deprecated. Old name for `pad_cval`. Returns ------- (H',W') ndarray or (H',W',C') ndarray Array after pooling. rbrrr) rNrrrrrrrrrr )rrrrrrr!Nr"zB`cval` is a deprecated argument in pool(). Use `pad_cval` instead.rcSrrb)rOrrrrr,rzpool..ztExpected argument 'block_size' to be a single integer >0 or a tuple of 2 or 3 values with each one being >0. Got %s.)Zheight_multipleZwidth_multiplemodecval)rD)r5rZ augmentersrrFrr6rr?rOrTr>rr.rjpad_to_multiples_ofr^rmeasureZ block_reducerkrr) arr block_sizer<pad_modepad_cvalpreserve_dtyperDr=ZiasizeZ is_valid_intZis_valid_tuplerZ arr_reducedrrrpoolVsP E       rLreflectc Ct||tj||||dS)a|Resize an array using average pooling. Defaults to ``pad_mode="reflect"`` to ensure that padded values do not affect the average. **Supported dtypes**: See :func:`~imgaug.imgaug.pool`. Parameters ---------- arr : (H,W) ndarray or (H,W,C) ndarray Image-like array to pool. See :func:`~imgaug.imgaug.pool` for details. block_size : int or tuple of int or tuple of int Size of each block of values to pool. See :func:`~imgaug.imgaug.pool` for details. pad_mode : str, optional Padding mode to use if the array cannot be divided by `block_size` without remainder. See :func:`~imgaug.imgaug.pad` for details. pad_cval : number, optional Padding value. See :func:`~imgaug.imgaug.pool` for details. preserve_dtype : bool, optional Whether to preserve the input array dtype. See :func:`~imgaug.imgaug.pool` for details. cval : None or number, optional Deprecated. Old name for `pad_cval`. Returns ------- (H',W') ndarray or (H',W',C') ndarray Array after average pooling. rIrJrKrD)rLrFZaveragerGrHrIrJrKrDrrravg_pool +rRedgec CrO)aResize an array using max-pooling. Defaults to ``pad_mode="edge"`` to ensure that padded values do not affect the maximum, even if the dtype was something else than ``uint8``. **Supported dtypes**: See :func:`~imgaug.imgaug.pool`. Parameters ---------- arr : (H,W) ndarray or (H,W,C) ndarray Image-like array to pool. See :func:`~imgaug.imgaug.pool` for details. block_size : int or tuple of int or tuple of int Size of each block of values to pool. See :func:`~imgaug.imgaug.pool` for details. pad_mode : str, optional Padding mode to use if the array cannot be divided by `block_size` without remainder. See :func:`~imgaug.imgaug.pad` for details. pad_cval : number, optional Padding value. See :func:`~imgaug.imgaug.pool` for details. preserve_dtype : bool, optional Whether to preserve the input array dtype. See :func:`~imgaug.imgaug.pool` for details. cval : None or number, optional Deprecated. Old name for `pad_cval`. Returns ------- (H',W') ndarray or (H',W',C') ndarray Array after max-pooling. rP)rLrFmaxrQrrrmax_poolrSrVrcCt||tj|||dS)aTResize an array using min-pooling. Defaults to ``pad_mode="edge"`` to ensure that padded values do not affect the minimum, even if the dtype was something else than ``uint8``. **Supported dtypes**: See :func:`~imgaug.imgaug.pool`. Parameters ---------- arr : (H,W) ndarray or (H,W,C) ndarray Image-like array to pool. See :func:`~imgaug.imgaug.pool` for details. block_size : int or tuple of int or tuple of int Size of each block of values to pool. See :func:`~imgaug.imgaug.pool` for details. pad_mode : str, optional Padding mode to use if the array cannot be divided by `block_size` without remainder. See :func:`~imgaug.imgaug.pad` for details. pad_cval : number, optional Padding value. See :func:`~imgaug.imgaug.pool` for details. preserve_dtype : bool, optional Whether to preserve the input array dtype. See :func:`~imgaug.imgaug.pool` for details. Returns ------- (H',W') ndarray or (H',W',C') ndarray Array after min-pooling. rIrJrK)rLrFminrGrHrIrJrKrrrmin_pool2s(r[cCrW)a%Resize an array using median-pooling. Defaults to ``pad_mode="reflect"`` to ensure that padded values do not affect the average. **Supported dtypes**: See :func:`~imgaug.imgaug.pool`. Parameters ---------- arr : (H,W) ndarray or (H,W,C) ndarray Image-like array to pool. See :func:`~imgaug.imgaug.pool` for details. block_size : int or tuple of int or tuple of int Size of each block of values to pool. See :func:`~imgaug.imgaug.pool` for details. pad_mode : str, optional Padding mode to use if the array cannot be divided by `block_size` without remainder. See :func:`~imgaug.imgaug.pad` for details. pad_cval : number, optional Padding value. See :func:`~imgaug.imgaug.pool` for details. preserve_dtype : bool, optional Whether to preserve the input array dtype. See :func:`~imgaug.imgaug.pool` for details. Returns ------- (H',W') ndarray or (H',W',C') ndarray Array after min-pooling. rX)rLrFZmedianrZrrr median_pool^s (r\cCst|}|dks Jdt|r |jdksJd|j|jfnmt|s-Jdt|ftdd|DsDJdd d d|Dtd d|Ds[Jd d d d|Dtdd|DdkstJdd dd|Dtdd|DdksJdd dd|Dtdd|D}tdd|D}|djd}|dur|durt t t |}}n|durt t ||}n |durt t ||}|||ksJd|||||f||}||}t|r|j n|dj } tj|||f| d} d} t|D]<} t|D]3} | |krB|| }|| }||jd}|| }||jd}|| ||||ddf<| d7} qq | S)aCombine multiple images into a single grid-like image. Calling this function with four images of the same shape and ``rows=2``, ``cols=2`` will combine the four images to a single image array of shape ``(2*H, 2*W, C)``, where ``H`` is the height of any of the images (analogous ``W``) and ``C`` is the number of channels of any image. Calling this function with four images of the same shape and ``rows=4``, ``cols=1`` is analogous to calling :func:`numpy.vstack` on the images. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: yes; fully tested * ``uint32``: yes; fully tested * ``uint64``: yes; fully tested * ``int8``: yes; fully tested * ``int16``: yes; fully tested * ``int32``: yes; fully tested * ``int64``: yes; fully tested * ``float16``: yes; fully tested * ``float32``: yes; fully tested * ``float64``: yes; fully tested * ``float128``: yes; fully tested * ``bool``: yes; fully tested Parameters ---------- images : (N,H,W,3) ndarray or iterable of (H,W,3) array The input images to convert to a grid. rows : None or int, optional The number of rows to show in the grid. If ``None``, it will be automatically derived. cols : None or int, optional The number of cols to show in the grid. If ``None``, it will be automatically derived. Returns ------- (H',W',3) ndarray Image of the generated grid. rz-Expected to get at least one image, got none.rzbExpected to get an array of four dimensions denoting (N, H, W, C), got %d dimensions and shape %s.z0Expected to get an iterable of ndarrays, got %s.cSrr)rIrrrrr,rzdraw_grid..z6Expected to get an iterable of ndarrays, got types %s.rcSsg|]}tt|qSr)rrZrrrrr,scSsg|]}|jdkqSr)r.rrrrr,z.rbz;Expected to get images with the same dtypes, got dtypes %s.cSsg|]}|jjqSrr`rrrrr,rcSsh|]}|jdqS)r+rrrrrrr]zGExpected to get images with the same number of channels, got shapes %s.cSr^rr_rrrrr,r]cSg|]}|jdqSrrrrrrr,r]cSrarBrrrrrr,r]rNzExpected rows*cols to lead to at least as many cells as there were images provided, but got %d rows, %d cols (=%d cells) for %d images. r)r>rIr.rrTrZrr?rUrmathceilsqrtr^rFrr7r8)r:rowscolsr;Z cell_height cell_widthr<rrr^gridZcell_idxZrow_idxZcol_idxrZcell_y1Zcell_y2Zcell_x1Zcell_x2rrr draw_grids.     ricCst|||d}t|dS)aSCombine multiple images into a single image and plot the result. This will show a window of the results of :func:`~imgaug.imgaug.draw_grid`. **Supported dtypes**: minimum of ( :func:`~imgaug.imgaug.draw_grid`, :func:`~imgaug.imgaug.imshow` ) Parameters ---------- images : (N,H,W,3) ndarray or iterable of (H,W,3) array See :func:`~imgaug.imgaug.draw_grid`. rows : None or int, optional See :func:`~imgaug.imgaug.draw_grid`. cols : None or int, optional See :func:`~imgaug.imgaug.draw_grid`. )rerfN)riimshow)r:rerfrhrrr show_grids rkc Cs |dvs Jd|f|dkrG|}|jdkr,|jddvr,|dddfdd d d f}d }t|tjt||tdt|d Sdd lm }d }|jd||jd |}}t |d}|j ||f|d\}} |j d|jf| j|dd|d S)aShow an image in a window. **Supported dtypes**: * ``uint8``: yes; not tested * ``uint16``: ? * ``uint32``: ? * ``uint64``: ? * ``int8``: ? * ``int16``: ? * ``int32``: ? * ``int64``: ? * ``float16``: ? * ``float32``: ? * ``float64``: ? * ``float128``: ? * ``bool``: ? Parameters ---------- image : (H,W,3) ndarray Image to show. backend : {'matplotlib', 'cv2'}, optional Library to use to show the image. May be either matplotlib or OpenCV ('cv2'). OpenCV tends to be faster, but apparently causes more technical issues. )r r&z/Expected backend 'matplotlib' or 'cv2', got %s.r&r0rr.rNr+zimgaug-default-window`rb)Zfigsizedpizimgaug.imshow(%s)gray)Zcmap)r.rr&Z namedWindowZ WINDOW_NORMALrjZwaitKeyZ destroyWindowZmatplotlib.pyplotZpyplotrUZsubplotsZcanvasset_window_titleshow) rbackendZ image_bgrZwin_nameZpltrnhwZfigaxrrrrjs(      rjAssertion failed.cCs|stt|dS)aAssert that a ``condition`` holds or raise an ``Exception`` otherwise. This was added because `assert` statements are removed in optimized code. It replaced `assert` statements throughout the library, but that was reverted again for readability and performance reasons. Parameters ---------- condition : bool If ``False``, an exception is raised. message : str, optional Error message. N)AssertionErrorr) conditionmessagerrr do_assertNs rzcCs4|j}|dst|}|j}|dst|}|S)NZOWNDATAZ C_CONTIGUOUS)rrFrZascontiguousarray)rGrrrr_normalize_cv2_input_arr_cs  r{cCstt||S)aMap an input image to a new one using a lookup table. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.imgaug.apply_lut_`. Parameters ---------- image : ndarray See :func:`~imgaug.imgaug.apply_lut_`. table : ndarray or list of ndarray See :func:`~imgaug.imgaug.apply_lut_`. Returns ------- ndarray Image after mapping via lookup table. ) apply_lut_rFr)rtablerrr apply_lutmsr~c Cs|j}t|dkr dn|d}d|vr|St|}t|tr5t||ks.Jd|t|ftj|dd}|jd|fkrH|tjddddf}|jd ks_|jdd|fks_Jd |j||f|d kr|jd krzt|tjddtjfdd|f}g}t t t |d D](}|d }|d }| t |dddd||f|dddd||fqtj|ddS|jjd ksJd |jjf|jjd ksJd|jjftj|||d}|S)aMap an input image in-place to a new one using a lookup table. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no Parameters ---------- image : ndarray Image of dtype ``uint8`` and shape ``(H,W)`` or ``(H,W,C)``. table : ndarray or list of ndarray Table of dtype ``uint8`` containing the mapping from old to new values. Either a ``list`` of ``C`` ``(256,)`` arrays or a single array of shape ``(256,)`` or ``(256, C)`` or ``(1, 256, C)``. In case of ``(256,)`` the same table is used for all channels, otherwise a channelwise table is used and ``C`` is expected to match the number of channels. Returns ------- ndarray Image after mapping via lookup table. This *might* be the same array instance as provided via `image`. rrbr+rzr{rErjrFr9r ZtileZarangerrcrr|Z concatenater^rr&ZLUT)rr}Zimage_shape_origr<ZsublutsZ group_idxZc_startZc_endrrrr|sR*    r|c@s>eZdZdZ  d ddZddZddZd d Zd d ZdS) HooksImagesa Class to intervene with image augmentation runs. This is e.g. useful to dynamically deactivate some augmenters. Parameters ---------- activator : None or callable, optional A function that gives permission to execute an augmenter. The expected interface is:: ``f(images, augmenter, parents, default)`` where ``images`` are the input images to augment, ``augmenter`` is the instance of the augmenter to execute, ``parents`` are previously executed augmenters and ``default`` is an expected default value to be returned if the activator function does not plan to make a decision for the given inputs. propagator : None or callable, optional A function that gives permission to propagate the augmentation further to the children of an augmenter. This happens after the activator. In theory, an augmenter may augment images itself (if allowed by the activator) and then execute child augmenters afterwards (if allowed by the propagator). If the activator returned ``False``, the propagation step will never be executed. The expected interface is:: ``f(images, augmenter, parents, default)`` with all arguments having identical meaning to the activator. preprocessor : None or callable, optional A function to call before an augmenter performed any augmentations. The interface is: ``f(images, augmenter, parents)`` with all arguments having identical meaning to the activator. It is expected to return the input images, optionally modified. postprocessor : None or callable, optional A function to call after an augmenter performed augmentations. The interface is the same as for the `preprocessor`. Examples -------- >>> import numpy as np >>> import imgaug as ia >>> import imgaug.augmenters as iaa >>> seq = iaa.Sequential([ >>> iaa.GaussianBlur(3.0, name="blur"), >>> iaa.Dropout(0.05, name="dropout"), >>> iaa.Affine(translate_px=-5, name="affine") >>> ]) >>> images = [np.zeros((10, 10), dtype=np.uint8)] >>> >>> def activator(images, augmenter, parents, default): >>> return False if augmenter.name in ["blur", "dropout"] else default >>> >>> seq_det = seq.to_deterministic() >>> images_aug = seq_det.augment_images(images) >>> heatmaps = [np.random.rand(*(3, 10, 10))] >>> heatmaps_aug = seq_det.augment_images( >>> heatmaps, >>> hooks=ia.HooksImages(activator=activator) >>> ) This augments images and their respective heatmaps in the same way. The heatmaps however are only modified by ``Affine``, not by ``GaussianBlur`` or ``Dropout``. NcCr!r") activator propagator preprocessor postprocessor)r'rrrrrrrr(. r)zHooksImages.__init__cC|jdur|S|||||S)aEstimate whether an augmenter may be executed. This also affects propagation of data to child augmenters. Returns ------- bool If ``True``, the augmenter may be executed. Otherwise ``False``. N)rr'r:r$parentsdefaultrrr is_activated5 s zHooksImages.is_activatedcCr)aEstimate whether an augmenter may call its children. This function decides whether an augmenter with children is allowed to call these in order to further augment the inputs. Note that if the augmenter itself performs augmentations (before/after calling its children), these may still be executed, even if this method returns ``False``. Returns ------- bool If ``True``, the augmenter may propagate data to its children. Otherwise ``False``. N)rrrrris_propagatingE s zHooksImages.is_propagatingcC|jdur|S||||S)zPreprocess input data per augmenter before augmentation. Returns ------- (N,H,W,C) ndarray or (N,H,W) ndarray or list of (H,W,C) ndarray or list of (H,W) ndarray The input images, optionally modified. N)rr'r:r$rrrr preprocessY  zHooksImages.preprocesscCr)zPostprocess input data per augmenter after augmentation. Returns ------- (N,H,W,C) ndarray or (N,H,W) ndarray or list of (H,W,C) ndarray or list of (H,W) ndarray The input images, optionally modified. N)rrrrr postprocessf rzHooksImages.postprocess)NNNN) rrrrr(rrrrrrrrrsI  rc@r) HooksHeatmapszClass to intervene with heatmap augmentation runs. This is e.g. useful to dynamically deactivate some augmenters. This class is currently the same as the one for images. This may or may not change in the future. Nrrrrrrt rrc@r)HooksKeypointszClass to intervene with keypoint augmentation runs. This is e.g. useful to dynamically deactivate some augmenters. This class is currently the same as the one for images. This may or may not change in the future. Nrrrrrr rrcs$durnfdd}|S)Ncs8ddl}tdf|}t||i|S)Nrz8Using imgaug.imgaug.%s is deprecated. Use %s.%s instead.) importlibr import_modulegetattr)r8r9rmoduleclass_name_newclass_name_oldmodule_name_newrr_func s z,_mark_moved_class_or_function.._funcr)rrrrrrr_mark_moved_class_or_function s  r))rimgaug.augmentables.kpsN)rrN)rimgaug.augmentables.bbsN)rrN)rimgaug.augmentables.polysN)rrN)Z MultiPolygonrN)Z_ConcavePolygonRecovererrN)rzimgaug.augmentables.heatmapsN)rzimgaug.augmentables.segmapsN)ZBatchzimgaug.augmentables.batchesN)Z BatchLoaderimgaug.multicoreN)ZBackgroundAugmenterrN)Zcompute_geometric_medianrN)Z&_convert_points_to_shapely_line_stringrN)Z_interpolate_point_pairrN)Z_interpolate_pointsrN)Z#_interpolate_points_by_max_distancerN)padimgaug.augmenters.sizeN)Zpad_to_aspect_ratiorN)rErN)Z!compute_paddings_for_aspect_ratiorZ&compute_paddings_to_reach_aspect_ratio)Z&compute_paddings_to_reach_multiples_ofrN)Z&compute_paddings_to_reach_exponents_ofrN)r)NN)NF)FrBr")rr)rArTN)rMrNTN)rTrTN)rTrT)rMrNT)rv)sr __future__rrrrbrLrcosrrgr@collections.abcr ImportError collectionsnumpyrFr&rrUZ six.movesZmovesr7Z skimage.drawrZskimage.measurerpathdirnameabspath__file__ZFILE_DIRr?rrrrsetZsctypesZNP_FLOAT_TYPESZ NP_INT_TYPESZ NP_UINT_TYPESZIMSHOW_BACKEND_DEFAULTr3r2r1r4r0Warningr UserWarningrrobjectr rIrKrOrRrSrTrWr[r`rarfrirlrrrurzr}rrrrrrrrrrrrrrrrrrr r?rrLrRrVr[r\rirkrjrzr{r~r|rrrrMOVEDrrrlocalsrrrrs     \ ,         8 K ,  ( 3 . 53* D Z ' ~ / / , , k  = [