imgcodecs.hpp

/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                          License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
 
#ifndef OPENCV_IMGCODECS_HPP
#define OPENCV_IMGCODECS_HPP
 
#include "opencv2/core.hpp"
 
namespace cv
{
 
 
 
enum ImreadModes {
       IMREAD_UNCHANGED            = -1, 
       IMREAD_GRAYSCALE            = 0,  
       IMREAD_COLOR                = 1,  
       IMREAD_ANYDEPTH             = 2,  
       IMREAD_ANYCOLOR             = 4,  
       IMREAD_LOAD_GDAL            = 8,  
       IMREAD_REDUCED_GRAYSCALE_2  = 16, 
       IMREAD_REDUCED_COLOR_2      = 17, 
       IMREAD_REDUCED_GRAYSCALE_4  = 32, 
       IMREAD_REDUCED_COLOR_4      = 33, 
       IMREAD_REDUCED_GRAYSCALE_8  = 64, 
       IMREAD_REDUCED_COLOR_8      = 65, 
       IMREAD_IGNORE_ORIENTATION   = 128 
     };
 
enum ImwriteFlags {
       IMWRITE_JPEG_QUALITY        = 1,  
       IMWRITE_JPEG_PROGRESSIVE    = 2,  
       IMWRITE_JPEG_OPTIMIZE       = 3,  
       IMWRITE_JPEG_RST_INTERVAL   = 4,  
       IMWRITE_JPEG_LUMA_QUALITY   = 5,  
       IMWRITE_JPEG_CHROMA_QUALITY = 6,  
       IMWRITE_JPEG_SAMPLING_FACTOR = 7, 
       IMWRITE_PNG_COMPRESSION     = 16, 
       IMWRITE_PNG_STRATEGY        = 17, 
       IMWRITE_PNG_BILEVEL         = 18, 
       IMWRITE_PXM_BINARY          = 32, 
       IMWRITE_EXR_TYPE            = (3 << 4) + 0 /* 48 */, 
       IMWRITE_EXR_COMPRESSION     = (3 << 4) + 1 /* 49 */, 
       IMWRITE_EXR_DWA_COMPRESSION_LEVEL = (3 << 4) + 2 /* 50 */, 
       IMWRITE_WEBP_QUALITY        = 64, 
       IMWRITE_HDR_COMPRESSION     = (5 << 4) + 0 /* 80 */, 
       IMWRITE_PAM_TUPLETYPE       = 128,
       IMWRITE_TIFF_RESUNIT        = 256,
       IMWRITE_TIFF_XDPI           = 257,
       IMWRITE_TIFF_YDPI           = 258,
       IMWRITE_TIFF_COMPRESSION    = 259,
       IMWRITE_TIFF_ROWSPERSTRIP   = 278,
       IMWRITE_TIFF_PREDICTOR      = 317,
       IMWRITE_JPEG2000_COMPRESSION_X1000 = 272,
       IMWRITE_AVIF_QUALITY        = 512,
       IMWRITE_AVIF_DEPTH          = 513,
       IMWRITE_AVIF_SPEED          = 514 
     };
 
enum ImwriteJPEGSamplingFactorParams {
       IMWRITE_JPEG_SAMPLING_FACTOR_411 = 0x411111, 
       IMWRITE_JPEG_SAMPLING_FACTOR_420 = 0x221111, 
       IMWRITE_JPEG_SAMPLING_FACTOR_422 = 0x211111, 
       IMWRITE_JPEG_SAMPLING_FACTOR_440 = 0x121111, 
       IMWRITE_JPEG_SAMPLING_FACTOR_444 = 0x111111  
     };
 
enum ImwriteTiffCompressionFlags {
        IMWRITE_TIFF_COMPRESSION_NONE = 1,            
        IMWRITE_TIFF_COMPRESSION_CCITTRLE = 2,        
        IMWRITE_TIFF_COMPRESSION_CCITTFAX3 = 3,       
        IMWRITE_TIFF_COMPRESSION_CCITT_T4 = 3,        
        IMWRITE_TIFF_COMPRESSION_CCITTFAX4 = 4,       
        IMWRITE_TIFF_COMPRESSION_CCITT_T6 = 4,        
        IMWRITE_TIFF_COMPRESSION_LZW = 5,             
        IMWRITE_TIFF_COMPRESSION_OJPEG = 6,           
        IMWRITE_TIFF_COMPRESSION_JPEG = 7,            
        IMWRITE_TIFF_COMPRESSION_T85 = 9,             
        IMWRITE_TIFF_COMPRESSION_T43 = 10,            
        IMWRITE_TIFF_COMPRESSION_NEXT = 32766,        
        IMWRITE_TIFF_COMPRESSION_CCITTRLEW = 32771,   
        IMWRITE_TIFF_COMPRESSION_PACKBITS = 32773,    
        IMWRITE_TIFF_COMPRESSION_THUNDERSCAN = 32809, 
        IMWRITE_TIFF_COMPRESSION_IT8CTPAD = 32895,    
        IMWRITE_TIFF_COMPRESSION_IT8LW = 32896,       
        IMWRITE_TIFF_COMPRESSION_IT8MP = 32897,       
        IMWRITE_TIFF_COMPRESSION_IT8BL = 32898,       
        IMWRITE_TIFF_COMPRESSION_PIXARFILM = 32908,   
        IMWRITE_TIFF_COMPRESSION_PIXARLOG = 32909,    
        IMWRITE_TIFF_COMPRESSION_DEFLATE = 32946,     
        IMWRITE_TIFF_COMPRESSION_ADOBE_DEFLATE = 8,   
        IMWRITE_TIFF_COMPRESSION_DCS = 32947,         
        IMWRITE_TIFF_COMPRESSION_JBIG = 34661,        
        IMWRITE_TIFF_COMPRESSION_SGILOG = 34676,      
        IMWRITE_TIFF_COMPRESSION_SGILOG24 = 34677,    
        IMWRITE_TIFF_COMPRESSION_JP2000 = 34712,      
        IMWRITE_TIFF_COMPRESSION_LERC = 34887,        
        IMWRITE_TIFF_COMPRESSION_LZMA = 34925,        
        IMWRITE_TIFF_COMPRESSION_ZSTD = 50000,        
        IMWRITE_TIFF_COMPRESSION_WEBP = 50001,        
        IMWRITE_TIFF_COMPRESSION_JXL = 50002          
};
 
enum ImwriteTiffPredictorFlags {
        IMWRITE_TIFF_PREDICTOR_NONE = 1,              
        IMWRITE_TIFF_PREDICTOR_HORIZONTAL = 2,        
        IMWRITE_TIFF_PREDICTOR_FLOATINGPOINT = 3      
 
};
 
enum ImwriteEXRTypeFlags {
       /*IMWRITE_EXR_TYPE_UNIT = 0, //!< not supported */
       IMWRITE_EXR_TYPE_HALF   = 1, 
       IMWRITE_EXR_TYPE_FLOAT  = 2  
     };
 
enum ImwriteEXRCompressionFlags {
       IMWRITE_EXR_COMPRESSION_NO    = 0, 
       IMWRITE_EXR_COMPRESSION_RLE   = 1, 
       IMWRITE_EXR_COMPRESSION_ZIPS  = 2, 
       IMWRITE_EXR_COMPRESSION_ZIP   = 3, 
       IMWRITE_EXR_COMPRESSION_PIZ   = 4, 
       IMWRITE_EXR_COMPRESSION_PXR24 = 5, 
       IMWRITE_EXR_COMPRESSION_B44   = 6, 
       IMWRITE_EXR_COMPRESSION_B44A  = 7, 
       IMWRITE_EXR_COMPRESSION_DWAA  = 8, 
       IMWRITE_EXR_COMPRESSION_DWAB  = 9, 
     };
 
 
enum ImwritePNGFlags {
       IMWRITE_PNG_STRATEGY_DEFAULT      = 0, 
       IMWRITE_PNG_STRATEGY_FILTERED     = 1, 
       IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY = 2, 
       IMWRITE_PNG_STRATEGY_RLE          = 3, 
       IMWRITE_PNG_STRATEGY_FIXED        = 4  
     };
 
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
     };
 
enum ImwriteHDRCompressionFlags {
    IMWRITE_HDR_COMPRESSION_NONE = 0,
    IMWRITE_HDR_COMPRESSION_RLE = 1
};
 
 
CV_EXPORTS_W Mat imread( const String& filename, int flags = IMREAD_COLOR );
 
CV_EXPORTS_W void imread( const String& filename, OutputArray dst, int flags = IMREAD_COLOR );
 
CV_EXPORTS_W bool imreadmulti(const String& filename, CV_OUT std::vector<Mat>& mats, int flags = IMREAD_ANYCOLOR);
 
CV_EXPORTS_W bool imreadmulti(const String& filename, CV_OUT std::vector<Mat>& mats, int start, int count, int flags = IMREAD_ANYCOLOR);
 
CV_EXPORTS_W size_t imcount(const String& filename, int flags = IMREAD_ANYCOLOR);
 
CV_EXPORTS_W bool imwrite( const String& filename, InputArray img,
              const std::vector<int>& params = std::vector<int>());
 
CV_WRAP static inline
bool imwritemulti(const String& filename, InputArrayOfArrays img,
                  const std::vector<int>& params = std::vector<int>())
{
    return imwrite(filename, img, params);
}
 
CV_EXPORTS_W Mat imdecode( InputArray buf, int flags );
 
CV_EXPORTS Mat imdecode( InputArray buf, int flags, Mat* dst);
 
CV_EXPORTS_W bool imdecodemulti(InputArray buf, int flags, CV_OUT std::vector<Mat>& mats, const cv::Range& range = Range::all());
 
CV_EXPORTS_W bool imencode( const String& ext, InputArray img,
                            CV_OUT std::vector<uchar>& buf,
                            const std::vector<int>& params = std::vector<int>());
 
CV_EXPORTS_W bool haveImageReader( const String& filename );
 
CV_EXPORTS_W bool haveImageWriter( const String& filename );
 
class CV_EXPORTS ImageCollection {
public:
    struct CV_EXPORTS iterator {
        iterator(ImageCollection* col);
        iterator(ImageCollection* col, int end);
        Mat& operator*();
        Mat* operator->();
        iterator& operator++();
        iterator operator++(int);
        friend bool operator== (const iterator& a, const iterator& b) { return a.m_curr == b.m_curr; }
        friend bool operator!= (const iterator& a, const iterator& b) { return a.m_curr != b.m_curr; }
 
    private:
        ImageCollection* m_pCollection;
        int m_curr;
    };
 
    ImageCollection();
    ImageCollection(const String& filename, int flags);
    void init(const String& img, int flags);
    size_t size() const;
    const Mat& at(int index);
    const Mat& operator[](int index);
    void releaseCache(int index);
    iterator begin();
    iterator end();
 
    class Impl;
    Ptr<Impl> getImpl();
protected:
    Ptr<Impl> pImpl;
};
 
 
} // cv
 
#endif //OPENCV_IMGCODECS_HPP