AbstractColorCamera.h

Go to the documentation of this file.

/*
 * Copyright 2017 Fraunhofer Institute for Manufacturing Engineering and Automation (IPA)
 *
 * 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 __IPA_ABSTRACTCOLORCAMERA_H__
#define __IPA_ABSTRACTCOLORCAMERA_H__

#include "StdAfx.h"

#ifdef __LINUX__
        #include "cob_vision_utils/CameraSensorDefines.h"
        #include "cob_vision_utils/CameraSensorTypes.h"
#else
        #include "cob_common/cob_vision_utils/common/include/cob_vision_utils/CameraSensorDefines.h"
        #include "cob_common/cob_vision_utils/common/include/cob_vision_utils/CameraSensorTypes.h"
#endif

#include <boost/shared_ptr.hpp>
#include <sstream>
#include <opencv/cv.h>

namespace ipa_CameraSensors {

class AbstractColorCamera;
typedef boost::shared_ptr<AbstractColorCamera> AbstractColorCameraPtr;

class __DLL_LIBCAMERASENSORS__ AbstractColorCamera
{
        public:

                struct t_ColorCameraParameters
                {
                        ipa_CameraSensors::t_cameraRole m_CameraRole;   
                        std::stringstream m_VideoFormat;                                
                        std::stringstream m_VideoMode;                                  
                        std::stringstream m_ColorMode;                                  
                        std::stringstream m_IsoSpeed;                                   
                        std::stringstream m_FrameRate;
                        std::stringstream m_Shutter;
                        std::stringstream m_WhiteBalanceU;
                        std::stringstream m_WhiteBalanceV;
                        std::stringstream m_Hue;
                        std::stringstream m_Saturation;
                        std::stringstream m_Gamma;
                        std::stringstream m_ExposureTime;
                        std::stringstream m_Gain;
                        std::stringstream m_Brightness;
                        std::stringstream m_ImageWidth;
                        std::stringstream m_ImageHeight;
                        std::stringstream m_Interface;                          
                        std::stringstream m_IP;                                         
                };

                virtual unsigned long Init(std::string directory, int cameraIndex = 0) =0;

                virtual bool isInitialized() {return m_initialized;}

                virtual bool isOpen() {return m_open;}

                virtual unsigned long Open() =0;

                virtual unsigned long Close() =0; //Save intrinsic params back to File

                unsigned long GetColorImage(char* colorImageData, bool getLatestFrame=true) {return RET_FAILED;}

                virtual unsigned long GetColorImage(cv::Mat* colorImage, bool getLatestFrame=true)=0;

                virtual t_cameraType GetCameraType();

                virtual unsigned long SetProperty(t_cameraProperty* cameraProperty) =0;

                virtual unsigned long SetPropertyDefaults() =0;

                virtual unsigned long GetProperty(t_cameraProperty* cameraProperty) =0;

                virtual unsigned long PrintCameraInformation() =0;

                virtual unsigned long SaveParameters(const char* filename)=0;

                virtual unsigned long TestCamera(const char* filename);

                virtual int GetNumberOfImages() {return std::numeric_limits<int>::max();};

                virtual unsigned long SetPathToImages(std::string path) {return RET_OK;};

                virtual ~AbstractColorCamera();

        protected:

                bool m_initialized; 
                bool m_open;            

                t_ColorCameraParameters m_ColorCameraParameters; 

                t_cameraType m_CameraType; 

                unsigned int m_BufferSize; 
        private:

                virtual unsigned long LoadParameters(const char* filename, int cameraIndex)=0;

                virtual unsigned long SetParameters()=0;

};

__DLL_LIBCAMERASENSORS__ AbstractColorCameraPtr CreateColorCamera_VirtualCam();
__DLL_LIBCAMERASENSORS__ AbstractColorCameraPtr CreateColorCamera_ICCam();
__DLL_LIBCAMERASENSORS__ AbstractColorCameraPtr CreateColorCamera_AxisCam();
__DLL_LIBCAMERASENSORS__ AbstractColorCameraPtr CreateColorCamera_AVTPikeCam();
__DLL_LIBCAMERASENSORS__ AbstractColorCameraPtr CreateColorCamera_OpenCVCamera();


} // end namespace
#endif // __IPA_ABSTRACTCOLORCAMERA_H__