cap_tyzx.cpp

/*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;
}