/*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.
//
//
//                        Intel License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, 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 Intel Corporation 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*/

#include "precomp.hpp"
#include <DeepSeaIF.h>

#if _MSC_VER >= 1200
    #pragma comment(lib,"DeepSeaIF.lib")
#endif


/****************** Capturing video from TYZX stereo camera  *******************/
/** Initially developed by Roman Stanchak rstanchak@yahoo.com                  */

class CvCaptureCAM_TYZX : public CvCapture
{
public:
    CvCaptureCAM_TYZX() { index = -1; image = 0; }
    virtual ~CvCaptureCAM_TYZX() { close(); }

    virtual bool open( int _index );
    virtual void close();
    bool isOpened() { return index >= 0; }

    virtual double getProperty(int);
    virtual bool setProperty(int, double) { return false; }
    virtual bool grabFrame();
    virtual IplImage* retrieveFrame(int);
    virtual int getCaptureDomain() { return CV_CAP_TYZX; } // Return the type of the capture object: CV_CAP_VFW, etc...

protected:
    virtual bool allocateImage();

    int index;
    IplImage* image;
}
CvCaptureCAM_TYZX;

DeepSeaIF * g_tyzx_camera   = 0;
int         g_tyzx_refcount = 0;

bool CvCaptureCAM_TYZX::open( int _index )
{
    close();

    if(!g_tyzx_camera){
        g_tyzx_camera = new DeepSeaIF;
        if(!g_tyzx_camera) return false;

        if(!g_tyzx_camera->initializeSettings(NULL)){
            delete g_tyzx_camera;
            return false;
        }

        // set initial sensor mode
        // TODO is g_tyzx_camera redundant?
        g_tyzx_camera->setSensorMode(g_tyzx_camera->getSensorMode());

        // mm's
        g_tyzx_camera->setZUnits((int) 1000);

        g_tyzx_camera->enableLeftColor(true);
        g_tyzx_camera->setColorMode(DeepSeaIF::BGRcolor);
        g_tyzx_camera->setDoIntensityCrop(true);
        g_tyzx_camera->enable8bitImages(true);
        if(!g_tyzx_camera->startCapture()){
            return false;
        }
        g_tyzx_refcount++;
    }
    index = _index;
    return true;
}

void CvCaptureCAM_TYZX::close()
{
    if( isOpened() )
    {
        cvReleaseImage( &image );
        g_tyzx_refcount--;
        if(g_tyzx_refcount==0){
            delete g_tyzx_camera;
        }
    }
}

bool CvCaptureCAM_TYZX::grabFrame()
{
    return isOpened() && g_tyzx_camera && g_tyzx_camera->grab();
}

bool CvCaptureCAM_TYZX::allocateImage()
{
    int depth, nch;
    CvSize size;

    // assume we want to resize
    cvReleaseImage(&image);

    // figure out size depending on index provided
    switch(index){
        case CV_TYZX_RIGHT:
            size = cvSize(g_tyzx_camera->intensityWidth(), g_tyzx_camera->intensityHeight());
            depth = 8;
            nch = 1;
            break;
        case CV_TYZX_Z:
            size = cvSize(g_tyzx_camera->zWidth(), g_tyzx_camera->zHeight());
            depth = IPL_DEPTH_16S;
            nch = 1;
            break;
        case CV_TYZX_LEFT:
        default:
            size = cvSize(g_tyzx_camera->intensityWidth(), g_tyzx_camera->intensityHeight());
            depth = 8;
            nch = 1;
            break;
    }
    image = cvCreateImage(size, depth, nch);
    return image != 0;
}

/// Copy 'grabbed' image into capture buffer and return it.
IplImage * CvCaptureCAM_TYZX::retrieveFrame(int)
{
    if(!isOpened() || !g_tyzx_camera) return 0;

    if(!image && !alocateImage())
        return 0;

    // copy camera image into buffer.
    // tempting to reference TYZX memory directly to avoid copying.
    switch (index)
    {
        case CV_TYZX_RIGHT:
            memcpy(image->imageData, g_tyzx_camera->getRImage(), image->imageSize);
            break;
        case CV_TYZX_Z:
            memcpy(image->imageData, g_tyzx_camera->getZImage(), image->imageSize);
            break;
        case CV_TYZX_LEFT:
        default:
            memcpy(image->imageData, g_tyzx_camera->getLImage(), image->imageSize);
            break;
    }

    return image;
}

double CvCaptureCAM_TYZX::getProperty(int property_id)
{
    CvSize size;
    switch(capture->index)
    {
        case CV_TYZX_LEFT:
            size = cvSize(g_tyzx_camera->intensityWidth(), g_tyzx_camera->intensityHeight());
            break;
        case CV_TYZX_RIGHT:
            size = cvSize(g_tyzx_camera->intensityWidth(), g_tyzx_camera->intensityHeight());
            break;
        case CV_TYZX_Z:
            size = cvSize(g_tyzx_camera->zWidth(), g_tyzx_camera->zHeight());
            break;
        default:
            size = cvSize(0,0);
    }

    switch( property_id )
    {
        case CV_CAP_PROP_FRAME_WIDTH:
            return size.width;
        case CV_CAP_PROP_FRAME_HEIGHT:
            return size.height;
    }

    return 0;
}

bool CvCaptureCAM_TYZX::setProperty( int, double )
{
    return false;
}

CvCapture * cvCreateCameraCapture_TYZX (int index)
{
    CvCaptureCAM_TYZX * capture = new CvCaptureCAM_TYZX;
    if( capture->open(index) )
        return capture;

    delete capture;
    return 0;
}
