opencv_imgcodecs (JavaCPP Presets for OpenCV 3.4.3-1.4.3 API)

java.lang.Object
- org.bytedeco.javacpp.presets.opencv_imgcodecs
- - org.bytedeco.javacpp.helper.opencv_imgcodecs
  - - org.bytedeco.javacpp.opencv_imgcodecs

All Implemented Interfaces:

org.bytedeco.javacpp.tools.InfoMapper
```
public class opencv_imgcodecs
extends opencv_imgcodecs
```

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`CV_CVTIMG_FLIP` enum
`static int`	`CV_CVTIMG_SWAP_RB` enum
`static int`	`CV_IMWRITE_EXR_TYPE` enum
`static int`	`CV_IMWRITE_JPEG_CHROMA_QUALITY` enum
`static int`	`CV_IMWRITE_JPEG_LUMA_QUALITY` enum
`static int`	`CV_IMWRITE_JPEG_OPTIMIZE` enum
`static int`	`CV_IMWRITE_JPEG_PROGRESSIVE` enum
`static int`	`CV_IMWRITE_JPEG_QUALITY` enum
`static int`	`CV_IMWRITE_JPEG_RST_INTERVAL` enum
`static int`	`CV_IMWRITE_PAM_FORMAT_BLACKANDWHITE` enum
`static int`	`CV_IMWRITE_PAM_FORMAT_GRAYSCALE` enum
`static int`	`CV_IMWRITE_PAM_FORMAT_GRAYSCALE_ALPHA` enum
`static int`	`CV_IMWRITE_PAM_FORMAT_NULL` enum
`static int`	`CV_IMWRITE_PAM_FORMAT_RGB` enum
`static int`	`CV_IMWRITE_PAM_FORMAT_RGB_ALPHA` enum
`static int`	`CV_IMWRITE_PAM_TUPLETYPE` enum
`static int`	`CV_IMWRITE_PNG_BILEVEL` enum
`static int`	`CV_IMWRITE_PNG_COMPRESSION` enum
`static int`	`CV_IMWRITE_PNG_STRATEGY` enum
`static int`	`CV_IMWRITE_PNG_STRATEGY_DEFAULT` enum
`static int`	`CV_IMWRITE_PNG_STRATEGY_FILTERED` enum
`static int`	`CV_IMWRITE_PNG_STRATEGY_FIXED` enum
`static int`	`CV_IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY` enum
`static int`	`CV_IMWRITE_PNG_STRATEGY_RLE` enum
`static int`	`CV_IMWRITE_PXM_BINARY` enum
`static int`	`CV_IMWRITE_WEBP_QUALITY` enum
`static int`	`CV_LOAD_IMAGE_ANYCOLOR` enum
`static int`	`CV_LOAD_IMAGE_ANYDEPTH` enum
`static int`	`CV_LOAD_IMAGE_COLOR` enum
`static int`	`CV_LOAD_IMAGE_GRAYSCALE` enum
`static int`	`CV_LOAD_IMAGE_IGNORE_ORIENTATION` enum
`static int`	`CV_LOAD_IMAGE_UNCHANGED` enum
`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_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_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 void`	`cvConvertImage(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvConvertImage(opencv_core.CvArr src, opencv_core.CvArr dst, int flags)`
`static opencv_core.IplImage`	`cvDecodeImage(opencv_core.CvMat buf)`
`static opencv_core.IplImage`	`cvDecodeImage(opencv_core.CvMat buf, int iscolor)`
`static opencv_core.CvMat`	`cvDecodeImageM(opencv_core.CvMat buf)`
`static opencv_core.CvMat`	`cvDecodeImageM(opencv_core.CvMat buf, int iscolor)`
`static opencv_core.CvMat`	`cvEncodeImage(org.bytedeco.javacpp.BytePointer ext, opencv_core.CvArr image)`
`static opencv_core.CvMat`	`cvEncodeImage(org.bytedeco.javacpp.BytePointer ext, opencv_core.CvArr image, int[] params)`
`static opencv_core.CvMat`	`cvEncodeImage(org.bytedeco.javacpp.BytePointer ext, opencv_core.CvArr image, IntBuffer params)`
`static opencv_core.CvMat`	`cvEncodeImage(org.bytedeco.javacpp.BytePointer ext, opencv_core.CvArr image, org.bytedeco.javacpp.IntPointer params)`
`static opencv_core.CvMat`	`cvEncodeImage(String ext, opencv_core.CvArr image)`
`static opencv_core.CvMat`	`cvEncodeImage(String ext, opencv_core.CvArr image, int[] params)`
`static opencv_core.CvMat`	`cvEncodeImage(String ext, opencv_core.CvArr image, IntBuffer params)`
`static opencv_core.CvMat`	`cvEncodeImage(String ext, opencv_core.CvArr image, org.bytedeco.javacpp.IntPointer params)`
`static int`	`cvHaveImageReader(org.bytedeco.javacpp.BytePointer filename)`
`static int`	`cvHaveImageReader(String filename)`
`static int`	`cvHaveImageWriter(org.bytedeco.javacpp.BytePointer filename)`
`static int`	`cvHaveImageWriter(String filename)`
`static opencv_core.IplImage`	`cvLoadImage(org.bytedeco.javacpp.BytePointer filename)`
`static opencv_core.IplImage`	`cvLoadImage(org.bytedeco.javacpp.BytePointer filename, int iscolor)`
`static opencv_core.IplImage`	`cvLoadImage(String filename)`
`static opencv_core.IplImage`	`cvLoadImage(String filename, int iscolor)`
`static opencv_core.CvMat`	`cvLoadImageM(org.bytedeco.javacpp.BytePointer filename)`
`static opencv_core.CvMat`	`cvLoadImageM(org.bytedeco.javacpp.BytePointer filename, int iscolor)`
`static opencv_core.CvMat`	`cvLoadImageM(String filename)`
`static opencv_core.CvMat`	`cvLoadImageM(String filename, int iscolor)`
`static int`	`cvSaveImage(org.bytedeco.javacpp.BytePointer filename, opencv_core.CvArr image)`
`static int`	`cvSaveImage(org.bytedeco.javacpp.BytePointer filename, opencv_core.CvArr image, int[] params)`
`static int`	`cvSaveImage(org.bytedeco.javacpp.BytePointer filename, opencv_core.CvArr image, IntBuffer params)`
`static int`	`cvSaveImage(org.bytedeco.javacpp.BytePointer filename, opencv_core.CvArr image, org.bytedeco.javacpp.IntPointer params)`
`static int`	`cvSaveImage(String filename, opencv_core.CvArr image)`
`static int`	`cvSaveImage(String filename, opencv_core.CvArr image, int[] params)`
`static int`	`cvSaveImage(String filename, opencv_core.CvArr image, IntBuffer params)`
`static int`	`cvSaveImage(String filename, opencv_core.CvArr image, org.bytedeco.javacpp.IntPointer params)`
`static void`	`cvvConvertImage(opencv_core.CvArr arg1, opencv_core.CvArr arg2, int arg3)`
`static opencv_core.IplImage`	`cvvLoadImage(org.bytedeco.javacpp.BytePointer name)` \ Obsolete functions/synonyms * \
`static opencv_core.IplImage`	`cvvLoadImage(String name)`
`static int`	`cvvSaveImage(org.bytedeco.javacpp.BytePointer arg1, opencv_core.CvArr arg2, int[] arg3)`
`static int`	`cvvSaveImage(org.bytedeco.javacpp.BytePointer arg1, opencv_core.CvArr arg2, IntBuffer arg3)`
`static int`	`cvvSaveImage(org.bytedeco.javacpp.BytePointer arg1, opencv_core.CvArr arg2, org.bytedeco.javacpp.IntPointer arg3)`
`static int`	`cvvSaveImage(String arg1, opencv_core.CvArr arg2, int[] arg3)`
`static int`	`cvvSaveImage(String arg1, opencv_core.CvArr arg2, IntBuffer arg3)`
`static int`	`cvvSaveImage(String arg1, opencv_core.CvArr arg2, org.bytedeco.javacpp.IntPointer arg3)`
`static opencv_core.Mat`	`imdecode(opencv_core.GpuMat buf, int flags)`
`static opencv_core.Mat`	`imdecode(opencv_core.GpuMat buf, int flags, opencv_core.Mat dst)`
`static opencv_core.Mat`	`imdecode(opencv_core.Mat buf, int flags)` \brief Reads an image from a buffer in memory.
`static opencv_core.Mat`	`imdecode(opencv_core.Mat buf, int flags, opencv_core.Mat dst)` \overload
`static opencv_core.Mat`	`imdecode(opencv_core.UMat buf, int flags)`
`static opencv_core.Mat`	`imdecode(opencv_core.UMat buf, int flags, opencv_core.Mat dst)`
`static boolean`	`imencode(org.bytedeco.javacpp.BytePointer ext, opencv_core.GpuMat img, byte[] buf)`
`static boolean`	`imencode(org.bytedeco.javacpp.BytePointer ext, opencv_core.GpuMat img, byte[] buf, int[] params)`
`static boolean`	`imencode(org.bytedeco.javacpp.BytePointer ext, opencv_core.GpuMat img, ByteBuffer buf)`
`static boolean`	`imencode(org.bytedeco.javacpp.BytePointer ext, opencv_core.GpuMat img, ByteBuffer buf, IntBuffer params)`
`static boolean`	`imencode(org.bytedeco.javacpp.BytePointer ext, opencv_core.GpuMat img, org.bytedeco.javacpp.BytePointer buf)`
`static boolean`	`imencode(org.bytedeco.javacpp.BytePointer ext, opencv_core.GpuMat img, org.bytedeco.javacpp.BytePointer buf, org.bytedeco.javacpp.IntPointer params)`
`static boolean`	`imencode(org.bytedeco.javacpp.BytePointer ext, opencv_core.Mat img, byte[] buf)`
`static boolean`	`imencode(org.bytedeco.javacpp.BytePointer ext, opencv_core.Mat img, byte[] buf, int[] params)`
`static boolean`	`imencode(org.bytedeco.javacpp.BytePointer ext, opencv_core.Mat img, ByteBuffer buf)`
`static boolean`	`imencode(org.bytedeco.javacpp.BytePointer ext, opencv_core.Mat img, ByteBuffer buf, IntBuffer params)`
`static boolean`	`imencode(org.bytedeco.javacpp.BytePointer ext, opencv_core.Mat img, org.bytedeco.javacpp.BytePointer buf)`
`static boolean`	`imencode(org.bytedeco.javacpp.BytePointer ext, opencv_core.Mat img, org.bytedeco.javacpp.BytePointer buf, org.bytedeco.javacpp.IntPointer params)` \brief Encodes an image into a memory buffer.
`static boolean`	`imencode(org.bytedeco.javacpp.BytePointer ext, opencv_core.UMat img, byte[] buf)`
`static boolean`	`imencode(org.bytedeco.javacpp.BytePointer ext, opencv_core.UMat img, byte[] buf, int[] params)`
`static boolean`	`imencode(org.bytedeco.javacpp.BytePointer ext, opencv_core.UMat img, ByteBuffer buf)`
`static boolean`	`imencode(org.bytedeco.javacpp.BytePointer ext, opencv_core.UMat img, ByteBuffer buf, IntBuffer params)`
`static boolean`	`imencode(org.bytedeco.javacpp.BytePointer ext, opencv_core.UMat img, org.bytedeco.javacpp.BytePointer buf)`
`static boolean`	`imencode(org.bytedeco.javacpp.BytePointer ext, opencv_core.UMat img, org.bytedeco.javacpp.BytePointer buf, org.bytedeco.javacpp.IntPointer params)`
`static boolean`	`imencode(String ext, opencv_core.GpuMat img, byte[] buf)`
`static boolean`	`imencode(String ext, opencv_core.GpuMat img, byte[] buf, int[] params)`
`static boolean`	`imencode(String ext, opencv_core.GpuMat img, ByteBuffer buf)`
`static boolean`	`imencode(String ext, opencv_core.GpuMat img, ByteBuffer buf, IntBuffer params)`
`static boolean`	`imencode(String ext, opencv_core.GpuMat img, org.bytedeco.javacpp.BytePointer buf)`
`static boolean`	`imencode(String ext, opencv_core.GpuMat img, org.bytedeco.javacpp.BytePointer buf, org.bytedeco.javacpp.IntPointer params)`
`static boolean`	`imencode(String ext, opencv_core.Mat img, byte[] buf)`
`static boolean`	`imencode(String ext, opencv_core.Mat img, byte[] buf, int[] params)`
`static boolean`	`imencode(String ext, opencv_core.Mat img, ByteBuffer buf)`
`static boolean`	`imencode(String ext, opencv_core.Mat img, ByteBuffer buf, IntBuffer params)`
`static boolean`	`imencode(String ext, opencv_core.Mat img, org.bytedeco.javacpp.BytePointer buf)`
`static boolean`	`imencode(String ext, opencv_core.Mat img, org.bytedeco.javacpp.BytePointer buf, org.bytedeco.javacpp.IntPointer params)`
`static boolean`	`imencode(String ext, opencv_core.UMat img, byte[] buf)`
`static boolean`	`imencode(String ext, opencv_core.UMat img, byte[] buf, int[] params)`
`static boolean`	`imencode(String ext, opencv_core.UMat img, ByteBuffer buf)`
`static boolean`	`imencode(String ext, opencv_core.UMat img, ByteBuffer buf, IntBuffer params)`
`static boolean`	`imencode(String ext, opencv_core.UMat img, org.bytedeco.javacpp.BytePointer buf)`
`static boolean`	`imencode(String ext, opencv_core.UMat img, org.bytedeco.javacpp.BytePointer buf, org.bytedeco.javacpp.IntPointer params)`
`static opencv_core.Mat`	`imread(org.bytedeco.javacpp.BytePointer filename)`
`static opencv_core.Mat`	`imread(org.bytedeco.javacpp.BytePointer filename, int flags)` \brief Loads an image from a file.
`static opencv_core.Mat`	`imread(String filename)`
`static opencv_core.Mat`	`imread(String filename, int flags)`
`static boolean`	`imreadmulti(org.bytedeco.javacpp.BytePointer filename, opencv_core.MatVector mats)`
`static boolean`	`imreadmulti(org.bytedeco.javacpp.BytePointer filename, opencv_core.MatVector mats, int flags)` \brief Loads a multi-page image from a file.
`static boolean`	`imreadmulti(String filename, opencv_core.MatVector mats)`
`static boolean`	`imreadmulti(String filename, opencv_core.MatVector mats, int flags)`
`static boolean`	`imwrite(org.bytedeco.javacpp.BytePointer filename, opencv_core.GpuMat img)`
`static boolean`	`imwrite(org.bytedeco.javacpp.BytePointer filename, opencv_core.GpuMat img, int[] params)`
`static boolean`	`imwrite(org.bytedeco.javacpp.BytePointer filename, opencv_core.GpuMat img, IntBuffer params)`
`static boolean`	`imwrite(org.bytedeco.javacpp.BytePointer filename, opencv_core.GpuMat img, org.bytedeco.javacpp.IntPointer params)`
`static boolean`	`imwrite(org.bytedeco.javacpp.BytePointer filename, opencv_core.Mat img)`
`static boolean`	`imwrite(org.bytedeco.javacpp.BytePointer filename, opencv_core.Mat img, int[] params)`
`static boolean`	`imwrite(org.bytedeco.javacpp.BytePointer filename, opencv_core.Mat img, IntBuffer params)`
`static boolean`	`imwrite(org.bytedeco.javacpp.BytePointer filename, opencv_core.Mat img, org.bytedeco.javacpp.IntPointer params)` \brief Saves an image to a specified file.
`static boolean`	`imwrite(org.bytedeco.javacpp.BytePointer filename, opencv_core.UMat img)`
`static boolean`	`imwrite(org.bytedeco.javacpp.BytePointer filename, opencv_core.UMat img, int[] params)`
`static boolean`	`imwrite(org.bytedeco.javacpp.BytePointer filename, opencv_core.UMat img, IntBuffer params)`
`static boolean`	`imwrite(org.bytedeco.javacpp.BytePointer filename, opencv_core.UMat img, org.bytedeco.javacpp.IntPointer params)`
`static boolean`	`imwrite(String filename, opencv_core.GpuMat img)`
`static boolean`	`imwrite(String filename, opencv_core.GpuMat img, int[] params)`
`static boolean`	`imwrite(String filename, opencv_core.GpuMat img, IntBuffer params)`
`static boolean`	`imwrite(String filename, opencv_core.GpuMat img, org.bytedeco.javacpp.IntPointer params)`
`static boolean`	`imwrite(String filename, opencv_core.Mat img)`
`static boolean`	`imwrite(String filename, opencv_core.Mat img, int[] params)`
`static boolean`	`imwrite(String filename, opencv_core.Mat img, IntBuffer params)`
`static boolean`	`imwrite(String filename, opencv_core.Mat img, org.bytedeco.javacpp.IntPointer params)`
`static boolean`	`imwrite(String filename, opencv_core.UMat img)`
`static boolean`	`imwrite(String filename, opencv_core.UMat img, int[] params)`
`static boolean`	`imwrite(String filename, opencv_core.UMat img, IntBuffer params)`
`static boolean`	`imwrite(String filename, opencv_core.UMat img, org.bytedeco.javacpp.IntPointer params)`

Methods inherited from class org.bytedeco.javacpp.helper.opencv_imgcodecs
cvLoadImageBGRA, cvLoadImageRGBA

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

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

Field Detail
- CV_LOAD_IMAGE_UNCHANGED
```
public static final int CV_LOAD_IMAGE_UNCHANGED
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_LOAD_IMAGE_GRAYSCALE
```
public static final int CV_LOAD_IMAGE_GRAYSCALE
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_LOAD_IMAGE_COLOR
```
public static final int CV_LOAD_IMAGE_COLOR
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_LOAD_IMAGE_ANYDEPTH
```
public static final int CV_LOAD_IMAGE_ANYDEPTH
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_LOAD_IMAGE_ANYCOLOR
```
public static final int CV_LOAD_IMAGE_ANYCOLOR
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_LOAD_IMAGE_IGNORE_ORIENTATION
```
public static final int CV_LOAD_IMAGE_IGNORE_ORIENTATION
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_JPEG_QUALITY
```
public static final int CV_IMWRITE_JPEG_QUALITY
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_JPEG_PROGRESSIVE
```
public static final int CV_IMWRITE_JPEG_PROGRESSIVE
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_JPEG_OPTIMIZE
```
public static final int CV_IMWRITE_JPEG_OPTIMIZE
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_JPEG_RST_INTERVAL
```
public static final int CV_IMWRITE_JPEG_RST_INTERVAL
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_JPEG_LUMA_QUALITY
```
public static final int CV_IMWRITE_JPEG_LUMA_QUALITY
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_JPEG_CHROMA_QUALITY
```
public static final int CV_IMWRITE_JPEG_CHROMA_QUALITY
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_PNG_COMPRESSION
```
public static final int CV_IMWRITE_PNG_COMPRESSION
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_PNG_STRATEGY
```
public static final int CV_IMWRITE_PNG_STRATEGY
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_PNG_BILEVEL
```
public static final int CV_IMWRITE_PNG_BILEVEL
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_PNG_STRATEGY_DEFAULT
```
public static final int CV_IMWRITE_PNG_STRATEGY_DEFAULT
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_PNG_STRATEGY_FILTERED
```
public static final int CV_IMWRITE_PNG_STRATEGY_FILTERED
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY
```
public static final int CV_IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_PNG_STRATEGY_RLE
```
public static final int CV_IMWRITE_PNG_STRATEGY_RLE
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_PNG_STRATEGY_FIXED
```
public static final int CV_IMWRITE_PNG_STRATEGY_FIXED
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_PXM_BINARY
```
public static final int CV_IMWRITE_PXM_BINARY
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_EXR_TYPE
```
public static final int CV_IMWRITE_EXR_TYPE
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_WEBP_QUALITY
```
public static final int CV_IMWRITE_WEBP_QUALITY
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_PAM_TUPLETYPE
```
public static final int CV_IMWRITE_PAM_TUPLETYPE
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_PAM_FORMAT_NULL
```
public static final int CV_IMWRITE_PAM_FORMAT_NULL
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_PAM_FORMAT_BLACKANDWHITE
```
public static final int CV_IMWRITE_PAM_FORMAT_BLACKANDWHITE
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_PAM_FORMAT_GRAYSCALE
```
public static final int CV_IMWRITE_PAM_FORMAT_GRAYSCALE
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_PAM_FORMAT_GRAYSCALE_ALPHA
```
public static final int CV_IMWRITE_PAM_FORMAT_GRAYSCALE_ALPHA
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_PAM_FORMAT_RGB
```
public static final int CV_IMWRITE_PAM_FORMAT_RGB
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_IMWRITE_PAM_FORMAT_RGB_ALPHA
```
public static final int CV_IMWRITE_PAM_FORMAT_RGB_ALPHA
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_CVTIMG_FLIP
```
public static final int CV_CVTIMG_FLIP
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_CVTIMG_SWAP_RB
```
public static final int CV_CVTIMG_SWAP_RB
```
  enum
  
  See Also:
  
  Constant Field Values
- 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_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

cvLoadImage

public static opencv_core.IplImage cvLoadImage(@Cast(value="const char*")
                                               org.bytedeco.javacpp.BytePointer filename,
                                               int iscolor)

cvLoadImage

public static opencv_core.IplImage cvLoadImage(@Cast(value="const char*")
                                               org.bytedeco.javacpp.BytePointer filename)

cvLoadImage

public static opencv_core.IplImage cvLoadImage(String filename,
                                               int iscolor)

cvLoadImage

public static opencv_core.IplImage cvLoadImage(String filename)

cvLoadImageM

public static opencv_core.CvMat cvLoadImageM(@Cast(value="const char*")
                                             org.bytedeco.javacpp.BytePointer filename,
                                             int iscolor)

cvLoadImageM

public static opencv_core.CvMat cvLoadImageM(@Cast(value="const char*")
                                             org.bytedeco.javacpp.BytePointer filename)

cvLoadImageM

public static opencv_core.CvMat cvLoadImageM(String filename,
                                             int iscolor)

cvLoadImageM

public static opencv_core.CvMat cvLoadImageM(String filename)

cvSaveImage

public static int cvSaveImage(@Cast(value="const char*")
                              org.bytedeco.javacpp.BytePointer filename,
                              @Const
                              opencv_core.CvArr image,
                              @Const
                              org.bytedeco.javacpp.IntPointer params)

cvSaveImage

public static int cvSaveImage(@Cast(value="const char*")
                              org.bytedeco.javacpp.BytePointer filename,
                              @Const
                              opencv_core.CvArr image)

cvSaveImage

public static int cvSaveImage(String filename,
                              @Const
                              opencv_core.CvArr image,
                              @Const
                              IntBuffer params)

cvSaveImage

public static int cvSaveImage(String filename,
                              @Const
                              opencv_core.CvArr image)

cvSaveImage

public static int cvSaveImage(@Cast(value="const char*")
                              org.bytedeco.javacpp.BytePointer filename,
                              @Const
                              opencv_core.CvArr image,
                              @Const
                              int[] params)

cvSaveImage

public static int cvSaveImage(String filename,
                              @Const
                              opencv_core.CvArr image,
                              @Const
                              org.bytedeco.javacpp.IntPointer params)

cvSaveImage

public static int cvSaveImage(@Cast(value="const char*")
                              org.bytedeco.javacpp.BytePointer filename,
                              @Const
                              opencv_core.CvArr image,
                              @Const
                              IntBuffer params)

cvSaveImage

public static int cvSaveImage(String filename,
                              @Const
                              opencv_core.CvArr image,
                              @Const
                              int[] params)

cvDecodeImage

public static opencv_core.IplImage cvDecodeImage(@Const
                                                 opencv_core.CvMat buf,
                                                 int iscolor)

cvDecodeImage

public static opencv_core.IplImage cvDecodeImage(@Const
                                                 opencv_core.CvMat buf)

cvDecodeImageM

public static opencv_core.CvMat cvDecodeImageM(@Const
                                               opencv_core.CvMat buf,
                                               int iscolor)

cvDecodeImageM

public static opencv_core.CvMat cvDecodeImageM(@Const
                                               opencv_core.CvMat buf)

cvEncodeImage

public static opencv_core.CvMat cvEncodeImage(@Cast(value="const char*")
                                              org.bytedeco.javacpp.BytePointer ext,
                                              @Const
                                              opencv_core.CvArr image,
                                              @Const
                                              org.bytedeco.javacpp.IntPointer params)

cvEncodeImage

public static opencv_core.CvMat cvEncodeImage(@Cast(value="const char*")
                                              org.bytedeco.javacpp.BytePointer ext,
                                              @Const
                                              opencv_core.CvArr image)

cvEncodeImage

public static opencv_core.CvMat cvEncodeImage(String ext,
                                              @Const
                                              opencv_core.CvArr image,
                                              @Const
                                              IntBuffer params)

cvEncodeImage

public static opencv_core.CvMat cvEncodeImage(String ext,
                                              @Const
                                              opencv_core.CvArr image)

cvEncodeImage

public static opencv_core.CvMat cvEncodeImage(@Cast(value="const char*")
                                              org.bytedeco.javacpp.BytePointer ext,
                                              @Const
                                              opencv_core.CvArr image,
                                              @Const
                                              int[] params)

cvEncodeImage

public static opencv_core.CvMat cvEncodeImage(String ext,
                                              @Const
                                              opencv_core.CvArr image,
                                              @Const
                                              org.bytedeco.javacpp.IntPointer params)

cvEncodeImage

public static opencv_core.CvMat cvEncodeImage(@Cast(value="const char*")
                                              org.bytedeco.javacpp.BytePointer ext,
                                              @Const
                                              opencv_core.CvArr image,
                                              @Const
                                              IntBuffer params)

cvEncodeImage

public static opencv_core.CvMat cvEncodeImage(String ext,
                                              @Const
                                              opencv_core.CvArr image,
                                              @Const
                                              int[] params)

cvConvertImage

public static void cvConvertImage(@Const
                                  opencv_core.CvArr src,
                                  opencv_core.CvArr dst,
                                  int flags)

cvConvertImage

public static void cvConvertImage(@Const
                                  opencv_core.CvArr src,
                                  opencv_core.CvArr dst)

cvHaveImageReader

public static int cvHaveImageReader(@Cast(value="const char*")
                                    org.bytedeco.javacpp.BytePointer filename)

cvHaveImageReader

public static int cvHaveImageReader(String filename)

cvHaveImageWriter

public static int cvHaveImageWriter(@Cast(value="const char*")
                                    org.bytedeco.javacpp.BytePointer filename)

cvHaveImageWriter

public static int cvHaveImageWriter(String filename)

cvvLoadImage

public static opencv_core.IplImage cvvLoadImage(@Cast(value="const char*")
                                                org.bytedeco.javacpp.BytePointer name)

\ Obsolete functions/synonyms * \

cvvLoadImage

public static opencv_core.IplImage cvvLoadImage(String name)

cvvSaveImage

public static int cvvSaveImage(@Cast(value="const char*")
                               org.bytedeco.javacpp.BytePointer arg1,
                               opencv_core.CvArr arg2,
                               org.bytedeco.javacpp.IntPointer arg3)

cvvSaveImage

public static int cvvSaveImage(String arg1,
                               opencv_core.CvArr arg2,
                               IntBuffer arg3)

cvvSaveImage

public static int cvvSaveImage(@Cast(value="const char*")
                               org.bytedeco.javacpp.BytePointer arg1,
                               opencv_core.CvArr arg2,
                               int[] arg3)

cvvSaveImage

public static int cvvSaveImage(String arg1,
                               opencv_core.CvArr arg2,
                               org.bytedeco.javacpp.IntPointer arg3)

cvvSaveImage

public static int cvvSaveImage(@Cast(value="const char*")
                               org.bytedeco.javacpp.BytePointer arg1,
                               opencv_core.CvArr arg2,
                               IntBuffer arg3)

cvvSaveImage

public static int cvvSaveImage(String arg1,
                               opencv_core.CvArr arg2,
                               int[] arg3)

cvvConvertImage

public static void cvvConvertImage(opencv_core.CvArr arg1,
                                   opencv_core.CvArr arg2,
                                   int arg3)

imread
```
@Namespace(value="cv")
 @ByVal
public static opencv_core.Mat imread(@opencv_core.Str
                                                                    org.bytedeco.javacpp.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 *Notes* section) - JPEG 2000 files - \*.jp2 (see the *Notes* section) - Portable Network Graphics - \*.png (see the *Notes* section) - WebP - \*.webp (see the *Notes* section) - Portable image format - \*.pbm, \*.pgm, \*.ppm \*.pxm, \*.pnm (always supported) - Sun rasters - \*.sr, \*.ras (always supported) - TIFF files - \*.tiff, \*.tif (see the *Notes* section) - OpenEXR Image files - \*.exr (see the *Notes* section) - Radiance HDR - \*.hdr, \*.pic (always supported) - Raster and Vector geospatial data supported by Gdal (see the *Notes* 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. - 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 [GDAL](http://www.gdal.org) driver will be used in order to decode the image by supporting the following formats: [Raster](http://www.gdal.org/formats_list.html), [Vector](http://www.gdal.org/ogr_formats.html). - If EXIF information are embedded in the image file, the EXIF orientation will be taken into account and thus the image will be rotated accordingly except if the flag \ref IMREAD_IGNORE_ORIENTATION is passed.

Parameters:

filename - Name of file to be loaded.

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

imread

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

imread

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

imread

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

imreadmulti

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imreadmulti(@opencv_core.Str
                                                                              org.bytedeco.javacpp.BytePointer filename,
                                                                              @ByRef
                                                                              opencv_core.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. \sa cv::imread

imreadmulti

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

imreadmulti

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

imreadmulti

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

imwrite
```
@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imwrite(@opencv_core.Str
                                                                          org.bytedeco.javacpp.BytePointer filename,
                                                                          @ByVal
                                                                          opencv_core.Mat img,
                                                                          @StdVector
                                                                          org.bytedeco.javacpp.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). Only 8-bit (or 16-bit unsigned (CV_16U) in case of PNG, JPEG 2000, and TIFF) single-channel or 3-channel (with 'BGR' channel order) images can be saved using this function. 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.
It is possible to store PNG images with an alpha channel 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.
The sample below shows how to create such a BGRA image and store to 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
                                                                          org.bytedeco.javacpp.BytePointer filename,
                                                                          @ByVal
                                                                          opencv_core.Mat img)

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imwrite

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

imdecode
```
@Namespace(value="cv")
 @ByVal
public static opencv_core.Mat imdecode(@ByVal
                                                                      opencv_core.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 opencv_core.Mat imdecode(@ByVal
                                                                      opencv_core.UMat buf,
                                                                      int flags)

imdecode

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

imdecode

@Namespace(value="cv")
 @ByVal
public static opencv_core.Mat imdecode(@ByVal
                                                                      opencv_core.Mat buf,
                                                                      int flags,
                                                                      opencv_core.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 opencv_core.Mat imdecode(@ByVal
                                                                      opencv_core.UMat buf,
                                                                      int flags,
                                                                      opencv_core.Mat dst)

imdecode

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

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           org.bytedeco.javacpp.BytePointer ext,
                                                                           @ByVal
                                                                           opencv_core.Mat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           org.bytedeco.javacpp.BytePointer buf,
                                                                           @StdVector
                                                                           org.bytedeco.javacpp.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
                                                                           org.bytedeco.javacpp.BytePointer ext,
                                                                           @ByVal
                                                                           opencv_core.Mat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           org.bytedeco.javacpp.BytePointer buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           opencv_core.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
                                                                           opencv_core.Mat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           ByteBuffer buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           org.bytedeco.javacpp.BytePointer ext,
                                                                           @ByVal
                                                                           opencv_core.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
                                                                           org.bytedeco.javacpp.BytePointer ext,
                                                                           @ByVal
                                                                           opencv_core.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
                                                                           opencv_core.UMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           org.bytedeco.javacpp.BytePointer buf,
                                                                           @StdVector
                                                                           org.bytedeco.javacpp.IntPointer params)

imencode

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

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           org.bytedeco.javacpp.BytePointer ext,
                                                                           @ByVal
                                                                           opencv_core.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
                                                                           org.bytedeco.javacpp.BytePointer ext,
                                                                           @ByVal
                                                                           opencv_core.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
                                                                           opencv_core.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
                                                                           opencv_core.UMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           byte[] buf)

imencode

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

imencode

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

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           opencv_core.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
                                                                           opencv_core.GpuMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           ByteBuffer buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           org.bytedeco.javacpp.BytePointer ext,
                                                                           @ByVal
                                                                           opencv_core.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
                                                                           org.bytedeco.javacpp.BytePointer ext,
                                                                           @ByVal
                                                                           opencv_core.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
                                                                           opencv_core.Mat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           org.bytedeco.javacpp.BytePointer buf,
                                                                           @StdVector
                                                                           org.bytedeco.javacpp.IntPointer params)

imencode

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

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           org.bytedeco.javacpp.BytePointer ext,
                                                                           @ByVal
                                                                           opencv_core.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
                                                                           org.bytedeco.javacpp.BytePointer ext,
                                                                           @ByVal
                                                                           opencv_core.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
                                                                           opencv_core.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
                                                                           opencv_core.Mat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           byte[] buf)

imencode

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

imencode

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

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           String ext,
                                                                           @ByVal
                                                                           opencv_core.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
                                                                           opencv_core.UMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           ByteBuffer buf)

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           org.bytedeco.javacpp.BytePointer ext,
                                                                           @ByVal
                                                                           opencv_core.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
                                                                           org.bytedeco.javacpp.BytePointer ext,
                                                                           @ByVal
                                                                           opencv_core.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
                                                                           opencv_core.GpuMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           org.bytedeco.javacpp.BytePointer buf,
                                                                           @StdVector
                                                                           org.bytedeco.javacpp.IntPointer params)

imencode

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

imencode

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean imencode(@opencv_core.Str
                                                                           org.bytedeco.javacpp.BytePointer ext,
                                                                           @ByVal
                                                                           opencv_core.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
                                                                           org.bytedeco.javacpp.BytePointer ext,
                                                                           @ByVal
                                                                           opencv_core.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
                                                                           opencv_core.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
                                                                           opencv_core.GpuMat img,
                                                                           @Cast(value="uchar*") @StdVector
                                                                           byte[] buf)

Class opencv_imgcodecs

Field Summary

Constructor Summary

Method Summary

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

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

Methods inherited from class java.lang.Object

Field Detail

CV_LOAD_IMAGE_UNCHANGED

CV_LOAD_IMAGE_GRAYSCALE

CV_LOAD_IMAGE_COLOR

CV_LOAD_IMAGE_ANYDEPTH

CV_LOAD_IMAGE_ANYCOLOR

CV_LOAD_IMAGE_IGNORE_ORIENTATION

CV_IMWRITE_JPEG_QUALITY

CV_IMWRITE_JPEG_PROGRESSIVE

CV_IMWRITE_JPEG_OPTIMIZE

CV_IMWRITE_JPEG_RST_INTERVAL

CV_IMWRITE_JPEG_LUMA_QUALITY

CV_IMWRITE_JPEG_CHROMA_QUALITY

CV_IMWRITE_PNG_COMPRESSION

CV_IMWRITE_PNG_STRATEGY

CV_IMWRITE_PNG_BILEVEL

CV_IMWRITE_PNG_STRATEGY_DEFAULT

CV_IMWRITE_PNG_STRATEGY_FILTERED

CV_IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY

CV_IMWRITE_PNG_STRATEGY_RLE

CV_IMWRITE_PNG_STRATEGY_FIXED

CV_IMWRITE_PXM_BINARY

CV_IMWRITE_EXR_TYPE

CV_IMWRITE_WEBP_QUALITY

CV_IMWRITE_PAM_TUPLETYPE

CV_IMWRITE_PAM_FORMAT_NULL

CV_IMWRITE_PAM_FORMAT_BLACKANDWHITE

CV_IMWRITE_PAM_FORMAT_GRAYSCALE

CV_IMWRITE_PAM_FORMAT_GRAYSCALE_ALPHA

CV_IMWRITE_PAM_FORMAT_RGB

CV_IMWRITE_PAM_FORMAT_RGB_ALPHA

CV_CVTIMG_FLIP

CV_CVTIMG_SWAP_RB

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_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