Image.h

/* 
*  Copyright 2011 Matthias Fuchs
*
*  Licensed under the Apache License, Version 2.0 (the "License");
*  you may not use this file except in compliance with the License.
*  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*/

#ifndef STROMX_CVSUPPORT_IMAGE_H
#define STROMX_CVSUPPORT_IMAGE_H

#include <string>
#include "stromx/cvsupport/Config.h"
#include <stromx/runtime/ImageWrapper.h>

namespace cv
{
    class Mat;
}

namespace stromx
{
    namespace cvsupport
    {
        class STROMX_CVSUPPORT_API Image : public runtime::ImageWrapper
        {
             friend STROMX_CVSUPPORT_API cv::Mat getOpenCvMat(const runtime::Image& image);
             
        public:
            enum Conversion
            {
                UNCHANGED,
                
                GRAYSCALE = 0x2,
                
                COLOR = 0x4,
                
                DEPTH_16 = 0x8
            };
            
            static void save(const std::string& filename, const runtime::Image & image);
            
            Image();
            
            explicit Image(const unsigned int width, const unsigned int height, const PixelType pixelType);
            
            explicit Image(const std::string & filename);
            
            explicit Image(const std::string & filename, const Conversion access);
                        
            explicit Image(const stromx::runtime::Image& image);
            
            explicit Image(const stromx::cvsupport::Image& image);
            
            explicit Image(const cv::Mat & cvImage);
            
            explicit Image(const cv::Mat & cvImage, const PixelType pixelType);
            
            explicit Image(const unsigned int size);
            
            virtual ~Image();
            
            virtual const runtime::Version & version() const { return VERSION; }
            virtual const std::string & type() const { return TYPE; }
            virtual const std::string & package() const { return PACKAGE; }
            
            virtual Data* clone() const;
            
            virtual void serialize(runtime::OutputProvider & output) const;
            virtual void deserialize(runtime::InputProvider & input, const stromx::runtime::Version & version);
            
            virtual void initializeImage(const unsigned int width, 
                                         const unsigned int height, 
                                         const unsigned int stride, 
                                         uint8_t* data, 
                                         const PixelType pixelType);
                                         
            virtual void initializeMatrix(const unsigned int rows, 
                                          const unsigned int cols, 
                                          const unsigned int stride, 
                                          uint8_t* data, 
                                          const ValueType valueType);
            
            void open(const std::string& filename);
            
            void open(const std::string & filename, const Conversion access);
            
            void save(const std::string& filename) const;
            
        private:
            static const std::string TYPE;
            static const std::string PACKAGE;
            static const runtime::Version VERSION;
            
            static PixelType pixelTypeFromParameters(const int depth, const int numChannels);
            static int getCvAccessType(const Conversion access);
            static int cvTypeFromPixelType(const runtime::Image::PixelType pixelType);
            static int cvTypeFromValueType(const runtime::Matrix::ValueType valueType);
            static runtime::Image::PixelType pixelTypeFromCvType(const int cvType);
            
            void getDataFromCvImage(const PixelType pixelType);
            void copy(const stromx::runtime::Image & image);
            void allocate(const unsigned int width, const unsigned int height, const Image::PixelType pixelType);
            
            cv::Mat* m_image;
        };
    }
}

#endif // STROMX_CVSUPPORT_IMAGE_H