AbstractRangeImagingSensor.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_ABSTRACTRANGEIMAGINGSENSOR_H__
#define __IPA_ABSTRACTRANGEIMAGINGSENSOR_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 <opencv/cv.h>

#include <iostream>
#include <limits>
#include <vector>

#include <boost/shared_ptr.hpp>

namespace ipa_CameraSensors {

class AbstractRangeImagingSensor;
typedef boost::shared_ptr<AbstractRangeImagingSensor> AbstractRangeImagingSensorPtr;

class __DLL_LIBCAMERASENSORS__ AbstractRangeImagingSensor
{
public:

        struct t_RangeCameraParameters
        {
                ipa_CameraSensors::t_cameraRole m_CameraRole;   
                std::stringstream m_AmplitudeThreshold;         

                std::stringstream m_IntegrationTime;            
                std::stringstream m_ModulationFrequency;        
                std::stringstream m_AcquireMode;                        
                std::stringstream m_ExposureMode;                       
                std::stringstream m_DistanceOffset;                     
                std::stringstream m_ROI;                                        
                std::stringstream m_LensCalibration;            

                std::stringstream m_Interface;                          
                std::stringstream m_IP;                                         
        };

        virtual ~AbstractRangeImagingSensor();

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

        virtual unsigned long Open() = 0;

        virtual unsigned long Close() = 0;

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

        virtual unsigned long SetPropertyDefaults() =0;

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

        virtual unsigned long AcquireImages(cv::Mat* rangeImage = 0, cv::Mat* intensityImage = 0,
                cv::Mat* cartesianImage = 0, bool getLatestFrame=true, bool undistort=true,
                ipa_CameraSensors::t_ToFGrayImageType grayImageType = ipa_CameraSensors::INTENSITY_32F1) = 0;

        virtual unsigned long AcquireImages(int widthStepRange, int widthStepGray, int widthStepCartesian, char* rangeImage=NULL, char* grayImage=NULL,
                char* cartesianImage=NULL, bool getLatestFrame=true, bool undistort=true,
                ipa_CameraSensors::t_ToFGrayImageType grayImageType = ipa_CameraSensors::INTENSITY_32F1) = 0;

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

        virtual bool isInitialized() = 0;

        virtual bool isOpen() = 0;

        virtual t_CalibrationMethod GetCalibrationMethod() {return m_CalibrationMethod;}

        virtual t_cameraType GetCameraType() {return m_CameraType;}

        virtual unsigned long SetIntrinsics(cv::Mat& intrinsicMatrix,
                cv::Mat& undistortMapX, cv::Mat& undistortMapY);

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

        virtual unsigned long SetPathToImages(std::string path);

        unsigned int m_ImageCounter; 

protected:

        t_CalibrationMethod m_CalibrationMethod; 
        t_RangeCameraParameters m_RangeCameraParameters; 
        t_cameraType m_CameraType; 

        bool m_initialized; 
        bool m_open;            

        unsigned int m_BufferSize; 

        cv::Mat m_intrinsicMatrix;              
        cv::Mat m_undistortMapX;                
        cv::Mat m_undistortMapY;                

private:

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

__DLL_LIBCAMERASENSORS__ AbstractRangeImagingSensorPtr CreateRangeImagingSensor_VirtualCam();
__DLL_LIBCAMERASENSORS__ AbstractRangeImagingSensorPtr CreateRangeImagingSensor_Swissranger();
__DLL_LIBCAMERASENSORS__ AbstractRangeImagingSensorPtr CreateRangeImagingSensor_PMDCam();
__DLL_LIBCAMERASENSORS__ AbstractRangeImagingSensorPtr CreateRangeImagingSensor_Kinect();

} // end namespace ipa_CameraSensors
#endif // __IPA_ABSTRACTRANGEIMAGINGSENSOR_H__