Dh 6ddlZddlZddlZddlmZmZmZmZmZmZm Z m Z m Z m Z dZ dZdZdZdZdZd Zd d d d d ddddddd Zedej-DZddddddddddd ZdZGd d!eZGd"d#ej8e$Zd#gZy)%N) ffiglib_libvips_libError _to_bytes _to_string_to_string_copyGValueat_least_libvips Introspectct|tjxs-t|txrt|tj  SN) isinstancenumbersNumberlistpyvipsImage)values o/var/www/fastuser/data/www/generator.snapmosaic.io/flask_app/venv/lib/python3.12/site-packages/pyvips/vimage.py _is_pixelr s< ugnn - - t $, ufll +*,.ct|tsy|D]0}t|tsyt|t|dk7s0yy)NFrT)rrlen)arrayxs r_is_2DrsG eT " !T" q6Sq] "  rc\t|trtt||S||Sr)rrmap)funcrs r_smapr!#s&!TCaL!!Awrct|r%tjj|dz|||Stjj||||S)N_const)rr Operationcall)imageotherbase operations r _call_enumr**sH$$TH_eYNN$$T5%CCrc|j}|jdk7r|jdk7r|jdzdk7r td|jdk7r |jdk7r|jd}|jdk(rd}nd}|j ||jdz }||}|dk7r9|dk7r4|jdk(rd}nd}|j ||jdz}|S) zRun a complex function on a non-complex image. The image needs to be complex, or have an even number of bands. The input can be int, the output is always float or double. complex dpcomplexrznot an even number of bandsfloatdouble)formatbands)r1r2rcastcopy)fnr&original_format new_formats r _run_cmplxr81s llO ||y U\\[%@ ;;?a 56 6 <<7 "u||x'?JJw'E <<8 #$J"J *EKK!O D uIE)#;(F <<; &!J J *EKK!O D Lrct tjj|fd}|S#t$rdYwxYw)Nc|_|Sr)__doc__)r docstrings r_docz_add_doc.._doc[s   r)rr$generate_docstringr)namer=r<s @r_add_docr@Us@$$77=  K  s ) 77cfd}|S)Nc|_|Sr)__deprecated__)r notes r_depz_deprecated.._depds" r)rDrEs` r _deprecatedrGcs Krucharcharushortshortuintintr/r,r0r-) |b1z|u1z|i1zrSzsFDAq!QFsBcHhIifd) rHrIrJrKrLrMr/r0r,r-c6|tvrtd|t|tr|dkr tdd}|dk(r|dvrd}|S|dvrd }|S|d k(r |dk(rd }|S|d k(r|dvrd }|S|dvrd}|S|dk(r |dk(rd }|S|dvr|dvrd}|S|dvrd}|S|dvrd}|S)a[Return a best-guess interpretation string based on bands and libvips format. Args: bands (int): Number of bands in the image. format (str): libvips format string. Returns: str: the best-guess libvips interpretation string. This function is a helper for :class:`.Image` creation from arrays when the user specifies 'auto' for `interpretation`. The heuristic used here can be defined in the following table:: | bands | format | interpretation | reason | | ----- | --------- | -------------- | ------------ | | 1 | uchar | b-w | L | | 2 | uchar | b-w | LA | | 3 | uchar | rgb | RGB | | 4 | uchar | rgb | RGBA | | 5+ | uchar | multiband | spectral | | 1 | char | matrix | conv. kernel | | 2+ | char | multiband | | | 1 | ushort | grey16 | L | | 2 | ushort | grey16 | LA | | 3 | ushort | rgb16 | RGB | | 4 | ushort | rgb16 | RGBA | | 5+ | ushort | multiband | spectral | | any | short | multiband | | | 1 | float | b-w | L | | 2 | float | b-w | LA | | 3 | float | scrgb | RGB | | 4 | float | scrgb | RGBA | | 5+ | float | multiband | spectral | | 1 | double | b-w | L | | 2 | double | b-w | LA | | 3 | double | scrgb | RGB | | 4 | double | scrgb | RGBA | | 5+ | double | multiband | spectral | | any | complex | fourier | FFT | | any | dpcomplex | fourier | FFT | zUnknown format: z+Number of bands must be a positive integer. multibandrH)r]r.zb-w)rgbrImatrixrJgrey16rgb16rK)r/r0scrgbr,r-fourier)FORMAT_TO_TYPESTR ValueErrorrrM)r2r1interps r_guess_interpretationrks(\&&+F8455 eS !UQYFGGF  F?F, M+f_F( M' 6  A:F" M! 8  F?F Mf_F M 7  A:F M & & F?F M f_F M + + MrceZdZdZy) ImageTypec tjt fd}|S#t$rtwxYw)NcJtjjg|i|Srrr$r%)argskwargsr?s r call_functionz,ImageType.__getattr__..call_functions$##((??? ?r)r getrAttributeErrorr@)clsr?rss ` r __getattr__zImageType.__getattr__sO ! NN4 $ @  @ !!  !s-=N)__name__ __module__ __qualname__rwrFrrrmrmsrrmceZdZdZdZedZfdZedZedZ eddZ e ddZ ed Z ed Zed Zd Zd ZdZdZdZdZdZdZdZdZfdZfdZdZdZdZdZdZ ddZ!ddZ"dZ#fd Z$e%d!d"Z&e%d#d$Z'e%d%d&Z(e%d'd(Z)d)Z*d*Z+d+Z,d,Z-d-Z.d.Z/d/Z0d0Z1d1Z2d2Z3d3Z4d4Z5d5Z6d6Z7d7Z8d8Z9d9Z:d:Z;d;Zd>Z?d?Z@d@ZAdAZBdBZCdCZDdDZEdEZFdFZGdGZHdHZIdIZJdJZKdKZLdLZMdMZNdNZOdOZPdPZQdQZRdRZSdSZTdTZUdUZVdVZWdWZXdXZYdYZZdZZ[d[Z\d\Z]d]Z^d^Z_d_Z`d`ZadaZbdbZcdcZdddZedeZfdfZgdgZhdhZidiZjdjZkdkZldlZmdmZndnZodoZpdpZqdqZrdrZsdsZtdtZuduZvdvZwdwZxdxZydyZzdzZ{d{Z|d|Z}d}Z~ed~dZdZxZS)rzWrap a VipsImage object. ) _referencesct|tr|St|rtj|S|j |Sr)rrrnew_from_arraynew_from_image)selfrs r _imageizezImage._imageizes< eU #L E]''. .&&u- -rc:g|_tt||yr)r|superr__init__)rpointer __class__s rrzImage.__init__s  eT#G,rc `t|}tj|}t|}tj|}t|}tj |}|t jk(rtd|t|}tjj||fd|i|S)aLoad an image from a file. This method can load images in any format supported by vips. The filename can include load options, for example:: image = pyvips.Image.new_from_file('fred.jpg[shrink=2]') You can also supply options as keyword arguments, for example:: image = pyvips.Image.new_from_file('fred.jpg', shrink=2) The full set of options available depend upon the load operation that will be executed. Try something like:: $ vips jpegload at the command-line to see a summary of the available options for the JPEG loader. Loading is fast: only enough of the image is loaded to be able to fill out the header. Pixels will only be decompressed when they are needed. Args: vips_filename (str): The disc file to load the image from, with optional appended arguments. All loaders support at least the following options: Keyword args: memory (bool): If set True, load the image via memory rather than via a temporary disc file. See :meth:`.new_temp_file` for notes on where temporary files are created. Small images are loaded via memory by default, use ``VIPS_DISC_THRESHOLD`` to set the definition of small. access (Access): Hint the expected access pattern for the image. fail (bool): If set True, the loader will fail with an error on the first serious error in the file. By default, libvips will attempt to read everything it can from a damaged image. Returns: A new :class:`.Image`. Raises: :class:`.Error` zunable to load from file string_options) rrvips_filename_get_filenamer vips_filename_get_optionsvips_foreign_find_loadrNULLrrrr$r%) vips_filenamerrrfilenameoptionsr?s r new_from_filezImage.new_from_file s`"-0 55mD"7+44]C!'*11-@ chh 3M?CD D'"$$T8G4;G?EG Grc tj|t|}|tjk(r t dt |}tjj||fd|i|S)aLoad a formatted image from memory. This behaves exactly as :meth:`new_from_file`, but the image is loaded from the memory object rather than from a file. The memory object can be anything that supports the Python buffer protocol. Args: data (array, bytearray, bytes, buffer): The memory object to load the image from. options (str): Load options as a string. Use ``""`` for no options. All loaders support at least the following options: Keyword args: access (Access): Hint the expected access pattern for the image. fail (bool): If set True, the loader will fail with an error on the first serious error in the image. By default, libvips will attempt to read everything it can from a damaged image. Returns: A new :class:`Image`. Raises: :class:`.Error` zunable to load from bufferr) rvips_foreign_find_load_bufferrrrrrrr$r%)datarrrrr?s rnew_from_bufferzImage.new_from_bufferLsm888s4yI chh 45 5'"$$T4G4;G?EG Grc t|s|g}t|}t|d}||z}tjd|}t d|D]$}t d|D]}|||||||zz<&t j ||||} | tjk(r tdtj| } | jtjd|| jtjd|| S)aCreate an image from a list or list of lists. A new one-band image with :class:`BandFormat` ``'double'`` pixels is created from the array. These image are useful with the libvips convolution operator :meth:`Image.conv`. Args: array (list[list[float]]): Create the image from these values. 1D arrays become a single row of pixels. scale (float): Default to 1.0. What to divide each pixel by after convolution. Useful for integer convolution masks. offset (float): Default to 0.0. What to subtract from each pixel after convolution. Useful for integer convolution masks. Returns: A new :class:`Image`. Raises: :class:`.Error` rzdouble[]z unable to make image from matrixscaleoffset)rrrnewranger vips_image_new_matrix_from_arrayrrrrset_typer gdouble_type) rrrheightwidthnayrvir&s r new_from_listzImage.new_from_listps.e}GEUE!H  FN GGJ "q&! /A1e_ /#(8A;!a%i-  / / 6 6ufa K >:; ; R  v**GU; v**Hf= rc`t|tr|j|||St|drI|j}|d}|d}t |}|j dd} |dkDr td|tvrtd|d |d k(rd } d } d } n'|d k(r |d } d } d } n|d k(r|\} } d } n |dk(r|\} } } t|} | t|d r |j}nEt|dr|j}n(t|dr|j}n td|j|   | }|dk(r|jdd }|#|dk(r t| | }|j!|}|St|dr|j#|j%Std)a Create a new Image from a list or an array-like object. Array-like objects are those which define `__array_interface__` or `__array__`. For details about the array interface, see `The Array Interface `_. If `__array_interface__` is not available, `__array__` is used as a fallback. The behavior for input objects with different dimensions is summarized as:: | array ndim | array shape | Image w | Image h | Image bands | |------------|-------------|---------|---------|-------------| | 0 | () | 1 | 1 | 1 | | 1 | (W,) | W | 1 | 1 | | 2 | (H, W) | W | H | 1 | | 3 | (H, W, C) | W | H | C | Args: obj (list or object width `__array_interface__` or `__array__`): The object to convert to an image. If the input object is a list, `Image.new_from_list` is used with the given `scale` and `offset` If the input object is an array-like object, a new image is created from the object's data and shape. The memory is shared except in the following cases: - The object's memory is not contiguous. In this case, a copy is made by attempting to call the object's `tobytes()` method or its `tostring()` method. - The object is an array of bools, in which case it is converted to a pyvips uchar image with True values becoming 255 and False values becoming 0. scale (float): Default to 1.0. **Ignored for non-list inputs**. What to divide each pixel by after convolution. Useful for integer convolution masks. offset (float): Default to 0.0. **Ignored for non-list inputs**. What to subtract from each pixel after convolution. Useful for integer convolution masks. interpretation (str, optional): **Ignored for list inputs** The libvips interpretation of the array. If None, the interpretation defaults to the pyvips one for `Image.new_from_memory`. If 'auto', a heuristic is used to determine a best-guess interpretation as defined in the `_guess_interpretation` function. Must be one of None, 'auto', 'error', 'multiband', 'b-w', 'histogram', 'xyz', 'lab', 'cmyk', 'labq', 'rgb', 'cmc', 'lch', 'labs', 'srgb', 'yxy', 'fourier', 'rgb16', 'grey16', 'matrix', 'scrgb', or 'hsv' Returns: The new image. See Also: :func:`_guess_interpretation` __array_interface__shapetypestrstridesNr_z array has more than 3 dimensionszconversion from z not supportedrr]r.rtobytestostringz#object has no .tobytes or .tostringrNauto)interpretation __array__z0does not define __array_interface__ or __array__)rrrhasattrrrrtriTYPESTR_TO_FORMATrrr TypeErrornew_from_memory ifthenelserkr4r~r)rvobjrrrrrrndimrrrr2r1rims rr~zImage.new_from_arraysH c4 $$S%8 8 3- .''AgJE lGu:DeeIt,Gax !CDD// #3G9N!KLLqya % ',$u&w/F73#7xx3 *;;=DS*-<<>D#$IJJ$$ B%]]3*)!V+%:5&%INWWNW;I S+ &%%cmmo6 6+, ,rctjtj|}tj|}t |dr |j n t|}tj||||||}|tjk(r tdtj|} | jj|| S)aCWrap an image around a memory array. Wraps an Image around an area of memory containing a C-style array. For example, if the ``data`` memory array contains four bytes with the values 1, 2, 3, 4, you can make a one-band, 2x2 uchar image from it like this:: image = Image.new_from_memory(data, 2, 2, 1, 'uchar') A reference is kept to the data object, so it will not be garbage-collected until the returned image is garbage-collected. This method is useful for efficiently transferring images from PIL or NumPy into libvips. See :meth:`.write_to_memory` for the opposite operation. Use :meth:`.copy` to set other image attributes. Args: data (bytes): A memoryview or buffer object. width (int): Image width in pixels. height (int): Image height in pixels. bands (int): Number of bands. format (BandFormat): Band format. Returns: A new :class:`Image`. Raises: :class:`.Error` nbytesz unable to make image from memory)r to_enum format_typer from_bufferrrrrvips_image_new_from_memoryrrrrr|append) rrrr2r1 format_valuerrrr&s rrzImage.new_from_memory(sF~~f&8&8&A //$' 'h 7SY  0 017161=? >:; ; R    & rc tj|j}|tjk(r t dt |}tjj||fd|i|}|jj||S)a4Load a formatted image from a source. This behaves exactly as :meth:`new_from_file`, but the image is loaded from the source rather than from a file. Args: source (Source): The source to load the image from. options (str): Load options as a string. Use ``""`` for no options. All loaders support at least the following options: Keyword args: access (Access): Hint the expected access pattern for the image. fail (bool): If set True, the loader will fail with an error on the first serious error in the image. By default, libvips will attempt to read everything it can from a damaged image. Returns: A new :class:`Image`. Raises: :class:`.Error` zunable to load from sourcer) rvips_foreign_find_load_sourcerrrrrrr$r%r|r)sourcerrrrr?r&s rnew_from_sourcezImage.new_from_source^s488H chh 45 5'"  %%dFH5<H@FH   ( rctjt|}|tjk(r t dt j|S)aMake a new temporary image. Returns an image backed by a temporary file. When written to with :func:`Image.write`, a temporary file will be created on disc in the specified format. When the image is closed, the file will be deleted automatically. The file is created in the temporary directory. This is set with the environment variable ``TMPDIR``. If this is not set, then on Unix systems, vips will default to ``/tmp``. On Windows, vips uses ``GetTempPath()`` to find the temporary directory. vips uses ``g_mkstemp()`` to make the temporary filename. They generally look something like ``"vips-12-EJKJFGH.v"``. Args: format (str): The format for the temp file, for example ``"%s.v"`` for a vips format file. The ``%s`` is substituted by the file path. Returns: A new :class:`Image`. Raises: :class:`.Error` zunable to make temp file)rvips_image_new_temp_filerrrrrr)r1rs r new_temp_filezImage.new_temp_files?: . .y/@ A >23 3||BrcNtjdd|zj|j}|j dd|j |j d}|j|j|j|j|j|j}|S)aMake a new image from an existing one. A new image is created which has the same size, format, interpretation and resolution as ``self``, but with every pixel set to ``value``. Args: value (float, list[float]): The value for the pixels. Use a single number to make a one-band image; use an array constant to make a many-band image. Returns: A new :class:`Image`. Raises: :class:`.Error` r]rr4)extend)rxresyresxoffsetyoffset) rblackr3r1embedrrr4rrrrr)rrpixelr&s rrzImage.new_from_images$Q"U*00= Aq$**dkk#)+ $*=*= $ $ #'<<#'<< 1  rctj|j}|tjk(r t dt j|S)a,Copy an image to memory. A large area of memory is allocated, the image is rendered to that memory area, and a new image is returned which wraps that large memory area. Returns: A new :class:`Image`. Raises: :class:`.Error` zunable to copy to memory)rvips_image_copy_memoryrrrrrr)rrs r copy_memoryzImage.copy_memorys> , ,T\\ : >23 3||Brc bt|}tj|}t|}tj|}t|}tj |}|t jk(rtd|t|}tjj|||fd|i|S)aWrite an image to a file on disc. This method can save images in any format supported by vips. The format is selected from the filename suffix. The filename can include embedded save options, see :func:`Image.new_from_file`. For example:: image.write_to_file('fred.jpg[Q=95]') You can also supply options as keyword arguments, for example:: image.write_to_file('fred.jpg', Q=95) The full set of options available depend upon the load operation that will be executed. Try something like:: $ vips jpegsave at the command-line to see a summary of the available options for the JPEG saver. Args: vips_filename (str): The disc file to save the image to, with optional appended arguments. Other arguments depend upon the save operation. Returns: None Raises: :class:`.Error` zunable to write to file r) rrrr rvips_foreign_find_saverrrrrr$r%)rrrrrrrr?s r write_to_filezImage.write_to_filesH"-0 55mD"7+44]C!'*11-@ chh 2=/BC C'"$$T4G4;G?EG Grc (t|}tj|}tj|t j }tj|}t|}tj}tddr=tjtj|}tj|tjk7r`t|}tj j#}tj$j&|||fd|i||j)d}|Stj*|}|tjk(r t-dt|}tj$j&||fd|i|}|S)aWrite an image to memory. This method can save images in any format supported by vips. The format is selected from the suffix in the format string. This can include embedded save options, see :func:`Image.write_to_file`. For example:: data = image.write_to_buffer('.jpg[Q=95]') You can also supply options as keyword arguments, for example:: data = image.write_to_buffer('.jpg', Q=95) The full set of options available depend upon the load operation that will be executed. Try something like:: $ vips jpegsave_buffer at the command-line to see a summary of the available options for the JPEG saver. Args: format_string (str): The suffix, plus any string-form arguments. Other arguments depend upon the save operation. Returns: A byte string. Raises: :class:`.Error`  rblobzunable to write to buffer)rrrrgcrg_freerr rr vips_error_freezevips_foreign_find_save_targetvips_error_thawrrTarget new_to_memoryr$r%rtvips_foreign_find_save_bufferr) r format_stringrrrrrr?targetbuffers rwrite_to_bufferzImage.write_to_buffersZF"-0 66}E66(HOO444]C!'*(( Aq !  & & (<""$$*$6$6vs$CDStCyDD !/4Aw.BCAaD2a!f9$C!C! ED!sC C 4C C C cddl}|j|jt|jj |j |j|j}|jdk(rB|jd}|jdk(r!|j dk(r|jd}||j|}|S)aConversion to a NumPy array. Args: dtype (str or numpy dtype, optional) The dtype to use for the numpy array. If None, the default dtype of the image is used as defined the global `FORMAT_TO_TYPESTR` dictionary. Returns: numpy.ndarray: The array representation of the image. * Single-band images lose their channel axis. * Single-pixel single-band images are converted to a 0D array. See https://numpy.org/devdocs/user/basics.dispatch.html for more details. This enables a :class:`Image` to be used where a numpy array is expected, including in plotting and conversion to other array container types (pytorch, JAX, dask, etc.), for example. `numpy` is a runtime dependency of this function. See Also `Image.new_from_array` for the inverse operation. #TODO rNdtyper])axis)rr]) numpy frombufferrrhr1reshaperrr2squeezeastype)rrnparrs rrzImage.__array__s0  MM$..0 1$++ >  @ WT[[$**djj 9 ::?++2+&CzzQ4;;!#3kkvk.  **U#C rc&|j|S)aConvenience function to allow numpy conversion to be at the end of a method chain. This mimics the behavior of pytorch: ``arr = im.op1().op2().numpy()`` numpy is a runtime dependency of this function. Args: dtype (str or numpy dtype): The dtype to use for the numpy array. If None, the default dtype of the image is used. Returns: numpy.ndarray: The image as a numpy array. See Also: - :meth:`.__array__` - `FORMAT_TO_TYPESTR`: Global dictionary mapping libvips format strings to numpy dtype strings. r)r)rrs rr!z Image.numpys*~~E~**rc 8|jdk(rH|jdkr9|jdkr*|jdk(r|j }t |Sd|jd|jd|j d|jd|jd S) Nrbr]z)rrrr2rreprr1)rrs r__repr__zImage.__repr__s   8 + R b  aKKME; $TZZL$++a }Bzzl(4+>+>*?qB Crcdk(r&jddk7rjdSydk(r&jddk7rjdSyttdk7rttS t jtfd}|S#t $rt wxYw)a}Divert unknown names to libvips. Unknown attributes are first looked up in the image properties as accessors, for example:: width = image.width and then in the libvips operation table, where they become method calls, for example:: new_image = image.invert() Use :func:`get` to fetch image metadata. A ``__getattr__`` on the metatype lets you call static members in the same way. Args: name (str): The name of the piece of metadata to get. Returns: Mixed. Raises: :class:`.Error` rr?rcLtjjg|i|Srrp)rqrrr?rs rrsz(Image.__getattr__..call_function*s&##((tEdEfE Er)rrtrrr rrur@)rr?rsrs`` rrwzImage.__getattr__s> 7?w'1,xx(( 8 x(A-xx))  ( .! 3)$/ / ! NN4 $ F  F !!  !s B//B?zuse Image.get() insteadc$|j|Sr)rtr s r get_valuezImage.get_value2sxx~rzuse Image.set() insteadc(|j||yr)r)rr?rs r set_valuezImage.set_value6s urzuse Image.scale insteadc|jSr)rrs r get_scalezImage.get_scale:s zzrzuse Image.offset insteadc|jSr)rrs r get_offsetzImage.get_offset>s {{rc|SrrFrs r __enter__zImage.__enter__D rcyrrF)rtyper tracebacks r__exit__zImage.__exit__Gs rc:t|trt|j|}d}nct|trCt|j|}t |dk(r t d|d}t |}nt|tr|s t dtd|Dstd|Ds t dt|dtrit ||jk7r t dt|Dcgc] \}}|s | }}}t |}|dk(r t d |dk(rN|d}nHt|j}|Dcgc]}|| }}t |}|dk(r|d}n t d |dk(r|jSt|tr"|jdk(r|j| SDcgc]}|j|}}|dj|dd Scc}}wcc}wcc}w) agOverload [] to pull out band elements from an image. The following arguments types are accepted: * int:: green = rgb_image[1] Will make a new one-band image from band 1 (the middle band). * slice:: last_two = rgb_image[1:] last_band = rgb_image[-1] middle_few = multiband[1:-2] reversed = multiband[::-1] every_other = multiband[::2] other_every_other = multiband[1::2] * list of int:: # list of integers desired_bands = [1, 2, 2, -1] four_band = multiband[desired_bands] * list of bool:: wanted_bands = [True, False, True, True, False] three_band = five_band[wanted_bands] In the case of integer or slice arguments, the semantics of slicing exactly match those of slicing `range(self.bands)`. In the case of list arguments, the semantics match those of numpy's extended slicing syntax. Thus, lists of booleans must have as many elements as there are bands in the image. r]rz empty slicez empty listc3@K|]}t|tk(ywr)r?rMrPrs rrSz$Image.__getitem__..s41Q34c3@K|]}t|tk(ywr)r?boolrDs rrSz$Image.__getitem__..s5AQ45rEz)list must contain only ints or only boolsz,boolean index must have same length as bandszempty boolean indexz>argument must be an int, slice, list of ints, or list of bools)rN)rrMrr2slicer IndexErrorrallrG enumerate extract_bandstepbandjoin)rargrYrband_seqr all_bandsr2s r __getitem__zImage.__getitem__JsN c3 djj!#&AA U #TZZ(-H8}! // AH A T " ..444555 !LMM#a&$'s8tzz)$&788+4C.>$!QAA>>M6$%:;;6  A!$**- 256QIaL66M6  A>? ? 6$$Q' ' U #A $$Q!$, ,4<zImage.__sub__..s "q&r)rrrsubtractrXr!rYs r__sub__z Image.__sub__s8 eV\\ *==' ';;q%(8%"@A Arc&|jd|Sr`)rXrYs r__rsub__zImage.__rsub__s{{2u%%rcht|tr|j|S|j|dS)Nr)rrmultiplyrXrYs r__mul__z Image.__mul__s, eU #==' ';;ua( (rc$|j|Sr)rirYs r__rmul__zImage.__rmul__r]rct|tjr|j|S|j t d|dS)Nc d|z SNr0rFras rrbzImage.__div__.. sQwrr)rrrdividerXr!rYs r__div__z Image.__div__s8 eV\\ *;;u% %;;u%6>B Brc|dz|zSr`rFrYs r__rdiv__zImage.__rdiv__s e##rc$|j|Sr)rqrYs r __truediv__zImage.__truediv__r]rc$|j|Sr)rsrYs r __rtruediv__zImage.__rtruediv__s}}U##rct|tjr|j|j S|j t d|dj S)Nc d|z SrnrFras rrbz$Image.__floordiv__..rorr)rrrrpfloorrXr!rYs r __floordiv__zImage.__floordiv__sJ eV\\ *;;u%++- -;;u%6>BHHJ Jrc.|dz|zjSr`)rzrYs r __rfloordiv__zImage.__rfloordiv__su$++--rczt|tjr|j|S|j |Sr)rrr remainderremainder_constrYs r__mod__z Image.__mod__s0 eV\\ *>>%( (''. .rct||ddS)Nmath2powr*rYs r__pow__z Image.__pow__$w66rct||ddS)NrwoprrYs r__rpow__zImage.__rpow__rrc"|jSr)absrs r__abs__z Image.__abs__sxxzrct||ddS)NbooleanlshiftrrYs r __lshift__zImage.__lshift__$y(;;rct||ddS)NrrshiftrrYs r __rshift__zImage.__rshift__rrct||ddS)NrandrrYs r__and__z Image.__and__$y%88rc$|j|Sr)rrYs r__rand__zImage.__rand__r]rct||ddS)NrorrrYs r__or__z Image.__or__ s$y$77rc$|j|Sr)rrYs r__ror__z Image.__ror__s{{5!!rct||ddS)NreorrrYs r__xor__z Image.__xor__rrc$|j|Sr)rrYs r__rxor__zImage.__rxor__r]rc d|zSr`rFrs r__neg__z Image.__neg__s Dyrc|SrrFrs r__pos__z Image.__pos__r=rc |dz Sr`rFrs r __invert__zImage.__invert__s byrct||ddS)N relationalmorerrYs r__gt__z Image.__gt__ $|V<>rct||ddS)NrlessrrYs r__lt__z Image.__lt__&rrct||ddS)NrlesseqrrYs r__le__z Image.__le__)rrc$|yt||ddS)NFrequalrrYs r__eq__z Image.__eq__,s =$|W==rc$|yt||ddS)NTrnoteqrrYs r__ne__z Image.__ne__3s =$|W==rc$|jdS)z@Return the largest integral value not greater than the argument.rzroundrs rrzz Image.floor:szz'""rc$|jdS)z>Return the smallest integral value not less than the argument.ceilrrs rrz Image.ceil>zz&!!rc$|jdS)z"Return the nearest integral value.rintrrs rrz Image.rintBrrc$|jdS)zAND image bands together.rbandboolrs rbandandz Image.bandandF}}U##rc$|jdS)zOR image bands together.rrrs rbandorz Image.bandorJs}}T""rc$|jdS)zEOR image bands together.rrrs rbandeorz Image.bandeorNrrc,|Dcgc]}|c}Scc}w)z-Split an n-band image into n separate images.rF)rrs r bandsplitzImage.bandsplitRs a   s ct|ts|g}|s|Std|Dd}||j|Stj j d|g|zS)z-Append a set of images or constants bandwise.c3TK|] }t|tjs|"ywr)rrrrDs rrSz!Image.bandjoin..`s'A",Q"?As&(NrN)rrnextbandjoin_constrr$r%)rr' non_numbers rrNzImage.bandjoinVsr%&GEKAeA   &&u- -##((dVe^D Drct||ddS)Nratan2rrYs rrz Image.atan2is$w88rctddrtj|jS|j ddk7r|j dSdS)aGet the number of pages in an image file, or 1. This is the number of pages in the file the image was loaded from, not the number of pages in the image. To get the number of pages in an image, divide the image height by the page height. rzn-pagesrr])r rvips_image_get_n_pagesrrrtrs r get_n_pageszImage.get_n_pageslsQ Aq !224<<@ @??9-288I& :89 :rc$tddrtj|jS|j ddk7r|j d}n |j }|dkDr#||j kr|j |zdk(r|S|j S)z=Get the page height in a many-page image, or height. r page-heightr)r rvips_image_get_page_heightrrrtr)r page_heights rget_page_heightzImage.get_page_height{s Aq !66t||D D}-2"hh}5 "kk Qt{{*KK+-2""{{"rc |j}td|j|Dcgc] }|jd||j|"c}Scc}w)z@Split an N-page image into a list of N separate images. r)rrrcropr)rrrs r pagesplitzImage.pagesplitsR**, q$++{;= !Q K8= ==s%Act|ts|g}dt|z}tj |g|zd}|j }|j tjd|j|z |S)z}Join a set of pages vertically to make a multipage image. Also sets the page-height property on the result. r])acrossr) rrrr arrayjoinr4rr gint_typer)rr'n_pagesr&s rpagejoinzImage.pagejoinsi %&GEc%j.q9  v'' w8NO rc t|ts|g}t|ts|g}|Dcgc]&}tjtj|(}}t j jd|g|z|fi|Scc}w)z.Composite a set of images with a set of modes. composite)rrr rblend_mode_typerr$r%)rr'moderrrs rrzImage.composites%&GE$%6DDHHav55q9HH$$[4&5.$/'-/ /Is+A>c rt|ts|g}tjjd|g|zfi|S)z&Band-wise rank filter a set of images.bandrank)rrrr$r%)rr'rrs rrzImage.bandranks7%&GE$$Z$%J6JJrcL|jdd\}}|d}|d}|||fS)z,Return the coordinates of the image maximum.Trrrr)maxrrRoptsrrs rmaxposz Image.maxpos5((TT(*4 I I!QwrcL|jdd\}}|d}|d}|||fS)z,Return the coordinates of the image minimum.Trrr)minrs rminposz Image.minposrrc$|jdS)z(Return the real part of a complex image.real complexgetrs rrz Image.realv&&rc$|jdS)z-Return the imaginary part of a complex image.imagrrs rrz Image.imagrrctd|S)z/Return an image converted to polar coordinates.c$|jdS)Npolarr,ras rrbzImage.polar..sAIIg$6rr8rs rrz Image.polars6==rctd|S)z5Return an image converted to rectangular coordinates.c$|jdS)Nrectrras rrbzImage.rect..sAIIf$5rrrs rr z Image.rects5t<>#""$#$!E&9 :#$= /K''>=$   !!!!!!""" " ")*8'%  :(l M M>rr) metaclass)rrrrrrrrrr r r r rrr!r*r8r@rGrdictitemsrhrrkr?rm VipsObjectr__all__rFrrrgs FFF .  D H $#"$#"!#%$( *F,=,C,C,EFF #! #"! " #!$#& (Nd(z>F  z>z3 )r