pub mod imgcodecs { //! # Image file reading and writing //! # Flags used for image file reading and writing //! # iOS glue //! # MacOS(OSX) glue use crate::mod_prelude::*; use crate::{core, sys, types}; pub mod prelude { pub use super::{ImageCollectionTrait, ImageCollectionTraitConst, ImageCollection_iteratorTrait, ImageCollection_iteratorTraitConst}; } /// If set, the image is read in any possible color format. pub const IMREAD_ANYCOLOR: i32 = 4; /// If set, return 16-bit/32-bit image when the input has the corresponding depth, otherwise convert it to 8-bit. pub const IMREAD_ANYDEPTH: i32 = 2; /// If set, always convert image to the 3 channel BGR color image. pub const IMREAD_COLOR: i32 = 1; /// If set, always convert image to the single channel grayscale image (codec internal conversion). pub const IMREAD_GRAYSCALE: i32 = 0; /// If set, do not rotate the image according to EXIF's orientation flag. pub const IMREAD_IGNORE_ORIENTATION: i32 = 128; /// If set, use the gdal driver for loading the image. pub const IMREAD_LOAD_GDAL: i32 = 8; /// If set, always convert image to the 3 channel BGR color image and the image size reduced 1/2. pub const IMREAD_REDUCED_COLOR_2: i32 = 17; /// If set, always convert image to the 3 channel BGR color image and the image size reduced 1/4. pub const IMREAD_REDUCED_COLOR_4: i32 = 33; /// If set, always convert image to the 3 channel BGR color image and the image size reduced 1/8. pub const IMREAD_REDUCED_COLOR_8: i32 = 65; /// If set, always convert image to the single channel grayscale image and the image size reduced 1/2. pub const IMREAD_REDUCED_GRAYSCALE_2: i32 = 16; /// If set, always convert image to the single channel grayscale image and the image size reduced 1/4. pub const IMREAD_REDUCED_GRAYSCALE_4: i32 = 32; /// If set, always convert image to the single channel grayscale image and the image size reduced 1/8. pub const IMREAD_REDUCED_GRAYSCALE_8: i32 = 64; /// If set, return the loaded image as is (with alpha channel, otherwise it gets cropped). Ignore EXIF orientation. pub const IMREAD_UNCHANGED: i32 = -1; /// For AVIF, it can be 8, 10 or 12. If >8, it is stored/read as CV_32F. Default is 8. pub const IMWRITE_AVIF_DEPTH: i32 = 513; /// For AVIF, it can be a quality between 0 and 100 (the higher the better). Default is 95. pub const IMWRITE_AVIF_QUALITY: i32 = 512; /// For AVIF, it is between 0 (slowest) and (fastest). Default is 9. pub const IMWRITE_AVIF_SPEED: i32 = 514; /// override EXR compression type (ZIP_COMPRESSION = 3 is default) pub const IMWRITE_EXR_COMPRESSION: i32 = 49; /// lossy 4-by-4 pixel block compression, fixed compression rate pub const IMWRITE_EXR_COMPRESSION_B44: i32 = 6; /// lossy 4-by-4 pixel block compression, flat fields are compressed more pub const IMWRITE_EXR_COMPRESSION_B44A: i32 = 7; /// lossy DCT based compression, in blocks of 32 scanlines. More efficient for partial buffer access. Supported since OpenEXR 2.2.0. pub const IMWRITE_EXR_COMPRESSION_DWAA: i32 = 8; /// lossy DCT based compression, in blocks of 256 scanlines. More efficient space wise and faster to decode full frames than DWAA_COMPRESSION. Supported since OpenEXR 2.2.0. pub const IMWRITE_EXR_COMPRESSION_DWAB: i32 = 9; /// no compression pub const IMWRITE_EXR_COMPRESSION_NO: i32 = 0; /// piz-based wavelet compression pub const IMWRITE_EXR_COMPRESSION_PIZ: i32 = 4; /// lossy 24-bit float compression pub const IMWRITE_EXR_COMPRESSION_PXR24: i32 = 5; /// run length encoding pub const IMWRITE_EXR_COMPRESSION_RLE: i32 = 1; /// zlib compression, in blocks of 16 scan lines pub const IMWRITE_EXR_COMPRESSION_ZIP: i32 = 3; /// zlib compression, one scan line at a time pub const IMWRITE_EXR_COMPRESSION_ZIPS: i32 = 2; /// override EXR DWA compression level (45 is default) pub const IMWRITE_EXR_DWA_COMPRESSION_LEVEL: i32 = 50; /// override EXR storage type (FLOAT (FP32) is default) pub const IMWRITE_EXR_TYPE: i32 = 48; /// store as FP32 (default) pub const IMWRITE_EXR_TYPE_FLOAT: i32 = 2; /// store as HALF (FP16) pub const IMWRITE_EXR_TYPE_HALF: i32 = 1; /// specify HDR compression pub const IMWRITE_HDR_COMPRESSION: i32 = 80; pub const IMWRITE_HDR_COMPRESSION_NONE: i32 = 0; pub const IMWRITE_HDR_COMPRESSION_RLE: i32 = 1; /// For JPEG2000, use to specify the target compression rate (multiplied by 1000). The value can be from 0 to 1000. Default is 1000. pub const IMWRITE_JPEG2000_COMPRESSION_X1000: i32 = 272; /// Separate chroma quality level, 0 - 100, default is -1 - don't use. If JPEG_LIB_VERSION < 70, Not supported. pub const IMWRITE_JPEG_CHROMA_QUALITY: i32 = 6; /// Separate luma quality level, 0 - 100, default is -1 - don't use. If JPEG_LIB_VERSION < 70, Not supported. pub const IMWRITE_JPEG_LUMA_QUALITY: i32 = 5; /// Enable JPEG features, 0 or 1, default is False. pub const IMWRITE_JPEG_OPTIMIZE: i32 = 3; /// Enable JPEG features, 0 or 1, default is False. pub const IMWRITE_JPEG_PROGRESSIVE: i32 = 2; /// For JPEG, it can be a quality from 0 to 100 (the higher is the better). Default value is 95. pub const IMWRITE_JPEG_QUALITY: i32 = 1; /// JPEG restart interval, 0 - 65535, default is 0 - no restart. pub const IMWRITE_JPEG_RST_INTERVAL: i32 = 4; /// For JPEG, set sampling factor. See cv::ImwriteJPEGSamplingFactorParams. pub const IMWRITE_JPEG_SAMPLING_FACTOR: i32 = 7; /// 4x1,1x1,1x1 pub const IMWRITE_JPEG_SAMPLING_FACTOR_411: i32 = 4264209; /// 2x2,1x1,1x1(Default) pub const IMWRITE_JPEG_SAMPLING_FACTOR_420: i32 = 2232593; /// 2x1,1x1,1x1 pub const IMWRITE_JPEG_SAMPLING_FACTOR_422: i32 = 2167057; /// 1x2,1x1,1x1 pub const IMWRITE_JPEG_SAMPLING_FACTOR_440: i32 = 1184017; /// 1x1,1x1,1x1(No subsampling) pub const IMWRITE_JPEG_SAMPLING_FACTOR_444: i32 = 1118481; pub const IMWRITE_PAM_FORMAT_BLACKANDWHITE: i32 = 1; pub const IMWRITE_PAM_FORMAT_GRAYSCALE: i32 = 2; pub const IMWRITE_PAM_FORMAT_GRAYSCALE_ALPHA: i32 = 3; pub const IMWRITE_PAM_FORMAT_NULL: i32 = 0; pub const IMWRITE_PAM_FORMAT_RGB: i32 = 4; pub const IMWRITE_PAM_FORMAT_RGB_ALPHA: i32 = 5; /// For PAM, sets the TUPLETYPE field to the corresponding string value that is defined for the format pub const IMWRITE_PAM_TUPLETYPE: i32 = 128; /// Binary level PNG, 0 or 1, default is 0. pub const IMWRITE_PNG_BILEVEL: i32 = 18; /// For PNG, it can be the compression level from 0 to 9. A higher value means a smaller size and longer compression time. If specified, strategy is changed to IMWRITE_PNG_STRATEGY_DEFAULT (Z_DEFAULT_STRATEGY). Default value is 1 (best speed setting). pub const IMWRITE_PNG_COMPRESSION: i32 = 16; /// One of cv::ImwritePNGFlags, default is IMWRITE_PNG_STRATEGY_RLE. pub const IMWRITE_PNG_STRATEGY: i32 = 17; /// Use this value for normal data. pub const IMWRITE_PNG_STRATEGY_DEFAULT: i32 = 0; /// Use this value for data produced by a filter (or predictor).Filtered data consists mostly of small values with a somewhat random distribution. In this case, the compression algorithm is tuned to compress them better. pub const IMWRITE_PNG_STRATEGY_FILTERED: i32 = 1; /// Using this value prevents the use of dynamic Huffman codes, allowing for a simpler decoder for special applications. pub const IMWRITE_PNG_STRATEGY_FIXED: i32 = 4; /// Use this value to force Huffman encoding only (no string match). pub const IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY: i32 = 2; /// Use this value to limit match distances to one (run-length encoding). pub const IMWRITE_PNG_STRATEGY_RLE: i32 = 3; /// For PPM, PGM, or PBM, it can be a binary format flag, 0 or 1. Default value is 1. pub const IMWRITE_PXM_BINARY: i32 = 32; /// For TIFF, use to specify the image compression scheme. See cv::ImwriteTiffCompressionFlags. Note, for images whose depth is CV_32F, only libtiff's SGILOG compression scheme is used. For other supported depths, the compression scheme can be specified by this flag; LZW compression is the default. pub const IMWRITE_TIFF_COMPRESSION: i32 = 259; /// Deflate compression, as recognized by Adobe pub const IMWRITE_TIFF_COMPRESSION_ADOBE_DEFLATE: i32 = 8; /// CCITT Group 3 fax encoding pub const IMWRITE_TIFF_COMPRESSION_CCITTFAX3: i32 = 3; /// CCITT Group 4 fax encoding pub const IMWRITE_TIFF_COMPRESSION_CCITTFAX4: i32 = 4; /// CCITT modified Huffman RLE pub const IMWRITE_TIFF_COMPRESSION_CCITTRLE: i32 = 2; /// [1] w/ word alignment pub const IMWRITE_TIFF_COMPRESSION_CCITTRLEW: i32 = 32771; /// CCITT T.4 (TIFF 6 name) pub const IMWRITE_TIFF_COMPRESSION_CCITT_T4: i32 = 3; /// CCITT T.6 (TIFF 6 name) pub const IMWRITE_TIFF_COMPRESSION_CCITT_T6: i32 = 4; /// Kodak DCS encoding pub const IMWRITE_TIFF_COMPRESSION_DCS: i32 = 32947; /// Deflate compression, legacy tag pub const IMWRITE_TIFF_COMPRESSION_DEFLATE: i32 = 32946; /// IT8 Binary line art pub const IMWRITE_TIFF_COMPRESSION_IT8BL: i32 = 32898; /// IT8 CT w/padding pub const IMWRITE_TIFF_COMPRESSION_IT8CTPAD: i32 = 32895; /// IT8 Linework RLE pub const IMWRITE_TIFF_COMPRESSION_IT8LW: i32 = 32896; /// IT8 Monochrome picture pub const IMWRITE_TIFF_COMPRESSION_IT8MP: i32 = 32897; /// ISO JBIG pub const IMWRITE_TIFF_COMPRESSION_JBIG: i32 = 34661; /// Leadtools JPEG2000 pub const IMWRITE_TIFF_COMPRESSION_JP2000: i32 = 34712; /// %JPEG DCT compression pub const IMWRITE_TIFF_COMPRESSION_JPEG: i32 = 7; /// JPEGXL: WARNING not registered in Adobe-maintained registry pub const IMWRITE_TIFF_COMPRESSION_JXL: i32 = 50002; /// ESRI Lerc codec: pub const IMWRITE_TIFF_COMPRESSION_LERC: i32 = 34887; /// LZMA2 pub const IMWRITE_TIFF_COMPRESSION_LZMA: i32 = 34925; /// Lempel-Ziv & Welch pub const IMWRITE_TIFF_COMPRESSION_LZW: i32 = 5; /// NeXT 2-bit RLE pub const IMWRITE_TIFF_COMPRESSION_NEXT: i32 = 32766; /// dump mode pub const IMWRITE_TIFF_COMPRESSION_NONE: i32 = 1; /// !6.0 JPEG pub const IMWRITE_TIFF_COMPRESSION_OJPEG: i32 = 6; /// Macintosh RLE pub const IMWRITE_TIFF_COMPRESSION_PACKBITS: i32 = 32773; /// Pixar companded 10bit LZW pub const IMWRITE_TIFF_COMPRESSION_PIXARFILM: i32 = 32908; /// Pixar companded 11bit ZIP pub const IMWRITE_TIFF_COMPRESSION_PIXARLOG: i32 = 32909; /// SGI Log Luminance RLE pub const IMWRITE_TIFF_COMPRESSION_SGILOG: i32 = 34676; /// SGI Log 24-bit packed pub const IMWRITE_TIFF_COMPRESSION_SGILOG24: i32 = 34677; /// !TIFF/FX T.43 colour by layered JBIG compression pub const IMWRITE_TIFF_COMPRESSION_T43: i32 = 10; /// !TIFF/FX T.85 JBIG compression pub const IMWRITE_TIFF_COMPRESSION_T85: i32 = 9; /// ThunderScan RLE pub const IMWRITE_TIFF_COMPRESSION_THUNDERSCAN: i32 = 32809; /// WEBP: WARNING not registered in Adobe-maintained registry pub const IMWRITE_TIFF_COMPRESSION_WEBP: i32 = 50001; /// ZSTD: WARNING not registered in Adobe-maintained registry pub const IMWRITE_TIFF_COMPRESSION_ZSTD: i32 = 50000; /// For TIFF, use to specify predictor. See cv::ImwriteTiffPredictorFlags. pub const IMWRITE_TIFF_PREDICTOR: i32 = 317; /// floating point predictor pub const IMWRITE_TIFF_PREDICTOR_FLOATINGPOINT: i32 = 3; /// horizontal differencing pub const IMWRITE_TIFF_PREDICTOR_HORIZONTAL: i32 = 2; /// no prediction scheme used pub const IMWRITE_TIFF_PREDICTOR_NONE: i32 = 1; /// For TIFF, use to specify which DPI resolution unit to set; see libtiff documentation for valid values pub const IMWRITE_TIFF_RESUNIT: i32 = 256; /// For TIFF, use to specify the number of rows per strip. pub const IMWRITE_TIFF_ROWSPERSTRIP: i32 = 278; /// For TIFF, use to specify the X direction DPI pub const IMWRITE_TIFF_XDPI: i32 = 257; /// For TIFF, use to specify the Y direction DPI pub const IMWRITE_TIFF_YDPI: i32 = 258; /// For WEBP, it can be a quality from 1 to 100 (the higher is the better). By default (without any parameter) and for quality above 100 the lossless compression is used. pub const IMWRITE_WEBP_QUALITY: i32 = 64; /// Imread flags #[repr(C)] #[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ImreadModes { /// If set, return the loaded image as is (with alpha channel, otherwise it gets cropped). Ignore EXIF orientation. IMREAD_UNCHANGED = -1, /// If set, always convert image to the single channel grayscale image (codec internal conversion). IMREAD_GRAYSCALE = 0, /// If set, always convert image to the 3 channel BGR color image. IMREAD_COLOR = 1, /// If set, return 16-bit/32-bit image when the input has the corresponding depth, otherwise convert it to 8-bit. IMREAD_ANYDEPTH = 2, /// If set, the image is read in any possible color format. IMREAD_ANYCOLOR = 4, /// If set, use the gdal driver for loading the image. IMREAD_LOAD_GDAL = 8, /// If set, always convert image to the single channel grayscale image and the image size reduced 1/2. IMREAD_REDUCED_GRAYSCALE_2 = 16, /// If set, always convert image to the 3 channel BGR color image and the image size reduced 1/2. IMREAD_REDUCED_COLOR_2 = 17, /// If set, always convert image to the single channel grayscale image and the image size reduced 1/4. IMREAD_REDUCED_GRAYSCALE_4 = 32, /// If set, always convert image to the 3 channel BGR color image and the image size reduced 1/4. IMREAD_REDUCED_COLOR_4 = 33, /// If set, always convert image to the single channel grayscale image and the image size reduced 1/8. IMREAD_REDUCED_GRAYSCALE_8 = 64, /// If set, always convert image to the 3 channel BGR color image and the image size reduced 1/8. IMREAD_REDUCED_COLOR_8 = 65, /// If set, do not rotate the image according to EXIF's orientation flag. IMREAD_IGNORE_ORIENTATION = 128, } impl TryFrom for ImreadModes { type Error = crate::Error; fn try_from(value: i32) -> Result { match value { -1 => Ok(Self::IMREAD_UNCHANGED), 0 => Ok(Self::IMREAD_GRAYSCALE), 1 => Ok(Self::IMREAD_COLOR), 2 => Ok(Self::IMREAD_ANYDEPTH), 4 => Ok(Self::IMREAD_ANYCOLOR), 8 => Ok(Self::IMREAD_LOAD_GDAL), 16 => Ok(Self::IMREAD_REDUCED_GRAYSCALE_2), 17 => Ok(Self::IMREAD_REDUCED_COLOR_2), 32 => Ok(Self::IMREAD_REDUCED_GRAYSCALE_4), 33 => Ok(Self::IMREAD_REDUCED_COLOR_4), 64 => Ok(Self::IMREAD_REDUCED_GRAYSCALE_8), 65 => Ok(Self::IMREAD_REDUCED_COLOR_8), 128 => Ok(Self::IMREAD_IGNORE_ORIENTATION), _ => Err(crate::Error::new(crate::core::StsBadArg, format!("Value: {value} is not valid for enum: crate::imgcodecs::ImreadModes"))), } } } opencv_type_enum! { crate::imgcodecs::ImreadModes } #[repr(C)] #[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ImwriteEXRCompressionFlags { /// no compression IMWRITE_EXR_COMPRESSION_NO = 0, /// run length encoding IMWRITE_EXR_COMPRESSION_RLE = 1, /// zlib compression, one scan line at a time IMWRITE_EXR_COMPRESSION_ZIPS = 2, /// zlib compression, in blocks of 16 scan lines IMWRITE_EXR_COMPRESSION_ZIP = 3, /// piz-based wavelet compression IMWRITE_EXR_COMPRESSION_PIZ = 4, /// lossy 24-bit float compression IMWRITE_EXR_COMPRESSION_PXR24 = 5, /// lossy 4-by-4 pixel block compression, fixed compression rate IMWRITE_EXR_COMPRESSION_B44 = 6, /// lossy 4-by-4 pixel block compression, flat fields are compressed more IMWRITE_EXR_COMPRESSION_B44A = 7, /// lossy DCT based compression, in blocks of 32 scanlines. More efficient for partial buffer access. Supported since OpenEXR 2.2.0. IMWRITE_EXR_COMPRESSION_DWAA = 8, /// lossy DCT based compression, in blocks of 256 scanlines. More efficient space wise and faster to decode full frames than DWAA_COMPRESSION. Supported since OpenEXR 2.2.0. IMWRITE_EXR_COMPRESSION_DWAB = 9, } impl TryFrom for ImwriteEXRCompressionFlags { type Error = crate::Error; fn try_from(value: i32) -> Result { match value { 0 => Ok(Self::IMWRITE_EXR_COMPRESSION_NO), 1 => Ok(Self::IMWRITE_EXR_COMPRESSION_RLE), 2 => Ok(Self::IMWRITE_EXR_COMPRESSION_ZIPS), 3 => Ok(Self::IMWRITE_EXR_COMPRESSION_ZIP), 4 => Ok(Self::IMWRITE_EXR_COMPRESSION_PIZ), 5 => Ok(Self::IMWRITE_EXR_COMPRESSION_PXR24), 6 => Ok(Self::IMWRITE_EXR_COMPRESSION_B44), 7 => Ok(Self::IMWRITE_EXR_COMPRESSION_B44A), 8 => Ok(Self::IMWRITE_EXR_COMPRESSION_DWAA), 9 => Ok(Self::IMWRITE_EXR_COMPRESSION_DWAB), _ => Err(crate::Error::new(crate::core::StsBadArg, format!("Value: {value} is not valid for enum: crate::imgcodecs::ImwriteEXRCompressionFlags"))), } } } opencv_type_enum! { crate::imgcodecs::ImwriteEXRCompressionFlags } #[repr(C)] #[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ImwriteEXRTypeFlags { /// store as HALF (FP16) IMWRITE_EXR_TYPE_HALF = 1, /// store as FP32 (default) IMWRITE_EXR_TYPE_FLOAT = 2, } impl TryFrom for ImwriteEXRTypeFlags { type Error = crate::Error; fn try_from(value: i32) -> Result { match value { 1 => Ok(Self::IMWRITE_EXR_TYPE_HALF), 2 => Ok(Self::IMWRITE_EXR_TYPE_FLOAT), _ => Err(crate::Error::new(crate::core::StsBadArg, format!("Value: {value} is not valid for enum: crate::imgcodecs::ImwriteEXRTypeFlags"))), } } } opencv_type_enum! { crate::imgcodecs::ImwriteEXRTypeFlags } /// Imwrite flags #[repr(C)] #[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ImwriteFlags { /// For JPEG, it can be a quality from 0 to 100 (the higher is the better). Default value is 95. IMWRITE_JPEG_QUALITY = 1, /// Enable JPEG features, 0 or 1, default is False. IMWRITE_JPEG_PROGRESSIVE = 2, /// Enable JPEG features, 0 or 1, default is False. IMWRITE_JPEG_OPTIMIZE = 3, /// JPEG restart interval, 0 - 65535, default is 0 - no restart. IMWRITE_JPEG_RST_INTERVAL = 4, /// Separate luma quality level, 0 - 100, default is -1 - don't use. If JPEG_LIB_VERSION < 70, Not supported. IMWRITE_JPEG_LUMA_QUALITY = 5, /// Separate chroma quality level, 0 - 100, default is -1 - don't use. If JPEG_LIB_VERSION < 70, Not supported. IMWRITE_JPEG_CHROMA_QUALITY = 6, /// For JPEG, set sampling factor. See cv::ImwriteJPEGSamplingFactorParams. IMWRITE_JPEG_SAMPLING_FACTOR = 7, /// For PNG, it can be the compression level from 0 to 9. A higher value means a smaller size and longer compression time. If specified, strategy is changed to IMWRITE_PNG_STRATEGY_DEFAULT (Z_DEFAULT_STRATEGY). Default value is 1 (best speed setting). IMWRITE_PNG_COMPRESSION = 16, /// One of cv::ImwritePNGFlags, default is IMWRITE_PNG_STRATEGY_RLE. IMWRITE_PNG_STRATEGY = 17, /// Binary level PNG, 0 or 1, default is 0. IMWRITE_PNG_BILEVEL = 18, /// For PPM, PGM, or PBM, it can be a binary format flag, 0 or 1. Default value is 1. IMWRITE_PXM_BINARY = 32, /// override EXR storage type (FLOAT (FP32) is default) IMWRITE_EXR_TYPE = 48, /// override EXR compression type (ZIP_COMPRESSION = 3 is default) IMWRITE_EXR_COMPRESSION = 49, /// override EXR DWA compression level (45 is default) IMWRITE_EXR_DWA_COMPRESSION_LEVEL = 50, /// For WEBP, it can be a quality from 1 to 100 (the higher is the better). By default (without any parameter) and for quality above 100 the lossless compression is used. IMWRITE_WEBP_QUALITY = 64, /// specify HDR compression IMWRITE_HDR_COMPRESSION = 80, /// For PAM, sets the TUPLETYPE field to the corresponding string value that is defined for the format IMWRITE_PAM_TUPLETYPE = 128, /// For TIFF, use to specify which DPI resolution unit to set; see libtiff documentation for valid values IMWRITE_TIFF_RESUNIT = 256, /// For TIFF, use to specify the X direction DPI IMWRITE_TIFF_XDPI = 257, /// For TIFF, use to specify the Y direction DPI IMWRITE_TIFF_YDPI = 258, /// For TIFF, use to specify the image compression scheme. See cv::ImwriteTiffCompressionFlags. Note, for images whose depth is CV_32F, only libtiff's SGILOG compression scheme is used. For other supported depths, the compression scheme can be specified by this flag; LZW compression is the default. IMWRITE_TIFF_COMPRESSION = 259, /// For TIFF, use to specify the number of rows per strip. IMWRITE_TIFF_ROWSPERSTRIP = 278, /// For TIFF, use to specify predictor. See cv::ImwriteTiffPredictorFlags. IMWRITE_TIFF_PREDICTOR = 317, /// For JPEG2000, use to specify the target compression rate (multiplied by 1000). The value can be from 0 to 1000. Default is 1000. IMWRITE_JPEG2000_COMPRESSION_X1000 = 272, /// For AVIF, it can be a quality between 0 and 100 (the higher the better). Default is 95. IMWRITE_AVIF_QUALITY = 512, /// For AVIF, it can be 8, 10 or 12. If >8, it is stored/read as CV_32F. Default is 8. IMWRITE_AVIF_DEPTH = 513, /// For AVIF, it is between 0 (slowest) and (fastest). Default is 9. IMWRITE_AVIF_SPEED = 514, } impl TryFrom for ImwriteFlags { type Error = crate::Error; fn try_from(value: i32) -> Result { match value { 1 => Ok(Self::IMWRITE_JPEG_QUALITY), 2 => Ok(Self::IMWRITE_JPEG_PROGRESSIVE), 3 => Ok(Self::IMWRITE_JPEG_OPTIMIZE), 4 => Ok(Self::IMWRITE_JPEG_RST_INTERVAL), 5 => Ok(Self::IMWRITE_JPEG_LUMA_QUALITY), 6 => Ok(Self::IMWRITE_JPEG_CHROMA_QUALITY), 7 => Ok(Self::IMWRITE_JPEG_SAMPLING_FACTOR), 16 => Ok(Self::IMWRITE_PNG_COMPRESSION), 17 => Ok(Self::IMWRITE_PNG_STRATEGY), 18 => Ok(Self::IMWRITE_PNG_BILEVEL), 32 => Ok(Self::IMWRITE_PXM_BINARY), 48 => Ok(Self::IMWRITE_EXR_TYPE), 49 => Ok(Self::IMWRITE_EXR_COMPRESSION), 50 => Ok(Self::IMWRITE_EXR_DWA_COMPRESSION_LEVEL), 64 => Ok(Self::IMWRITE_WEBP_QUALITY), 80 => Ok(Self::IMWRITE_HDR_COMPRESSION), 128 => Ok(Self::IMWRITE_PAM_TUPLETYPE), 256 => Ok(Self::IMWRITE_TIFF_RESUNIT), 257 => Ok(Self::IMWRITE_TIFF_XDPI), 258 => Ok(Self::IMWRITE_TIFF_YDPI), 259 => Ok(Self::IMWRITE_TIFF_COMPRESSION), 278 => Ok(Self::IMWRITE_TIFF_ROWSPERSTRIP), 317 => Ok(Self::IMWRITE_TIFF_PREDICTOR), 272 => Ok(Self::IMWRITE_JPEG2000_COMPRESSION_X1000), 512 => Ok(Self::IMWRITE_AVIF_QUALITY), 513 => Ok(Self::IMWRITE_AVIF_DEPTH), 514 => Ok(Self::IMWRITE_AVIF_SPEED), _ => Err(crate::Error::new(crate::core::StsBadArg, format!("Value: {value} is not valid for enum: crate::imgcodecs::ImwriteFlags"))), } } } opencv_type_enum! { crate::imgcodecs::ImwriteFlags } /// Imwrite HDR specific values for IMWRITE_HDR_COMPRESSION parameter key #[repr(C)] #[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ImwriteHDRCompressionFlags { IMWRITE_HDR_COMPRESSION_NONE = 0, IMWRITE_HDR_COMPRESSION_RLE = 1, } impl TryFrom for ImwriteHDRCompressionFlags { type Error = crate::Error; fn try_from(value: i32) -> Result { match value { 0 => Ok(Self::IMWRITE_HDR_COMPRESSION_NONE), 1 => Ok(Self::IMWRITE_HDR_COMPRESSION_RLE), _ => Err(crate::Error::new(crate::core::StsBadArg, format!("Value: {value} is not valid for enum: crate::imgcodecs::ImwriteHDRCompressionFlags"))), } } } opencv_type_enum! { crate::imgcodecs::ImwriteHDRCompressionFlags } #[repr(C)] #[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ImwriteJPEGSamplingFactorParams { /// 4x1,1x1,1x1 IMWRITE_JPEG_SAMPLING_FACTOR_411 = 4264209, /// 2x2,1x1,1x1(Default) IMWRITE_JPEG_SAMPLING_FACTOR_420 = 2232593, /// 2x1,1x1,1x1 IMWRITE_JPEG_SAMPLING_FACTOR_422 = 2167057, /// 1x2,1x1,1x1 IMWRITE_JPEG_SAMPLING_FACTOR_440 = 1184017, /// 1x1,1x1,1x1(No subsampling) IMWRITE_JPEG_SAMPLING_FACTOR_444 = 1118481, } impl TryFrom for ImwriteJPEGSamplingFactorParams { type Error = crate::Error; fn try_from(value: i32) -> Result { match value { 4264209 => Ok(Self::IMWRITE_JPEG_SAMPLING_FACTOR_411), 2232593 => Ok(Self::IMWRITE_JPEG_SAMPLING_FACTOR_420), 2167057 => Ok(Self::IMWRITE_JPEG_SAMPLING_FACTOR_422), 1184017 => Ok(Self::IMWRITE_JPEG_SAMPLING_FACTOR_440), 1118481 => Ok(Self::IMWRITE_JPEG_SAMPLING_FACTOR_444), _ => Err(crate::Error::new(crate::core::StsBadArg, format!("Value: {value} is not valid for enum: crate::imgcodecs::ImwriteJPEGSamplingFactorParams"))), } } } opencv_type_enum! { crate::imgcodecs::ImwriteJPEGSamplingFactorParams } /// Imwrite PAM specific tupletype flags used to define the 'TUPLETYPE' field of a PAM file. #[repr(C)] #[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ImwritePAMFlags { IMWRITE_PAM_FORMAT_NULL = 0, IMWRITE_PAM_FORMAT_BLACKANDWHITE = 1, IMWRITE_PAM_FORMAT_GRAYSCALE = 2, IMWRITE_PAM_FORMAT_GRAYSCALE_ALPHA = 3, IMWRITE_PAM_FORMAT_RGB = 4, IMWRITE_PAM_FORMAT_RGB_ALPHA = 5, } impl TryFrom for ImwritePAMFlags { type Error = crate::Error; fn try_from(value: i32) -> Result { match value { 0 => Ok(Self::IMWRITE_PAM_FORMAT_NULL), 1 => Ok(Self::IMWRITE_PAM_FORMAT_BLACKANDWHITE), 2 => Ok(Self::IMWRITE_PAM_FORMAT_GRAYSCALE), 3 => Ok(Self::IMWRITE_PAM_FORMAT_GRAYSCALE_ALPHA), 4 => Ok(Self::IMWRITE_PAM_FORMAT_RGB), 5 => Ok(Self::IMWRITE_PAM_FORMAT_RGB_ALPHA), _ => Err(crate::Error::new(crate::core::StsBadArg, format!("Value: {value} is not valid for enum: crate::imgcodecs::ImwritePAMFlags"))), } } } opencv_type_enum! { crate::imgcodecs::ImwritePAMFlags } /// Imwrite PNG specific flags used to tune the compression algorithm. /// These flags will be modify the way of PNG image compression and will be passed to the underlying zlib processing stage. /// /// * The effect of IMWRITE_PNG_STRATEGY_FILTERED is to force more Huffman coding and less string matching; it is somewhat intermediate between IMWRITE_PNG_STRATEGY_DEFAULT and IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY. /// * IMWRITE_PNG_STRATEGY_RLE is designed to be almost as fast as IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY, but give better compression for PNG image data. /// * The strategy parameter only affects the compression ratio but not the correctness of the compressed output even if it is not set appropriately. /// * IMWRITE_PNG_STRATEGY_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler decoder for special applications. #[repr(C)] #[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ImwritePNGFlags { /// Use this value for normal data. IMWRITE_PNG_STRATEGY_DEFAULT = 0, /// Use this value for data produced by a filter (or predictor).Filtered data consists mostly of small values with a somewhat random distribution. In this case, the compression algorithm is tuned to compress them better. IMWRITE_PNG_STRATEGY_FILTERED = 1, /// Use this value to force Huffman encoding only (no string match). IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY = 2, /// Use this value to limit match distances to one (run-length encoding). IMWRITE_PNG_STRATEGY_RLE = 3, /// Using this value prevents the use of dynamic Huffman codes, allowing for a simpler decoder for special applications. IMWRITE_PNG_STRATEGY_FIXED = 4, } impl TryFrom for ImwritePNGFlags { type Error = crate::Error; fn try_from(value: i32) -> Result { match value { 0 => Ok(Self::IMWRITE_PNG_STRATEGY_DEFAULT), 1 => Ok(Self::IMWRITE_PNG_STRATEGY_FILTERED), 2 => Ok(Self::IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY), 3 => Ok(Self::IMWRITE_PNG_STRATEGY_RLE), 4 => Ok(Self::IMWRITE_PNG_STRATEGY_FIXED), _ => Err(crate::Error::new(crate::core::StsBadArg, format!("Value: {value} is not valid for enum: crate::imgcodecs::ImwritePNGFlags"))), } } } opencv_type_enum! { crate::imgcodecs::ImwritePNGFlags } #[repr(C)] #[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ImwriteTiffCompressionFlags { /// dump mode IMWRITE_TIFF_COMPRESSION_NONE = 1, /// CCITT modified Huffman RLE IMWRITE_TIFF_COMPRESSION_CCITTRLE = 2, /// CCITT Group 3 fax encoding IMWRITE_TIFF_COMPRESSION_CCITTFAX3 = 3, // CCITT T.4 (TIFF 6 name) // Duplicate, use IMWRITE_TIFF_COMPRESSION_CCITTFAX3 instead // IMWRITE_TIFF_COMPRESSION_CCITT_T4 = 3, /// CCITT Group 4 fax encoding IMWRITE_TIFF_COMPRESSION_CCITTFAX4 = 4, // CCITT T.6 (TIFF 6 name) // Duplicate, use IMWRITE_TIFF_COMPRESSION_CCITTFAX4 instead // IMWRITE_TIFF_COMPRESSION_CCITT_T6 = 4, /// Lempel-Ziv & Welch IMWRITE_TIFF_COMPRESSION_LZW = 5, /// !6.0 JPEG IMWRITE_TIFF_COMPRESSION_OJPEG = 6, /// %JPEG DCT compression IMWRITE_TIFF_COMPRESSION_JPEG = 7, /// !TIFF/FX T.85 JBIG compression IMWRITE_TIFF_COMPRESSION_T85 = 9, /// !TIFF/FX T.43 colour by layered JBIG compression IMWRITE_TIFF_COMPRESSION_T43 = 10, /// NeXT 2-bit RLE IMWRITE_TIFF_COMPRESSION_NEXT = 32766, /// [1] w/ word alignment IMWRITE_TIFF_COMPRESSION_CCITTRLEW = 32771, /// Macintosh RLE IMWRITE_TIFF_COMPRESSION_PACKBITS = 32773, /// ThunderScan RLE IMWRITE_TIFF_COMPRESSION_THUNDERSCAN = 32809, /// IT8 CT w/padding IMWRITE_TIFF_COMPRESSION_IT8CTPAD = 32895, /// IT8 Linework RLE IMWRITE_TIFF_COMPRESSION_IT8LW = 32896, /// IT8 Monochrome picture IMWRITE_TIFF_COMPRESSION_IT8MP = 32897, /// IT8 Binary line art IMWRITE_TIFF_COMPRESSION_IT8BL = 32898, /// Pixar companded 10bit LZW IMWRITE_TIFF_COMPRESSION_PIXARFILM = 32908, /// Pixar companded 11bit ZIP IMWRITE_TIFF_COMPRESSION_PIXARLOG = 32909, /// Deflate compression, legacy tag IMWRITE_TIFF_COMPRESSION_DEFLATE = 32946, /// Deflate compression, as recognized by Adobe IMWRITE_TIFF_COMPRESSION_ADOBE_DEFLATE = 8, /// Kodak DCS encoding IMWRITE_TIFF_COMPRESSION_DCS = 32947, /// ISO JBIG IMWRITE_TIFF_COMPRESSION_JBIG = 34661, /// SGI Log Luminance RLE IMWRITE_TIFF_COMPRESSION_SGILOG = 34676, /// SGI Log 24-bit packed IMWRITE_TIFF_COMPRESSION_SGILOG24 = 34677, /// Leadtools JPEG2000 IMWRITE_TIFF_COMPRESSION_JP2000 = 34712, /// ESRI Lerc codec: IMWRITE_TIFF_COMPRESSION_LERC = 34887, /// LZMA2 IMWRITE_TIFF_COMPRESSION_LZMA = 34925, /// ZSTD: WARNING not registered in Adobe-maintained registry IMWRITE_TIFF_COMPRESSION_ZSTD = 50000, /// WEBP: WARNING not registered in Adobe-maintained registry IMWRITE_TIFF_COMPRESSION_WEBP = 50001, /// JPEGXL: WARNING not registered in Adobe-maintained registry IMWRITE_TIFF_COMPRESSION_JXL = 50002, } impl TryFrom for ImwriteTiffCompressionFlags { type Error = crate::Error; fn try_from(value: i32) -> Result { match value { 1 => Ok(Self::IMWRITE_TIFF_COMPRESSION_NONE), 2 => Ok(Self::IMWRITE_TIFF_COMPRESSION_CCITTRLE), 3 => Ok(Self::IMWRITE_TIFF_COMPRESSION_CCITTFAX3), // Duplicate of IMWRITE_TIFF_COMPRESSION_CCITTFAX3 // 3 => Ok(Self::IMWRITE_TIFF_COMPRESSION_CCITT_T4), 4 => Ok(Self::IMWRITE_TIFF_COMPRESSION_CCITTFAX4), // Duplicate of IMWRITE_TIFF_COMPRESSION_CCITTFAX4 // 4 => Ok(Self::IMWRITE_TIFF_COMPRESSION_CCITT_T6), 5 => Ok(Self::IMWRITE_TIFF_COMPRESSION_LZW), 6 => Ok(Self::IMWRITE_TIFF_COMPRESSION_OJPEG), 7 => Ok(Self::IMWRITE_TIFF_COMPRESSION_JPEG), 9 => Ok(Self::IMWRITE_TIFF_COMPRESSION_T85), 10 => Ok(Self::IMWRITE_TIFF_COMPRESSION_T43), 32766 => Ok(Self::IMWRITE_TIFF_COMPRESSION_NEXT), 32771 => Ok(Self::IMWRITE_TIFF_COMPRESSION_CCITTRLEW), 32773 => Ok(Self::IMWRITE_TIFF_COMPRESSION_PACKBITS), 32809 => Ok(Self::IMWRITE_TIFF_COMPRESSION_THUNDERSCAN), 32895 => Ok(Self::IMWRITE_TIFF_COMPRESSION_IT8CTPAD), 32896 => Ok(Self::IMWRITE_TIFF_COMPRESSION_IT8LW), 32897 => Ok(Self::IMWRITE_TIFF_COMPRESSION_IT8MP), 32898 => Ok(Self::IMWRITE_TIFF_COMPRESSION_IT8BL), 32908 => Ok(Self::IMWRITE_TIFF_COMPRESSION_PIXARFILM), 32909 => Ok(Self::IMWRITE_TIFF_COMPRESSION_PIXARLOG), 32946 => Ok(Self::IMWRITE_TIFF_COMPRESSION_DEFLATE), 8 => Ok(Self::IMWRITE_TIFF_COMPRESSION_ADOBE_DEFLATE), 32947 => Ok(Self::IMWRITE_TIFF_COMPRESSION_DCS), 34661 => Ok(Self::IMWRITE_TIFF_COMPRESSION_JBIG), 34676 => Ok(Self::IMWRITE_TIFF_COMPRESSION_SGILOG), 34677 => Ok(Self::IMWRITE_TIFF_COMPRESSION_SGILOG24), 34712 => Ok(Self::IMWRITE_TIFF_COMPRESSION_JP2000), 34887 => Ok(Self::IMWRITE_TIFF_COMPRESSION_LERC), 34925 => Ok(Self::IMWRITE_TIFF_COMPRESSION_LZMA), 50000 => Ok(Self::IMWRITE_TIFF_COMPRESSION_ZSTD), 50001 => Ok(Self::IMWRITE_TIFF_COMPRESSION_WEBP), 50002 => Ok(Self::IMWRITE_TIFF_COMPRESSION_JXL), _ => Err(crate::Error::new(crate::core::StsBadArg, format!("Value: {value} is not valid for enum: crate::imgcodecs::ImwriteTiffCompressionFlags"))), } } } opencv_type_enum! { crate::imgcodecs::ImwriteTiffCompressionFlags } #[repr(C)] #[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ImwriteTiffPredictorFlags { /// no prediction scheme used IMWRITE_TIFF_PREDICTOR_NONE = 1, /// horizontal differencing IMWRITE_TIFF_PREDICTOR_HORIZONTAL = 2, /// floating point predictor IMWRITE_TIFF_PREDICTOR_FLOATINGPOINT = 3, } impl TryFrom for ImwriteTiffPredictorFlags { type Error = crate::Error; fn try_from(value: i32) -> Result { match value { 1 => Ok(Self::IMWRITE_TIFF_PREDICTOR_NONE), 2 => Ok(Self::IMWRITE_TIFF_PREDICTOR_HORIZONTAL), 3 => Ok(Self::IMWRITE_TIFF_PREDICTOR_FLOATINGPOINT), _ => Err(crate::Error::new(crate::core::StsBadArg, format!("Value: {value} is not valid for enum: crate::imgcodecs::ImwriteTiffPredictorFlags"))), } } } opencv_type_enum! { crate::imgcodecs::ImwriteTiffPredictorFlags } /// Returns true if the specified image can be decoded by OpenCV /// /// ## Parameters /// * filename: File name of the image #[inline] pub fn have_image_reader(filename: &str) -> Result { extern_container_arg!(filename); return_send!(via ocvrs_return); unsafe { sys::cv_haveImageReader_const_StringR(filename.opencv_as_extern(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } /// Returns true if an image with the specified filename can be encoded by OpenCV /// /// ## Parameters /// * filename: File name of the image #[inline] pub fn have_image_writer(filename: &str) -> Result { extern_container_arg!(filename); return_send!(via ocvrs_return); unsafe { sys::cv_haveImageWriter_const_StringR(filename.opencv_as_extern(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } /// Returns the number of images inside the give file /// /// The function imcount will return the number of pages in a multi-page image, or 1 for single-page images /// ## Parameters /// * filename: Name of file to be loaded. /// * flags: Flag that can take values of cv::ImreadModes, default with cv::IMREAD_ANYCOLOR. /// /// ## Note /// This alternative version of [imcount] function uses the following default values for its arguments: /// * flags: IMREAD_ANYCOLOR #[inline] pub fn imcount_def(filename: &str) -> Result { extern_container_arg!(filename); return_send!(via ocvrs_return); unsafe { sys::cv_imcount_const_StringR(filename.opencv_as_extern(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } /// Returns the number of images inside the give file /// /// The function imcount will return the number of pages in a multi-page image, or 1 for single-page images /// ## Parameters /// * filename: Name of file to be loaded. /// * flags: Flag that can take values of cv::ImreadModes, default with cv::IMREAD_ANYCOLOR. /// /// ## C++ default parameters /// * flags: IMREAD_ANYCOLOR #[inline] pub fn imcount(filename: &str, flags: i32) -> Result { extern_container_arg!(filename); return_send!(via ocvrs_return); unsafe { sys::cv_imcount_const_StringR_int(filename.opencv_as_extern(), flags, ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } /// 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. #[inline] pub fn imdecode(buf: &impl ToInputArray, flags: i32) -> Result { input_array_arg!(buf); return_send!(via ocvrs_return); unsafe { sys::cv_imdecode_const__InputArrayR_int(buf.as_raw__InputArray(), flags, ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; let ret = unsafe { core::Mat::opencv_from_extern(ret) }; Ok(ret) } /// 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. /// /// ## Overloaded parameters /// /// * buf: Input array or vector of bytes. /// * flags: The same flags as in cv::imread, see cv::ImreadModes. /// * 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. In case of decoder /// failure the function returns empty cv::Mat object, but does not release user-provided dst buffer. #[inline] pub fn imdecode_to(buf: &impl ToInputArray, flags: i32, dst: &mut impl core::MatTrait) -> Result { input_array_arg!(buf); return_send!(via ocvrs_return); unsafe { sys::cv_imdecode_const__InputArrayR_int_MatX(buf.as_raw__InputArray(), flags, dst.as_raw_mut_Mat(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; let ret = unsafe { core::Mat::opencv_from_extern(ret) }; Ok(ret) } /// Reads a multi-page image from a buffer in memory. /// /// The function imdecodemulti reads a multi-page image from the specified buffer in the memory. If the buffer is too short or /// contains invalid data, the function returns false. /// /// See cv::imreadmulti 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. /// * mats: A vector of Mat objects holding each page, if more than one. /// * range: A continuous selection of pages. /// /// ## Note /// This alternative version of [imdecodemulti] function uses the following default values for its arguments: /// * range: Range::all() #[inline] pub fn imdecodemulti_def(buf: &impl ToInputArray, flags: i32, mats: &mut core::Vector) -> Result { input_array_arg!(buf); return_send!(via ocvrs_return); unsafe { sys::cv_imdecodemulti_const__InputArrayR_int_vectorLMatGR(buf.as_raw__InputArray(), flags, mats.as_raw_mut_VectorOfMat(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } /// Reads a multi-page image from a buffer in memory. /// /// The function imdecodemulti reads a multi-page image from the specified buffer in the memory. If the buffer is too short or /// contains invalid data, the function returns false. /// /// See cv::imreadmulti 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. /// * mats: A vector of Mat objects holding each page, if more than one. /// * range: A continuous selection of pages. /// /// ## C++ default parameters /// * range: Range::all() #[inline] pub fn imdecodemulti(buf: &impl ToInputArray, flags: i32, mats: &mut core::Vector, range: &impl core::RangeTraitConst) -> Result { input_array_arg!(buf); return_send!(via ocvrs_return); unsafe { sys::cv_imdecodemulti_const__InputArrayR_int_vectorLMatGR_const_RangeR(buf.as_raw__InputArray(), flags, mats.as_raw_mut_VectorOfMat(), range.as_raw_Range(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } /// 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. Must include a leading period. /// * img: Image to be written. /// * buf: Output buffer resized to fit the compressed image. /// * params: Format-specific parameters. See cv::imwrite and cv::ImwriteFlags. /// /// ## Note /// This alternative version of [imencode] function uses the following default values for its arguments: /// * params: std::vector() #[inline] pub fn imencode_def(ext: &str, img: &impl ToInputArray, buf: &mut core::Vector) -> Result { extern_container_arg!(ext); input_array_arg!(img); return_send!(via ocvrs_return); unsafe { sys::cv_imencode_const_StringR_const__InputArrayR_vectorLunsigned_charGR(ext.opencv_as_extern(), img.as_raw__InputArray(), buf.as_raw_mut_VectorOfu8(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } /// 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. Must include a leading period. /// * img: Image to be written. /// * buf: Output buffer resized to fit the compressed image. /// * params: Format-specific parameters. See cv::imwrite and cv::ImwriteFlags. /// /// ## C++ default parameters /// * params: std::vector() #[inline] pub fn imencode(ext: &str, img: &impl ToInputArray, buf: &mut core::Vector, params: &core::Vector) -> Result { extern_container_arg!(ext); input_array_arg!(img); return_send!(via ocvrs_return); unsafe { sys::cv_imencode_const_StringR_const__InputArrayR_vectorLunsigned_charGR_const_vectorLintGR(ext.opencv_as_extern(), img.as_raw__InputArray(), buf.as_raw_mut_VectorOfu8(), params.as_raw_VectorOfi32(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } /// 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) /// * AVIF - \*.avif (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 [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 [IMREAD_IGNORE_ORIENTATION] /// or [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 /// /// ## Note /// This alternative version of [imread] function uses the following default values for its arguments: /// * flags: IMREAD_COLOR #[inline] pub fn imread_def(filename: &str) -> Result { extern_container_arg!(filename); return_send!(via ocvrs_return); unsafe { sys::cv_imread_const_StringR(filename.opencv_as_extern(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; let ret = unsafe { core::Mat::opencv_from_extern(ret) }; Ok(ret) } /// Loads an image from a file. /// /// This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts and the return value. /// ## Parameters /// * filename: Name of file to be loaded. /// * dst: object in which the image will be loaded. /// * flags: Flag that can take values of cv::ImreadModes /// /// Note: /// The image passing through the img parameter can be pre-allocated. The memory is reused if the shape and the type match with the load image. /// /// ## Note /// This alternative version of [imread_1] function uses the following default values for its arguments: /// * flags: IMREAD_COLOR #[inline] pub fn imread_1_def(filename: &str, dst: &mut impl ToOutputArray) -> Result<()> { extern_container_arg!(filename); output_array_arg!(dst); return_send!(via ocvrs_return); unsafe { sys::cv_imread_const_StringR_const__OutputArrayR(filename.opencv_as_extern(), dst.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } /// Loads an image from a file. /// /// This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts and the return value. /// ## Parameters /// * filename: Name of file to be loaded. /// * dst: object in which the image will be loaded. /// * flags: Flag that can take values of cv::ImreadModes /// /// Note: /// The image passing through the img parameter can be pre-allocated. The memory is reused if the shape and the type match with the load image. /// /// ## C++ default parameters /// * flags: IMREAD_COLOR #[inline] pub fn imread_1(filename: &str, dst: &mut impl ToOutputArray, flags: i32) -> Result<()> { extern_container_arg!(filename); output_array_arg!(dst); return_send!(via ocvrs_return); unsafe { sys::cv_imread_const_StringR_const__OutputArrayR_int(filename.opencv_as_extern(), dst.as_raw__OutputArray(), flags, ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } /// 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) /// * AVIF - \*.avif (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 [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 [IMREAD_IGNORE_ORIENTATION] /// or [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 /// /// ## C++ default parameters /// * flags: IMREAD_COLOR #[inline] pub fn imread(filename: &str, flags: i32) -> Result { extern_container_arg!(filename); return_send!(via ocvrs_return); unsafe { sys::cv_imread_const_StringR_int(filename.opencv_as_extern(), flags, ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; let ret = unsafe { core::Mat::opencv_from_extern(ret) }; Ok(ret) } /// 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. /// * mats: A vector of Mat objects holding each page. /// * flags: Flag that can take values of cv::ImreadModes, default with cv::IMREAD_ANYCOLOR. /// ## See also /// cv::imread /// /// ## Note /// This alternative version of [imreadmulti] function uses the following default values for its arguments: /// * flags: IMREAD_ANYCOLOR #[inline] pub fn imreadmulti_def(filename: &str, mats: &mut core::Vector) -> Result { extern_container_arg!(filename); return_send!(via ocvrs_return); unsafe { sys::cv_imreadmulti_const_StringR_vectorLMatGR(filename.opencv_as_extern(), mats.as_raw_mut_VectorOfMat(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } /// 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. /// * mats: A vector of Mat objects holding each page. /// * flags: Flag that can take values of cv::ImreadModes, default with cv::IMREAD_ANYCOLOR. /// ## See also /// cv::imread /// /// ## C++ default parameters /// * flags: IMREAD_ANYCOLOR #[inline] pub fn imreadmulti(filename: &str, mats: &mut core::Vector, flags: i32) -> Result { extern_container_arg!(filename); return_send!(via ocvrs_return); unsafe { sys::cv_imreadmulti_const_StringR_vectorLMatGR_int(filename.opencv_as_extern(), mats.as_raw_mut_VectorOfMat(), flags, ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } /// Loads a of images of a multi-page image from a file. /// /// The function imreadmulti loads a specified range from a multi-page image from the specified file into a vector of Mat objects. /// ## Parameters /// * filename: Name of file to be loaded. /// * mats: A vector of Mat objects holding each page. /// * start: Start index of the image to load /// * count: Count number of images to load /// * flags: Flag that can take values of cv::ImreadModes, default with cv::IMREAD_ANYCOLOR. /// ## See also /// cv::imread /// /// ## Note /// This alternative version of [imreadmulti_range] function uses the following default values for its arguments: /// * flags: IMREAD_ANYCOLOR #[inline] pub fn imreadmulti_range_def(filename: &str, mats: &mut core::Vector, start: i32, count: i32) -> Result { extern_container_arg!(filename); return_send!(via ocvrs_return); unsafe { sys::cv_imreadmulti_const_StringR_vectorLMatGR_int_int(filename.opencv_as_extern(), mats.as_raw_mut_VectorOfMat(), start, count, ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } /// Loads a of images of a multi-page image from a file. /// /// The function imreadmulti loads a specified range from a multi-page image from the specified file into a vector of Mat objects. /// ## Parameters /// * filename: Name of file to be loaded. /// * mats: A vector of Mat objects holding each page. /// * start: Start index of the image to load /// * count: Count number of images to load /// * flags: Flag that can take values of cv::ImreadModes, default with cv::IMREAD_ANYCOLOR. /// ## See also /// cv::imread /// /// ## C++ default parameters /// * flags: IMREAD_ANYCOLOR #[inline] pub fn imreadmulti_range(filename: &str, mats: &mut core::Vector, start: i32, count: i32, flags: i32) -> Result { extern_container_arg!(filename); return_send!(via ocvrs_return); unsafe { sys::cv_imreadmulti_const_StringR_vectorLMatGR_int_int_int(filename.opencv_as_extern(), mats.as_raw_mut_VectorOfMat(), start, count, flags, ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } /// 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 unsigned (CV_8U) /// single-channel or 3-channel (with 'BGR' channel order) images /// can be saved using this function, with these exceptions: /// /// - With OpenEXR encoder, only 32-bit float (CV_32F) images can be saved. /// - 8-bit unsigned (CV_8U) images are not supported. /// - With Radiance HDR encoder, non 64-bit float (CV_64F) images can be saved. /// - All images will be converted to 32-bit float (CV_32F). /// - With JPEG 2000 encoder, 8-bit unsigned (CV_8U) and 16-bit unsigned (CV_16U) images can be saved. /// - With PAM encoder, 8-bit unsigned (CV_8U) and 16-bit unsigned (CV_16U) images can be saved. /// - With PNG encoder, 8-bit unsigned (CV_8U) and 16-bit unsigned (CV_16U) images can be saved. /// - 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). /// - With PGM/PPM encoder, 8-bit unsigned (CV_8U) and 16-bit unsigned (CV_16U) images can be saved. /// - With TIFF encoder, 8-bit unsigned (CV_8U), 16-bit unsigned (CV_16U), /// 32-bit float (CV_32F) and 64-bit float (CV_64F) images can be saved. /// - Multiple images (vector of Mat) can be saved in TIFF format (see the code sample below). /// - 32-bit float 3-channel (CV_32FC3) TIFF images will be saved /// using the LogLuv high dynamic range encoding (4 bytes per pixel) /// /// If the image format is not supported, the image will be converted to 8-bit unsigned (CV_8U) and saved that way. /// /// 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, how to set custom compression parameters and save it to a PNG file. /// It also demonstrates how to save multiple images in a TIFF file: /// @include snippets/imgcodecs_imwrite.cpp /// ## Parameters /// * filename: Name of the file. /// * img: (Mat or vector of Mat) Image or Images to be saved. /// * params: Format-specific parameters encoded as pairs (paramId_1, paramValue_1, paramId_2, paramValue_2, ... .) see cv::ImwriteFlags /// /// ## Note /// This alternative version of [imwrite] function uses the following default values for its arguments: /// * params: std::vector() #[inline] pub fn imwrite_def(filename: &str, img: &impl ToInputArray) -> Result { extern_container_arg!(filename); input_array_arg!(img); return_send!(via ocvrs_return); unsafe { sys::cv_imwrite_const_StringR_const__InputArrayR(filename.opencv_as_extern(), img.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } /// 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 unsigned (CV_8U) /// single-channel or 3-channel (with 'BGR' channel order) images /// can be saved using this function, with these exceptions: /// /// - With OpenEXR encoder, only 32-bit float (CV_32F) images can be saved. /// - 8-bit unsigned (CV_8U) images are not supported. /// - With Radiance HDR encoder, non 64-bit float (CV_64F) images can be saved. /// - All images will be converted to 32-bit float (CV_32F). /// - With JPEG 2000 encoder, 8-bit unsigned (CV_8U) and 16-bit unsigned (CV_16U) images can be saved. /// - With PAM encoder, 8-bit unsigned (CV_8U) and 16-bit unsigned (CV_16U) images can be saved. /// - With PNG encoder, 8-bit unsigned (CV_8U) and 16-bit unsigned (CV_16U) images can be saved. /// - 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). /// - With PGM/PPM encoder, 8-bit unsigned (CV_8U) and 16-bit unsigned (CV_16U) images can be saved. /// - With TIFF encoder, 8-bit unsigned (CV_8U), 16-bit unsigned (CV_16U), /// 32-bit float (CV_32F) and 64-bit float (CV_64F) images can be saved. /// - Multiple images (vector of Mat) can be saved in TIFF format (see the code sample below). /// - 32-bit float 3-channel (CV_32FC3) TIFF images will be saved /// using the LogLuv high dynamic range encoding (4 bytes per pixel) /// /// If the image format is not supported, the image will be converted to 8-bit unsigned (CV_8U) and saved that way. /// /// 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, how to set custom compression parameters and save it to a PNG file. /// It also demonstrates how to save multiple images in a TIFF file: /// @include snippets/imgcodecs_imwrite.cpp /// ## Parameters /// * filename: Name of the file. /// * img: (Mat or vector of Mat) Image or Images to be saved. /// * params: Format-specific parameters encoded as pairs (paramId_1, paramValue_1, paramId_2, paramValue_2, ... .) see cv::ImwriteFlags /// /// ## C++ default parameters /// * params: std::vector() #[inline] pub fn imwrite(filename: &str, img: &impl ToInputArray, params: &core::Vector) -> Result { extern_container_arg!(filename); input_array_arg!(img); return_send!(via ocvrs_return); unsafe { sys::cv_imwrite_const_StringR_const__InputArrayR_const_vectorLintGR(filename.opencv_as_extern(), img.as_raw__InputArray(), params.as_raw_VectorOfi32(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } /// multi-image overload for bindings /// /// ## Note /// This alternative version of [imwritemulti] function uses the following default values for its arguments: /// * params: std::vector() #[inline] pub fn imwritemulti_def(filename: &str, img: &impl ToInputArray) -> Result { extern_container_arg!(filename); input_array_arg!(img); return_send!(via ocvrs_return); unsafe { sys::cv_imwritemulti_const_StringR_const__InputArrayR(filename.opencv_as_extern(), img.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } /// multi-image overload for bindings /// /// ## C++ default parameters /// * params: std::vector() #[inline] pub fn imwritemulti(filename: &str, img: &impl ToInputArray, params: &core::Vector) -> Result { extern_container_arg!(filename); input_array_arg!(img); return_send!(via ocvrs_return); unsafe { sys::cv_imwritemulti_const_StringR_const__InputArrayR_const_vectorLintGR(filename.opencv_as_extern(), img.as_raw__InputArray(), params.as_raw_VectorOfi32(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } /// Constant methods for [crate::imgcodecs::ImageCollection] pub trait ImageCollectionTraitConst { fn as_raw_ImageCollection(&self) -> *const c_void; #[inline] fn size(&self) -> Result { return_send!(via ocvrs_return); unsafe { sys::cv_ImageCollection_size_const(self.as_raw_ImageCollection(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } } /// Mutable methods for [crate::imgcodecs::ImageCollection] pub trait ImageCollectionTrait: crate::imgcodecs::ImageCollectionTraitConst { fn as_raw_mut_ImageCollection(&mut self) -> *mut c_void; #[inline] fn init(&mut self, img: &str, flags: i32) -> Result<()> { extern_container_arg!(img); return_send!(via ocvrs_return); unsafe { sys::cv_ImageCollection_init_const_StringR_int(self.as_raw_mut_ImageCollection(), img.opencv_as_extern(), flags, ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } #[inline] fn at(&mut self, index: i32) -> Result { return_send!(via ocvrs_return); unsafe { sys::cv_ImageCollection_at_int(self.as_raw_mut_ImageCollection(), index, ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; let ret = unsafe { core::Mat::opencv_from_extern(ret) }; Ok(ret) } #[inline] fn get_mut(&mut self, index: i32) -> Result { return_send!(via ocvrs_return); unsafe { sys::cv_ImageCollection_operator___int(self.as_raw_mut_ImageCollection(), index, ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; let ret = unsafe { core::Mat::opencv_from_extern(ret) }; Ok(ret) } #[inline] fn release_cache(&mut self, index: i32) -> Result<()> { return_send!(via ocvrs_return); unsafe { sys::cv_ImageCollection_releaseCache_int(self.as_raw_mut_ImageCollection(), index, ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } #[inline] fn begin(&mut self) -> Result { return_send!(via ocvrs_return); unsafe { sys::cv_ImageCollection_begin(self.as_raw_mut_ImageCollection(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; let ret = unsafe { crate::imgcodecs::ImageCollection_iterator::opencv_from_extern(ret) }; Ok(ret) } #[inline] fn end(&mut self) -> Result { return_send!(via ocvrs_return); unsafe { sys::cv_ImageCollection_end(self.as_raw_mut_ImageCollection(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; let ret = unsafe { crate::imgcodecs::ImageCollection_iterator::opencv_from_extern(ret) }; Ok(ret) } } /// To read Multi Page images on demand /// /// The ImageCollection class provides iterator API to read multi page images on demand. Create iterator /// to the collection of the images and iterate over the collection. Decode the necessary page with operator*. /// /// The performance of page decoding is O(1) if collection is increment sequentially. If the user wants to access random page, /// then the time Complexity is O(n) because the collection has to be reinitialized every time in order to go to the correct page. /// However, the intermediate pages are not decoded during the process, so typically it's quite fast. /// This is required because multipage codecs does not support going backwards. /// After decoding the one page, it is stored inside the collection cache. Hence, trying to get Mat object from already decoded page is O(1). /// If you need memory, you can use .releaseCache() method to release cached index. /// The space complexity is O(n) if all pages are decoded into memory. The user is able to decode and release images on demand. pub struct ImageCollection { ptr: *mut c_void, } opencv_type_boxed! { ImageCollection } impl Drop for ImageCollection { #[inline] fn drop(&mut self) { unsafe { sys::cv_ImageCollection_delete(self.as_raw_mut_ImageCollection()) }; } } unsafe impl Send for ImageCollection {} impl crate::imgcodecs::ImageCollectionTraitConst for ImageCollection { #[inline] fn as_raw_ImageCollection(&self) -> *const c_void { self.as_raw() } } impl crate::imgcodecs::ImageCollectionTrait for ImageCollection { #[inline] fn as_raw_mut_ImageCollection(&mut self) -> *mut c_void { self.as_raw_mut() } } boxed_ref! { ImageCollection, crate::imgcodecs::ImageCollectionTraitConst, as_raw_ImageCollection, crate::imgcodecs::ImageCollectionTrait, as_raw_mut_ImageCollection } impl ImageCollection { #[inline] pub fn default() -> Result { return_send!(via ocvrs_return); unsafe { sys::cv_ImageCollection_ImageCollection(ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; let ret = unsafe { crate::imgcodecs::ImageCollection::opencv_from_extern(ret) }; Ok(ret) } #[inline] pub fn new(filename: &str, flags: i32) -> Result { extern_container_arg!(filename); return_send!(via ocvrs_return); unsafe { sys::cv_ImageCollection_ImageCollection_const_StringR_int(filename.opencv_as_extern(), flags, ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; let ret = unsafe { crate::imgcodecs::ImageCollection::opencv_from_extern(ret) }; Ok(ret) } } impl std::fmt::Debug for ImageCollection { #[inline] fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { f.debug_struct("ImageCollection") .finish() } } /// Constant methods for [crate::imgcodecs::ImageCollection_iterator] pub trait ImageCollection_iteratorTraitConst { fn as_raw_ImageCollection_iterator(&self) -> *const c_void; } /// Mutable methods for [crate::imgcodecs::ImageCollection_iterator] pub trait ImageCollection_iteratorTrait: crate::imgcodecs::ImageCollection_iteratorTraitConst { fn as_raw_mut_ImageCollection_iterator(&mut self) -> *mut c_void; #[inline] fn try_deref_mut(&mut self) -> Result { return_send!(via ocvrs_return); unsafe { sys::cv_ImageCollection_iterator_operatorX(self.as_raw_mut_ImageCollection_iterator(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; let ret = unsafe { core::Mat::opencv_from_extern(ret) }; Ok(ret) } #[inline] fn incr(&mut self) -> Result { return_send!(via ocvrs_return); unsafe { sys::cv_ImageCollection_iterator_operatorAA(self.as_raw_mut_ImageCollection_iterator(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; let ret = unsafe { crate::imgcodecs::ImageCollection_iterator::opencv_from_extern(ret) }; Ok(ret) } } pub struct ImageCollection_iterator { ptr: *mut c_void, } opencv_type_boxed! { ImageCollection_iterator } impl Drop for ImageCollection_iterator { #[inline] fn drop(&mut self) { unsafe { sys::cv_ImageCollection_iterator_delete(self.as_raw_mut_ImageCollection_iterator()) }; } } unsafe impl Send for ImageCollection_iterator {} impl crate::imgcodecs::ImageCollection_iteratorTraitConst for ImageCollection_iterator { #[inline] fn as_raw_ImageCollection_iterator(&self) -> *const c_void { self.as_raw() } } impl crate::imgcodecs::ImageCollection_iteratorTrait for ImageCollection_iterator { #[inline] fn as_raw_mut_ImageCollection_iterator(&mut self) -> *mut c_void { self.as_raw_mut() } } boxed_ref! { ImageCollection_iterator, crate::imgcodecs::ImageCollection_iteratorTraitConst, as_raw_ImageCollection_iterator, crate::imgcodecs::ImageCollection_iteratorTrait, as_raw_mut_ImageCollection_iterator } impl ImageCollection_iterator { #[inline] pub fn new(col: &mut impl crate::imgcodecs::ImageCollectionTrait) -> Result { return_send!(via ocvrs_return); unsafe { sys::cv_ImageCollection_iterator_iterator_ImageCollectionX(col.as_raw_mut_ImageCollection(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; let ret = unsafe { crate::imgcodecs::ImageCollection_iterator::opencv_from_extern(ret) }; Ok(ret) } #[inline] pub fn new_1(col: &mut impl crate::imgcodecs::ImageCollectionTrait, end: i32) -> Result { return_send!(via ocvrs_return); unsafe { sys::cv_ImageCollection_iterator_iterator_ImageCollectionX_int(col.as_raw_mut_ImageCollection(), end, ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; let ret = unsafe { crate::imgcodecs::ImageCollection_iterator::opencv_from_extern(ret) }; Ok(ret) } } impl std::fmt::Debug for ImageCollection_iterator { #[inline] fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { f.debug_struct("ImageCollection_iterator") .finish() } } }