diff --git a/Modules/ToFHardware/mitkKinectController.cpp b/Modules/ToFHardware/mitkKinectController.cpp
index 332a17cf11..cf5bf9823a 100644
--- a/Modules/ToFHardware/mitkKinectController.cpp
+++ b/Modules/ToFHardware/mitkKinectController.cpp
@@ -1,324 +1,285 @@
/*=========================================================================
Program: Medical Imaging & Interaction Toolkit
Module: $RCSfile$
Language: C++
Date: $Date: 2010-05-27 16:06:53 +0200 (Do, 27 Mai 2010) $
Version: $Revision: $
Copyright (c) German Cancer Research Center, Division of Medical and
Biological Informatics. All rights reserved.
See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#include "mitkKinectController.h"
#ifdef MITK_USE_TOF_KINECT
#include <XnCppWrapper.h>
#endif
namespace mitk
{
class KinectController::KinectControllerPrivate
{
public:
KinectControllerPrivate();
~KinectControllerPrivate();
bool ErrorText(unsigned int error);
#ifdef MITK_USE_TOF_KINECT
xn::Context m_Context; ///< OpenNI context
xn::DepthGenerator m_DepthGenerator; ///< Depth generator to access depth image of kinect
xn::ImageGenerator m_ImageGenerator; ///< Image generator to access RGB image of kinect
xn::IRGenerator m_IRGenerator; ///< IR generator to access IR image of kinect
#endif
bool m_ConnectionCheck; ///< check if camera is connected or not
bool m_UseIR; ///< flag indicating whether IR image is used or not
unsigned int m_CaptureWidth; ///< image width
unsigned int m_CaptureHeight; ///< image height
};
KinectController::KinectControllerPrivate::KinectControllerPrivate():
m_Context(NULL),
m_DepthGenerator(NULL),
m_ImageGenerator(NULL),
m_IRGenerator(NULL),
m_ConnectionCheck(false),
m_UseIR(false),
m_CaptureWidth(640),
m_CaptureHeight(480)
{
}
KinectController::KinectControllerPrivate::~KinectControllerPrivate()
{
}
bool KinectController::KinectControllerPrivate::ErrorText(unsigned int error)
{
if(error != XN_STATUS_OK)
{
MITK_ERROR << "Camera Error " << xnGetStatusString(error);
return false;
}
else return true;
}
KinectController::KinectController(): d(new KinectControllerPrivate)
{
}
KinectController::~KinectController()
{
delete d;
}
bool KinectController::OpenCameraConnection()
{
if (!d->m_ConnectionCheck)
{
// Initialize the OpenNI status
d->m_ConnectionCheck = !d->ErrorText(d->m_Context.Init());
// Create a depth generator and set its resolution
XnMapOutputMode DepthMode;
d->m_ConnectionCheck = !d->ErrorText(d->m_DepthGenerator.Create(d->m_Context));
d->m_DepthGenerator.GetMapOutputMode(DepthMode);
DepthMode.nXRes = xn::Resolution((XnResolution)XN_RES_VGA).GetXResolution();
DepthMode.nYRes = xn::Resolution((XnResolution)XN_RES_VGA).GetYResolution();
d->m_ConnectionCheck = !d->ErrorText(d->m_DepthGenerator.SetMapOutputMode(DepthMode));
- {
- XnUInt32 NumModes = 10;
- XnMapOutputMode *SupportedModes = new XnMapOutputMode[NumModes];
- d->m_ConnectionCheck = !d->ErrorText(d->m_DepthGenerator.GetSupportedMapOutputModes(SupportedModes, NumModes));
- for ( unsigned int i = 0; i < NumModes; i++ )
- {
- std::cout << "DepthModes #" << i << std::endl;
- std::cout << "Nx=" << SupportedModes[i].nXRes << std::endl;
- std::cout << "Ny=" << SupportedModes[i].nYRes << std::endl;
- std::cout << "FPS=" << SupportedModes[i].nFPS << std::endl;
- }
- delete[] SupportedModes;
- }
if (d->m_UseIR)
{
// Create the IR generator and set its resolution
d->m_ConnectionCheck = !d->ErrorText(d->m_IRGenerator.Create(d->m_Context));
XnMapOutputMode IRMode;
d->m_IRGenerator.GetMapOutputMode(IRMode);
IRMode.nXRes = XN_VGA_X_RES;
IRMode.nYRes = XN_VGA_Y_RES;
IRMode.nFPS = 30;
d->m_ConnectionCheck = !d->ErrorText(d->m_IRGenerator.SetMapOutputMode(IRMode));
-
- XnUInt32 NumModes = 10;
- XnMapOutputMode *SupportedModes = new XnMapOutputMode[NumModes];
- d->m_ConnectionCheck = !d->ErrorText(d->m_IRGenerator.GetSupportedMapOutputModes(SupportedModes, NumModes));
- for ( unsigned int i = 0; i < NumModes; i++ )
- {
- std::cout << "Mode #" << i << std::endl;
- std::cout << "Nx=" << SupportedModes[i].nXRes << std::endl;
- std::cout << "Ny=" << SupportedModes[i].nYRes << std::endl;
- std::cout << "FPS=" << SupportedModes[i].nFPS << std::endl;
- }
- delete[] SupportedModes;
}
else
{
// Create an image generator and set its resolution
XnMapOutputMode ImageMode;
d->m_ConnectionCheck = !d->ErrorText(d->m_ImageGenerator.Create(d->m_Context));
d->m_ImageGenerator.GetMapOutputMode(ImageMode);
ImageMode.nXRes = xn::Resolution((XnResolution)XN_RES_VGA).GetXResolution();
ImageMode.nYRes = xn::Resolution((XnResolution)XN_RES_VGA).GetYResolution();
d->m_ConnectionCheck = !d->ErrorText(d->m_ImageGenerator.SetMapOutputMode(ImageMode));
- {
- XnUInt32 NumModes = 10;
- XnMapOutputMode *SupportedModes = new XnMapOutputMode[NumModes];
- d->m_ConnectionCheck = !d->ErrorText(d->m_ImageGenerator.GetSupportedMapOutputModes(SupportedModes, NumModes));
- for ( unsigned int i = 0; i < NumModes; i++ )
- {
- std::cout << "ImageModes #" << i << std::endl;
- std::cout << "Nx=" << SupportedModes[i].nXRes << std::endl;
- std::cout << "Ny=" << SupportedModes[i].nYRes << std::endl;
- std::cout << "FPS=" << SupportedModes[i].nFPS << std::endl;
- }
- delete[] SupportedModes;
- }
}
// Camera registration
if ( d->m_DepthGenerator.IsCapabilitySupported(XN_CAPABILITY_ALTERNATIVE_VIEW_POINT) )
{
if (d->m_UseIR)
{
d->m_ConnectionCheck = !d->ErrorText(d->m_DepthGenerator.GetAlternativeViewPointCap().SetViewPoint(d->m_IRGenerator));
}
else
{
d->m_ConnectionCheck = !d->ErrorText(d->m_DepthGenerator.GetAlternativeViewPointCap().SetViewPoint(d->m_ImageGenerator));
}
}
else
{
std::cout << "Alternative view point not supported by the depth generator..." << std::endl;
}
if (d->m_UseIR)
{
if ( d->m_IRGenerator.IsCapabilitySupported(XN_CAPABILITY_ALTERNATIVE_VIEW_POINT) )
{
d->m_ConnectionCheck = !d->ErrorText(d->m_IRGenerator.GetAlternativeViewPointCap().SetViewPoint(d->m_DepthGenerator));
}
else
{
std::cout << "Alternative view point not supported by the depth generator..." << std::endl;
}
}
// Mirror data
d->m_ConnectionCheck = d->ErrorText(d->m_Context.SetGlobalMirror(!d->m_Context.GetGlobalMirror()));
// Start data generation
d->m_ConnectionCheck = d->ErrorText(d->m_Context.StartGeneratingAll());
// // Update the connected flag
// d->m_ConnectionCheck = true;
}
- MITK_INFO<<"Controller connect?"<<d->m_ConnectionCheck;
return d->m_ConnectionCheck;
}
bool KinectController::CloseCameraConnection()
{
d->m_ConnectionCheck = !d->ErrorText(d->m_Context.StopGeneratingAll());
return !d->m_ConnectionCheck;
}
bool KinectController::UpdateCamera()
{
bool updateSuccessful = d->ErrorText(d->m_Context.WaitAndUpdateAll());
xn::DepthMetaData DepthMD;
d->m_DepthGenerator.GetMetaData(DepthMD);
d->m_CaptureWidth = DepthMD.XRes();
d->m_CaptureHeight = DepthMD.YRes();
return updateSuccessful;
}
// TODO flag image
void KinectController::GetDistances(float* distances)
{
xn::DepthMetaData DepthMD;
d->m_DepthGenerator.GetMetaData(DepthMD);
const XnDepthPixel* DepthData = DepthMD.Data();
for (unsigned int i=0; i<d->m_CaptureWidth*d->m_CaptureHeight; i++)
{
distances[i] = DepthData[i];
}
}
void KinectController::GetRgb(unsigned char* rgb)
{
if (!d->m_UseIR)
{
xn::ImageMetaData ImageMD;
d->m_ImageGenerator.GetMetaData(ImageMD);
const XnRGB24Pixel* rgbPixelArray = ImageMD.RGB24Data();
for (int i=0; i<d->m_CaptureWidth*d->m_CaptureHeight; i++)
{
rgb[i*3] = rgbPixelArray[i].nRed;
rgb[i*3+1] = rgbPixelArray[i].nGreen;
rgb[i*3+2] = rgbPixelArray[i].nBlue;
}
}
}
void KinectController::GetAllData(float* distances, float* amplitudes, unsigned char* rgb)
{
// get current distance data
xn::DepthMetaData DepthMD;
d->m_DepthGenerator.GetMetaData(DepthMD);
const XnDepthPixel* DepthData = DepthMD.Data();
// IR data
xn::IRMetaData IRData;
const XnIRPixel* IRPixelData;
// Image data
xn::ImageMetaData ImageMD;
const XnRGB24Pixel* rgbPixelArray;
if (d->m_UseIR)
{
d->m_IRGenerator.GetMetaData(IRData);
IRPixelData = IRData.Data();
}
else
{
// get current rgb data
d->m_ImageGenerator.GetMetaData(ImageMD);
rgbPixelArray = ImageMD.RGB24Data();
}
for (unsigned int i=0; i<d->m_CaptureWidth*d->m_CaptureHeight; i++)
{
distances[i] = DepthData[i];
if (d->m_UseIR)
{
amplitudes[i] = IRPixelData[i];
}
else
{
rgb[i*3] = rgbPixelArray[i].nRed;
rgb[i*3+1] = rgbPixelArray[i].nGreen;
rgb[i*3+2] = rgbPixelArray[i].nBlue;
}
}
}
void KinectController::GetAmplitudes( float* amplitudes )
{
if (d->m_UseIR)
{
xn::IRMetaData IRData;
d->m_IRGenerator.GetMetaData(IRData);
const XnIRPixel* IRPixelData = IRData.Data();
for (unsigned int i=0; i<d->m_CaptureWidth*d->m_CaptureHeight; i++)
{
amplitudes[i] = IRPixelData[i];
}
}
}
void KinectController::GetIntensities( float* intensities )
{
}
unsigned int KinectController::GetCaptureWidth() const
{
return d->m_CaptureWidth;
}
unsigned int KinectController::GetCaptureHeight() const
{
return d->m_CaptureHeight;
}
bool KinectController::GetUseIR() const
{
return d->m_UseIR;
}
void KinectController::SetUseIR(bool useIR)
{
if (d->m_UseIR!=useIR)
{
d->m_UseIR = useIR;
this->Modified();
}
}
}
diff --git a/Modules/ToFHardware/mitkKinectDevice.cpp b/Modules/ToFHardware/mitkKinectDevice.cpp
index 2c86bce71c..fc19087c8c 100644
--- a/Modules/ToFHardware/mitkKinectDevice.cpp
+++ b/Modules/ToFHardware/mitkKinectDevice.cpp
@@ -1,427 +1,426 @@
/*=========================================================================
Program: Medical Imaging & Interaction Toolkit
Module: $RCSfile$
Language: C++
Date: $Date: 2010-05-27 16:06:53 +0200 (Do, 27 Mai 2010) $
Version: $Revision: $
Copyright (c) German Cancer Research Center, Division of Medical and
Biological Informatics. All rights reserved.
See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#include "mitkKinectDevice.h"
#include "mitkRealTimeClock.h"
#include "itkMultiThreader.h"
#include <itksys/SystemTools.hxx>
namespace mitk
{
KinectDevice::KinectDevice()
{
m_Controller = mitk::KinectController::New();
}
KinectDevice::~KinectDevice()
{
}
bool KinectDevice::ConnectCamera()
{
bool ok = false;
if (m_Controller)
{
ok = m_Controller->OpenCameraConnection();
- MITK_INFO<<"Device ok? "<<ok;
if (ok)
{
this->m_CaptureWidth = m_Controller->GetCaptureWidth();
this->m_CaptureHeight = m_Controller->GetCaptureHeight();
this->m_PixelNumber = this->m_CaptureWidth * this->m_CaptureHeight;
// allocate buffer
this->m_IntensityArray = new float[this->m_PixelNumber];
for(int i=0; i<this->m_PixelNumber; i++) {this->m_IntensityArray[i]=0.0;}
this->m_DistanceArray = new float[this->m_PixelNumber];
for(int i=0; i<this->m_PixelNumber; i++) {this->m_DistanceArray[i]=0.0;}
this->m_AmplitudeArray = new float[this->m_PixelNumber];
for(int i=0; i<this->m_PixelNumber; i++) {this->m_AmplitudeArray[i]=0.0;}
this->m_DistanceDataBuffer = new float*[this->m_MaxBufferSize];
for(int i=0; i<this->m_MaxBufferSize; i++)
{
this->m_DistanceDataBuffer[i] = new float[this->m_PixelNumber];
}
this->m_AmplitudeDataBuffer = new float*[this->m_MaxBufferSize];
for(int i=0; i<this->m_MaxBufferSize; i++)
{
this->m_AmplitudeDataBuffer[i] = new float[this->m_PixelNumber];
}
this->m_IntensityDataBuffer = new float*[this->m_MaxBufferSize];
for(int i=0; i<this->m_MaxBufferSize; i++)
{
this->m_IntensityDataBuffer[i] = new float[this->m_PixelNumber];
}
this->m_RGBDataBuffer = new unsigned char*[this->m_MaxBufferSize];
for (int i=0; i<this->m_MaxBufferSize; i++)
{
this->m_RGBDataBuffer[i] = new unsigned char[this->m_PixelNumber*3];
}
m_CameraConnected = true;
}
}
return ok;
}
bool KinectDevice::DisconnectCamera()
{
bool ok = false;
if (m_Controller)
{
ok = m_Controller->CloseCameraConnection();
// clean-up only if camera was connected
if (m_CameraConnected)
{
delete [] m_IntensityArray;
delete [] m_DistanceArray;
delete [] m_AmplitudeArray;
for(int i=0; i<this->m_MaxBufferSize; i++)
{
delete[] this->m_DistanceDataBuffer[i];
delete[] this->m_AmplitudeDataBuffer[i];
delete[] this->m_IntensityDataBuffer[i];
delete[] this->m_RGBDataBuffer[i];
}
delete[] this->m_DistanceDataBuffer;
delete[] this->m_AmplitudeDataBuffer;
delete[] this->m_IntensityDataBuffer;
delete[] this->m_RGBDataBuffer;
m_CameraConnected = false;
}
}
return ok;
}
void KinectDevice::StartCamera()
{
if (m_CameraConnected)
{
// get the first image
this->m_Controller->UpdateCamera();
this->m_ImageMutex->Lock();
this->m_Controller->GetAllData(this->m_DistanceDataBuffer[this->m_FreePos],this->m_AmplitudeDataBuffer[this->m_FreePos],this->m_RGBDataBuffer[this->m_FreePos]);
this->m_FreePos = (this->m_FreePos+1) % this->m_BufferSize;
this->m_CurrentPos = (this->m_CurrentPos+1) % this->m_BufferSize;
this->m_ImageSequence++;
this->m_ImageMutex->Unlock();
this->m_CameraActiveMutex->Lock();
this->m_CameraActive = true;
this->m_CameraActiveMutex->Unlock();
this->m_ThreadID = this->m_MultiThreader->SpawnThread(this->Acquire, this);
// wait a little to make sure that the thread is started
itksys::SystemTools::Delay(10);
}
else
{
MITK_INFO<<"Camera not connected";
}
}
void KinectDevice::StopCamera()
{
m_CameraActiveMutex->Lock();
m_CameraActive = false;
m_CameraActiveMutex->Unlock();
itksys::SystemTools::Delay(100);
if (m_MultiThreader.IsNotNull())
{
m_MultiThreader->TerminateThread(m_ThreadID);
}
// wait a little to make sure that the thread is terminated
itksys::SystemTools::Delay(10);
}
bool KinectDevice::IsCameraActive()
{
m_CameraActiveMutex->Lock();
bool ok = m_CameraActive;
m_CameraActiveMutex->Unlock();
return ok;
}
void KinectDevice::UpdateCamera()
{
if (m_Controller)
{
m_Controller->UpdateCamera();
}
}
ITK_THREAD_RETURN_TYPE KinectDevice::Acquire(void* pInfoStruct)
{
/* extract this pointer from Thread Info structure */
struct itk::MultiThreader::ThreadInfoStruct * pInfo = (struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
if (pInfo == NULL)
{
return ITK_THREAD_RETURN_VALUE;
}
if (pInfo->UserData == NULL)
{
return ITK_THREAD_RETURN_VALUE;
}
KinectDevice* toFCameraDevice = (KinectDevice*)pInfo->UserData;
if (toFCameraDevice!=NULL)
{
mitk::RealTimeClock::Pointer realTimeClock;
realTimeClock = mitk::RealTimeClock::New();
double t1, t2;
t1 = realTimeClock->GetCurrentStamp();
int n = 100;
bool overflow = false;
bool printStatus = false;
while (toFCameraDevice->IsCameraActive())
{
// update the ToF camera
toFCameraDevice->UpdateCamera();
// get the image data from the camera and write it at the next free position in the buffer
toFCameraDevice->m_ImageMutex->Lock();
toFCameraDevice->m_Controller->GetAllData(toFCameraDevice->m_DistanceDataBuffer[toFCameraDevice->m_FreePos],toFCameraDevice->m_AmplitudeDataBuffer[toFCameraDevice->m_FreePos],toFCameraDevice->m_RGBDataBuffer[toFCameraDevice->m_FreePos]);
toFCameraDevice->m_ImageMutex->Unlock();
// call modified to indicate that cameraDevice was modified
toFCameraDevice->Modified();
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
TODO Buffer Handling currently only works for buffer size 1
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
//toFCameraDevice->m_ImageSequence++;
toFCameraDevice->m_FreePos = (toFCameraDevice->m_FreePos+1) % toFCameraDevice->m_BufferSize;
toFCameraDevice->m_CurrentPos = (toFCameraDevice->m_CurrentPos+1) % toFCameraDevice->m_BufferSize;
toFCameraDevice->m_ImageSequence++;
if (toFCameraDevice->m_FreePos == toFCameraDevice->m_CurrentPos)
{
// buffer overflow
//MITK_INFO << "Buffer overflow!! ";
//toFCameraDevice->m_CurrentPos = (toFCameraDevice->m_CurrentPos+1) % toFCameraDevice->m_BufferSize;
//toFCameraDevice->m_ImageSequence++;
overflow = true;
}
if (toFCameraDevice->m_ImageSequence % n == 0)
{
printStatus = true;
}
if (overflow)
{
//itksys::SystemTools::Delay(10);
overflow = false;
}
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
END TODO Buffer Handling currently only works for buffer size 1
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
// print current framerate
if (printStatus)
{
t2 = realTimeClock->GetCurrentStamp() - t1;
//MITK_INFO << "t2: " << t2 <<" Time (s) for 1 image: " << (t2/1000) / n << " Framerate (fps): " << n / (t2/1000) << " Sequence: " << toFCameraDevice->m_ImageSequence;
MITK_INFO << " Framerate (fps): " << n / (t2/1000) << " Sequence: " << toFCameraDevice->m_ImageSequence;
t1 = realTimeClock->GetCurrentStamp();
printStatus = false;
}
} // end of while loop
}
return ITK_THREAD_RETURN_VALUE;
}
// TODO: Buffer size currently set to 1. Once Buffer handling is working correctly, method may be reactivated
// void KinectDevice::ResetBuffer(int bufferSize)
// {
// this->m_BufferSize = bufferSize;
// this->m_CurrentPos = -1;
// this->m_FreePos = 0;
// }
void KinectDevice::GetAmplitudes(float* amplitudeArray, int& imageSequence)
{
m_ImageMutex->Lock();
if (m_CameraActive)
{
// 1) copy the image buffer
// 2) Flip around y- axis (vertical axis)
/*
this->m_Controller->GetAmplitudes(this->m_SourceDataBuffer[this->m_CurrentPos], this->m_AmplitudeArray);
for (int i=0; i<this->m_CaptureHeight; i++)
{
for (int j=0; j<this->m_CaptureWidth; j++)
{
amplitudeArray[i*this->m_CaptureWidth+j] = this->m_AmplitudeArray[(i+1)*this->m_CaptureWidth-1-j];
}
}
*/
for (int i=0; i<this->m_PixelNumber; i++)
{
amplitudeArray[i] = this->m_AmplitudeDataBuffer[this->m_CurrentPos][i];
}
imageSequence = this->m_ImageSequence;
}
else
{
MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
}
m_ImageMutex->Unlock();
}
void KinectDevice::GetIntensities(float* intensityArray, int& imageSequence)
{
m_ImageMutex->Lock();
if (m_CameraActive)
{
// 1) copy the image buffer
// 2) Flip around y- axis (vertical axis)
/*
this->m_Controller->GetIntensities(this->m_SourceDataBuffer[this->m_CurrentPos], this->m_IntensityArray);
for (int i=0; i<this->m_CaptureHeight; i++)
{
for (int j=0; j<this->m_CaptureWidth; j++)
{
intensityArray[i*this->m_CaptureWidth+j] = this->m_IntensityArray[(i+1)*this->m_CaptureWidth-1-j];
}
}
*/
for (int i=0; i<this->m_PixelNumber; i++)
{
intensityArray[i] = this->m_IntensityDataBuffer[this->m_CurrentPos][i];
}
imageSequence = this->m_ImageSequence;
}
else
{
MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
}
m_ImageMutex->Unlock();
}
void KinectDevice::GetDistances(float* distanceArray, int& imageSequence)
{
m_ImageMutex->Lock();
if (m_CameraActive)
{
// 1) copy the image buffer
// 2) convert the distance values from m to mm
// 3) Flip around y- axis (vertical axis)
/*
this->m_Controller->GetDistances(this->m_SourceDataBuffer[this->m_CurrentPos], this->m_DistanceArray);
for (int i=0; i<this->m_CaptureHeight; i++)
{
for (int j=0; j<this->m_CaptureWidth; j++)
{
distanceArray[i*this->m_CaptureWidth+j] = 1000 * this->m_DistanceArray[(i+1)*this->m_CaptureWidth-1-j];
}
}
*/
for (int i=0; i<this->m_PixelNumber; i++)
{
distanceArray[i] = this->m_DistanceDataBuffer[this->m_CurrentPos][i]; // * 1000
}
imageSequence = this->m_ImageSequence;
}
else
{
MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
}
m_ImageMutex->Unlock();
}
void KinectDevice::GetAllImages(float* distanceArray, float* amplitudeArray, float* intensityArray, char* sourceDataArray,
int requiredImageSequence, int& capturedImageSequence, unsigned char* rgbDataArray)
{
if (m_CameraActive)
{
// 1) copy the image buffer
// 2) convert the distance values from m to mm
// 3) Flip around y- axis (vertical axis)
// check for empty buffer
if (this->m_ImageSequence < 0)
{
// buffer empty
MITK_INFO << "Buffer empty!! ";
capturedImageSequence = this->m_ImageSequence;
return;
}
// determine position of image in buffer
int pos = 0;
if ((requiredImageSequence < 0) || (requiredImageSequence > this->m_ImageSequence))
{
capturedImageSequence = this->m_ImageSequence;
pos = this->m_CurrentPos;
//MITK_INFO << "Required image not found! Required: " << requiredImageSequence << " delivered/current: " << this->m_ImageSequence;
}
else if (requiredImageSequence <= this->m_ImageSequence - this->m_BufferSize)
{
capturedImageSequence = (this->m_ImageSequence - this->m_BufferSize) + 1;
pos = (this->m_CurrentPos + 1) % this->m_BufferSize;
//MITK_INFO << "Out of buffer! Required: " << requiredImageSequence << " delivered: " << capturedImageSequence << " current: " << this->m_ImageSequence;
}
else // (requiredImageSequence > this->m_ImageSequence - this->m_BufferSize) && (requiredImageSequence <= this->m_ImageSequence)
{
capturedImageSequence = requiredImageSequence;
pos = (this->m_CurrentPos + (10-(this->m_ImageSequence - requiredImageSequence))) % this->m_BufferSize;
}
// write image data to float arrays
for (int i=0; i<this->m_PixelNumber; i++)
{
distanceArray[i] = this->m_DistanceDataBuffer[pos][i];
amplitudeArray[i] = this->m_AmplitudeDataBuffer[pos][i];
intensityArray[i] = this->m_IntensityDataBuffer[pos][i];
rgbDataArray[i*3] = this->m_RGBDataBuffer[pos][i*3];
rgbDataArray[i*3+1] = this->m_RGBDataBuffer[pos][i*3+1];
rgbDataArray[i*3+2] = this->m_RGBDataBuffer[pos][i*3+2];
}
}
else
{
MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
}
}
KinectController::Pointer KinectDevice::GetController()
{
return this->m_Controller;
}
void KinectDevice::SetProperty( const char *propertyKey, BaseProperty* propertyValue )
{
ToFCameraDevice::SetProperty(propertyKey,propertyValue);
this->m_PropertyList->SetProperty(propertyKey, propertyValue);
if (strcmp(propertyKey, "RGB") == 0)
{
bool rgb = false;
GetBoolProperty(propertyKey, rgb);
m_Controller->SetUseIR(!rgb);
}
else if (strcmp(propertyKey, "IR") == 0)
{
bool ir = false;
GetBoolProperty(propertyKey, ir);
m_Controller->SetUseIR(ir);
}
}
}
diff --git a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
index 6c566e25a3..7910c95b3e 100644
--- a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
+++ b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
@@ -1,525 +1,525 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// Qmitk
#include "QmitkToFUtilView.h"
#include <QmitkStdMultiWidget.h>
#include <QmitkTextOverlay.h>
// Qt
#include <QMessageBox>
#include <QString>
// MITK
#include <mitkBaseRenderer.h>
#include <mitkGlobalInteraction.h>
#include <mitkLookupTableProperty.h>
#include <mitkToFDistanceImageToPointSetFilter.h>
#include <mitkTransferFunction.h>
#include <mitkTransferFunctionProperty.h>
// VTK
#include <vtkCamera.h>
// ITK
#include <itkCommand.h>
const std::string QmitkToFUtilView::VIEW_ID = "org.mitk.views.tofutil";
QmitkToFUtilView::QmitkToFUtilView()
: QmitkFunctionality()
, m_Controls(NULL), m_MultiWidget( NULL )
, m_MitkDistanceImage(NULL), m_MitkAmplitudeImage(NULL), m_MitkIntensityImage(NULL), m_Surface(NULL)
, m_DistanceImageNode(NULL), m_AmplitudeImageNode(NULL), m_IntensityImageNode(NULL), m_RGBImageNode(NULL), m_SurfaceNode(NULL)
, m_ToFImageRecorder(NULL), m_ToFImageGrabber(NULL), m_ToFDistanceImageToSurfaceFilter(NULL), m_ToFCompositeFilter(NULL)
, m_SurfaceDisplayCount(0), m_2DDisplayCount(0)
, m_RealTimeClock(NULL)
, m_StepsForFramerate(100)
, m_2DTimeBefore(0.0)
, m_2DTimeAfter(0.0)
, m_VideoEnabled(false)
{
this->m_Frametimer = new QTimer(this);
this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
this->m_ToFSurfaceVtkMapper3D = mitk::ToFSurfaceVtkMapper3D::New();
}
QmitkToFUtilView::~QmitkToFUtilView()
{
OnToFCameraStopped();
OnToFCameraDisconnected();
}
void QmitkToFUtilView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkToFUtilViewControls;
m_Controls->setupUi( parent );
connect(m_Frametimer, SIGNAL(timeout()), this, SLOT(OnUpdateCamera()));
connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraConnected()), this, SLOT(OnToFCameraConnected()) );
connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraDisconnected()), this, SLOT(OnToFCameraDisconnected()) );
connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraSelected(const QString)), this, SLOT(OnToFCameraSelected(const QString)) );
connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStarted()), this, SLOT(OnToFCameraStarted()) );
connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStopped()), this, SLOT(OnToFCameraStopped()) );
connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStarted()), this, SLOT(OnToFCameraStopped()) );
connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStopped()), this, SLOT(OnToFCameraStarted()) );
connect( (QObject*)(m_Controls->m_TextureCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnTextureCheckBoxChecked(bool)) );
connect( (QObject*)(m_Controls->m_VideoTextureCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnVideoTextureCheckBoxChecked(bool)) );
}
}
void QmitkToFUtilView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkToFUtilView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkToFUtilView::Activated()
{
QmitkFunctionality::Activated();
// configure views
m_MultiWidget->SetWidgetPlanesVisibility(false);
m_MultiWidget->mitkWidget1->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Transversal);
m_MultiWidget->mitkWidget1->GetSliceNavigationController()->SliceLockedOn();
m_MultiWidget->mitkWidget2->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Transversal);
m_MultiWidget->mitkWidget2->GetSliceNavigationController()->SliceLockedOn();
m_MultiWidget->mitkWidget3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Transversal);
m_MultiWidget->mitkWidget3->GetSliceNavigationController()->SliceLockedOn();
m_MultiWidget->ResetCrosshair();
mitk::RenderingManager::GetInstance()->InitializeViews();
this->UseToFVisibilitySettings(true);
m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
m_Controls->m_ToFCompositeFilterWidget->SetDataStorage(this->GetDefaultDataStorage());
if (this->m_ToFImageGrabber.IsNull())
{
m_Controls->m_ToFRecorderWidget->setEnabled(false);
m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
}
}
void QmitkToFUtilView::Deactivated()
{
m_MultiWidget->SetWidgetPlanesVisibility(true);
m_MultiWidget->mitkWidget1->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Transversal);
m_MultiWidget->mitkWidget1->GetSliceNavigationController()->SliceLockedOff();
m_MultiWidget->mitkWidget2->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
m_MultiWidget->mitkWidget2->GetSliceNavigationController()->SliceLockedOff();
m_MultiWidget->mitkWidget3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
m_MultiWidget->mitkWidget3->GetSliceNavigationController()->SliceLockedOff();
m_MultiWidget->ResetCrosshair();
this->UseToFVisibilitySettings(false);
mitk::RenderingManager::GetInstance()->InitializeViews();
QmitkFunctionality::Deactivated();
}
void QmitkToFUtilView::OnToFCameraConnected()
{
this->m_SurfaceDisplayCount = 0;
this->m_2DDisplayCount = 0;
this->m_ToFImageGrabber = m_Controls->m_ToFConnectionWidget->GetToFImageGrabber();
this->m_ToFImageRecorder->SetCameraDevice(this->m_ToFImageGrabber->GetCameraDevice());
m_Controls->m_ToFRecorderWidget->SetParameter(this->m_ToFImageGrabber, this->m_ToFImageRecorder);
m_Controls->m_ToFRecorderWidget->setEnabled(true);
m_Controls->m_ToFRecorderWidget->ResetGUIToInitial();
m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(true);
//TODO
this->m_RealTimeClock = mitk::RealTimeClock::New();
this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
try
{
this->m_VideoSource = mitk::OpenCVVideoSource::New();
this->m_VideoSource->SetVideoCameraInput(0, false);
this->m_VideoSource->StartCapturing();
if(!this->m_VideoSource->IsCapturingEnabled())
{
- MITK_INFO << "unable to initialize video grabbing/playback";
+ MITK_INFO << "unable to initialize video grabbing/playback, probably not video camera connected";
this->m_VideoEnabled = false;
m_Controls->m_VideoTextureCheckBox->setEnabled(false);
}
else
{
this->m_VideoEnabled = true;
m_Controls->m_VideoTextureCheckBox->setEnabled(true);
}
if (this->m_VideoEnabled)
{
this->m_VideoSource->FetchFrame();
this->m_VideoCaptureHeight = this->m_VideoSource->GetImageHeight();
this->m_VideoCaptureWidth = this->m_VideoSource->GetImageWidth();
int videoTexSize = this->m_VideoCaptureWidth * this->m_VideoCaptureHeight * 3; // for each pixel three values for rgb are needed!!
this->m_VideoTexture = this->m_VideoSource->GetVideoTexture();
unsigned int dimensions[2];
dimensions[0] = this->m_VideoCaptureWidth;
dimensions[1] = this->m_VideoCaptureHeight;
this->m_ToFDistanceImageToSurfaceFilter->SetTextureImageWidth(this->m_VideoCaptureWidth);
this->m_ToFDistanceImageToSurfaceFilter->SetTextureImageHeight(this->m_VideoCaptureHeight);
this->m_ToFSurfaceVtkMapper3D->SetTextureWidth(this->m_VideoCaptureWidth);
this->m_ToFSurfaceVtkMapper3D->SetTextureHeight(this->m_VideoCaptureHeight);
}
m_MultiWidget->DisableGradientBackground();
}
catch (std::logic_error& e)
{
QMessageBox::warning(NULL, "Warning", QString(e.what()));
MITK_ERROR << e.what();
return;
}
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
void QmitkToFUtilView::OnToFCameraDisconnected()
{
m_Controls->m_ToFRecorderWidget->OnStop();
m_Controls->m_ToFRecorderWidget->setEnabled(false);
m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
if(this->m_VideoSource)
{
this->m_VideoSource->StopCapturing();
this->m_VideoSource = NULL;
}
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
void QmitkToFUtilView::OnToFCameraStarted()
{
if (m_ToFImageGrabber.IsNotNull())
{
// initial update of image grabber
this->m_ToFImageGrabber->Update();
this->m_ToFCompositeFilter->SetInput(0,this->m_ToFImageGrabber->GetOutput(0));
this->m_ToFCompositeFilter->SetInput(1,this->m_ToFImageGrabber->GetOutput(1));
this->m_ToFCompositeFilter->SetInput(2,this->m_ToFImageGrabber->GetOutput(2));
// initial update of composite filter
this->m_ToFCompositeFilter->Update();
this->m_MitkDistanceImage = m_ToFCompositeFilter->GetOutput(0);
this->m_DistanceImageNode = ReplaceNodeData("Distance image",m_MitkDistanceImage);
this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
this->m_MitkIntensityImage = m_ToFCompositeFilter->GetOutput(2);
this->m_IntensityImageNode = ReplaceNodeData("Intensity image",m_MitkIntensityImage);
std::string rgbFileName;
m_ToFImageGrabber->GetCameraDevice()->GetStringProperty("RGBImageFileName",rgbFileName);
if ((m_SelectedCamera=="Microsoft Kinect")||(rgbFileName!=""))
{
this->m_RGBImageNode = ReplaceNodeData("RGB image",this->m_ToFImageGrabber->GetOutput(3));
}
else
{
this->m_RGBImageNode = NULL;
}
this->m_ToFDistanceImageToSurfaceFilter->SetInput(0,m_MitkDistanceImage);
this->m_ToFDistanceImageToSurfaceFilter->SetInput(1,m_MitkAmplitudeImage);
this->m_ToFDistanceImageToSurfaceFilter->SetInput(2,m_MitkIntensityImage);
this->m_Surface = this->m_ToFDistanceImageToSurfaceFilter->GetOutput(0);
this->m_SurfaceNode = ReplaceNodeData("Surface",m_Surface);
this->UseToFVisibilitySettings(true);
m_Controls->m_ToFCompositeFilterWidget->UpdateFilterParameter();
// initialize visualization widget
m_Controls->m_ToFVisualisationSettingsWidget->Initialize(this->m_DistanceImageNode, this->m_AmplitudeImageNode, this->m_IntensityImageNode);
this->m_Frametimer->start(0);
if (m_Controls->m_TextureCheckBox->isChecked())
{
OnTextureCheckBoxChecked(true);
}
if (m_Controls->m_VideoTextureCheckBox->isChecked())
{
OnVideoTextureCheckBoxChecked(true);
}
}
m_Controls->m_TextureCheckBox->setEnabled(true);
// initialize point set measurement
m_Controls->tofMeasurementWidget->InitializeWidget(m_MultiWidget,this->GetDefaultDataStorage(),m_MitkDistanceImage);
}
void QmitkToFUtilView::OnToFCameraStopped()
{
this->m_Frametimer->stop();
}
void QmitkToFUtilView::OnToFCameraSelected(const QString selected)
{
m_SelectedCamera = selected;
if ((selected=="PMD CamBoard")||(selected=="PMD O3D"))
{
MITK_INFO<<"Surface representation currently not available for CamBoard and O3. Intrinsic parameters missing.";
this->m_Controls->m_SurfaceCheckBox->setEnabled(false);
this->m_Controls->m_TextureCheckBox->setEnabled(false);
this->m_Controls->m_VideoTextureCheckBox->setEnabled(false);
this->m_Controls->m_SurfaceCheckBox->setChecked(false);
this->m_Controls->m_TextureCheckBox->setChecked(false);
this->m_Controls->m_VideoTextureCheckBox->setChecked(false);
}
else
{
this->m_Controls->m_SurfaceCheckBox->setEnabled(true);
this->m_Controls->m_TextureCheckBox->setEnabled(true); // TODO enable when bug 8106 is solved
this->m_Controls->m_VideoTextureCheckBox->setEnabled(true);
}
}
void QmitkToFUtilView::OnUpdateCamera()
{
if (m_Controls->m_VideoTextureCheckBox->isChecked() && this->m_VideoEnabled && this->m_VideoSource)
{
this->m_VideoTexture = this->m_VideoSource->GetVideoTexture();
ProcessVideoTransform();
}
if (m_Controls->m_SurfaceCheckBox->isChecked())
{
// update surface
m_ToFDistanceImageToSurfaceFilter->SetTextureIndex(m_Controls->m_ToFVisualisationSettingsWidget->GetSelectedImageIndex());
this->m_Surface->Update();
vtkColorTransferFunction* colorTransferFunction = m_Controls->m_ToFVisualisationSettingsWidget->GetSelectedColorTransferFunction();
this->m_ToFSurfaceVtkMapper3D->SetVtkScalarsToColors(colorTransferFunction);
if (this->m_SurfaceDisplayCount<2)
{
this->m_SurfaceNode->SetData(this->m_Surface);
this->m_SurfaceNode->SetMapper(mitk::BaseRenderer::Standard3D, m_ToFSurfaceVtkMapper3D);
mitk::RenderingManager::GetInstance()->InitializeViews(
this->m_Surface->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS, true);
mitk::Point3D surfaceCenter= this->m_Surface->GetGeometry()->GetCenter();
m_MultiWidget->mitkWidget4->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetPosition(0,0,-50);
m_MultiWidget->mitkWidget4->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetViewUp(0,-1,0);
m_MultiWidget->mitkWidget4->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetFocalPoint(0,0,surfaceCenter[2]);
m_MultiWidget->mitkWidget4->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetViewAngle(40);
m_MultiWidget->mitkWidget4->GetRenderer()->GetVtkRenderer()->GetActiveCamera()->SetClippingRange(1, 10000);
}
this->m_SurfaceDisplayCount++;
}
else
{
// update pipeline
this->m_MitkDistanceImage->Update();
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->m_2DDisplayCount++;
if ((this->m_2DDisplayCount % this->m_StepsForFramerate) == 0)
{
this->m_2DTimeAfter = this->m_RealTimeClock->GetCurrentStamp() - this->m_2DTimeBefore;
MITK_INFO << " 2D-Display-framerate (fps): " << this->m_StepsForFramerate / (this->m_2DTimeAfter/1000);
this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
}
}
void QmitkToFUtilView::ProcessVideoTransform()
{
IplImage *src, *dst;
src = cvCreateImageHeader(cvSize(this->m_VideoCaptureWidth, this->m_VideoCaptureHeight), IPL_DEPTH_8U, 3);
src->imageData = (char*)this->m_VideoTexture;
CvPoint2D32f srcTri[3], dstTri[3];
CvMat* rot_mat = cvCreateMat(2,3,CV_32FC1);
CvMat* warp_mat = cvCreateMat(2,3,CV_32FC1);
dst = cvCloneImage(src);
dst->origin = src->origin;
cvZero( dst );
int xOffset = 0;//m_Controls->m_XOffsetSpinBox->value();
int yOffset = 0;//m_Controls->m_YOffsetSpinBox->value();
int zoom = 0;//m_Controls->m_ZoomSpinBox->value();
// Compute warp matrix
srcTri[0].x = 0 + zoom;
srcTri[0].y = 0 + zoom;
srcTri[1].x = src->width - 1 - zoom;
srcTri[1].y = 0 + zoom;
srcTri[2].x = 0 + zoom;
srcTri[2].y = src->height - 1 - zoom;
dstTri[0].x = 0;
dstTri[0].y = 0;
dstTri[1].x = src->width - 1;
dstTri[1].y = 0;
dstTri[2].x = 0;
dstTri[2].y = src->height - 1;
cvGetAffineTransform( srcTri, dstTri, warp_mat );
cvWarpAffine( src, dst, warp_mat );
cvCopy ( dst, src );
// Compute warp matrix
srcTri[0].x = 0;
srcTri[0].y = 0;
srcTri[1].x = src->width - 1;
srcTri[1].y = 0;
srcTri[2].x = 0;
srcTri[2].y = src->height - 1;
dstTri[0].x = srcTri[0].x + xOffset;
dstTri[0].y = srcTri[0].y + yOffset;
dstTri[1].x = srcTri[1].x + xOffset;
dstTri[1].y = srcTri[1].y + yOffset;
dstTri[2].x = srcTri[2].x + xOffset;
dstTri[2].y = srcTri[2].y + yOffset;
cvGetAffineTransform( srcTri, dstTri, warp_mat );
cvWarpAffine( src, dst, warp_mat );
cvCopy ( dst, src );
src->imageData = NULL;
cvReleaseImage( &src );
cvReleaseImage( &dst );
cvReleaseMat( &rot_mat );
cvReleaseMat( &warp_mat );
}
void QmitkToFUtilView::OnTextureCheckBoxChecked(bool checked)
{
if(m_SurfaceNode.IsNotNull())
{
if (checked)
{
this->m_SurfaceNode->SetBoolProperty("scalar visibility", true);
}
else
{
this->m_SurfaceNode->SetBoolProperty("scalar visibility", false);
}
}
}
void QmitkToFUtilView::OnVideoTextureCheckBoxChecked(bool checked)
{
if (checked)
{
if (this->m_VideoEnabled)
{
this->m_ToFSurfaceVtkMapper3D->SetTexture(this->m_VideoTexture);
}
else
{
this->m_ToFSurfaceVtkMapper3D->SetTexture(NULL);
}
}
else
{
this->m_ToFSurfaceVtkMapper3D->SetTexture(NULL);
}
}
mitk::DataNode::Pointer QmitkToFUtilView::ReplaceNodeData( std::string nodeName, mitk::BaseData* data )
{
mitk::DataNode::Pointer node = this->GetDefaultDataStorage()->GetNamedNode(nodeName);
if (node.IsNull())
{
node = mitk::DataNode::New();
node->SetData(data);
node->SetName(nodeName);
node->SetBoolProperty("binary",false);
this->GetDefaultDataStorage()->Add(node);
}
else
{
node->SetData(data);
}
return node;
}
void QmitkToFUtilView::UseToFVisibilitySettings(bool useToF)
{
// set node properties
if (m_DistanceImageNode.IsNotNull())
{
this->m_DistanceImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetActiveStdMultiWidget()->mitkWidget2->GetRenderWindow() ) );
this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetActiveStdMultiWidget()->mitkWidget3->GetRenderWindow() ) );
this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetActiveStdMultiWidget()->mitkWidget4->GetRenderWindow() ) );
this->m_DistanceImageNode->SetBoolProperty("use color",!useToF);
this->m_DistanceImageNode->GetPropertyList()->DeleteProperty("LookupTable");
}
if (m_AmplitudeImageNode.IsNotNull())
{
this->m_AmplitudeImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetActiveStdMultiWidget()->mitkWidget1->GetRenderWindow() ) );
this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetActiveStdMultiWidget()->mitkWidget3->GetRenderWindow() ) );
this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetActiveStdMultiWidget()->mitkWidget4->GetRenderWindow() ) );
this->m_AmplitudeImageNode->SetBoolProperty("use color",!useToF);
this->m_AmplitudeImageNode->GetPropertyList()->DeleteProperty("LookupTable");
}
if (m_IntensityImageNode.IsNotNull())
{
this->m_IntensityImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetActiveStdMultiWidget()->mitkWidget1->GetRenderWindow() ) );
this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetActiveStdMultiWidget()->mitkWidget2->GetRenderWindow() ) );
this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetActiveStdMultiWidget()->mitkWidget4->GetRenderWindow() ) );
this->m_IntensityImageNode->SetBoolProperty("use color",!useToF);
this->m_IntensityImageNode->GetPropertyList()->DeleteProperty("LookupTable");
}
if ((m_RGBImageNode.IsNotNull()))
{
this->m_RGBImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetActiveStdMultiWidget()->mitkWidget1->GetRenderWindow() ) );
this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetActiveStdMultiWidget()->mitkWidget2->GetRenderWindow() ) );
this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetActiveStdMultiWidget()->mitkWidget4->GetRenderWindow() ) );
}
// initialize images
if (m_MitkDistanceImage.IsNotNull())
{
mitk::RenderingManager::GetInstance()->InitializeViews(
this->m_MitkDistanceImage->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS, true);
}
}