opencv_imgcodecs (JavaCPP Presets for OpenCV 4.3.0-1.5.3 API)

java.lang.Object
- org.bytedeco.opencv.presets.opencv_imgcodecs
- - org.bytedeco.opencv.helper.opencv_imgcodecs
  - - org.bytedeco.opencv.global.opencv_imgcodecs

All Implemented Interfaces:: InfoMapper

public class opencv_imgcodecs
extends opencv_imgcodecs

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`IMREAD_ANYCOLOR` enum cv::ImreadModes
`static int`	`IMREAD_ANYDEPTH` enum cv::ImreadModes
`static int`	`IMREAD_COLOR` enum cv::ImreadModes
`static int`	`IMREAD_GRAYSCALE` enum cv::ImreadModes
`static int`	`IMREAD_IGNORE_ORIENTATION` enum cv::ImreadModes
`static int`	`IMREAD_LOAD_GDAL` enum cv::ImreadModes
`static int`	`IMREAD_REDUCED_COLOR_2` enum cv::ImreadModes
`static int`	`IMREAD_REDUCED_COLOR_4` enum cv::ImreadModes
`static int`	`IMREAD_REDUCED_COLOR_8` enum cv::ImreadModes
`static int`	`IMREAD_REDUCED_GRAYSCALE_2` enum cv::ImreadModes
`static int`	`IMREAD_REDUCED_GRAYSCALE_4` enum cv::ImreadModes
`static int`	`IMREAD_REDUCED_GRAYSCALE_8` enum cv::ImreadModes
`static int`	`IMREAD_UNCHANGED` enum cv::ImreadModes
`static int`	`IMWRITE_EXR_TYPE` enum cv::ImwriteFlags
`static int`	`IMWRITE_EXR_TYPE_FLOAT` enum cv::ImwriteEXRTypeFlags
`static int`	`IMWRITE_EXR_TYPE_HALF` enum cv::ImwriteEXRTypeFlags
`static int`	`IMWRITE_JPEG_CHROMA_QUALITY` enum cv::ImwriteFlags
`static int`	`IMWRITE_JPEG_LUMA_QUALITY` enum cv::ImwriteFlags
`static int`	`IMWRITE_JPEG_OPTIMIZE` enum cv::ImwriteFlags
`static int`	`IMWRITE_JPEG_PROGRESSIVE` enum cv::ImwriteFlags
`static int`	`IMWRITE_JPEG_QUALITY` enum cv::ImwriteFlags
`static int`	`IMWRITE_JPEG_RST_INTERVAL` enum cv::ImwriteFlags
`static int`	`IMWRITE_JPEG2000_COMPRESSION_X1000` enum cv::ImwriteFlags
`static int`	`IMWRITE_PAM_FORMAT_BLACKANDWHITE` enum cv::ImwritePAMFlags
`static int`	`IMWRITE_PAM_FORMAT_GRAYSCALE` enum cv::ImwritePAMFlags
`static int`	`IMWRITE_PAM_FORMAT_GRAYSCALE_ALPHA` enum cv::ImwritePAMFlags
`static int`	`IMWRITE_PAM_FORMAT_NULL` enum cv::ImwritePAMFlags
`static int`	`IMWRITE_PAM_FORMAT_RGB` enum cv::ImwritePAMFlags
`static int`	`IMWRITE_PAM_FORMAT_RGB_ALPHA` enum cv::ImwritePAMFlags
`static int`	`IMWRITE_PAM_TUPLETYPE` enum cv::ImwriteFlags
`static int`	`IMWRITE_PNG_BILEVEL` enum cv::ImwriteFlags
`static int`	`IMWRITE_PNG_COMPRESSION` enum cv::ImwriteFlags
`static int`	`IMWRITE_PNG_STRATEGY` enum cv::ImwriteFlags
`static int`	`IMWRITE_PNG_STRATEGY_DEFAULT` enum cv::ImwritePNGFlags
`static int`	`IMWRITE_PNG_STRATEGY_FILTERED` enum cv::ImwritePNGFlags
`static int`	`IMWRITE_PNG_STRATEGY_FIXED` enum cv::ImwritePNGFlags
`static int`	`IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY` enum cv::ImwritePNGFlags
`static int`	`IMWRITE_PNG_STRATEGY_RLE` enum cv::ImwritePNGFlags
`static int`	`IMWRITE_PXM_BINARY` enum cv::ImwriteFlags
`static int`	`IMWRITE_TIFF_COMPRESSION` enum cv::ImwriteFlags
`static int`	`IMWRITE_TIFF_RESUNIT` enum cv::ImwriteFlags
`static int`	`IMWRITE_TIFF_XDPI` enum cv::ImwriteFlags
`static int`	`IMWRITE_TIFF_YDPI` enum cv::ImwriteFlags
`static int`	`IMWRITE_WEBP_QUALITY` enum cv::ImwriteFlags

Constructor Summary

Constructors
Constructor and Description

opencv_imgcodecs()

Constructors
Constructor and Description
`opencv_imgcodecs()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`haveImageReader(BytePointer filename)` \brief Returns true if the specified image can be decoded by OpenCV
`static boolean`	`haveImageReader(String filename)`
`static boolean`	`haveImageWriter(BytePointer filename)` \brief Returns true if an image with the specified filename can be encoded by OpenCV
`static boolean`	`haveImageWriter(String filename)`
`static Mat`	`imdecode(GpuMat buf, int flags)`
`static Mat`	`imdecode(GpuMat buf, int flags, Mat dst)`
`static Mat`	`imdecode(Mat buf, int flags)` \brief Reads an image from a buffer in memory.
`static Mat`	`imdecode(Mat buf, int flags, Mat dst)` \overload
`static Mat`	`imdecode(UMat buf, int flags)`
`static Mat`	`imdecode(UMat buf, int flags, Mat dst)`
`static boolean`	`imencode(BytePointer ext, GpuMat img, byte[] buf)`
`static boolean`	`imencode(BytePointer ext, GpuMat img, byte[] buf, int[] params)`
`static boolean`	`imencode(BytePointer ext, GpuMat img, ByteBuffer buf)`
`static boolean`	`imencode(BytePointer ext, GpuMat img, ByteBuffer buf, IntBuffer params)`
`static boolean`	`imencode(BytePointer ext, GpuMat img, BytePointer buf)`
`static boolean`	`imencode(BytePointer ext, GpuMat img, BytePointer buf, IntPointer params)`
`static boolean`	`imencode(BytePointer ext, Mat img, byte[] buf)`
`static boolean`	`imencode(BytePointer ext, Mat img, byte[] buf, int[] params)`
`static boolean`	`imencode(BytePointer ext, Mat img, ByteBuffer buf)`
`static boolean`	`imencode(BytePointer ext, Mat img, ByteBuffer buf, IntBuffer params)`
`static boolean`	`imencode(BytePointer ext, Mat img, BytePointer buf)`
`static boolean`	`imencode(BytePointer ext, Mat img, BytePointer buf, IntPointer params)` \brief Encodes an image into a memory buffer.
`static boolean`	`imencode(BytePointer ext, UMat img, byte[] buf)`
`static boolean`	`imencode(BytePointer ext, UMat img, byte[] buf, int[] params)`
`static boolean`	`imencode(BytePointer ext, UMat img, ByteBuffer buf)`
`static boolean`	`imencode(BytePointer ext, UMat img, ByteBuffer buf, IntBuffer params)`
`static boolean`	`imencode(BytePointer ext, UMat img, BytePointer buf)`
`static boolean`	`imencode(BytePointer ext, UMat img, BytePointer buf, IntPointer params)`
`static boolean`	`imencode(String ext, GpuMat img, byte[] buf)`
`static boolean`	`imencode(String ext, GpuMat img, byte[] buf, int[] params)`
`static boolean`	`imencode(String ext, GpuMat img, ByteBuffer buf)`
`static boolean`	`imencode(String ext, GpuMat img, ByteBuffer buf, IntBuffer params)`
`static boolean`	`imencode(String ext, GpuMat img, BytePointer buf)`
`static boolean`	`imencode(String ext, GpuMat img, BytePointer buf, IntPointer params)`
`static boolean`	`imencode(String ext, Mat img, byte[] buf)`
`static boolean`	`imencode(String ext, Mat img, byte[] buf, int[] params)`
`static boolean`	`imencode(String ext, Mat img, ByteBuffer buf)`
`static boolean`	`imencode(String ext, Mat img, ByteBuffer buf, IntBuffer params)`
`static boolean`	`imencode(String ext, Mat img, BytePointer buf)`
`static boolean`	`imencode(String ext, Mat img, BytePointer buf, IntPointer params)`
`static boolean`	`imencode(String ext, UMat img, byte[] buf)`
`static boolean`	`imencode(String ext, UMat img, byte[] buf, int[] params)`
`static boolean`	`imencode(String ext, UMat img, ByteBuffer buf)`
`static boolean`	`imencode(String ext, UMat img, ByteBuffer buf, IntBuffer params)`
`static boolean`	`imencode(String ext, UMat img, BytePointer buf)`
`static boolean`	`imencode(String ext, UMat img, BytePointer buf, IntPointer params)`
`static Mat`	`imread(BytePointer filename)`
`static Mat`	`imread(BytePointer filename, int flags)` \brief Loads an image from a file.
`static Mat`	`imread(String filename)`
`static Mat`	`imread(String filename, int flags)`
`static boolean`	`imreadmulti(BytePointer filename, MatVector mats)`
`static boolean`	`imreadmulti(BytePointer filename, MatVector mats, int flags)` \brief Loads a multi-page image from a file.
`static boolean`	`imreadmulti(String filename, MatVector mats)`
`static boolean`	`imreadmulti(String filename, MatVector mats, int flags)`
`static boolean`	`imwrite(BytePointer filename, GpuMat img)`
`static boolean`	`imwrite(BytePointer filename, GpuMat img, int[] params)`
`static boolean`	`imwrite(BytePointer filename, GpuMat img, IntBuffer params)`
`static boolean`	`imwrite(BytePointer filename, GpuMat img, IntPointer params)`
`static boolean`	`imwrite(BytePointer filename, Mat img)`
`static boolean`	`imwrite(BytePointer filename, Mat img, int[] params)`
`static boolean`	`imwrite(BytePointer filename, Mat img, IntBuffer params)`
`static boolean`	`imwrite(BytePointer filename, Mat img, IntPointer params)` \brief Saves an image to a specified file.
`static boolean`	`imwrite(BytePointer filename, UMat img)`
`static boolean`	`imwrite(BytePointer filename, UMat img, int[] params)`
`static boolean`	`imwrite(BytePointer filename, UMat img, IntBuffer params)`
`static boolean`	`imwrite(BytePointer filename, UMat img, IntPointer params)`
`static boolean`	`imwrite(String filename, GpuMat img)`
`static boolean`	`imwrite(String filename, GpuMat img, int[] params)`
`static boolean`	`imwrite(String filename, GpuMat img, IntBuffer params)`
`static boolean`	`imwrite(String filename, GpuMat img, IntPointer params)`
`static boolean`	`imwrite(String filename, Mat img)`
`static boolean`	`imwrite(String filename, Mat img, int[] params)`
`static boolean`	`imwrite(String filename, Mat img, IntBuffer params)`
`static boolean`	`imwrite(String filename, Mat img, IntPointer params)`
`static boolean`	`imwrite(String filename, UMat img)`
`static boolean`	`imwrite(String filename, UMat img, int[] params)`
`static boolean`	`imwrite(String filename, UMat img, IntBuffer params)`
`static boolean`	`imwrite(String filename, UMat img, IntPointer params)`

Methods inherited from class org.bytedeco.opencv.helper.opencv_imgcodecs
cvLoadImage, cvLoadImage, cvLoadImageBGRA, cvLoadImageRGBA, cvSaveImage, cvSaveImage

Methods inherited from class org.bytedeco.opencv.presets.opencv_imgcodecs
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- IMREAD_UNCHANGED
```
public static final int IMREAD_UNCHANGED
```
  enum cv::ImreadModes
  
  See Also:
  
  Constant Field Values
- IMREAD_GRAYSCALE
```
public static final int IMREAD_GRAYSCALE
```
  enum cv::ImreadModes
  
  See Also:
  
  Constant Field Values
- IMREAD_COLOR
```
public static final int IMREAD_COLOR
```
  enum cv::ImreadModes
  
  See Also:
  
  Constant Field Values
- IMREAD_ANYDEPTH
```
public static final int IMREAD_ANYDEPTH
```
  enum cv::ImreadModes
  
  See Also:
  
  Constant Field Values
- IMREAD_ANYCOLOR
```
public static final int IMREAD_ANYCOLOR
```
  enum cv::ImreadModes
  
  See Also:
  
  Constant Field Values
- IMREAD_LOAD_GDAL
```
public static final int IMREAD_LOAD_GDAL
```
  enum cv::ImreadModes
  
  See Also:
  
  Constant Field Values
- IMREAD_REDUCED_GRAYSCALE_2
```
public static final int IMREAD_REDUCED_GRAYSCALE_2
```
  enum cv::ImreadModes
  
  See Also:
  
  Constant Field Values
- IMREAD_REDUCED_COLOR_2
```
public static final int IMREAD_REDUCED_COLOR_2
```
  enum cv::ImreadModes
  
  See Also:
  
  Constant Field Values
- IMREAD_REDUCED_GRAYSCALE_4
```
public static final int IMREAD_REDUCED_GRAYSCALE_4
```
  enum cv::ImreadModes
  
  See Also:
  
  Constant Field Values
- IMREAD_REDUCED_COLOR_4
```
public static final int IMREAD_REDUCED_COLOR_4
```
  enum cv::ImreadModes
  
  See Also:
  
  Constant Field Values
- IMREAD_REDUCED_GRAYSCALE_8
```
public static final int IMREAD_REDUCED_GRAYSCALE_8
```
  enum cv::ImreadModes
  
  See Also:
  
  Constant Field Values
- IMREAD_REDUCED_COLOR_8
```
public static final int IMREAD_REDUCED_COLOR_8
```
  enum cv::ImreadModes
  
  See Also:
  
  Constant Field Values
- IMREAD_IGNORE_ORIENTATION
```
public static final int IMREAD_IGNORE_ORIENTATION
```
  enum cv::ImreadModes
  
  See Also:
  
  Constant Field Values
- IMWRITE_JPEG_QUALITY
```
public static final int IMWRITE_JPEG_QUALITY
```
  enum cv::ImwriteFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_JPEG_PROGRESSIVE
```
public static final int IMWRITE_JPEG_PROGRESSIVE
```
  enum cv::ImwriteFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_JPEG_OPTIMIZE
```
public static final int IMWRITE_JPEG_OPTIMIZE
```
  enum cv::ImwriteFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_JPEG_RST_INTERVAL
```
public static final int IMWRITE_JPEG_RST_INTERVAL
```
  enum cv::ImwriteFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_JPEG_LUMA_QUALITY
```
public static final int IMWRITE_JPEG_LUMA_QUALITY
```
  enum cv::ImwriteFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_JPEG_CHROMA_QUALITY
```
public static final int IMWRITE_JPEG_CHROMA_QUALITY
```
  enum cv::ImwriteFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_PNG_COMPRESSION
```
public static final int IMWRITE_PNG_COMPRESSION
```
  enum cv::ImwriteFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_PNG_STRATEGY
```
public static final int IMWRITE_PNG_STRATEGY
```
  enum cv::ImwriteFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_PNG_BILEVEL
```
public static final int IMWRITE_PNG_BILEVEL
```
  enum cv::ImwriteFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_PXM_BINARY
```
public static final int IMWRITE_PXM_BINARY
```
  enum cv::ImwriteFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_EXR_TYPE
```
public static final int IMWRITE_EXR_TYPE
```
  enum cv::ImwriteFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_WEBP_QUALITY
```
public static final int IMWRITE_WEBP_QUALITY
```
  enum cv::ImwriteFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_PAM_TUPLETYPE
```
public static final int IMWRITE_PAM_TUPLETYPE
```
  enum cv::ImwriteFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_TIFF_RESUNIT
```
public static final int IMWRITE_TIFF_RESUNIT
```
  enum cv::ImwriteFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_TIFF_XDPI
```
public static final int IMWRITE_TIFF_XDPI
```
  enum cv::ImwriteFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_TIFF_YDPI
```
public static final int IMWRITE_TIFF_YDPI
```
  enum cv::ImwriteFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_TIFF_COMPRESSION
```
public static final int IMWRITE_TIFF_COMPRESSION
```
  enum cv::ImwriteFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_JPEG2000_COMPRESSION_X1000
```
public static final int IMWRITE_JPEG2000_COMPRESSION_X1000
```
  enum cv::ImwriteFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_EXR_TYPE_HALF
```
public static final int IMWRITE_EXR_TYPE_HALF
```
  enum cv::ImwriteEXRTypeFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_EXR_TYPE_FLOAT
```
public static final int IMWRITE_EXR_TYPE_FLOAT
```
  enum cv::ImwriteEXRTypeFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_PNG_STRATEGY_DEFAULT
```
public static final int IMWRITE_PNG_STRATEGY_DEFAULT
```
  enum cv::ImwritePNGFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_PNG_STRATEGY_FILTERED
```
public static final int IMWRITE_PNG_STRATEGY_FILTERED
```
  enum cv::ImwritePNGFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY
```
public static final int IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY
```
  enum cv::ImwritePNGFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_PNG_STRATEGY_RLE
```
public static final int IMWRITE_PNG_STRATEGY_RLE
```
  enum cv::ImwritePNGFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_PNG_STRATEGY_FIXED
```
public static final int IMWRITE_PNG_STRATEGY_FIXED
```
  enum cv::ImwritePNGFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_PAM_FORMAT_NULL
```
public static final int IMWRITE_PAM_FORMAT_NULL
```
  enum cv::ImwritePAMFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_PAM_FORMAT_BLACKANDWHITE
```
public static final int IMWRITE_PAM_FORMAT_BLACKANDWHITE
```
  enum cv::ImwritePAMFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_PAM_FORMAT_GRAYSCALE
```
public static final int IMWRITE_PAM_FORMAT_GRAYSCALE
```
  enum cv::ImwritePAMFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_PAM_FORMAT_GRAYSCALE_ALPHA
```
public static final int IMWRITE_PAM_FORMAT_GRAYSCALE_ALPHA
```
  enum cv::ImwritePAMFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_PAM_FORMAT_RGB
```
public static final int IMWRITE_PAM_FORMAT_RGB
```
  enum cv::ImwritePAMFlags
  
  See Also:
  
  Constant Field Values
- IMWRITE_PAM_FORMAT_RGB_ALPHA
```
public static final int IMWRITE_PAM_FORMAT_RGB_ALPHA
```
  enum cv::ImwritePAMFlags
  
  See Also:
  
  Constant Field Values

Constructor Detail
- opencv_imgcodecs
```
public opencv_imgcodecs()
```

Method Detail

imread
```
@Namespace(value="cv")
 @ByVal
public static Mat imread(@opencv_core.Str
                                                        BytePointer filename,
                                                        int flags)
```
\brief Loads an image from a file.
\anchor imread
The function imread loads an image from the specified file and returns it. If the image cannot be read (because of missing file, improper permissions, unsupported or invalid format), the function returns an empty matrix ( Mat::data==NULL ).
Currently, the following file formats are supported:
- Windows bitmaps - \*.bmp, \*.dib (always supported) - JPEG files - \*.jpeg, \*.jpg, \*.jpe (see the *Note* section) - JPEG 2000 files - \*.jp2 (see the *Note* section) - Portable Network Graphics - \*.png (see the *Note* section) - WebP - \*.webp (see the *Note* section) - Portable image format - \*.pbm, \*.pgm, \*.ppm \*.pxm, \*.pnm (always supported) - PFM files - \*.pfm (see the *Note* section) - Sun rasters - \*.sr, \*.ras (always supported) - TIFF files - \*.tiff, \*.tif (see the *Note* section) - OpenEXR Image files - \*.exr (see the *Note* section) - Radiance HDR - \*.hdr, \*.pic (always supported) - Raster and Vector geospatial data supported by GDAL (see the *Note* section)
\note - The function determines the type of an image by the content, not by the file extension. - In the case of color images, the decoded images will have the channels stored in **B G R** order. - When using IMREAD_GRAYSCALE, the codec's internal grayscale conversion will be used, if available. Results may differ to the output of cvtColor() - On Microsoft Windows\* OS and MacOSX\*, the codecs shipped with an OpenCV image (libjpeg, libpng, libtiff, and libjasper) are used by default. So, OpenCV can always read JPEGs, PNGs, and TIFFs. On MacOSX, there is also an option to use native MacOSX image readers. But beware that currently these native image loaders give images with different pixel values because of the color management embedded into MacOSX. - On Linux\*, BSD flavors and other Unix-like open-source operating systems, OpenCV looks for codecs supplied with an OS image. Install the relevant packages (do not forget the development files, for example, "libjpeg-dev", in Debian\* and Ubuntu\*) to get the codec support or turn on the OPENCV_BUILD_3RDPARTY_LIBS flag in CMake. - In the case you set *WITH_GDAL* flag to true in CMake and \ref IMREAD_LOAD_GDAL to load the image, then the [GDAL](http://www.gdal.org) driver will be used in order to decode the image, supporting the following formats: [Raster](http://www.gdal.org/formats_list.html), [Vector](http://www.gdal.org/ogr_formats.html). - If EXIF information is embedded in the image file, the EXIF orientation will be taken into account and thus the image will be rotated accordingly except if the flags \ref IMREAD_IGNORE_ORIENTATION or \ref IMREAD_UNCHANGED are passed. - Use the IMREAD_UNCHANGED flag to keep the floating point values from PFM image. - By default number of pixels must be less than 2^30. Limit can be set using system variable OPENCV_IO_MAX_IMAGE_PIXELS

Parameters:

filename - Name of file to be loaded.

flags - Flag that can take values of cv::ImreadModes

imread

@Namespace(value="cv")
 @ByVal
public static Mat imread(@opencv_core.Str
                                                        BytePointer filename)

imread

@Namespace(value="cv")
 @ByVal
public static Mat imread(@opencv_core.Str
                                                        String filename,
                                                        int flags)

imread

@Namespace(value="cv")
 @ByVal
public static Mat imread(@opencv_core.Str
                                                        String filename)

imreadmulti

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imreadmulti(@opencv_core.Str
                                                                              BytePointer filename,
                                                                              @ByRef
                                                                              MatVector mats,
                                                                              int flags)

\brief Loads a multi-page image from a file.

The function imreadmulti loads a multi-page image from the specified file into a vector of Mat objects.

Parameters:: filename - Name of file to be loaded.; flags - Flag that can take values of cv::ImreadModes, default with cv::IMREAD_ANYCOLOR.; mats - A vector of Mat objects holding each page, if more than one.
See Also:: cv::imread

imreadmulti

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imreadmulti(@opencv_core.Str
                                                                              BytePointer filename,
                                                                              @ByRef
                                                                              MatVector mats)

imreadmulti

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imreadmulti(@opencv_core.Str
                                                                              String filename,
                                                                              @ByRef
                                                                              MatVector mats,
                                                                              int flags)

imreadmulti

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imreadmulti(@opencv_core.Str
                                                                              String filename,
                                                                              @ByRef
                                                                              MatVector mats)

imwrite
```
@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          BytePointer filename,
                                                                          @ByVal
                                                                          Mat img,
                                                                          @StdVector
                                                                          IntPointer params)
```
\brief Saves an image to a specified file.
The function imwrite saves the image to the specified file. The image format is chosen based on the filename extension (see cv::imread for the list of extensions). In general, only 8-bit single-channel or 3-channel (with 'BGR' channel order) images can be saved using this function, with these exceptions:
- 16-bit unsigned (CV_16U) images can be saved in the case of PNG, JPEG 2000, and TIFF formats - 32-bit float (CV_32F) images can be saved in PFM, TIFF, OpenEXR, and Radiance HDR formats; 3-channel (CV_32FC3) TIFF images will be saved using the LogLuv high dynamic range encoding (4 bytes per pixel) - PNG images with an alpha channel can be saved using this function. To do this, create 8-bit (or 16-bit) 4-channel image BGRA, where the alpha channel goes last. Fully transparent pixels should have alpha set to 0, fully opaque pixels should have alpha set to 255/65535 (see the code sample below).
If the format, depth or channel order is different, use Mat::convertTo and cv::cvtColor to convert it before saving. Or, use the universal FileStorage I/O functions to save the image to XML or YAML format.
The sample below shows how to create a BGRA image and save it to a PNG file. It also demonstrates how to set custom compression parameters: \include snippets/imgcodecs_imwrite.cpp

Parameters:

filename - Name of the file.

img - Image to be saved.

params - Format-specific parameters encoded as pairs (paramId_1, paramValue_1, paramId_2, paramValue_2, ... .) see cv::ImwriteFlags

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          BytePointer filename,
                                                                          @ByVal
                                                                          Mat img)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          String filename,
                                                                          @ByVal
                                                                          Mat img,
                                                                          @StdVector
                                                                          IntBuffer params)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          String filename,
                                                                          @ByVal
                                                                          Mat img)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          BytePointer filename,
                                                                          @ByVal
                                                                          Mat img,
                                                                          @StdVector
                                                                          int[] params)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          String filename,
                                                                          @ByVal
                                                                          UMat img,
                                                                          @StdVector
                                                                          IntPointer params)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          String filename,
                                                                          @ByVal
                                                                          UMat img)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          BytePointer filename,
                                                                          @ByVal
                                                                          UMat img,
                                                                          @StdVector
                                                                          IntBuffer params)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          BytePointer filename,
                                                                          @ByVal
                                                                          UMat img)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          String filename,
                                                                          @ByVal
                                                                          UMat img,
                                                                          @StdVector
                                                                          int[] params)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          BytePointer filename,
                                                                          @ByVal
                                                                          GpuMat img,
                                                                          @StdVector
                                                                          IntPointer params)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          BytePointer filename,
                                                                          @ByVal
                                                                          GpuMat img)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          String filename,
                                                                          @ByVal
                                                                          GpuMat img,
                                                                          @StdVector
                                                                          IntBuffer params)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          String filename,
                                                                          @ByVal
                                                                          GpuMat img)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          BytePointer filename,
                                                                          @ByVal
                                                                          GpuMat img,
                                                                          @StdVector
                                                                          int[] params)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          String filename,
                                                                          @ByVal
                                                                          Mat img,
                                                                          @StdVector
                                                                          IntPointer params)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          BytePointer filename,
                                                                          @ByVal
                                                                          Mat img,
                                                                          @StdVector
                                                                          IntBuffer params)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          String filename,
                                                                          @ByVal
                                                                          Mat img,
                                                                          @StdVector
                                                                          int[] params)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          BytePointer filename,
                                                                          @ByVal
                                                                          UMat img,
                                                                          @StdVector
                                                                          IntPointer params)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          String filename,
                                                                          @ByVal
                                                                          UMat img,
                                                                          @StdVector
                                                                          IntBuffer params)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          BytePointer filename,
                                                                          @ByVal
                                                                          UMat img,
                                                                          @StdVector
                                                                          int[] params)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          String filename,
                                                                          @ByVal
                                                                          GpuMat img,
                                                                          @StdVector
                                                                          IntPointer params)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          BytePointer filename,
                                                                          @ByVal
                                                                          GpuMat img,
                                                                          @StdVector
                                                                          IntBuffer params)

imwrite

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          String filename,
                                                                          @ByVal
                                                                          GpuMat img,
                                                                          @StdVector
                                                                          int[] params)

imdecode
```
@Namespace(value="cv")
 @ByVal
public static Mat imdecode(@ByVal
                                                          Mat buf,
                                                          int flags)
```
\brief Reads an image from a buffer in memory.
The function imdecode reads an image from the specified buffer in the memory. If the buffer is too short or contains invalid data, the function returns an empty matrix ( Mat::data==NULL ).
See cv::imread for the list of supported formats and flags description.
\note In the case of color images, the decoded images will have the channels stored in **B G R** order.

Parameters:

buf - Input array or vector of bytes.

flags - The same flags as in cv::imread, see cv::ImreadModes.

imdecode

@Namespace(value="cv")
 @ByVal
public static Mat imdecode(@ByVal
                                                          UMat buf,
                                                          int flags)

imdecode

@Namespace(value="cv")
 @ByVal
public static Mat imdecode(@ByVal
                                                          GpuMat buf,
                                                          int flags)

imdecode

@Namespace(value="cv")
 @ByVal
public static Mat imdecode(@ByVal
                                                          Mat buf,
                                                          int flags,
                                                          Mat dst)

\overload

Parameters:: buf -; flags -; dst - The optional output placeholder for the decoded matrix. It can save the image reallocations when the function is called repeatedly for images of the same size.

imdecode

@Namespace(value="cv")
 @ByVal
public static Mat imdecode(@ByVal
                                                          UMat buf,
                                                          int flags,
                                                          Mat dst)

imdecode

@Namespace(value="cv")
 @ByVal
public static Mat imdecode(@ByVal
                                                          GpuMat buf,
                                                          int flags,
                                                          Mat dst)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           BytePointer ext,
                                                                           @ByVal
                                                                           Mat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           BytePointer buf,
                                                                           @StdVector
                                                                           IntPointer params)

\brief Encodes an image into a memory buffer.

The function imencode compresses the image and stores it in the memory buffer that is resized to fit the result. See cv::imwrite for the list of supported formats and flags description.

Parameters:: ext - File extension that defines the output format.; img - Image to be written.; buf - Output buffer resized to fit the compressed image.; params - Format-specific parameters. See cv::imwrite and cv::ImwriteFlags.

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           BytePointer ext,
                                                                           @ByVal
                                                                           Mat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           BytePointer buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           Mat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           ByteBuffer buf,
                                                                           @StdVector
                                                                           IntBuffer params)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           Mat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           ByteBuffer buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           BytePointer ext,
                                                                           @ByVal
                                                                           Mat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           byte[] buf,
                                                                           @StdVector
                                                                           int[] params)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           BytePointer ext,
                                                                           @ByVal
                                                                           Mat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           byte[] buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           UMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           BytePointer buf,
                                                                           @StdVector
                                                                           IntPointer params)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           UMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           BytePointer buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           BytePointer ext,
                                                                           @ByVal
                                                                           UMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           ByteBuffer buf,
                                                                           @StdVector
                                                                           IntBuffer params)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           BytePointer ext,
                                                                           @ByVal
                                                                           UMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           ByteBuffer buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           UMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           byte[] buf,
                                                                           @StdVector
                                                                           int[] params)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           UMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           byte[] buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           BytePointer ext,
                                                                           @ByVal
                                                                           GpuMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           BytePointer buf,
                                                                           @StdVector
                                                                           IntPointer params)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           BytePointer ext,
                                                                           @ByVal
                                                                           GpuMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           BytePointer buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           GpuMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           ByteBuffer buf,
                                                                           @StdVector
                                                                           IntBuffer params)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           GpuMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           ByteBuffer buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           BytePointer ext,
                                                                           @ByVal
                                                                           GpuMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           byte[] buf,
                                                                           @StdVector
                                                                           int[] params)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           BytePointer ext,
                                                                           @ByVal
                                                                           GpuMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           byte[] buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           Mat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           BytePointer buf,
                                                                           @StdVector
                                                                           IntPointer params)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           Mat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           BytePointer buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           BytePointer ext,
                                                                           @ByVal
                                                                           Mat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           ByteBuffer buf,
                                                                           @StdVector
                                                                           IntBuffer params)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           BytePointer ext,
                                                                           @ByVal
                                                                           Mat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           ByteBuffer buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           Mat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           byte[] buf,
                                                                           @StdVector
                                                                           int[] params)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           Mat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           byte[] buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           BytePointer ext,
                                                                           @ByVal
                                                                           UMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           BytePointer buf,
                                                                           @StdVector
                                                                           IntPointer params)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           BytePointer ext,
                                                                           @ByVal
                                                                           UMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           BytePointer buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           UMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           ByteBuffer buf,
                                                                           @StdVector
                                                                           IntBuffer params)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           UMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           ByteBuffer buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           BytePointer ext,
                                                                           @ByVal
                                                                           UMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           byte[] buf,
                                                                           @StdVector
                                                                           int[] params)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           BytePointer ext,
                                                                           @ByVal
                                                                           UMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           byte[] buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           GpuMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           BytePointer buf,
                                                                           @StdVector
                                                                           IntPointer params)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           GpuMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           BytePointer buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           BytePointer ext,
                                                                           @ByVal
                                                                           GpuMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           ByteBuffer buf,
                                                                           @StdVector
                                                                           IntBuffer params)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           BytePointer ext,
                                                                           @ByVal
                                                                           GpuMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           ByteBuffer buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           GpuMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           byte[] buf,
                                                                           @StdVector
                                                                           int[] params)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           GpuMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           byte[] buf)

haveImageReader

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean haveImageReader(@opencv_core.Str
                                                                                  BytePointer filename)

\brief Returns true if the specified image can be decoded by OpenCV

Parameters:: filename - File name of the image

haveImageReader

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean haveImageReader(@opencv_core.Str
                                                                                  String filename)

haveImageWriter

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean haveImageWriter(@opencv_core.Str
                                                                                  BytePointer filename)

\brief Returns true if an image with the specified filename can be encoded by OpenCV

Parameters:: filename - File name of the image

haveImageWriter

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean haveImageWriter(@opencv_core.Str
                                                                                  String filename)

Class opencv_imgcodecs

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.opencv.helper.opencv_imgcodecs

Methods inherited from class org.bytedeco.opencv.presets.opencv_imgcodecs

Methods inherited from class java.lang.Object

Field Detail

IMREAD_UNCHANGED

IMREAD_GRAYSCALE

IMREAD_COLOR

IMREAD_ANYDEPTH

IMREAD_ANYCOLOR

IMREAD_LOAD_GDAL

IMREAD_REDUCED_GRAYSCALE_2

IMREAD_REDUCED_COLOR_2

IMREAD_REDUCED_GRAYSCALE_4

IMREAD_REDUCED_COLOR_4

IMREAD_REDUCED_GRAYSCALE_8

IMREAD_REDUCED_COLOR_8

IMREAD_IGNORE_ORIENTATION

IMWRITE_JPEG_QUALITY

IMWRITE_JPEG_PROGRESSIVE

IMWRITE_JPEG_OPTIMIZE

IMWRITE_JPEG_RST_INTERVAL

IMWRITE_JPEG_LUMA_QUALITY

IMWRITE_JPEG_CHROMA_QUALITY

IMWRITE_PNG_COMPRESSION

IMWRITE_PNG_STRATEGY

IMWRITE_PNG_BILEVEL

IMWRITE_PXM_BINARY

IMWRITE_EXR_TYPE

IMWRITE_WEBP_QUALITY

IMWRITE_PAM_TUPLETYPE

IMWRITE_TIFF_RESUNIT

IMWRITE_TIFF_XDPI

IMWRITE_TIFF_YDPI

IMWRITE_TIFF_COMPRESSION

IMWRITE_JPEG2000_COMPRESSION_X1000

IMWRITE_EXR_TYPE_HALF

IMWRITE_EXR_TYPE_FLOAT

IMWRITE_PNG_STRATEGY_DEFAULT

IMWRITE_PNG_STRATEGY_FILTERED

IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY

IMWRITE_PNG_STRATEGY_RLE

IMWRITE_PNG_STRATEGY_FIXED

IMWRITE_PAM_FORMAT_NULL

IMWRITE_PAM_FORMAT_BLACKANDWHITE

IMWRITE_PAM_FORMAT_GRAYSCALE

IMWRITE_PAM_FORMAT_GRAYSCALE_ALPHA

IMWRITE_PAM_FORMAT_RGB

IMWRITE_PAM_FORMAT_RGB_ALPHA

Constructor Detail

opencv_imgcodecs

Method Detail

imread

imread

imread

imread

imreadmulti

imreadmulti

imreadmulti

imreadmulti

imwrite

imwrite

imwrite

imwrite

imwrite

imwrite

imwrite

imwrite

imwrite

imwrite

imwrite

imwrite

imwrite

imwrite

imwrite

imwrite

imwrite