# 3jbSSKJr SSKrSSKrSSKrSSKrSSKJ r Sr Sr Sr Sr SSjrS rSS jrSS jrS S jrS rS!SjrSrS"SjrSrSrSrSrS#SjrS$SjrSrSrS%SjrSr Sr!Sr"g)&)ImageNwrapsc0^[T5U4Sj5nU$)aDCreates a new function which operates on each channel Parameters ---------- single_channel_func: function Function that acts on a single color channel Returns ------- channel_func: function The same function that operates on all color channels Example ------- >>> from pymatting import * >>> import numpy as np >>> from scipy.signal import convolve2d >>> single_channel_fun = lambda x: convolve2d(x, np.ones((3, 3)), 'valid') >>> multi_channel_fun = apply_to_channels(single_channel_fun) >>> I = np.random.rand(480, 320, 3) >>> multi_channel_fun(I).shape (478, 318, 3) c >[UR5S:Xa T"U/UQ70UD6$URnURUSUSS5n[R"[ URS5Vs/sH'nT"USS2SS2U4R 5/UQ70UD6PM) snSS9nUR[URSS5[USS5-5$s snf)Nraxis)lenshapereshapenpstackrangecopylist)imageargskwargsrcresultsingle_channel_funcs M/home/wildlama/miniconda3/lib/python3.13/site-packages/pymatting/util/util.pymulti_channel_func-apply_to_channels..multi_channel_func"s u{{ q &u>t>v> >KKEMM%(E!Hb9EXX#5;;q>22(aAg(;(;(=OOO2 F>>$v||BQ'7"84ab ?"JK Ks6.C r)rrs` rapply_to_channelsr s'2 L L" c0[R"SX5$)aComputes the dot product of two vectors. Parameters ---------- a: numpy.ndarray First vector (if np.ndim(a) > 1 the function calculates the product for the two last axes) b: numpy.ndarray Second vector (if np.ndim(b) > 1 the function calculates the product for the two last axes) Returns ------- product: scalar Dot product of `a` and `b` Example ------- >>> import numpy as np >>> from pymatting import * >>> a = np.ones(2) >>> b = np.ones(2) >>> vec_vec_dot(a,b) 2.0 z...i,...i->...reinsumabs r vec_vec_dotr&7s0 99%q ,,rc0[R"SX5$)aCalculates the matrix vector product for two arrays. Parameters ---------- A: numpy.ndarray Matrix (if np.ndim(A) > 2 the function calculates the product for the two last axes) b: numpy.ndarray Vector (if np.ndim(b) > 1 the function calculates the product for the two last axes) Returns ------- product: numpy.ndarray Matrix vector product of both arrays Example ------- >>> import numpy as np >>> from pymatting import * >>> A = np.eye(2) >>> b = np.ones(2) >>> mat_vec_dot(A,b) array([1., 1.]) z...ij,...j->...ir!)Ar%s r mat_vec_dotr)Rs0 99' ..rc0[R"SX5$)aComputes the outer product of two vectors a: numpy.ndarray First vector (if np.ndim(b) > 1 the function calculates the product for the two last axes) b: numpy.ndarray Second vector (if np.ndim(b) > 1 the function calculates the product for the two last axes) Returns ------- product: numpy.ndarray Outer product of `a` and `b` as numpy.ndarray Example ------- >>> import numpy as np >>> from pymatting import * >>> a = np.arange(1,3) >>> b = np.arange(1,3) >>> vec_vec_outer(a,b) array([[1, 2], [2, 4]]) z ...i,...jr!r#s r vec_vec_outerr+ms. 99[! ''rcUS:dUS:a [S5eUS:dUS:a [S5eX:a [S5eX:nX:nS[R"U5-nSXT'SXS'U$)aFixes broken trimap :math:`T` by thresholding the values .. math:: T^{\text{fixed}}_{ij}= \begin{cases} 0,&\text{if } T_{ij}<\text{lower\_threshold}\\ 1,&\text{if }T_{ij}>\text{upper\_threshold}\\ 0.5, &\text{otherwise}.\\ \end{cases} Parameters ---------- trimap: numpy.ndarray Possibly broken trimap lower_threshold: float Threshold used to determine background pixels, defaults to 0.1 upper_threshold: float Threshold used to determine foreground pixels, defaults to 0.9 Returns ------- fixed_trimap: numpy.ndarray Trimap having values in :math:`\{0, 0.5, 1\}` Example ------- >>> from pymatting import * >>> import numpy as np >>> trimap = np.array([0,0.1, 0.4, 0.9, 1]) >>> fix_trimap(trimap, 0.2, 0.8) array([0. , 0. , 0.5, 1. , 1. ]) rr zInvalid lower thresholdzInvalid upper thresholdz4Lower threshold must be smaller than upper thresholdg?) ValueErrorr ones_like)trimaplower_thresholdupper_thresholdis_bgis_fgfixeds r fix_trimapr5sDo1233o1233(OPP  $E  $E ",,v& &EELEL Lrc<[U5 g![a gf=f)aChecks if an object is iterable Parameters ---------- obj: object Object to check Returns ------- is_iterable: bool Boolean variable indicating whether the object is iterable Example ------- >>> from pymatting import * >>> l = [] >>> isiterable(l) True TF)iter TypeError)objs r isiterabler:s#( S  s  c[R[R[R[R[R [R [R S.n[U5(d0[URU-5[URU-54nURXUR55nU$)N)bicubicbilinearboxhamminglanczosnearestnone) rBICUBICBILINEARBOXHAMMINGLANCZOSNEARESTr:intwidthheightresizelower)rsizeresamplefilterss r_resize_pil_imagerQs==NNyy====== G d  EKK$&'U\\D-@)AB LLx~~'78 9E Lrc[R"U5nUb+UR5nUS:XaSOUnURU5nUb [ XBU5n[ R "U5S- nU$)zThis function can be used to load an image from a file. Parameters ---------- path: str Path of image to load. mode: str Can be "GRAY", "RGB" or something else (see PIL.convert()) Returns ------- image: numpy.ndarray Loaded image GRAYLgo@)ropenupperconvertrQrarray)pathmoderNrOrs r load_imager[sg JJt E zz|fns$ d# !%x8 HHUOe #E Lrc0UR[R[R[R4;deUR[R[R4;a8[R "US-SS5R [R5nU(aE[RRU5up4[U5S:a[R"USS9 [R"U5RU5 g)axGiven a path, save an image there. Parameters ---------- path: str Where to save the image. image: numpy.ndarray, dtype in [np.uint8, np.float32, np.float64] Image to save. Images of float dtypes should be in range [0, 1]. Images of uint8 dtype should be in range [0, 255] make_directory: bool Whether to create the directories needed for the image path. rT)exist_okN)dtyperuint8float32float64clipastypeosrYsplitr makedirsr fromarraysave)rYrmake_directory directory_s r save_imagerms ;;288RZZ< << < {{rzz2::.. Q,33BHH=ww}}T* y>A  KK D 1 OOE%rc[UR5S;deUR[R[R [R 4;deUR[R [R 4;a8[R"US-SS5R[R5n[UR5S:Xa[R"U/S-SS9$URSS:Xa[R"U/S-SS9$URSS:XaU$URSS:XaUS S 2S S 2S S24$[S UR5e) aConvertes an image to rgb8 color space Parameters ---------- image: numpy.ndarray Image to convert Returns ------- image: numpy.ndarray Converted image with same height and width as input image but with three color channels Example ------- >>> from pymatting import * >>> import numpy as np >>> I = np.eye(2) >>> to_rgb8(I) array([[[255, 255, 255], [ 0, 0, 0]], [[ 0, 0, 0], [255, 255, 255]]], dtype=uint8) )rr]rrror r NzInvalid image shape:) r rr_rr`rarbrcrdr concatenater-)rs rto_rgb8rr"s. u{{ v %% % ;;288RZZ< << < {{rzz2::.. Q,33BHH= 5;;1xx! !,, {{1~~~ugk22 Q1  Q1 Q2A2X +U[[ 99rc UH8nUcMUR[R[R4;aM8e [ U5nUS:XagUcAUc>[ [R "[R"U555nXQ-S- U-nOUc XQ-S- U-nO Uc XR-S- U-nUVs/sHoDcMURPM nn[SU55n[SU55n[UV s/sHn [ U 5S:dMU SPM sn SS9n U S:a[U5HupUcM [ UR5S:XaUSS2SS2[R4nURSS:Xa[R"U/U -SS9nURSS :Xa<U S :Xa6[U[R"URSSURS 95nX@U 'M Uc[S U55n[R "Xr-X-U 4US 9n [#U5Hn [#U5HnXU--n U [ U5:a M*X nUcM%UR%URSURSS 5nUU X-X-URS-2X-X-URS-24'M M U RSS:Xa U SS2SS2S4n U $s snfs sn f)aPlots a grid of images. Parameters ---------- images : list of numpy.ndarray List of images to plot nx: int Number of rows ny: int Number of columns dtype: type Data type of output array Returns ------- grid: numpy.ndarray Grid of images with datatype `dtype` Nrr c3*# UH oSv M g7f)rN.0rs r make_grid..v )&!H&c3*# UH oSv M g7f)r Nrurvs rrxrywrzr{r)defaultr rorpr_c3B# UHocMURv M g7f)Nr~)rwrs rrxrysJfU[U[[fsr )r_rrarbr rIceilsqrtrmax enumeratenewaxisrq stack_imagesonesnextzerosrr)imagesnxnyr_rnshapeshwrdiryxs r make_gridrNs&  ;;2::rzz":: :: F AAv zbj $ %fqjR  fqjR  fqjR '- CvekekkvF C )& ))A )& ))A 6 <6%SZ!^XU1X6 Q&NNE7Q;Q?E;;q>Q&16(rwwu{{2AekkJE"q * }JfJJ XXqvqvq) 7F 2YrAF ACKIE  ekk!nekk!nbIEAEEKKN22AEAEEKKPQNK,=K1 K1c[U5n[R"US-SS5R[R5n[ R "U5nUR5 g)zPlot grid of images. Parameters ---------- images : list of numpy.ndarray List of images to plot height : int, matrix Height in pixels the output grid, defaults to 512 r]rN)rrrcrdr`rrhshow)rgrids r show_imagesrsJ V D 774#:q# & - -bhh 7D ??4 DIIKrc6U(aUR5nUR5nUR5nUS:a[R"SU-SS9 US:a[R"SU-SS9 UR [ R[ R4;a"[R"SUR -SS9 X:nX:*nUR5S:Xa[S U-5eUR5S:Xa[S U-5eXg-nU)n XgX4$) a~This function splits the trimap into foreground pixels, background pixels, and unknown pixels. Foreground pixels are pixels where the trimap has values larger than or equal to `fg_threshold` (default: 0.9). Background pixels are pixels where the trimap has values smaller than or equal to `bg_threshold` (default: 0.1). Pixels with other values are assumed to be unknown. Parameters ---------- trimap: numpy.ndarray Trimap with shape :math:`h \times w` flatten: bool If true np.flatten is called on the trimap Returns ------- is_fg: numpy.ndarray Boolean array indicating which pixel belongs to the foreground is_bg: numpy.ndarray Boolean array indicating which pixel belongs to the background is_known: numpy.ndarray Boolean array indicating which pixel is known is_unknown: numpy.ndarray Boolean array indicating which pixel is unknown bg_threshold: float Pixels with smaller trimap values will be considered background. fg_threshold: float Pixels with larger trimap values will be considered foreground. Example ------- >>> import numpy as np >>> from pymatting import * >>> trimap = np.array([[1,0],[0.5,0.2]]) >>> is_fg, is_bg, is_known, is_unknown = trimap_split(trimap) >>> is_fg array([ True, False, False, False]) >>> is_bg array([False, True, False, False]) >>> is_known array([ True, True, False, False]) >>> is_unknown array([False, False, True, True]) z:Trimap values should be in [0, 1], but trimap.min() is %s.ro stacklevel?z:Trimap values should be in [0, 1], but trimap.max() is %s.zfUnexpected trimap.dtype %s. Are you sure that you do not want to use np.float32 or np.float64 instead?rz7Trimap did not contain background values (values <= %f)z7Trimap did not contain foreground values (values >= %f)) flattenminrwarningswarnr_rrarbsumr-) r/r bg_threshold fg_threshold min_value max_valuer3r2is_known is_unknowns r trimap_splitrsZ! I I3 H9 T 3 H9 T ||BJJ 33 tll   "E  "E yy{a E T   yy{a E T  }HJ  --rc [UR5S:wdURSS:wa+[R"S[ UR5-SS9 UR 5nUR 5nUS:a[R"SU-SS9 US:a[R"SU-SS9 UR[R[R4;a#[R"S UR-SS9 g g ) aGPerforms a sanity check for input images. Image values should be in the range [0, 1], the `dtype` should be `np.float32` or `np.float64` and the image shape should be `(?, ?, 3)`. Parameters ---------- image: numpy.ndarray Image with shape :math:`h \times w \times 3` Example ------- >>> import numpy as np >>> from pymatting import check_image >>> image = (np.random.randn(64, 64, 2) * 255).astype(np.int32) >>> sanity_check_image(image) __main__:1: UserWarning: Expected RGB image of shape (?, ?, 3), but image.shape is (64, 64, 2). __main__:1: UserWarning: Image values should be in [0, 1], but image.min() is -933. __main__:1: UserWarning: Image values should be in [0, 1], but image.max() is 999. __main__:1: UserWarning: Unexpected image.dtype int32. Are you sure that you do not want to use np.float32 or np.float64 instead? rorz=Expected RGB image of shape (?, ?, 3), but image.shape is %s.rrz8Image values should be in [0, 1], but image.min() is %s.rz8Image values should be in [0, 1], but image.max() is %s.zeUnexpected image.dtype %s. Are you sure that you do not want to use np.float32 or np.float64 instead?N) r rrrstrrrr_rrarb)rrrs rsanity_check_imagers. 5;;1 A! 3 K%++   I I3 F R 3 F R  {{2::rzz22 skk  3rc[UR5S:XaUSS2SS2[R4nX -SU- U--$)aThis function composes a new image for given foreground image, background image and alpha matte. This is done by applying the composition equation .. math:: I = \alpha F + (1-\alpha)B. Parameters ---------- foreground: numpy.ndarray Foreground image background: numpy.ndarray Background image alpha: numpy.ndarray Alpha matte Returns ------- image: numpy.ndarray Composed image as numpy.ndarray Example ------- >>> from pymatting import * >>> foreground = load_image("data/lemur/lemur_foreground.png", "RGB") >>> background = load_image("data/lemur/beach.png", "RGB") >>> alpha = load_image("data/lemur/lemur_alpha.png", "GRAY") >>> I = blend(foreground, background, alpha) rNr )r rrr) foreground backgroundalphas rblendrEsA< 5;;1aBJJ&'  Uj 8 88rcUVs/sH8n[UR5S:XaUOUSS2SS2[R4PM: nn[R"USS9$s snf)aThis function stacks images along the third axis. This is useful for combining e.g. rgb color channels or color and alpha channels. Parameters ---------- *images: numpy.ndarray Images to be stacked. Returns ------- image: numpy.ndarray Stacked images as numpy.ndarray Example ------- >>> from pymatting.util.util import stack_images >>> import numpy as np >>> I = stack_images(np.random.rand(4,5,3), np.random.rand(4,5,3)) >>> I.shape (4, 5, 6) roNrr )r rrrrq)rrs rrrisa0Eekk"a'U1a3C-D D  >>&q )) s?AcUR[R"URSUR55nU$)aCalculate the sum of each row of a matrix Parameters ---------- A: np.ndarray or scipy.sparse.spmatrix Matrix to sum rows of Returns ------- row_sums: np.ndarray Vector of summed rows Example ------- >>> from pymatting import * >>> import numpy as np >>> A = np.random.rand(2,2) >>> A array([[0.62750946, 0.12917617], [0.8599449 , 0.5777254 ]]) >>> row_sum(A) array([0.75668563, 1.4376703 ]) r )dotrrrr_)r(row_sumss rrow_sumrs.0uuRWWQWWQZ12H Orc[U5nSX"U:'SU- n[RRU5nUR U5nU$)aNormalize the rows of a matrix Rows with sum below threshold are left as-is. Parameters ---------- A: scipy.sparse.spmatrix Matrix to normalize threshold: float Threshold to avoid division by zero Returns ------- A: scipy.sparse.spmatrix Matrix with normalized rows Example ------- >>> from pymatting import * >>> import numpy as np >>> A = np.arange(4).reshape(2,2) >>> normalize_rows(A) array([[0. , 1. ], [0.4, 0.6]]) r)rscipysparsediagsr)r( thresholdrrow_normalization_factorsDs rnormalize_rowsrsM4qzH&)H !" #h 45A aA HrcPU(aY[R"[R"U5U5n[R"[R"U5U5nX44$[R"U5n[R"U5n[R"X45up4X44$)a Calculates image pixel coordinates for an image with a specified shape Parameters ---------- width: int Width of the input image height: int Height of the input image flatten: bool Whether the array containing the coordinates should be flattened or not, defaults to False Returns ------- x: numpy.ndarray x coordinates y: numpy.ndarray y coordinates Example ------- >>> from pymatting import * >>> x, y = grid_coordinates(2,2) >>> x array([[0, 1], [0, 1]]) >>> y array([[0, 0], [1, 1]]) )rtilearangerepeatmeshgrid)rJrKrrrs rgrid_coordinatesrsw< GGBIIe$f - IIbii' / 4K IIe  IIf {{1  4Krc[R"U5R5n[U5nX-n[R"Xv-[R S9n[R"Xv-[R S9n [R"Xv-[R S9n Sn [XSS9up[X4U5Haupn[R"X-SUS- 5n[R"X-SUS- 5nXU--XX-&UUU--XX-&UXX-&X- n Mc [RRXU 44Xw4S9nU$)ajCalculates a convolution matrix that can be applied to a vectorized image Additionally, this function allows to specify which pixels should be used for the convoltion, i.e. .. math:: \left(I * K\right)_{ij} = \sum_k K_k I_{i+{\Delta_y}_k,j+{\Delta_y}_k}, where :math:`K` is the flattened convolution kernel. Parameters ---------- width: int Width of the input image height: int Height of the input image kernel: numpy.ndarray Convolutional kernel dx: numpy.ndarray Offset in x direction dy: nunpy.ndarray Offset in y direction Returns ------- M: scipy.sparse.csr_matrix Convolution matrix r~rTrr )r) rasarrayrr rint32rbrziprcrr csr_matrix)rJrKkerneldxdyweightscountri_indsj_indsvalueskrrdx2dy2weightx2y2r(s rsparse_conv_matrix_with_offsetsrs)6jj ((*G LE A XXairxx 0F XXairxx 0F XXairzz 2F A E4 8DA0& WWQWa + WWQWa! ,E M15eO15"15  1  &)9 :1&IA HrclURup4[XCSS9upVXTS--nXcS--n[XX%U5$)aCalculates a convolution matrix that can be applied to a vectorized image Parameters ---------- width: int Width of the input image height: int Height of the input image kernel: numpy.ndarray Convolutional kernel Returns ------- M: scipy.sparse.csr_matrix Convolution matrix Example ------- >>> from pymatting import * >>> import numpy as np >>> sparse_conv_matrix(3,3,np.ones((3,3))) <9x9 sparse matrix of type '' with 49 stored elements in Compressed Sparse Row format> Trr)rrr)rJrKrkhkwrrs rsparse_conv_matrixr'sB2\\FB BD 1DAqLAqLA *5&Q GGrcU(a [U5nU[U5-n[RR U5nX@- nU$)a~Calculates the random walk normalized Laplacian matrix from the weight matrix Parameters ---------- W: numpy.ndarray Array of weights normalize: bool Whether the rows of W should be normalized to 1, defaults to True regularization: float Regularization strength, defaults to 0, i.e. no regularizaion Returns ------- L: scipy.sparse.spmatrix Laplacian matrix Example ------- >>> from pymatting import * >>> import numpy as np >>> weights_to_laplacian(np.ones((4,4))) matrix([[ 0.75, -0.25, -0.25, -0.25], [-0.25, 0.75, -0.25, -0.25], [-0.25, -0.25, 0.75, -0.25], [-0.25, -0.25, -0.25, 0.75]]) )rrrrr)W normalizeregularizationrrrTs rweights_to_laplacianrHs?6 1 #A 1A A Hrc[R"U5nUR5nUR5nX- X!- - $)aDNormalizes an array such that all values are between 0 and 1 Parameters ---------- values: numpy.ndarray Array to normalize Returns ------- result: numpy.ndarray Normalized array Example ------- >>> from pymatting import * >>> import numpy as np >>> normalize(np.array([0, 1, 3, 10])) array([0. , 0.1, 0.3, 1. ]) )rrrr)rr$r%s rrrns7(ZZ F A A J15 !!rcX-S- U-$)zDivides a number x by another integer n and rounds up the result Parameters ---------- x: int Numerator n: int Denominator Returns ------- result: int Result Example ------- >>> from pymatting import * >>> div_round_up(3,2) 2 r ru)rrs r div_round_uprs* EAI! rcX- n[R"X- U-SS9[R"[R"U55- n[R"USS5nUSS2SS2S4n[R"USU- U-- U[R "U5US:gS9n[R"USS5n[R "Xu/5nU$)a]Remove background from image with at most two colors. Might not work if image has more than two colors. Parameters ---------- image: numpy.ndarray RGB input image fg_color: numpy.ndarray RGB Foreground color bg_color: numpy.ndarray RGB Background color Returns ------- output: numpy.ndarray RGBA output image Example ------- >>> from pymatting import * >>> import numpy as np >>> image = np.random.rand(480, 320, 3) >>> fg_color = np.random.rand(3) >>> bg_color = np.random.rand(3) >>> output = remove_background_bicolor(image, fg_color, bg_color) >>> print(output.shape) (480, 320, 4) r r rrNr )outwhere)rrsquarercdivide zeros_likedstack) rfg_colorbg_colorfg_bgurr$ actual_coloroutputs rremove_background_bicolorrs<  E  E)3bffRYYu=M6NNA GGAsC E aDjA99 !a%8# #aR]]5-AcL77<c2L YY , -F Mr)皙??)r<)NNr>)T)NNN)Trr)r)F)Tr)#PILrnumpyr scipy.sparserrer functoolsrrr&r)r+r5r:rQr[rmrrrrrrrrrrrrrrrrrrurrrs +\-6/6(40f6&>&6):XTn$V.r2 j!9H*::% P'T/ dHB# L"401r