Fg %SSKJr SSKrSSKJr SSKJrJr SSKJ r SSK r SSK r SSK JrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJ r J!r!J"r"J#r#J$r$ SSK%J&s J's J(r) SSK*J+r+J,r,J-r- SSK.J/r/J0r0 SS K1J2r2J3r3J4r4 /S Qr5\$\!SS j55r6\SS j5r7\$\SS j55r8SSSjjr9SSSjjr:SSjr;SSSjjr<\$\!SSSjj55r=\$SSj5r>\SSj5r?\$\!SSj55r@\\!SSj55rA\$\!SSj55rB\$SSj5rCSSjrD\$SSj5rE\$\!SSj55rFSSjrG\$\\!SSj555rH\$\!\SSj555rI\$\SSj55rJ\$\!SS j55rK\$\\!SS!j555rLSS"jrMSS#jrNSS$jrO\\SS%j55rPSS&jrQ\$\SS'j55rR\SS(j5rSSS)jrTSS*jrU\SS+j5rVSS,jrWSSS-jjrX\!\ R\ R4SS.jj5r[SS/jr\\\\!SS0j555r]\!SS1j5r^\!SS2j5r_\\!SSS3jj55r`SS4jraSS5jrb\$\!SS6j55rc\\\!SS7j555rd\!SS8j5re\\\!SS9j555rf\\\!SS:j555rg\$\SS;j55rhSS<jri\!SS=j5rj\!SS>j5rkSS?jrl\,"S@5SSAj5rm0SB/SCQ_SD/SEQ_SF/SGQ_SH/SIQ_SJ/SKQ_SL/SMQ_SN/SOQ_SP/SQQ_SR/SSQ_ST/SUQ_SV/SWQ_SX/SYQ_SZ/S[Q_S\/S]Q_S^/S_Q_S`/SaQ_Sb/ScQ_/SdQ/SeQ/SfQ/SgQ/ShQ/SiQ/SjQ/SkQSl.E0SF/SmQ_SH/SnQ_SJ/SoQ_SL/SpQ_SN/SqQ_SP/SrQ_SR/SsQ_ST/StQ_SV/SuQ_SX/SvQ_SZ/SwQ_S\/SxQ_S^/SyQ_S`/SzQ_Sb/S{Q_S|/S}Q_S~/SQ_/SQ/SQ/SQ/SQ/SQ/SQS.ES.rnS\oS'\SSj5rp\SSj5rqSGSSjjrr\!\GSSj55rsGSSjrtGSSjruGSSjrvGSSjrwGSSjrxGSSjryGSSjrzGSSjr{GSSjr|GSSjr}\\!GSSj55r~GS Sjr\ GR"/SQ/SQ/SQ/\ GRS9r\ GR"/SQ/SQ/SQ/\ GRS9rSrGS Sjr\\GS Sj55r\GS Sj5rGS Sjr\GSSj5r\GSSj5r\GSSj5r\$GSSj5rGSSjrGSSjrGSSjrGSSjrGSSjrGSSjrGSSjrGSSjr\ GR"/SQ/SQ/5\ GR"/SQ/SQ/5\ GR"/SQ/SQ/5\ GR"/SQ/SQ/5\ GR"/SQ/SQ/5\ GR"/SQ/SQ/5\ GR"/SQ/SQ/5\ GR"/SQ/SQ/5S.rGSGSSjjrGSSjrGSSjr"SS5r"SS5rGSSjr"SS\5r"SS\5rGSSSjjr\\GS Sj55rg(!) annotationsN)Sequence)AnyLiteral)warn)MAX_VALUES_BY_DTYPEadd add_array add_constant add_weightedclipclipped float32_io from_floatget_num_channelsis_grayscale_image is_rgb_imagemaybe_process_in_chunksmultiply multiply_addmultiply_by_arraymultiply_by_constantnormalize_per_imagepowerpreserve_channel_dimsz_lutto_floatuint8_io)PCAhandle_empty_array non_rgb_error)bboxes_from_masksmasks_from_bboxes)MONO_CHANNEL_DIMENSIONSNUM_MULTI_CHANNEL_DIMENSIONSNUM_RGB_CHANNELS)"add_fog add_graveladd_rain add_shadowadd_snow_bleachadd_snow_textureadd_sun_flare_overlayadd_sun_flare_physics_basedadjust_brightness_torchvisionadjust_contrast_torchvisionadjust_hue_torchvisionadjust_saturation_torchvisionchannel_shufflechromatic_aberrationclaheconvolvedilate downscaleequalizeerode fancy_pcagamma_transformimage_compressioninvert iso_noiselinear_transformation_rgbmove_tone_curvenoop posterize shift_hsvsolarize superpixelsto_gray unsharp_maskc2US:XaUS:XaUS:XaU$[U5nU(a?US:wdUS:waSnSn[SSS9 [R"U[R5n[R"U[R 5n[R "U5upVnUS:wad[R"SS[RS9n[R"X-S5R[R5n[XXSS 9nUS:wa [XbS S 9nUS:wa [XsS S 9n[R"XVU45n[R"U[R 5nU(a%[R"U[R"5$U$) NrzqHueSaturationValue: hue_shift and sat_shift are not applicable to grayscale image. Set them to 0 or use RGB image) stackleveldtypeFinplaceT)rrcv2cvtColorCOLOR_GRAY2RGB COLOR_RGB2HSVsplitnparangeint16modastypeuint8rr merge COLOR_HSV2RGBCOLOR_RGB2GRAY) img hue_shift sat_shift val_shiftis_grayhuesatvallut_hues x/Users/admin/workspace/ai/PDFMathTranslate/myenv/lib/python3.13/site-packages/albumentations/augmentations/functional.pyrDrDWsFA~)q.Y!^  %G >Y!^II 1  ll3 2 23 ,,sC-- .CIIcNMCcA~))As"((3&&,c299"((CS51A~348A~348 ))SsO $C ,,sC-- .C4;3<<S// 0DDcURn[UnU[R:Xa[ [ U5S-5Vs/sHoDX-:aX4- OUPM nnUR n[U[R"XRS9SS9n[U5UR:wa[R"US5$U$UR5nX:nX0U- X'U$s snf)aInvert all pixel values above a threshold. Args: img: The image to solarize. Can be uint8 or float32. threshold: Normalized threshold value in range [0, 1]. For uint8 images: pixels above threshold * 255 are inverted For float32 images: pixels above threshold are inverted Returns: Solarized image. Note: The threshold is normalized to [0, 1] range for both uint8 and float32 images. For uint8 images, the threshold is internally scaled by 255. rMFrP) rNrrWr\rangeintshaperarraylenndim expand_dimscopy)r` thresholdrNmax_valilut prev_shapeconds rirErEs" IIE!%(G INsSZ|^_O_I`aI`AI$77 Q>I`aYY S"((34eD*-j/SXX*Er~~c2&N3N ((*C  Dd)#CI JbsCc$[R"U5nUR(a[U5S:XaR[R"SS[RS9n[R"SSU- -S- 5)nX4-n[ XSS9$[R "U5n[U5Hbupg[R"SS[RS9n[R"SSU- -S- 5)nX4-n[ US U4US S9US U4'Md U$) aReduce the number of bits for each color channel by keeping only the highest N bits. This transform performs bit-depth reduction by masking out lower bits, effectively reducing the number of possible values per channel. This creates a posterization effect where similar colors are merged together. Args: img: Input image. Can be single or multi-channel. bits: Number of high bits to keep. Must be in range [1, 7]. Can be either: - A single value to apply the same bit reduction to all channels - A list of values to apply different bit reduction per channel. Length of list must match number of channels in image. Returns: np.ndarray: Image with reduced bit depth. Has same shape and dtype as input. Note: - The transform keeps the N highest bits and sets all other bits to 0 - For example, if bits=3: - Original value: 11010110 (214) - Keep 3 bits: 11000000 (192) - The number of unique colors per channel will be 2^bits - Higher bits values = more colors = more subtle effect - Lower bits values = fewer colors = more dramatic posterization Examples: >>> import numpy as np >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> # Same posterization for all channels >>> result = posterize(image, bits=3) >>> # Different posterization per channel >>> result = posterize(image, bits=[3, 4, 5]) # RGB channels rlrrLrMrJFrP.T)rWr\rprrrXr empty_like enumerate)r`bits bits_arrayrymask result_imgrx channel_bitss rirCrCsJ$J   s:!3ii3bhh/q:~.233 c..s#J$Z0ii3bhh/q</01455 #CQKdC 36 1 rjc[R"U/S/US/S5R5nUVs/sH o3(dM UPM nn[U5S::aUR 5$[ R "USS5S-nU(dUR 5$[ R"S[ RS9nUS-n[S5Hn[Xu-S5Xh'XrU- nM [U[ R"U5S S 9$s snf) NrrLrrLrlrmrMrJTrP) rRcalcHistravelrrrurWsumemptyr\rnminrrq) r`r histogram_fhsteprynrxs ri _equalize_pilrs cUQCuh?EEGI&i2iA& 1v{xxz 66!CR&>S D xxz ((3bhh 'C  A 3ZQY$ q\ #rxx}d 33 's DDcFUc[R"U5$[R"U/S/US/S5R5nSnUHnUS:a O US- nM [ US5n[ R "U5nX#U:Xa[ R"X5$SXRU- - nSn[ R"S[ RS9n[US-[U55H1n XrU - n[[Xv-5[ R5X'M3 [XSS 9$) NrrLrrlrgo@rMTrP)rR equalizeHistrrrrWr full_likezerosr\rnrrr roundr) r`rrrxrgtotalscale_sumryidxs ri _equalize_cvrs  |$$ cUQCuh?EEGI A 7  Q As A FF9 E|u||C## Uq\) *E D ((3bhh 'CQUC N+ #dl+RXX6, #D ))rjcUbx[U5(a5[U5(a%[SURSUR35eU(d+[U5(dSUR3n[U5eggg)NzWrong mask shape. Image shape: z. Mask shape: zAWhen by_channels=False only 1-channel mask supports. Mask shape: )rr ValueErrorrp)r`r by_channelsmsgs ri_check_preconditionsrs     "4S"9"91#))N4::,W #5d#;#;UVZV`V`UabCS/ !$<{ rjcUcgUR[R5n[U5(dUcU$USU4$)N.)r[rWr\r)rrxs ri _handle_maskrs@ | ;;rxx D$19 Q<rjc[XU5 US:Xa[O[n[U5(aU"U[ U55$U(db[ R "U[ R5nU"US[ U55US'[ R "U[ R5$[R"U5n[[5H!n[ X5nU"USU4U5USU4'M# U$)aApply histogram equalization to the input image. This function enhances the contrast of the input image by equalizing its histogram. It supports both grayscale and color images, and can operate on individual channels or on the luminance channel of the image. Args: img (np.ndarray): Input image. Can be grayscale (2D array) or RGB (3D array). mask (np.ndarray | None): Optional mask to apply the equalization selectively. If provided, must have the same shape as the input image. Default: None. mode (ImageMode): The backend to use for equalization. Can be either "cv" for OpenCV or "pil" for Pillow-style equalization. Default: "cv". by_channels (bool): If True, applies equalization to each channel independently. If False, converts the image to YCrCb color space and equalizes only the luminance channel. Only applicable to color images. Default: True. Returns: np.ndarray: Equalized image. The output has the same dtype as the input. Raises: ValueError: If the input image or mask have invalid shapes or types. Note: - If the input image is not uint8, it will be temporarily converted to uint8 for processing and then converted back to its original dtype. - For color images, when by_channels=False, the image is converted to YCrCb color space, equalized on the Y channel, and then converted back to RGB. - The function preserves the original number of channels in the image. Example: >>> import numpy as np >>> import albumentations as A >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> equalized = A.equalize(image, mode="cv", by_channels=True) >>> assert equalized.shape == image.shape >>> assert equalized.dtype == image.dtype pil.r.) rrrrrrRrSCOLOR_RGB2YCrCbCOLOR_YCrCb2RGBrWr~rnr&)r`rmoderfunctionrrx_masks rir9r9+sZK0 $ }[ [R "U"X1U55[R SS9n[XSS9$[U[R5(a[U[R5(a[ [R "U"USS2[R4X5R5[R SS9n[R"[U5Vs/sH.n[USS2SS2U4[R"Xx5SS9PM0 sn5$[!S[#U5S [#U535es snf) aRescales the relationship between bright and dark areas of the image by manipulating its tone curve. Args: img: np.ndarray. Any number of channels low_y: per-channel or single y-position of a Bezier control point used to adjust the tone curve, must be in range [0, 1] high_y: per-channel or single y-position of a Bezier control point used to adjust image tone curve, must be in range [0, 1] ?rLcXSU- nSUS--U-U-SU-US--U--US--S-$)NrlrJr)tlow_yhigh_y one_minus_ts ri evaluate_bez%move_tone_curve..evaluate_bez~sO !e KN"Q&.[1a41G&1PPSTVWSWW[^^^rjFrPNz?low_y and high_y must both be of type float or np.ndarray. Got z and )r np.ndarrayrfloat | np.ndarrayrrreturnr)rWlinspacerisscalarr rintr\r isinstancendarraynewaxisTrRr]rnascontiguousarray TypeErrortype) r`rrrr num_channelsrylutsrxs rirArAlsw Cc"A_ _!_#_  _$C(L {{5bkk&11277<&9:BHHeTc..%$$FBJJ)G)G GGL1bjj=!15ACC D HH  yyY^_kYl mYlTUVC1aL""6"6tw"? OYl m    I$u+V[\`ag\h[ij  ns5F2c.[R"X5$N)rR transform)r`transformation_matrixs rir@r@s == 44rjcjUR5n[R"XS9n[U5(aUR U5$[R "U[R 5nUR USS2SS2S45USS2SS2S4'[R "U[R5$)aApply Contrast Limited Adaptive Histogram Equalization (CLAHE) to the input image. This function enhances the contrast of the input image using CLAHE. For color images, it converts the image to the LAB color space, applies CLAHE to the L channel, and then converts the image back to RGB. Args: img (np.ndarray): Input image. Can be grayscale (2D array) or RGB (3D array). clip_limit (float): Threshold for contrast limiting. Higher values give more contrast. tile_grid_size (tuple[int, int]): Size of grid for histogram equalization. Width and height of the grid. Returns: np.ndarray: Image with CLAHE applied. The output has the same dtype as the input. Note: - If the input image is float32, it's temporarily converted to uint8 for processing and then converted back to float32. - For color images, CLAHE is applied only to the luminance channel in the LAB color space. Raises: ValueError: If the input image is not 2D or 3D. Example: >>> import numpy as np >>> img = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> result = clahe(img, clip_limit=2.0, tile_grid_size=(8, 8)) >>> assert result.shape == img.shape >>> assert result.dtype == img.dtype ) clipLimit tileGridSizeNr)rurR createCLAHErapplyrS COLOR_RGB2LAB COLOR_LAB2RGB)r` clip_limittile_grid_size clahe_mats rir5r5sJ ((*C*RI#s## ,,sC-- .C??3q!Qw<0C1aL <<S.. //rjcD[[RSUS9nU"U5$)Nrm)ddepthkernel)rrRfilter2D)r`rconv_fns rir6r6s &cll2fMG 3<rjcUS:Xa[RO[Rn[U5nUS:Xa^[R"X [ U5U45upV[R "U[R5nUS[R4$U[:XaI[R"X [ U5U45upV[R "U[R5$US:Xah[R"USSS9n[R"X([ U5U45upY[R "U [R5n U SSS24$USS[24n [R"X+[ U5U45upY[R "U [R5n U[:a/n [[U5Hn USU 4n[R"X.[ U5U45up_[R "U[R5n[UR5S:XaUS[R4nU R!U5 M [R""U /U Q5$U $) zApply compression to image. Args: img: Input image quality: Compression quality (0-100) image_type: Type of compression ('.jpg' or '.webp') Returns: Compressed image with same number of channels as input z.jpgrl.rJ)rrrrrlconstant)rN)rRIMWRITE_JPEG_QUALITYIMWRITE_WEBP_QUALITYrimencoderoimdecodeIMREAD_GRAYSCALErWrr&IMREAD_UNCHANGEDpadrnrrrpappenddstack)r`quality image_type quality_flagr_ encoded_imgdecodedpadded encoded_bgr decoded_bgrbgrextra_channelsrxchannelencodeds rir=r=s "0:V/C3++IaIaL#C(LqjL8I77ST,,{C,@,@AsBJJ''''jL8I77ST||K)=)=>>q5JGj3|;Lg:VWll;0D0DE 37## c$$$$ %C\\*C 4Ew3OPNA,,{C,@,@AK&&'6A#q&kGjC >> import numpy as np >>> import albumentations as A >>> image = np.random.randint(0, 256, [100, 100, 3], dtype=np.uint8) >>> snowy_image = A.functional.add_snow_v1(image, snow_point=0.5, brightness_coeff=1.5) References: - HLS Color Space: https://en.wikipedia.org/wiki/HSL_and_HSV - Original implementation: https://github.com/UjjwalSaxena/Automold--Road-Augmentation-Library rJrrMNrlTrP) rrWr\rRrS COLOR_RGB2HLSrqfloat32r COLOR_HLS2RGB)r` snow_pointbrightness_coeff max_value image_hlss rir+r+sh$BHH-Ia-Ja-J S#"3"34I"**5I aAgyAq)J67;KK7i1a0"((DIIaAg"((3I << 3#4#4 55rjcURUSSSSS9n[R"USSSS9nURUSS5S :nX#4$) zGenerate snow texture and sparkle mask. Args: img_shape (tuple[int, int]): Image shape. random_generator (np.random.Generator): Random generator to use. Returns: tuple[np.ndarray, np.ndarray]: Tuple of (snow_texture, sparkle_mask) arrays. NrJ?g333333?)sizelocrrrlsigmaXsigmaYGz?)normalrR GaussianBlurrandom) img_shaperandom_generator snow_texture sparkle_masks rigenerate_snow_texturesr ^s]$** "1 3c*RL##L&1ML$**9Ra=9D@L  %%rjcl[[Rn[R"U[R 5R [R5n[R"USS2SS2S4SX!---SU5USS2SS2S4'[R"USSSS9nURSn[R"SSU5SS2[R4nX8-n[R"U/S-5U-U-R [R5n [R"Xi5n [R"U S 5n [R "U S U S U-S5n [R"U R [R5[R"5n XUU/X'U $) aAdd a realistic snow effect to the input image. This function simulates snowfall by applying multiple visual effects to the image, including brightness adjustment, snow texture overlay, depth simulation, and color tinting. The result is a more natural-looking snow effect compared to simple pixel bleaching methods. Args: img (np.ndarray): Input image in RGB format. snow_point (float): Coefficient that controls the amount and intensity of snow. Should be in the range [0, 1], where 0 means no snow and 1 means maximum snow effect. brightness_coeff (float): Coefficient for brightness adjustment to simulate the reflective nature of snow. Should be in the range [0, 1], where higher values result in a brighter image. snow_texture (np.ndarray): Snow texture. sparkle_mask (np.ndarray): Sparkle mask. Returns: np.ndarray: Image with added snow effect. The output has the same dtype as the input. Note: - The function first converts the image to HSV color space for better control over brightness and color adjustments. - A snow texture is generated using Gaussian noise and then filtered for a more natural appearance. - A depth effect is simulated, with more snow at the top of the image and less at the bottom. - A slight blue tint is added to simulate the cool color of snow. - Random sparkle effects are added to simulate light reflecting off snow crystals. The snow effect is created through the following steps: 1. Brightness adjustment in HSV space 2. Generation of a snow texture using Gaussian noise 3. Application of a depth effect to the snow texture 4. Blending of the snow texture with the original image 5. Addition of a cool blue tint 6. Addition of sparkle effects Examples: >>> import numpy as np >>> import albumentations as A >>> image = np.random.randint(0, 256, [100, 100, 3], dtype=np.uint8) >>> snowy_image = A.functional.add_snow_v2(image, snow_coeff=0.5, brightness_coeff=0.2) Note: This function works with both uint8 and float32 image types, automatically handling the conversion between them. References: - Perlin Noise: https://en.wikipedia.org/wiki/Perlin_noise - HSV Color Space: https://en.wikipedia.org/wiki/HSL_and_HSV NrJrlrrrg?r)333333??rl333333?333333?)rrWr\rRrSrUr[rr rrprrrr r addWeightedr^) r`rrr r rimg_hsvrows depth_effect snow_layer img_with_snow blue_tints rir,r,usxt$BHH-Ill3 1 1299"**EGww1aA 0 ==> GAq!G##L&1ML 99Q>J HHj-A 6EMM RXX  A~ *5:FGGC%$ ScK Jrjc USSupE[S[[XE5S-U-55n[SUS-5n[U5Vs/sHoR Xv5PM sn$s snf)a[Generate radiuses for fog particles. Args: img_shape (tuple[int, int]): Image shape. num_particles (int): Number of fog particles. fog_intensity (float): Intensity of the fog effect, between 0 and 1. random_generator (np.random.Generator): Random generator to use. Returns: list[int]: List of radiuses for each fog particle. NrJ皙?rl)maxrorrnintegers) r num_particles fog_intensityrheightwidthmax_fog_radius min_radiusrs riget_fog_particle_radiusesr9sk"bqMMFCF 2S 8= HIJNQ!+,JKPQ^K_ `K_a % %j AK_ `` `sA%c URSSupV[U5n[R"XVU4[RS9n[ [Rn [ X45H/uupn US:XaU OU 4U-n [R"UX4U U SS9 M1 [R"USS5n[R"USS S 9U - U-U-nUSU- -X--n[U[RS S 9$) aAdd fog to the input image. Args: img (np.ndarray): Input image. fog_intensity (float): Intensity of the fog effect, between 0 and 1. alpha_coef (float): Base alpha (transparency) value for fog particles. fog_particle_positions (list[tuple[int, int]]): List of (x, y) coordinates for fog particles. fog_particle_radiuses (list[int]): List of radiuses for each fog particle. Returns: np.ndarray: Image with added fog effect. NrJrMrlrm)centerradiuscolor thickness)r?rTrkeepdimsrP) rprrWrr\rziprRcirclermeanr )r`r4 alpha_coeffog_particle_positionsfog_particle_radiusesr5r6r fog_layerrxyr<r=alpharesults rir'r')s,IIbqMMF#C(L&6bhhGI#BHH-I4L)Q. YL<4O 6  M  Ha8I GGIA 5 AJ NQ^ ^E AI !2 2F $ //rjc UR5nUR5nSnSnUH>un uppXyU -- nX- n[R"XZU 4XS5 [XYUSU - 5nM@ UV s/sHn [ U 5PM nn UR5nUS-nXx- S-n[ R "S[US5US9n [ R "SX/S9n[U5HYn[R"X^[ UU5US5 XU- S- XU- S- -XU- S- -n[UUUSU- 5nM[ U$s sn f)al Add a sun flare effect to an image using a simple overlay technique. This function creates a basic sun flare effect by overlaying multiple semi-transparent circles of varying sizes and intensities on the input image. The effect simulates a simple lens flare caused by bright light sources. Args: img (np.ndarray): The input image. flare_center (tuple[float, float]): (x, y) coordinates of the flare center in pixel coordinates. src_radius (int): The radius of the main sun circle in pixels. src_color (tuple[int, ...]): The color of the sun, represented as a tuple of RGB values. circles (list[Any]): A list of tuples, each representing a circle that contributes to the flare effect. Each tuple contains: - alpha (float): The transparency of the circle (0.0 to 1.0). - center (tuple[int, int]): (x, y) coordinates of the circle center. - radius (int): The radius of the circle. - color (tuple[int, int, int]): RGB color of the circle. Returns: np.ndarray: The output image with the sun flare effect added. Note: - This function uses a simple alpha blending technique to overlay flare elements. - The main sun is created as a gradient circle, fading from the center outwards. - Additional flare circles are added along an imaginary line from the sun's position. - This method is computationally efficient but may produce less realistic results compared to more advanced techniques. The flare effect is created through the following steps: 1. Create an overlay image and output image as copies of the input. 2. Add smaller flare circles to the overlay. 3. Blend the overlay with the output image using alpha compositing. 4. Add the main sun circle with a radial gradient. Examples: >>> import numpy as np >>> import albumentations as A >>> image = np.random.randint(0, 256, [100, 100, 3], dtype=np.uint8) >>> flare_center = (50, 50) >>> src_radius = 20 >>> src_color = (255, 255, 200) >>> circles = [ ... (0.1, (60, 60), 5, (255, 200, 200)), ... (0.2, (70, 70), 3, (200, 255, 200)) ... ] >>> flared_image = A.functional.add_sun_flare_overlay( ... image, flare_center, src_radius, src_color, circles ... ) References: - Alpha compositing: https://en.wikipedia.org/wiki/Alpha_compositing - Lens flare: https://en.wikipedia.org/wiki/Lens_flare rrmrl r)num) rurRrCr rorWrrrn)r` flare_center src_radius src_colorcirclesoverlayoutputweighted_brightnesstotal_radius_lengthrKrIrJrad3 circle_colorpoint num_times max_alpharadrxalps rir-r-Zs[@hhjG XXZF-4)vtt|+# 7FD;gfa%i@ .5 * *\SV\E *kkmGb I $9A=I KKSC0i @E ++a 3C 9  73s1v; 2>MA%&1}q/@)AAEVW-Z[J[D\\gsFAG< M% +s-D?c UR5nURSSupg[R"U[RS9n[ R "XX#S5 SHn [US[R"[R"U 55[Xv5--5[US[R"[R"U 55[Xv5--54n [ R"XXS5 M UH+upp[ R "X[U S-5US5 M- [ R"US S S S 9n[RSU2SU24unn[R"UUS- S-XS- S--5nS[R "U[Xv5S -- SS5- n[R""U/S -5nUU-n[%[ R&"U55n[ R"USS S S S 9US'[ R"USS SSS 9US'[ R("U5nSSU- SU- -S- - $)a0 Add a more realistic sun flare effect to the image. This function creates a complex sun flare effect by simulating various optical phenomena that occur in real camera lenses when capturing bright light sources. The result is a more realistic and physically plausible lens flare effect. Args: img (np.ndarray): Input image. flare_center (tuple[int, int]): (x, y) coordinates of the sun's center in pixels. src_radius (int): Radius of the main sun circle in pixels. src_color (tuple[int, int, int]): Color of the sun in RGB format. circles (list[Any]): List of tuples, each representing a flare circle with parameters: (alpha, center, size, color) - alpha (float): Transparency of the circle (0.0 to 1.0). - center (tuple[int, int]): (x, y) coordinates of the circle center. - size (float): Size factor for the circle radius. - color (tuple[int, int, int]): RGB color of the circle. Returns: np.ndarray: Image with added sun flare effect. Note: This function implements several techniques to create a more realistic flare: 1. Separate flare layer: Allows for complex manipulations of the flare effect. 2. Lens diffraction spikes: Simulates light diffraction in camera aperture. 3. Radial gradient mask: Creates natural fading of the flare from the center. 4. Gaussian blur: Softens the flare for a more natural glow effect. 5. Chromatic aberration: Simulates color fringing often seen in real lens flares. 6. Screen blending: Provides a more realistic blending of the flare with the image. The flare effect is created through the following steps: 1. Create a separate flare layer. 2. Add the main sun circle and diffraction spikes to the flare layer. 3. Add additional flare circles based on the input parameters. 4. Apply Gaussian blur to soften the flare. 5. Create and apply a radial gradient mask for natural fading. 6. Simulate chromatic aberration by applying different blurs to color channels. 7. Blend the flare with the original image using screen blending mode. Examples: >>> import numpy as np >>> import albumentations as A >>> image = np.random.randint(0, 256, [1000, 1000, 3], dtype=np.uint8) >>> flare_center = (500, 500) >>> src_radius = 50 >>> src_color = (255, 255, 200) >>> circles = [ ... (0.1, (550, 550), 10, (255, 200, 200)), ... (0.2, (600, 600), 5, (200, 255, 200)) ... ] >>> flared_image = A.functional.add_sun_flare_physics_based( ... image, flare_center, src_radius, src_color, circles ... ) References: - Lens flare: https://en.wikipedia.org/wiki/Lens_flare - Diffraction: https://en.wikipedia.org/wiki/Diffraction - Chromatic aberration: https://en.wikipedia.org/wiki/Chromatic_aberration - Screen blending: https://en.wikipedia.org/wiki/Blend_modes#Screen NrJrMrm)r-ZrrlgQ?rrffffff?rrOr)rurprWrrrRrCrocosradiansr1sinlinerogridsqrtr rlistrVr])r`rQrRrSrTrVr5r6 flare_layerangle end_pointrr;rr=rJrIrchannelss rir.r.s-JXXZFIIbqMMF--2::6KJJ{*D"  Q"&&E):";c%>P"PP Q  Q"&&E):";c%>P"PP Q  I!D "#*4 ;D$JC#*"";r"MK 88GVGVeVO $DAq 77A Q'A-!_1D0JJ KD rwwts51C78!Q? ?D 99dVaZ D4KCIIk*+H""  HQK ""  HQK ))H%K 3r>rs syy )C //rjcUR5n/n[U5Hup4URX4/5 M [R"U/U/U5 U$r)rurextendrR mixChannels)r`channels_shuffledfrom_torxjs rir3r3xsK ((*CG+,v-OOSEC5'* JrjcUR[R:XaE[R"SSS5U-S-n[ XR [R5SS9$[R "X5$)Nrg?gp?rFrP)rNrWr\rXrr[r)r`gammatables rir<r<sW yyBHH1k95>#Ec<<15AA 88C rjc[R"U[R5n[R"U5upVUR USU-UR SSS9nUR SX-UR SSS9nUS==U- ss'[USXr-SUS- -5US'[R"U[R5n [R"U SSU S 9$) aQApply poisson noise to an image to simulate camera sensor noise. Args: image (np.ndarray): Input image. Currently, only RGB images are supported. color_shift (float): The amount of color shift to apply. intensity (float): Multiplication factor for noise values. Values of ~0.5 produce a noticeable, yet acceptable level of noise. random_generator (np.random.Generator): If specified, this will be random generator used for noise generation. Returns: np.ndarray: The noised image. Image types: uint8, float32 Number of channels: 3 rlNrJrrr.rlrout) rRrSr meanStdDevpoissonrprr rrWr ) image color_shift intensityrhlsrstddevluminance_noise color_noise noised_hlss rir?r?s6 ,,uc// 0Cs#IA&..q I YYr]/O#))  YYr]*K K;K F #sS['89CK c3#4#45J 77:q! 44rjcL[R"U[R5$)aConvert an RGB image to grayscale using the weighted average method. This function uses OpenCV's cvtColor function with COLOR_RGB2GRAY conversion, which applies the following formula: Y = 0.299*R + 0.587*G + 0.114*B Args: img (np.ndarray): Input RGB image as a numpy array. Returns: np.ndarray: Grayscale image as a 2D numpy array. Image types: uint8, float32 Number of channels: 3 )rRrSr_rs rito_gray_weighted_averagers& <<S// 00rjcR[R"U[R5S$)aConvert an RGB image to grayscale using the L channel from the LAB color space. This function converts the RGB image to the LAB color space and extracts the L channel. The LAB color space is designed to approximate human vision, where L represents lightness. Key aspects of this method: 1. The L channel represents the lightness of each pixel, ranging from 0 (black) to 100 (white). 2. It's more perceptually uniform than RGB, meaning equal changes in L values correspond to roughly equal changes in perceived lightness. 3. The L channel is independent of the color information (A and B channels), making it suitable for grayscale conversion. This method can be particularly useful when you want a grayscale image that closely matches human perception of lightness, potentially preserving more perceived contrast than simple RGB-based methods. Args: img (np.ndarray): Input RGB image as a numpy array. Returns: np.ndarray: Grayscale image as a 2D numpy array, representing the L (lightness) channel. Values are scaled to match the input image's data type range. Image types: uint8, float32 Number of channels: 3 r)rRrSrrs rito_gray_from_labrs!@ <<S.. / 77rjcUR[R5n[R"USS9[R"USS9-S- $)zConvert an image to grayscale using the desaturation method. Args: img (np.ndarray): Input image as a numpy array. Returns: np.ndarray: Grayscale image as a 2D numpy array. Image types: uint8, float32 Number of channels: any rmrrJ)r[rWrr1r)r` float_images rito_gray_desaturationrs< **RZZ(K FF;R (266+B+G G1 LLrjc^[R"USS9RUR5$)a7Convert an image to grayscale using the average method. This function computes the arithmetic mean across all channels for each pixel, resulting in a grayscale representation of the image. Key aspects of this method: 1. It treats all channels equally, regardless of their perceptual importance. 2. Works with any number of channels, making it versatile for various image types. 3. Simple and fast to compute, but may not accurately represent perceived brightness. 4. For RGB images, the formula is: Gray = (R + G + B) / 3 Note: This method may produce different results compared to weighted methods (like RGB weighted average) which account for human perception of color brightness. It may also produce unexpected results for images with alpha channels or non-color data in additional channels. Args: img (np.ndarray): Input image as a numpy array. Can be any number of channels. Returns: np.ndarray: Grayscale image as a 2D numpy array. The output data type matches the input data type. Image types: uint8, float32 Number of channels: any rmr)rWrDr[rNrs rito_gray_averagers$< 773R ' ' 22rjc,[R"USS9$)aConvert an image to grayscale using the maximum channel value method. This function takes the maximum value across all channels for each pixel, resulting in a grayscale image that preserves the brightest parts of the original image. Key aspects of this method: 1. Works with any number of channels, making it versatile for various image types. 2. For 3-channel (e.g., RGB) images, this method is equivalent to extracting the V (Value) channel from the HSV color space. 3. Preserves the brightest parts of the image but may lose some color contrast information. 4. Simple and fast to compute. Note: - This method tends to produce brighter grayscale images compared to other conversion methods, as it always selects the highest intensity value from the channels. - For RGB images, it may not accurately represent perceived brightness as it doesn't account for human color perception. Args: img (np.ndarray): Input image as a numpy array. Can be any number of channels. Returns: np.ndarray: Grayscale image as a 2D numpy array. The output data type matches the input data type. Image types: uint8, float32 Number of channels: any rmr)rWr1rs ri to_gray_maxr)s@ 66#B rjcURnURSURS5n[SS9nUR U5nURURSS5n[ US5nU[ R:Xa [XQS9$U$)aPConvert an image to grayscale using Principal Component Analysis (PCA). This function applies PCA to reduce a multi-channel image to a single channel, effectively creating a grayscale representation that captures the maximum variance in the color data. Args: img (np.ndarray): Input image as a numpy array with shape (height, width, channels). Returns: np.ndarray: Grayscale image as a 2D numpy array with shape (height, width). If input is uint8, output is uint8 in range [0, 255]. If input is float32, output is float32 in range [0, 1]. Note: This method can potentially preserve more information from the original image compared to standard weighted average methods, as it accounts for the correlations between color channels. Image types: uint8, float32 Number of channels: any rmrJrl) n_componentsNmin_max target_dtype) rNreshaperpr fit_transformrrWr\r)r`rNpixelspca pca_result grayscales ri to_gray_pcarLs6 IIE [[SYYq\ *F 1 C""6*J""399Ra=1I#Iy9I8=8I:i 4XyXrjc US:Xa [U5nOhUS:Xa [U5nOVUS:Xa [U5nODUS:Xa [U5nO2US:Xa [ U5nO US:Xa [ U5nO[ SU35e[X15$)Nweighted_averagefrom_lab desaturationaverager1rzUnsupported method: )rrrrrrrgrayscale_to_multichannel)r`num_output_channelsmethodrLs rirGrGvs##)#. : !#& > !%c* 9  % 5S! 5S!/x899 $V AArjcrUS:XaU$[R"U5n[R"U/U-5$)aAConvert a grayscale image to a multi-channel image. This function takes a 2D grayscale image or a 3D image with a single channel and converts it to a multi-channel image by repeating the grayscale data across the specified number of channels. Args: grayscale_image (np.ndarray): Input grayscale image. Can be 2D (height, width) or 3D (height, width, 1). num_output_channels (int, optional): Number of channels in the output image. Defaults to 3. Returns: np.ndarray: Multi-channel image with shape (height, width, num_channels) rl)rWsqueezerRr])grayscale_imagersqueezeds rirrs9&azz/*H 99hZ"55 66rjcURSSupEU[R:g=(d U[R:g=(a UR[R :HnU(a [ U5n[R"USUUUS9n[R"XuU4US9nU(a[U[R S9$U$)NrJ)fxfy interpolationrr) rprR INTER_NEARESTrNrWr\rresizer) r`rdown_interpolationup_interpolationr5r6 need_cast downscaledupscaleds rir8r8sIIbqMMF C---X1CsGXGX1X ))rxx sm   ( Jzz*foEUVH:C:hRXX 6QQrjc U$rr) input_objparamss rirBrBs rjc URn[U5nURSU5n[R"USS9nXE- nUS:Xa"[R "U5nUSU-U-nO[R "USS9n [RRU 5upU SSS2R5n Xn U SS2U 4n [R"[R"U [R"X-55UR5RnXH-n U RU5n [R"U SSU S9$) a3Perform 'Fancy PCA' augmentation on an image with any number of channels. Args: img (np.ndarray): Input image alpha_vector (np.ndarray): Vector of scale factors for each principal component. Should have the same length as the number of channels in the image. Returns: np.ndarray: Augmented image of the same shape, type, and range as the input. Image types: uint8, float32 Number of channels: Any Note: - This function generalizes the Fancy PCA augmentation to work with any number of channels. - It preserves the original range of the image ([0, 255] for uint8, [0, 1] for float32). - For single-channel images, the augmentation is applied as a simple scaling of pixel intensity variation. - For multi-channel images, PCA is performed on the entire image, treating each pixel as a point in N-dimensional space (where N is the number of channels). - The augmentation preserves the correlation between channels while adding controlled noise. - Computation time may increase significantly for images with a large number of channels. Reference: Krizhevsky, A., Sutskever, I., & Hinton, G. E. (2012). ImageNet classification with deep convolutional neural networks. In Advances in neural information processing systems (pp. 1097-1105). rmrrrlF)rowvarNr)rprrrWrDstdcovlinalgeighargsortdotdiagrr )r` alpha_vector orig_shaper img_reshapedimg_mean img_centeredstd_devnoiseimg_coveig_valseig_vecs sort_permimg_pcas rir;r;s0DJ#C(L;;r<0Lww|!,H*Lq&&&Q')L8&&e4 YY^^G4TrTN**, &AyL) FF8RWW\%<= > NN  !  "Gooj)G 777Aqg ..rjc^US:Xa[R"U5$US:XaU$[XSS9$)NrrlFrP)rWrrr`factors rir/r/s1 {}}S!! { C //rjc|US:XaU$[U5(aUR5O2[R"U[R5R5nUS:XaKUR [ R:wa[US-5n[ R"XUR S9$[XUSU- -SS9$)NrlrrrMFrP) rrDrRrSr_rNrWrrorr)r`rrDs rir0r0&s { +C00388:cll3HZHZ6[6`6`6bD { 99 "tcz?D||CSYY77 TQZ%8% HHrjc US:Xd[U5(aU$[R"U[R5n[R"U[R5nUS:XaU$[R "XUSU- US9$)Nrlr)r)rrRrSr_rTr)r`rrgrays rir2r25sl{(-- <<S// 0D <<c00 1DQ;4_COOCq6zY^$__rjct[R"U[R5n[R"SS[R S9n[R "USU--S5R[R5n[USUSS9US'[R"U[R5$)NrrLrMrOrFrP) rRrSrUrWrXrYrZr[r\rr^)r`rrys ri_adjust_hue_torchvision_uint8rEs ,,sC-- .C ))As"(( +C &&sV|#S ) 0 0 :CVc59CK <<S.. //rjc^[U5(dUS:XaU$UR[R:Xa [ X5$[ R "U[ R5n[R"USUS--S5US'[ R "U[ R5$)Nrrih) rrNrWr\rrRrSrUrZr^rs rir1r1Os#&A+  yyBHH,S99 ,,sC-- .C&&Vv|3S9CK <<S.. //rjc [R"U5(dU$URnUbd[URSS5nXc:aGX6- nURSSup[ X-5[ X-5p[ R "X U 4U5n[UUSS9n Sn [URn[R"U5nUR[:Xa[R"USS9n[U5n[U5HnUSU4n[R "U 5nUSS:XaUSSn[#U5HunnUU[%U5-(dMU U:Hn[R&"UU5nURR(S ;a6[ [R*"U55n[-[UU 5U5nOUnUUU'M M XPR:wa[ R "XSSU5$U$) NrJrN) n_segments compactnessrrmr.rl)rxub)rWanyrpr1ro fgeometricrslicrrNrursr$rtrrnuniquerrrrDkindrr)rrreplace_samplesmax_sizerrrrr5r6 new_height new_widthsegments min_valuerrc image_sp_c unique_labelsrlabelrmean_intensityvalues rirFrF[s 66/ " " J5;;r?# ?OE!KKOMF$'$7U]9K %%e)-DmTE H I#EKK0I GGENE zz,,u2.#E*L < 36]  (+  q )!"-M$M2JCsS%99::5(!#D)9!:##((O;   89EE9 5yAE*E#( 4 #3!6GQT_T_F_:  UrNM Bjejjrjc[[RX4US9nUR[:Xa$[ U5S:Xa[ R"USS9nU"U5nX- n[ R"U5S-U:nUR[ R5nXU--n [ R"U SSU S9n U"U5n [[X5[USU - 5SS 9$) N)ksizerrlrmrrrrTrP)rrRrrsr%rrWrabsr[rr r r) rrsigmarKrvblur_fnr#residualrsharp soft_masks rirHrHs& nG  zz116Fu6MQR6R 5r* 5>D|H 66( c !I -D ;;rzz "D H$ $E GGE1aU +E I "I & rjc0[R"XU5$)a Apply pixel dropout to an image. Args: image: Input image drop_mask: Boolean mask of same shape as image indicating pixels to drop drop_values: Values to use for dropped pixels, same shape as image Returns: Image with pixels dropped according to mask )rWwhere)r drop_mask drop_valuess ri pixel_dropoutrs 88IE 22rjc[XSS9$NFrPr )r`rains ri spatter_rainrs s% ((rjc[X-USS9$rr)r`non_mudmuds ri spatter_mudrs s}c5 11rjcURSSupg[R"S[RS9nXxS'XhS'US- US'US- US'[R"XS S /[RS9n [R"X4S S /[RS9n [ US UU UUU5n [ US UU UUU5n [R "XS U /5$) NrJrrMr)rlrlg@)rrJ)rlrJrr.rJr)rprWeyerrq_distort_channelr) r`primary_distortion_redsecondary_distortion_redprimary_distortion_bluesecondary_distortion_bluerr5r6 camera_matdistortion_coeffs_reddistortion_coeffs_blue red_distortedblue_distorteds rir4r4sIIbqMMF,Jtts{Jt|JtHH 1a@jj XX QBjj % F   M& F   N 99m[.A BBrjc [R"UUSUXC4[RS9upg[R"UUUU[RS9$)N) cameraMatrix distCoeffsRnewCameraMatrixrm1type)r borderMode)rRinitUndistortRectifyMapCV_32FC1remapBORDER_REPLICATE)rr distortion_coeffsr5r6rmap_xmap_ys rirrsV..$ "_|| LE 99  #''  rjc,[R"XSS9$Nrl) iterations)rRr:r`rs rir:r:0s 99SQ //rjc,[R"XSS9$r4)rRr7r6s rir7r75s ::ca 00rjcbUS:Xa [X5$US:Xa [X5$[SU35e)NdilationerosionzUnsupported operation: )r7r:r)r`r operations ri morphologyr<:s= Jc""IS!! .yk: ;;rjbboxesc|UR5n[X5n[XAU5n[U5USS2SS24'U$)N)rur#r<r")r=rr; image_shapemaskss ribboxes_morphologyrBGs@[[]F f 2E ui 0E%e,F1bqb5M Mrji )gk+ݓ?gӼ?g_LU?i )a+e?gMSt$?gZd;O?i)gD?gs?g_L?i)g?rFg%䃞?)gOjM?rFgm?)glV}?rEg F%u?)g{Pk?rDg:#J{/?),.02468:)g,Ԛ?gAc]K?g QI?)goʡ?gZӼ?gY?)gDio?g QI?g46W[?)g]Fx ?gX2ı.?g:H?)gjM?g|a2U0?rCrH)gHP?g-1?g"~j?rI)g[B>٬?߾3?g?ܵ?)gʡE?rPg`"?)gۊe?rPgH}8?)gK7?rPg58EGr?)gJ4?rPg' ?)g+e?rPg?)gǘ?rPg/n?)rJrKrLrMrNrO) blackbodyciedz!dict[str, dict[int, list[float]]]PLANCKIAN_COEFFScUR5n[[UR55n[ [UR55n[ R "XU5nSn[ X-U-U5n[X-S-U-U5nXg:Xa![ R"[UU5nOUX- Xv- - n SU - n U [ R"[UU5-U [ R"[UU5--n[USS2SS2S4USUS- SS9USS2SS2S4'[USS2SS2S4USUS- SS9USS2SS2S4'U$)NirlrTrPrJ) rurrSkeysr1rWr rqr) r` temperaturermin_tempmax_temprt_leftt_rightcoeffsw_rightw_lefts riplanckian_jitterr^s ((*C#D)..01H#D)..01H''+:K D   $F  q D(G *4089'G,<=W"((#3D#9&#ABBWrxx T "7 +P F  ( Aq!G q F1IC1aL ( Aq!G q F1IC1aL Jrjc[XSS9$rr)r`rs ri add_noiser`s s5 ))rjc UR[:XaUS[R4nURSSupEXE-nUR [R 5[R"US-5- n[Xa- S-5n[R"US-XX5n [R"US-XH5n [R"U V V s/sHoHoU:dM X:dMX4PM M sn n 5n S[R"XE4[RS9-n[R"XE4[R5n[U5GHun[!U 5Hunn[US5[US 5p[S X- 5[#XKU-S-5nn[S X- 5[#X\U-S-5nnUUU2UU24nUX{U 4- n[R$"US-SS 9n[R&UU2UU24unnUU - S-UU - S--US-- nUUU--nUUUU2UU24:nUUUUU2UU24U'UUUU2UU24U'M [[)U 55HWnUU:Hn[R*"U5(dM%[R,"[R."U5S S 9SSS2U U'MY GMx U$s sn n f) aSimple Linear Iterative Clustering (SLIC) superpixel segmentation using OpenCV and NumPy. Args: image (np.ndarray): Input image (2D or 3D numpy array). n_segments (int): Approximate number of superpixels to generate. compactness (float): Balance between color proximity and space proximity. max_iterations (int): Maximum number of iterations for k-means. Returns: np.ndarray: Segmentation mask where each superpixel has a unique label. .NrJư>rrmrMrlrr)rsr$rWrrpr[rr1rorXrqonesr!fullinfrnrrrrjrrrrDargwhere)rrrmax_iterationsr5r6 num_pixelsimage_normalized grid_stepx_rangey_rangerJrIcenterslabels distancesrrxr;y_lowy_highx_lowx_highcrop color_diffcolor_distanceyyxxspatial_distancedistancers rirrs" zz,,c2::o&KKOMFJ||BJJ/"&&2FFZ,45Iii Q9Gii Q:Ghh NA'QY1:!'NG "''6/: :F0I > ""7+IAvvay>3vay>q 1=13v9}q?P3Q6E1=13u)ma>O3P6E$E&L%,$>?D 0A 66JVVJM;NXXeFlE&L89FB!#aA aA =)Q,O % 6F(FFHif eFl(BCCD:B4.IeFlE&L0 1$ 778F5<v- .t 4',,s7|$AQ;Dvvd||WWR[[%6Q?"E %/#8 MG OsK #K * K c [R"US5nX1S--U- n[URU5R [ R 5USS9n[[ R"USSUS9S5$) aApply shot noise to the image by simulating photon counting in linear light space. This function simulates photon shot noise, which occurs due to the quantum nature of light. The process: 1. Converts image to linear light space (removes gamma correction) 2. Scales pixel values to represent expected photon counts 3. Samples actual photon counts from Poisson distribution 4. Converts back to display space (reapplies gamma) The simulation is performed in linear light space because photon shot noise is a physical process that occurs before gamma correction is applied by cameras/displays. Args: img: Input image in range [0, 1]. Can be single or multi-channel. scale: Reciprocal of the number of photons (noise intensity). - Larger values = fewer photons = more noise - Smaller values = more photons = less noise For example: - scale = 0.1 simulates ~100 photons per unit intensity - scale = 10.0 simulates ~0.1 photons per unit intensity random_generator: NumPy random generator for Poisson sampling Returns: Image with shot noise applied, same shape and range [0, 1] as input. The noise characteristics will follow Poisson statistics in linear space: - Variance equals mean in linear space - More noise in brighter regions (but less relative noise) - Less noise in darker regions (but more relative noise) Note: - Uses gamma value of 2.2 for linear/display space conversion - Adds small constant (1e-6) to avoid issues with zero values - Clips final values to [0, 1] range - Operates on the image in-place for memory efficiency - Preserves float32 precision throughout calculations References: - https://en.wikipedia.org/wiki/Shot_noise - https://en.wikipedia.org/wiki/Gamma_correction g@rbTrPrrlrg]tE?) rRpowrrr[rWrrr )r`rr img_linear scaled_img noisy_imgs ri shot_noisersu`c"Jt|+u4J%  ,33BJJ? I Aqi8' BBrjcUS:a,[R"USU5n[XU- U- 5nXC4$[X5n[X*U- 5nXC4$)a{Calculate safe alpha and beta values to prevent overflow/underflow. For any pixel value x, we want: 0 <= alpha * x + beta <= max_value Args: alpha: Contrast factor (1 means no change) beta: Brightness offset max_value: Maximum allowed value (255 for uint8, 1 for float32) Returns: tuple[float, float]: Safe (alpha, beta) values that prevent overflow/underflow r)rWr rr1)rKbetar safe_beta safe_alphas ri#get_safe_brightness_contrast_paramsrHsd" qyGGD!Y/ Y!6) CD    (  Y 67   rjc.Uc#[R"U[RS9$URSS5n[R "U5 US:Xa[ UUUUU5$US:Xa$US:Xa[UUUUU5$[UUUUU5$USSup[S[X-55n [S[X-55n X4USS-n US:Xa[UU UUU5n O[UU UUU5n [R"XU 4[RS 9$) NrMrirrsharedrJrlr)rWrrr2rR setRNGSeedgenerate_constant_noisegenerate_shared_noisegenerate_per_pixel_noiser1rorr INTER_LINEAR) noise_type spatial_moderprr approximationrcv2_seedr5r6reduced_height reduced_width reduced_shapers rigenerate_noiserisV~xxRZZ00?((E2HNN8z!&         8 #(  (        "1IMFC 678N3u456M#3eABi?Mx%       )          UUO3CSCS TTrjcV[U5[:aUSOSn[UU4UUU5$)zGenerate one value per channel.rmrl)rrr$ sample_noise)rrprrrrs rirrs9!$E -D D59!L    rjc[XX#U5$)z-Generate separate noise map for each channel.)r)rrprrrs rirrs  6>N OOrjcUS:Xa[XU5U-$US:Xa[XU5U-$US:Xa[XU5U-$US:Xa[XU5U-$[ SU35e)z(Sample from specific noise distribution.uniformgaussianlaplacerzUnknown noise type: )sample_uniformsample_gaussiansample_laplace sample_betar)rrrrrs rirrsYd,<= IIZt-=>JJYd,<= IIV4)9:YFF +J<8 99rjc h[U5S:XaUSnUSn[U5S:XaX4-nO)[U5U:a[SUS[U535e[R"USUVVs/sHupVUR XV5PM snn5$USSupVUR XVUS9$s snnf)aSample from uniform distribution. Args: size: Output shape. If length is 1, generates constant noise per channel. params: Must contain 'ranges' key with list of (min, max) tuples. If only one range is provided, it will be used for all channels. random_generator: NumPy random generator instance Returns: Noise array of specified size. For single-channel constant mode, returns scalar instead of array with shape (1,). rlrangesrz%Not enough ranges provided. Expected z, got Nr)rrrrWrqr)rrrrrlowhighs rirrs" 4yA~!Aw v;! *F [< '7 ~VCPVK=Y xxBH,BW XBWYS  % %c 0BW X  x #IC  # #CD # 99 Ys/B. cUSSUSS:XaUSSOUR"US6nUSSUSS:XaUSSOUR"US6n[U5[:aUSOSnU[R"U4[R S9-nU[R"U4[R S9-n[R "US9n[R"XUS9 UR[R 5$) z"Sample from Gaussian distribution. mean_rangerrl std_rangerJ)rprN)rp)rrDr) rrrr$rWrcrrrRrandnr[) rrrrDrr mean_vectorstd_dev_vectorgaussian_sampled_arrs rirr s ,  "f\&:1&= = |Q  % %vl'; <  + q !VK%8%; ; {A  % %vk': ; "$i*AA47qL bjjIIK277, KKN88$/II&P  & &rzz 22rjcjUR"US6nUR"US6nURX4US9$)zSample from Laplace distribution. The Laplace distribution is also known as the double exponential distribution. It has heavier tails than the Gaussian distribution. r scale_range)rrr)rr)rrrrrs rirr sD  " "F<$8 9C  $ $f]&; Apply salt and pepper noise to image using pre-computed masks.rrr)rsrrNrWr )r` salt_mask pepper_maskrs riapply_salt_and_pepperrx sO xx1}i( !), #CII.I 88I"((;3*G HHrj)?rr)rrrrM)rrrrrc ~^S U4Sjjn[U5nS[R"[R"US- 55-S-n[ [R"US- 5S- 5n[R "[ U5Vs/sHoqU-PM sn5nTRSSS5R[R 5n UH n U"X5n M [R"[R"U SUS2SUS24SSS[R[RS9SS5$s snf) z3Generate Plasma Fractal with consistent brightness.c >URSS- S-S-nURSS- S-S-n[R"X#4[RS9nT R U*XU45R [R5nXSSS2SSS24-USSS2SSS24'[ R"US[[ RS9nUS:nXFU-U-- n[ R"US[[ RS9nUS:n XHU-U -- n[ R"USSS[ R[ RS9$)NrrlrJrMrm) borderType)rprWrrrr[rRrDIAMOND_KERNELBORDER_CONSTANT SQUARE_KERNEL normalize NORM_MINMAXCV_32F) current_grid noise_scale next_height next_width expanded_grid all_noisediamond_interpolation diamond_masksquare_interpolation square_maskrs rione_diamond_square_step8generate_plasma_pattern..one_diamond_square_step sK#))!,q0A59 "((+a/14q8 +!:"**M %,,k\;V`Habiijljtjtu #/3Q3!81D"D cc3Q3h!$ ]B[^[n[n o,q0 );|KK  #||M2}Y\YlYlm*Q. :kII }}]D!QszzZZrjrJrlrmrNrrM)rrrfloatrr)r1rWceillog2rorrnrr[r rRrrr) target_shape roughnessrr max_dimensionpower_of_two_size total_stepsrx noise_scales plasma_gridrs ` rigenerate_plasma_patternr s[6 %MRWWRWW]Q->%?@@1Dbgg/!34q89K::U;5GH5G!|5GHIL#**2q&9@@LK$ -kG $ 77 k"3LO"35F|A5F"FGqRSUXUdUdlolvlvw   Is D:cUS:XaUS:XaU$UR5nUR[:a:[R"US[R 4SSUR S45nUS:wa[X1SS9n[XSS9nUS:wa9UR5n[X2SS9S-n[XSS9nUSU- -n[XSS9$U$) z7Apply plasma-based brightness and contrast adjustments.r.rlrmFrPTr) rursr$rWtilerrprr rD)r`brightness_factorcontrast_factorplasma_patternbrightness_adjustmentrDcontrast_weights mean_factors ri apply_plasma_brightness_contrastr sA/Q"6 ((*C xx))RZZ!@1aSUBWXA (TY Z#d;!xxz#NUSVWWsd;c$445 3T22 JrjclX!-nUR[:aUS[R4nUSU- -$)zApply plasma-based shadow effect by darkening. Args: img: Input image intensity: Shadow intensity in [0, 1] plasma_pattern: Generated plasma pattern of shape (H, W) Returns: Image with applied shadow effect .rl)rsr$rWr)r`rrscaled_patterns riapply_plasma_shadowr s?"$/N xx))'RZZ8 !n$ %%rjc  US:XaR[R"SSU[RS9SSS24[R"US4[RS9-$US:XaR[R"SSU[RS9SSS24[R"US4[RS9-$US:XaR[R"SSU[RS9SS2S4[R"SU4[RS9-$US:XaR[R"SSU[RS9SS2S4[R"SU4[RS9-$US;GaU[R"SSU[RS9SSS24n[R"SSU[RS9SS2S4nUS :Xa7[R "X4-SSS[R [RS9$US :Xa;[R "SU- U-SSS[R [RS9$US :Xa>[R "SU- SU- -SSS[R [RS9$[R "USU- -SSS[R [RS9$[R"SSU[RS9SS2S4n[R"SSU[RS9SSS24n[R"U5n[R"U5n[R"U5n[R"X6US 9 [R"XGUS 9 X4-$) uCreate a directional gradient in [0, 1] range. Optimized implementation using broadcasting and fast paths for common angles: - 0°, 180°: horizontal gradients using single linspace - 90°, 270°: vertical gradients using single linspace - 45°, 135°, 225°, 315°: diagonal gradients using equal combinations of horizontal and vertical - Other angles: computed using trigonometric functions rrlrMNrOrbi)rarci;rarcrr) rWrrrcrRrrrdeg2radmathrfrhr)r5r6rnrIrJ angle_radcos_asin_as ricreate_directional_gradientr s z{{1abjj9$'BRWWfVW[`b`j`jEkkk |{{1abjj9$'BRWWfVW[`b`j`jEkkk {{{1arzz:1d7CbggqRWj`b`j`jFkkk |{{1arzz:1d7CbggqRWj`b`j`jFkkk ## KK1e2:: 6tQw ? KK1fBJJ 74 @ B;==aCOO3::V V C<==!a%1dAq#//QTQ[Q[\ \ C<==!a%AE!2D!QWZWaWab b}}Q!a%[$1cooSZZXX Aq& 3AtG!QPGD## [[&& GLL*6GDGGGQG$ xx//))WI ! 45 S **rjcUS:XaUR5$URSSupEXRS-nXBS-nS[XE5U-S--n[RSU2SU24upU R [R 5n U R [R 5n X-n X-n [R"XU S9 [R"XU S9 X-n [R"U SU- U S9 [R"XS9 [R"XU S9 [R"U SU S9 UR[:Xa'[R"U /URS-5n [X 5$)z#Apply gaussian illumination effect.rNrJrlrrm)rurpr1rWrjr[rrRrexpr rsr%r]r) r`rr;rr5r6center_xcenter_ysigma2rJrIs riapply_gaussian_illuminationr  sGA~xxzIIbqMMFay Hq !H #f$u,2 2F 88GVGVeVO $DA A AMAMALL1LL1 ALLBKQ'GGALL1%GGAqa xx// IIqcCIIaL( ) S $$rjc >UR5n[U5n[URnUR[ :a[ R"U5n/n[U5HgupUbX:XaURS5 M UcSOX:gn [ R"U /S/U S/SU/5n URU R55 Mi [U5Hn UbX:XaM UR[ :a WU n WU n O8UcSOX:gn [ R"U/S/U S/SU/5R5n Un [X5upX::aMx[XXU5nUbX/U'UR[ :a[X5USU 4'M[X5nM U$)aoApply auto contrast to the image. Args: img: Input image in uint8 or float32 format. cutoff: Percentage of pixels to cut off from the histogram edges. Range: 0-100. Default: 0 (no cutoff) ignore: Pixel value to ignore in auto contrast calculation. Useful for handling alpha channels or other special values. method: Method to use for contrast enhancement: - "cdf": Uses cumulative distribution function (original albumentations method) - "pil": Uses linear scaling like PIL.ImageOps.autocontrast Returns: Contrast-enhanced image in the same dtype as input. NrrL.)rurrrNrsr$rRrVrrrrrnget_histogram_boundscreate_contrast_lutr)r`cutoffignorerrLrrrphistsrxrrhistlohirys ri auto_contrastr s,XXZF#C(L#CII.I xx))99S>"$#H-JA!ak T"!>40AD<< A3sea^LD LL & .<   !+  88- -8DqkG!>4 D<<sD3%!YHNNPDG%d3 8 !$B6B   K 88- -#G1F36NG)F/!2 MrjcX:a#[R"S[RS9$US:XaXUS-nUR5nUSS:Xa#[R"S[RS9$XfS- U-USUS- - n[R"S[RS9n[R "[R "U5SU5R[R5XqUS-&X7US-S&U$X2U- - n[R"S[S9n [R "[R "X- U-5SU5R[R5nSUSU&X7US-S&U$)z,Create lookup table for contrast adjustment.rLrMcdfrlrmrN) rWrr\cumsumrXr rr[r) r min_intensity max_intensityrr hist_rangerryrindicess rir r  s_%xx288,, -!*;< ! r7a<99S1 1V|y(CGc!f,<=hhs"((+13#91U1\1\]_]e]e1fMA-.#,MA     6 7Eii5)G ''"((G3u<=q) L S STVT\T\ ]CC(  JrjcU(dE[R"U5Sn[U5S:Xag[US5[US54$[ UR 55nUS:XagX1-S- n[U5S:XaN[R "XS:H5(a.[[U5U-S- 5n[U5U- S- nXV4$SnSn[[U55HnXpU- nXt:dMUS-n O [U[U5S- 5nSn[U5S- n[[U5S- SS5HnXpU- nXt:dMUn O XV:a[U5S- S -n X4$XV4$) z.Find the low and high bounds of the histogram.rrrmgY@rLdrlrrJ) rWnonzerorrrorrallrnr) rr non_zero_intensities total_pixels pixels_to_cutrrrrx mid_points rir r > s !zz$/2 # $ )'*+S1Eb1I-JJJ$Lq )E1M 4yCBFF47?33CI.45 D M1A5 ++FM 3t9 q'  "EM    s4y1}5MFIMM 3t9q="b )q'  "M  *$Y]q( ##  ''rjcU(d[U5S:XaURSS/UUSU- /S9$URSS/USSUSU- /S9n[U5S:XaU$[R"USUSSS9$) a)Generate a boolean mask for pixel dropout. Args: shape: Shape of the input array per_channel: Whether to generate independent masks per channel dropout_prob: Probability of dropping a pixel random_generator: Random number generator Returns: Boolean mask matching input shape rJTFrl)pNrr)rrchoicerWrs)rp per_channel dropout_probrmask_2ds ri get_drop_maskr)m s"c%jAo&& 5M Q-.'  %% u  bq \) *&G 5zQ 99WY'q ::rjcU[R:Xa"URS[[U5UUS9$U[R :Xa UR SSUS9RU5$[SU35e)zGenerate random values for dropped pixels. Args: channels: Number of channels in the image dtype: Data type of the image random_generator: Random number generator Returns: Array of random values r)rrNrlrzUnsupported dtype: ) rWr\r2rorrrr[r)rprNrs rigenerate_random_valuesr+ s (( #E* + )    ''18'<CCEJJ *5'2 33rjcUc"[U5n[X0RU5nOq[U[[ 45(a)[ R"URXRS9$[ R"XRS9RS5nURS:Xa-[ R"URUSURS9$[ R"URSS[U54-X@RS9$)zPrepare values to fill dropped pixels. Args: array: Input array to determine shape and dtype value: User-specified drop values or None for random random_generator: Random number generator Returns: Array of values matching input shape NrMrmrJr) rr+rNrrorrWrdrprqrrsrr)rqrrrpvaluess riprepare_drop_valuesr. s }#E*'++?OP EC< ( (wwu{{E==%{{3;;B? zzQwwu{{F1IU[[AA 775;;r?c&k^3V;; OOrjc8SU;aUS$SU;aUSS$S$)z,Get mask array from input data if it exists.rrArNr)datas riget_mask_arrayr1 s- ~F|&$4= 8D8rjc[US-[RSS9nS[R"USS5- n[R "U[R S5n[R"USS[R5upC[R"USS S [RS 9n[U[RS S9n[U5n[R"/S Q/S Q/SQ/[RS9n[X55n[R"USSS[RS 9R[R5nUR[R5U-n[R "USS9nUS:a US U- -nO[R""U5nUSS2SS2S4U-US--nSU0$)z$Generate parameters for rain effect.rFrP2rOrrlrrrrT)rmr)rmrlrl)rrlrJrM)rOrOg?rrrNg?drops)r rWr\rRCannyrrrv THRESH_TRUNCrr/r9rqrr6r[r1r) liquid_layerr=rdistrkermm_maxr8s riget_rain_paramsr@ s  s*BHHeDL <S1 1D  s{{A 6DmmD"b#*:*:;GA    ''  D bhh -D D>D ((    jj  C D D    ''    fRZZ   BJJ'$.A FF16 "E qy QY MM!  aDjME !Y_ 5E  rjcURupgX:R[R5n[R"U5S:Xa^Xg-n [ S[ SU -55n URXSS9n [R"U[RS9nSURU 'US:a&[R"USUU[RS 9n[R "U5n U S:aX- nOSUS'X-n[R"XgS 4[RS9n [S 5HnXU-U S U4'M [R"U 5n[S 5HCnXS:a.[R "XU S U4- X- SS5US U4'M9SU- US U4'ME U R[R5UR[R5S .$) z5Generate mud effect parameters based on liquid layer.rrlr0F)replacerMrrr6r.)rr)rpr[rWrrr1ror%rflatrRrr/rrn ones_liker )r;r=cutout_thresholdrrrr5r6rrh num_needed flat_indicesmask_maxrrxrs riget_mud_paramsrI s!&&MF  + 3 3BJJ ?D vvd|q^ Cj 012 '..zu.U }}\<"% , qy ++  vvd|H!|T   D ((F1%RZZ 8C1X1XoCF ll3G 1X 8a< ggux#c1f+'=&I1aPGCFO!DjGCFO zz"**%>>"**- rjg&c`?g8?gH?gm?g?g҈}?)gX?g/' ?gH.?)gQkw?g3ı.n?g$?)g?reg(\?)gQ?r)\(?)皙?g)\(?rL)gQ?gQ?g\(\?)rgQ?g{Gz?)g{Gz?g(\?g ףp= ?)r rQ?)g(\?gffffff?r)g(\?rMrN)g ףp= ?g ףp= ?gzG?)g= ףp=?gQ?gRQ?)rg{Gz?gzG?)ruifrokmacenkostandard high_contrasth_heavye_heavydarklightc[URnURSS5R[R 5n[R "X2- U5n[R"U5*$)Nrmr)rrNrr[rWrmaximumlog)r`epsr pixel_matrixs rirgb_to_optical_densityr\ sT#CII.I;;r1%,,RZZ8L::l6E ?rjStainNormalizerc6US:Xa [5$[5$)z%Get stain normalizer based on method.vahadane)VahadaneNormalizerMacenkoNormalizer)rs riget_normalizerrf s#)Z#7  P=N=PPrjc,\rSrSrSrSSjrSSjrSrg) rai z!Base class for stain normalizers.cSUlgrstain_matrix_target)selfs ri__init__StainNormalizer.__init__ s #' rjc[e)z Extract stain matrix from image.)NotImplementedError)rkr`s rifitStainNormalizer.fit s!!rjriN)rNoner`rrrr)__name__ __module__ __qualname____firstlineno____doc__rlrp__static_attributes__rrjrirara s+("rjc,\rSrSrSSSjjrSSjrSrg) SimpleNMFi clXl[R"/SQ/SQ/[RS9Ulg)NrJrKrM)n_iterrWrqrinitial_colors)rkr}s rirlSimpleNMF.__init__ s,  hh.. **  rjcURR5n[U5n[R"XR -S5nSn[ UR5HnXR -nXBUR --nXGX-- -n[R"US5nUR U-nUR U-U-nX'X-- -n[R"US5n[U5nM XB4$)Nrrb)r~rur`rWrXrrnr}) rkoptical_density stain_colorsstain_colors_normalizedstain_concentrationsrZr numerator denominators rirSimpleNMF.fit_transform s**//1 #4L"A!zz/[TU]5 Xlgr)superrlangular_percentile)rkr __class__s rirlMacenkoNormalizer.__init__ s "4rjc [U5nSnX4:RSS9nX5n[U5S:a[SUS35e[R "U[R S9n[R"US[R[R-[R-5Sn[R"U5SSup[R"UR55S Sn [R "U SS2U 4[R S9n Xk-n [R"U SS2S4U SS2S45n [R "U S U- 5n[R "X5n[R""U5[R$"U5nn[R""U5[R$"U5nn[R&"UU/UU//[R S9n[R("UU R*SSS5n[R,"U5nU[R."[R0"US -SS S 95- nUSUS:aUUlgUSSS2Ulg)z:Extract H&E stain matrix using optimized Macenko's method.g?rlrz"No tissue pixels found (threshold=)rMNrr7rrJTr@r)rlrrm)r\rrrrrWrrrRcalcCovarMatrix COVAR_NORMAL COVAR_ROWS COVAR_SCALEeigenrrr percentilerfrhrqgemmrrrkrrj)rkr`rr od_thresholdthreshold_masktissue_density od_covariance eigenvalues eigenvectorsrprincipal_eigenvectorsplane_coordinates polar_angleshematoxylin_angle eosin_anglehem_coshem_sineos_coseos_sinangle_to_vector stain_vectorss rirpMacenkoNormalizer.fit sL15 )8==1=E(8 ~  "A,qQR R--nBJJO++     s~~ - ?   %(IIm$P8PQmmLE 66"34bff=N6O66+.{0C((w '7!3 4**   " $ $   }- &}a7GaZ^0_(`` 5B$4G-X\J]4]= cpqusuqucv rj)rrj)c)rr)r`rrrrrr) rtrurvrwrxrlrpry __classcell__)rs@rirere s?55@w@wrjrec`USS-USS--USS--nX!:nURS5$)a>Get binary mask of tissue regions based on luminosity. Args: img: RGB image in float32 format, range [0, 1] threshold: Luminosity threshold. Pixels with luminosity below this value are considered tissue. Range: 0 to 1. Default: 0.85 Returns: Binary mask where True indicates tissue regions rgA`"?rgbX9?rgv/?rm)r)r`rv luminosityrs riget_tissue_maskrK sGVu$s6{U'::S[5=PPJ  !D << rjc[U5n[R"U[RS9nSnXR-U[R "S5--nXR-n[R RXx5Rn U(d'[U5RS5n XU-U-X'OX-U-n X-n [R"U *5n U RUR5$![R Ra9 [R RURUUS9SRn Nf=f)NrMrbrJ)rcondrrm)r\rWrrrrrsolve LinAlgErrorlstsqrrrrp) r` stain_matrix scale_factors shift_valuesaugment_backgroundrregularizationstain_correlationdensity_projectionr tissue_maskoptical_density_result rgb_results riapply_he_stain_augmentationr_ sB-S1O'' BJJGLN$~~5PQ8RR%(9(99 !yy/@UWW %c*2226 ,@,MP],]`l,l) 4ClR2@//0J   cii ((+ 99 !yy NN   /   Q s()C<r3r<r?rrrrrrrGr INTER_AREArr8rBr;r/r0r2rr1rFrHrrrr4rr:r7r<rBrS__annotations__r^r`rrrrrrrrrrrrrrrqrrrINITIAL_GRID_SIZErrrrrrr rr r r)r+r.r1r@rISTAIN_MATRICESr\r`rfrar{rrdrerrrrjrirs0" $ 4GF P # L 'E 'E'E'E 'E  'E 'ET  D 4  4n4(*8 "  "  " " ""      #!% < < < < <  < <~ * * * * * *Z 5 5%55 5 -0 -0-0$-0 -0 -0`    9 9 9)9 9 9x A6 A6A6A6 A6 A6H&&)&#&. i iii i  i  i iX * * ** * % *  *"*** *Zaaaa* a  a0 +0 +0+0+02 +0 % +0  +0  +0\ [ [%[[ [  [  [ [| u> u>!u>u>$ u>  u>  u>  u>p * *#** * *Z 6  60   -5 -5-5-5* -5  -5  -5`1, 8  8B M M&3B  F &Y &YRB BB BB@ !77778"nn,, R R RR R  RR6 F/  F/R00 I I  `  `  `  ` `  `0 0 =k =k=k$=k =k  =k  =k =k@ ! ! ! !  !  !  !  !H3 333 33$ )  ) 2  2 -C -C!-C$-C# -C % -C  -C-C  -C` "      20011 <  <  <. < <H     . !     ' ' ' '  '  '  ' ' ' ' ' ' ' ' ( (!" (#$)(((((((36  '  '  '  '   '   '   '  '  '  '  '  '  (  (  (  (! " (# $)(((((/ 95735p - -- '- - -` * * B BBB B  BJ ;C ;C ;C*;C ;C ;C|! ! !! !BCUACU<CU CU " CU  CU  CU*CUCULA    *   $PAP P P P * P  P:A: : : : * :  :(": ": ":*": ":J3 3 3*3 32 E  E  E* E E% % %*% %&!A! ! ! ! * !  !H ) ) ))  )  ) )$ I  I I I I  **  **  2!22*2 2j             F & &&& & &4.b 7, 7,t %+ %+%+ %+ %+ %+P )% )%)% )%  )%  )% )%X > > > > " >  > >B$ $$$ $ " $  $N,(^$; $;$;$;* $;  $;N44 4*4 48P P 6P*P P>9?? ?? ?D<< <<  <  < * <<Bxx * *  xx $ $      XX    xx    xx    HH     XX   W1h!! Q "")2)2X&6  $GwGwT(  *) *)*)*) *)  *)  *)  *)rj