cxVideoSourceSHM.cpp

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
                 
Copyright (c) SINTEF Department of Medical Technology.
All rights reserved.
                 
CustusX is released under a BSD 3-Clause license.
                 
See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
=========================================================================*/


#include "cxVideoSourceSHM.h"

#include <boost/array.hpp>
#include <vector>

#include <vtkImageData.h>
#include <vtkImageImport.h>
#include <vtkPNGReader.h>


#include <qtimer.h>

namespace cx
{

VideoSourceSHM::VideoSourceSHM(int width, int height, int depth)
        : mImageWidth(width), mImageHeight(height), mImageColorDepth(depth), mImageImport(vtkImageImportPtr::New())
{
        mImportInitialized = false;
        mStartWhenConnected = false;

        mImageImport->SetDataScalarTypeToUnsignedChar();
        mImageImport->SetNumberOfScalarComponents(3);

        mConnected = false;
        mStreaming = false;

        mPollTimer = new QTimer(this);
        mPollTimer->setInterval(40);    // Polling interval (currently set @ 25 fps)
        mTimeStamp = 0;


        mImageData = mImageImport->GetOutput();
}

VideoSourceSHM::~VideoSourceSHM()
{
        // Disconnect
        disconnectServer();
}

QString VideoSourceSHM::getUid()
{
        return mSource.key();
}

QString VideoSourceSHM::getName()
{
        return "SHMLink";
}

vtkImageDataPtr VideoSourceSHM::getVtkImageData()
{
        return mImageImport->GetOutput();
}

double VideoSourceSHM::getTimestamp()
{
        return (double) mSource.timestamp().toMSecsSinceEpoch();
}

QString VideoSourceSHM::getInfoString() const
{
        return "NOT YET IMPLEMENTED";
}

QString VideoSourceSHM::getStatusString() const
{
        return QString("%1 and %2").arg(isConnected() ? "Connected" : "Not connected").arg(isStreaming() ? "streaming" : "not streaming");;
}

void VideoSourceSHM::start()
{
        if (!isConnected())
        {
                mStartWhenConnected = true;
                return;
        }
        mStartWhenConnected = false;
        if (!mStreaming)
        {
                mPollTimer->start();
                // If all is well - tell the system we're streaming
                mStreaming = true;

                emit streaming(mStreaming);
        }
}

void VideoSourceSHM::stop()
{
        mStartWhenConnected = false;
        if (mStreaming)
        {
                mPollTimer->stop();
                // If all is well - tell the system we've stopped streaming
                mStreaming = false;

                emit streaming(mStreaming);
        }

}

bool VideoSourceSHM::validData() const
{
        // return (isConnected() && isStreaming()); // Currently only check available
        return isConnected() && mImportInitialized;
}

bool VideoSourceSHM::isConnected() const
{
        return mConnected;
}

bool VideoSourceSHM::isStreaming() const
{
        return (isConnected() && mStreaming);
}

void VideoSourceSHM::update()
{
        unsigned char* buffer = (unsigned char*) mSource.isNew(); // Fetch new data from server - NULL if no new data present
        if (!buffer)
                return;

        mTimeStamp = mSource.timestamp().currentMSecsSinceEpoch();

        int numChannels = mImageColorDepth/sizeof(uchar);
        Q_UNUSED(numChannels);

        mImageImport->SetWholeExtent(0, mImageWidth - 1, 0, mImageHeight - 1, 0, 0);
        mImageImport->SetDataExtentToWholeExtent();

        mImageImport->SetImportVoidPointer(buffer);
        mImageImport->Update();
        mImportInitialized = true;

        emit newFrame();
}

void VideoSourceSHM::connectServer(const QString& key)
{
        mConnected = mSource.attach(key);

        if (mConnected)
        {
                connect(mPollTimer, SIGNAL(timeout()), this, SLOT(serverPollSlot()));
                serverPollSlot(); // Pull in a new frame here, even if we may no be started yet to initialize the image import
        }
        if (mStartWhenConnected)
        {
                start();
        }
}

void VideoSourceSHM::disconnectServer()
{
        stop();

        if (mConnected)
        {
                disconnect(mPollTimer, SIGNAL(timeout()), this, SLOT(serverPollSlot()));
                mSource.release();
        }

        mSource.detach();
        mConnected = false;
}

void VideoSourceSHM::serverPollSlot()
{
        this->update();
}

void VideoSourceSHM::setResolution(double resolution)
{
        mImageImport->SetDataSpacing(resolution, resolution, 1);
}
} // end namespace