diff --git a/Modules/ToFHardware/Testing/mitkToFImageGrabberTest.cpp b/Modules/ToFHardware/Testing/mitkToFImageGrabberTest.cpp index 74a39ada89..f0e937cee4 100644 --- a/Modules/ToFHardware/Testing/mitkToFImageGrabberTest.cpp +++ b/Modules/ToFHardware/Testing/mitkToFImageGrabberTest.cpp @@ -1,115 +1,115 @@ /*========================================================================= Program: Medical Imaging & Interaction Toolkit Language: C++ Date: $Date: 2010-03-12 14:05:50 +0100 (Fr, 12 Mrz 2010) $ Version: $Revision: 16010 $ 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 #include #include #include #include #include static bool CompareImages(mitk::Image::Pointer image1, mitk::Image::Pointer image2) { //check if epsilon is exceeded unsigned int sliceDimension = image1->GetDimension(0)*image1->GetDimension(1); bool picturesEqual = true; float* floatArray1 = (float*)image1->GetSliceData(0, 0, 0)->GetData(); float* floatArray2 = (float*)image2->GetSliceData(0, 0, 0)->GetData(); for(unsigned int i = 0; i < sliceDimension; i++) { if(!(mitk::Equal(floatArray1[i], floatArray2[i]))) { picturesEqual = false; } } return picturesEqual; } /**Documentation * test for the class "ToFImageGrabber". */ int mitkToFImageGrabberTest(int /* argc */, char* /*argv*/[]) { MITK_TEST_BEGIN("ToFImageGrabber"); std::string dirName = MITK_TOF_DATA_DIR; mitk::ToFImageGrabber::Pointer tofImageGrabber = mitk::ToFImageGrabber::New(); mitk::ToFCameraMITKPlayerDevice::Pointer tofCameraMITKPlayerDevice = mitk::ToFCameraMITKPlayerDevice::New(); tofImageGrabber->SetCameraDevice(tofCameraMITKPlayerDevice); MITK_TEST_CONDITION_REQUIRED(tofCameraMITKPlayerDevice==tofImageGrabber->GetCameraDevice(),"Test Set/GetCameraDevice()"); int modulationFrequency = 20; tofImageGrabber->SetModulationFrequency(modulationFrequency); MITK_TEST_CONDITION_REQUIRED(modulationFrequency==tofImageGrabber->GetModulationFrequency(),"Test Set/GetModulationFrequency()"); int integrationTime = 500; tofImageGrabber->SetIntegrationTime(integrationTime); MITK_TEST_CONDITION_REQUIRED(integrationTime==tofImageGrabber->GetIntegrationTime(),"Test Set/GetIntegrationTime()"); MITK_TEST_OUTPUT(<<"Test methods with invalid file name"); - MITK_TEST_CONDITION_REQUIRED(!tofImageGrabber->ConnectCamera(),"Test ConnectCamera() with no file name set"); + MITK_TEST_FOR_EXCEPTION(std::logic_error, !tofImageGrabber->ConnectCamera()); MITK_TEST_OUTPUT(<<"Call StartCamera()"); tofImageGrabber->StartCamera(); MITK_TEST_OUTPUT(<<"Call StopCamera()"); tofImageGrabber->StopCamera(); MITK_TEST_CONDITION_REQUIRED(!tofImageGrabber->DisconnectCamera(),"Test DisconnectCamera() with no file name set"); std::string distanceFileName = dirName + "/PMDCamCube2_MF0_IT0_1Images_DistanceImage.pic"; tofImageGrabber->SetProperty("DistanceImageFileName",mitk::StringProperty::New(distanceFileName)); std::string amplitudeFileName = dirName + "/PMDCamCube2_MF0_IT0_1Images_AmplitudeImage.pic"; tofImageGrabber->SetProperty("AmplitudeImageFileName",mitk::StringProperty::New(amplitudeFileName)); std::string intensityFileName = dirName + "/PMDCamCube2_MF0_IT0_1Images_IntensityImage.pic"; tofImageGrabber->SetProperty("IntensityImageFileName",mitk::StringProperty::New(intensityFileName)); // Load images with PicFileReader for comparison mitk::PicFileReader::Pointer picFileReader = mitk::PicFileReader::New(); mitk::Image::Pointer expectedResultImage = NULL; MITK_TEST_OUTPUT(<<"Test ToFImageGrabber using ToFCameraMITKPlayerDevice"); MITK_TEST_CONDITION_REQUIRED(tofImageGrabber->ConnectCamera(),"Test ConnectCamera()"); MITK_TEST_CONDITION_REQUIRED(!tofImageGrabber->IsCameraActive(),"IsCameraActive() before StartCamera()"); MITK_TEST_OUTPUT(<<"Call StartCamera()"); tofImageGrabber->StartCamera(); MITK_TEST_CONDITION_REQUIRED(tofImageGrabber->IsCameraActive(),"IsCameraActive() after StartCamera()"); picFileReader->SetFileName(distanceFileName); picFileReader->Update(); expectedResultImage = picFileReader->GetOutput(); int captureWidth = expectedResultImage->GetDimension(0); int captureHeight = expectedResultImage->GetDimension(1); MITK_TEST_CONDITION_REQUIRED(tofImageGrabber->GetCaptureWidth()==captureWidth,"Test GetCaptureWidth()"); MITK_TEST_CONDITION_REQUIRED(tofImageGrabber->GetCaptureHeight()==captureHeight,"Test GetCaptureHeight()"); MITK_TEST_OUTPUT(<<"Call Update()"); tofImageGrabber->Update(); mitk::Image::Pointer distanceImage = tofImageGrabber->GetOutput(0); MITK_TEST_CONDITION_REQUIRED(CompareImages(expectedResultImage,distanceImage),"Test GetOutput(0)"); picFileReader->SetFileName(amplitudeFileName); picFileReader->Update(); mitk::Image::Pointer amplitudeImage = tofImageGrabber->GetOutput(1); MITK_TEST_CONDITION_REQUIRED(CompareImages(expectedResultImage,amplitudeImage),"Test GetOutput(1)"); picFileReader->SetFileName(intensityFileName); picFileReader->Update(); mitk::Image::Pointer intensityImage = tofImageGrabber->GetOutput(2); MITK_TEST_CONDITION_REQUIRED(CompareImages(expectedResultImage,intensityImage),"Test GetOutput(2)"); MITK_TEST_OUTPUT(<<"Call StopCamera()"); tofImageGrabber->StopCamera(); MITK_TEST_CONDITION_REQUIRED(!tofImageGrabber->IsCameraActive(),"IsCameraActive() after StopCamera()"); MITK_TEST_CONDITION_REQUIRED(tofImageGrabber->DisconnectCamera(),"Test DisconnectCamera()"); MITK_TEST_CONDITION_REQUIRED(!tofImageGrabber->IsCameraActive(),"IsCameraActive() after DisconnectCamera()"); MITK_TEST_END();; } diff --git a/Modules/ToFHardware/Testing/mitkToFImageRecorderFilterTest.cpp b/Modules/ToFHardware/Testing/mitkToFImageRecorderFilterTest.cpp index 6be5390105..03c57d3287 100644 --- a/Modules/ToFHardware/Testing/mitkToFImageRecorderFilterTest.cpp +++ b/Modules/ToFHardware/Testing/mitkToFImageRecorderFilterTest.cpp @@ -1,160 +1,160 @@ /*========================================================================= Program: Medical Imaging & Interaction Toolkit Language: C++ Date: $Date: 2010-03-12 14:05:50 +0100 (Fr, 12 Mrz 2010) $ Version: $Revision: 16010 $ 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 #include #include #include #include #include #include #include mitk::Image::Pointer CreateTestImage(unsigned int dimX, unsigned int dimY) { typedef itk::Image ItkImageType2D; typedef itk::ImageRegionIterator ItkImageRegionIteratorType2D; ItkImageType2D::Pointer image = ItkImageType2D::New(); ItkImageType2D::IndexType start; start[0] = 0; start[1] = 0; ItkImageType2D::SizeType size; size[0] = dimX; size[1] = dimY; ItkImageType2D::RegionType region; region.SetSize(size); region.SetIndex( start); ItkImageType2D::SpacingType spacing; spacing[0] = 1.0; spacing[1] = 1.0; image->SetRegions( region ); image->SetSpacing ( spacing ); image->Allocate(); //Obtaining image data from ToF camera// - + //Correlate inten values to PixelIndex// ItkImageRegionIteratorType2D imageIterator(image,image->GetLargestPossibleRegion()); imageIterator.GoToBegin(); itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer randomGenerator = itk::Statistics::MersenneTwisterRandomVariateGenerator::New(); while (!imageIterator.IsAtEnd()) { double pixelValue = randomGenerator->GetUniformVariate(0.0,1000.0); imageIterator.Set(pixelValue); ++imageIterator; } mitk::Image::Pointer mitkImage = mitk::Image::New(); mitk::CastToMitkImage(image,mitkImage); return mitkImage; } static bool CompareImages(mitk::Image::Pointer image1, mitk::Image::Pointer image2) { //check if epsilon is exceeded unsigned int sliceDimension = image1->GetDimension(0)*image1->GetDimension(1); bool picturesEqual = true; float* floatArray1 = (float*)image1->GetSliceData(0, 0, 0)->GetData(); float* floatArray2 = (float*)image2->GetSliceData(0, 0, 0)->GetData(); for(unsigned int i = 0; i < sliceDimension; i++) { if(!(mitk::Equal(floatArray1[i], floatArray2[i]))) { picturesEqual = false; } } return picturesEqual; } /**Documentation * test for the class "ToFImageRecorderFilter". */ int mitkToFImageRecorderFilterTest(int /* argc */, char* /*argv*/[]) { MITK_TEST_BEGIN("ToFImageRecorder"); mitk::ToFImageRecorderFilter::Pointer tofImageRecorderFilter = mitk::ToFImageRecorderFilter::New(); MITK_TEST_OUTPUT(<< "Test SetFileName()"); std::string testFileName = "test.pic"; tofImageRecorderFilter->SetFileName(testFileName); mitk::ToFImageWriter::Pointer tofImageWriter = tofImageRecorderFilter->GetToFImageWriter(); std::string requiredName = "test_DistanceImage.pic"; std::string name = tofImageWriter->GetDistanceImageFileName(); MITK_TEST_CONDITION_REQUIRED(requiredName==name,"Test for distance image file name"); requiredName = "test_AmplitudeImage.pic"; name = tofImageWriter->GetAmplitudeImageFileName(); MITK_TEST_CONDITION_REQUIRED(requiredName==name,"Test for amplitude image file name"); requiredName = "test_IntensityImage.pic"; name = tofImageWriter->GetIntensityImageFileName(); MITK_TEST_CONDITION_REQUIRED(requiredName==name,"Test for intensity image file name"); mitk::Image::Pointer testDistanceImage = CreateTestImage(200,200); mitk::Image::Pointer testAmplitudeImage = CreateTestImage(200,200); mitk::Image::Pointer testIntensityImage = CreateTestImage(200,200); MITK_TEST_OUTPUT(<< "Apply filter"); tofImageRecorderFilter->StartRecording(); tofImageRecorderFilter->SetInput(0,testDistanceImage); tofImageRecorderFilter->SetInput(1,testAmplitudeImage); tofImageRecorderFilter->SetInput(2,testIntensityImage); tofImageRecorderFilter->Update(); MITK_TEST_OUTPUT(<< "Test outputs of filter"); mitk::Image::Pointer outputDistanceImage = tofImageRecorderFilter->GetOutput(0); MITK_TEST_CONDITION_REQUIRED(CompareImages(testDistanceImage,outputDistanceImage),"Test output 0 (distance image)"); mitk::Image::Pointer outputAmplitudeImage = tofImageRecorderFilter->GetOutput(1); MITK_TEST_CONDITION_REQUIRED(CompareImages(testAmplitudeImage,outputAmplitudeImage),"Test output 1 (amplitude image)"); mitk::Image::Pointer outputIntensityImage = tofImageRecorderFilter->GetOutput(2); MITK_TEST_CONDITION_REQUIRED(CompareImages(testIntensityImage,outputIntensityImage),"Test output 2 (intensity image)"); tofImageRecorderFilter->StopRecording(); MITK_TEST_OUTPUT(<< "Test content of written files"); mitk::PicFileReader::Pointer imageReader = mitk::PicFileReader::New(); imageReader->SetFileName("test_DistanceImage.pic"); imageReader->Update(); mitk::Image::Pointer loadedDistanceImage = imageReader->GetOutput(); MITK_TEST_CONDITION_REQUIRED(CompareImages(testDistanceImage,loadedDistanceImage),"Test loaded image 0 (distance image)"); imageReader->SetFileName("test_AmplitudeImage.pic"); imageReader->Update(); mitk::Image::Pointer loadedAmplitudeImage = imageReader->GetOutput(); MITK_TEST_CONDITION_REQUIRED(CompareImages(testAmplitudeImage,loadedAmplitudeImage),"Test loaded image 1 (amplitude image)"); imageReader->SetFileName("test_IntensityImage.pic"); imageReader->Update(); mitk::Image::Pointer loadedIntensityImage = imageReader->GetOutput(); MITK_TEST_CONDITION_REQUIRED(CompareImages(testIntensityImage,loadedIntensityImage),"Test loaded image 2 (intensity image)"); //clean up and delete saved image files if( remove( "test_DistanceImage.pic" ) != 0 ) { MITK_ERROR<<"File: test_DistanceImage.pic not successfully deleted!"; } if( remove( "test_AmplitudeImage.pic" ) != 0 ) { MITK_ERROR<<"File: test_AmplitudeImage.pic not successfully deleted!"; } if( remove( "test_IntensityImage.pic" ) != 0 ) { MITK_ERROR<<"File: test_IntensityImage.pic not successfully deleted!"; } MITK_TEST_END(); } diff --git a/Modules/ToFHardware/Testing/mitkToFImageRecorderTest.cpp b/Modules/ToFHardware/Testing/mitkToFImageRecorderTest.cpp index 021b1c33c0..9c6488fcd3 100644 --- a/Modules/ToFHardware/Testing/mitkToFImageRecorderTest.cpp +++ b/Modules/ToFHardware/Testing/mitkToFImageRecorderTest.cpp @@ -1,234 +1,235 @@ /*========================================================================= Program: Medical Imaging & Interaction Toolkit Language: C++ Date: $Date: 2010-03-12 14:05:50 +0100 (Fr, 12 Mrz 2010) $ Version: $Revision: 16010 $ 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 #include #include #include #include #include #include /**Documentation * test for the class "ToFImageRecorder". */ static bool CompareImages(mitk::Image::Pointer image1, mitk::Image::Pointer image2) { //check if epsilon is exceeded unsigned int sliceDimension = image1->GetDimension(0)*image1->GetDimension(1); bool picturesEqual = true; int numOfFrames = image1->GetDimension(2); for (unsigned int i=0; iGetSliceData(i, 0, 0)->GetData(); float* floatArray2 = (float*)image2->GetSliceData(i, 0, 0)->GetData(); for(unsigned int j = 0; j < sliceDimension; j++) { if(!(mitk::Equal(floatArray1[j], floatArray2[j]))) { picturesEqual = false; } } } return picturesEqual; } int mitkToFImageRecorderTest(int /* argc */, char* /*argv*/[]) { MITK_TEST_BEGIN("ToFImageRecorder"); mitk::ToFImageRecorder::Pointer tofImageRecorder = mitk::ToFImageRecorder::New(); MITK_TEST_OUTPUT(<< "Test itk-Set/Get-Makros"); std::string testFileName_Distance = "test_DistanceImage.pic"; std::string testFileName_Amplitude = "test_AmplitudeImage.pic"; std::string testFileName_Intensity = "test_IntensityImage.pic"; std::string requiredName_Distance; std::string requiredName_Amplitude; std::string requiredName_Intensity; tofImageRecorder->SetDistanceImageFileName(testFileName_Distance); requiredName_Distance = tofImageRecorder->GetDistanceImageFileName(); MITK_TEST_CONDITION_REQUIRED(requiredName_Distance==testFileName_Distance,"Test for distance image file name"); tofImageRecorder->SetAmplitudeImageFileName(testFileName_Amplitude); requiredName_Amplitude = tofImageRecorder->GetAmplitudeImageFileName(); MITK_TEST_CONDITION_REQUIRED(requiredName_Amplitude==testFileName_Amplitude,"Test for amplitude image file name"); tofImageRecorder->SetIntensityImageFileName(testFileName_Intensity); requiredName_Intensity = tofImageRecorder->GetIntensityImageFileName(); MITK_TEST_CONDITION_REQUIRED(requiredName_Intensity==testFileName_Intensity,"Test for intensity image file name"); bool distanceImageSelected = false; bool amplitudeImageSelected = false; bool intensityImageSelected = false; bool requiredDistanceImageSelected = false; bool requiredAmplitudeImageSelected = false; bool requiredIntensityImageSelected = false; tofImageRecorder->SetDistanceImageSelected(distanceImageSelected); requiredDistanceImageSelected = tofImageRecorder->GetDistanceImageSelected(); MITK_TEST_CONDITION_REQUIRED(distanceImageSelected==requiredDistanceImageSelected,"Test for distance selection"); tofImageRecorder->SetAmplitudeImageSelected(amplitudeImageSelected); requiredAmplitudeImageSelected = tofImageRecorder->GetAmplitudeImageSelected(); MITK_TEST_CONDITION_REQUIRED(amplitudeImageSelected==requiredAmplitudeImageSelected,"Test for amplitude selection"); tofImageRecorder->SetIntensityImageSelected(intensityImageSelected); requiredIntensityImageSelected = tofImageRecorder->GetIntensityImageSelected(); MITK_TEST_CONDITION_REQUIRED(intensityImageSelected==requiredIntensityImageSelected,"Test for intensity selection"); int numOfFrames = 7; tofImageRecorder->SetNumOfFrames(numOfFrames); MITK_TEST_CONDITION_REQUIRED(numOfFrames==tofImageRecorder->GetNumOfFrames(),"Test for get/set number of frames"); std::string fileFormat = ".pic"; tofImageRecorder->SetFileFormat(fileFormat); MITK_TEST_CONDITION_REQUIRED(fileFormat==tofImageRecorder->GetFileFormat(),"Test for get/set the file format"); MITK_TEST_OUTPUT(<< "Test other methods"); tofImageRecorder->SetRecordMode(mitk::ToFImageRecorder::Infinite); MITK_TEST_CONDITION_REQUIRED(mitk::ToFImageRecorder::Infinite==tofImageRecorder->GetRecordMode(),"Test for get/set the record mode"); mitk::ToFCameraDevice* testDevice = NULL; tofImageRecorder->SetCameraDevice(testDevice); MITK_TEST_CONDITION_REQUIRED(testDevice == tofImageRecorder->GetCameraDevice(),"Test for get/set the camera device"); tofImageRecorder->SetToFImageType(mitk::ToFImageWriter::ToFImageType2DPlusT); MITK_TEST_CONDITION_REQUIRED(mitk::ToFImageWriter::ToFImageType2DPlusT==tofImageRecorder->GetToFImageType(), "Testing set/get ToFImageType"); tofImageRecorder->SetToFImageType(mitk::ToFImageWriter::ToFImageType3D); MITK_TEST_CONDITION_REQUIRED(mitk::ToFImageWriter::ToFImageType3D==tofImageRecorder->GetToFImageType(), "Testing set/get ToFImageType"); MITK_TEST_OUTPUT(<< "Test recording"); tofImageRecorder = mitk::ToFImageRecorder::New(); std::string dirName = MITK_TOF_DATA_DIR; mitk::ToFCameraMITKPlayerDevice::Pointer tofCameraMITKPlayerDevice = mitk::ToFCameraMITKPlayerDevice::New(); tofImageRecorder->SetCameraDevice(tofCameraMITKPlayerDevice); MITK_TEST_CONDITION_REQUIRED(tofCameraMITKPlayerDevice == tofImageRecorder->GetCameraDevice(), "Testing set/get CameraDevice with ToFCameraPlayerDevice"); std::string distanceFileName = dirName + "/PMDCamCube2_MF0_IT0_20Images_DistanceImage.pic"; std::string amplitudeFileName = dirName + "/PMDCamCube2_MF0_IT0_20Images_AmplitudeImage.pic"; std::string intensityFileName = dirName + "/PMDCamCube2_MF0_IT0_20Images_IntensityImage.pic"; tofCameraMITKPlayerDevice->SetProperty("DistanceImageFileName",mitk::StringProperty::New(distanceFileName)); tofCameraMITKPlayerDevice->SetProperty("AmplitudeImageFileName",mitk::StringProperty::New(amplitudeFileName)); tofCameraMITKPlayerDevice->SetProperty("IntensityImageFileName",mitk::StringProperty::New(intensityFileName)); tofCameraMITKPlayerDevice->ConnectCamera(); tofCameraMITKPlayerDevice->StartCamera(); std::string distanceTestFileName = "test_distance.pic"; std::string amplitudeTestFileName = "test_amplitude.pic"; std::string intensityTestFileName = "test_intensity.pic"; tofImageRecorder->SetDistanceImageFileName(distanceTestFileName); tofImageRecorder->SetAmplitudeImageFileName(amplitudeTestFileName); tofImageRecorder->SetIntensityImageFileName(intensityTestFileName); + tofImageRecorder->SetFileFormat(".pic"); tofImageRecorder->SetRecordMode(mitk::ToFImageRecorder::PerFrames); tofImageRecorder->SetNumOfFrames(20); tofImageRecorder->StartRecording(); itksys::SystemTools::Delay(1000); // wait to allow recording tofImageRecorder->StopRecording(); tofCameraMITKPlayerDevice->StopCamera(); tofCameraMITKPlayerDevice->DisconnectCamera(); // Load images (recorded and original ones) with PicFileReader for comparison mitk::PicFileReader::Pointer picFileReader = mitk::PicFileReader::New(); mitk::Image::Pointer originalImage = NULL; mitk::Image::Pointer recordedImage = NULL; picFileReader->SetFileName(distanceFileName); picFileReader->Update(); originalImage = picFileReader->GetOutput(); picFileReader->SetFileName(distanceTestFileName); picFileReader->Update(); recordedImage = picFileReader->GetOutput(); MITK_TEST_CONDITION_REQUIRED(originalImage->GetDimension(0) == tofImageRecorder->GetCaptureWidth(), "Testing capture width"); MITK_TEST_CONDITION_REQUIRED(originalImage->GetDimension(1) == tofImageRecorder->GetCaptureHeight(), "Testing capture height"); MITK_TEST_CONDITION_REQUIRED(originalImage->GetDimension(2) == recordedImage->GetDimension(2), "Testing number of frames"); MITK_TEST_CONDITION_REQUIRED(CompareImages(originalImage, recordedImage), "Compare original and saved distance image"); picFileReader->SetFileName(amplitudeFileName); picFileReader->Update(); originalImage = picFileReader->GetOutput(); picFileReader->SetFileName(amplitudeTestFileName); picFileReader->Update(); recordedImage = picFileReader->GetOutput(); MITK_TEST_CONDITION_REQUIRED(originalImage->GetDimension(0) == tofImageRecorder->GetCaptureWidth(), "Testing capture width"); MITK_TEST_CONDITION_REQUIRED(originalImage->GetDimension(1) == tofImageRecorder->GetCaptureHeight(), "Testing capture height"); MITK_TEST_CONDITION_REQUIRED(originalImage->GetDimension(2) == recordedImage->GetDimension(2), "Testing number of frames"); MITK_TEST_CONDITION_REQUIRED(CompareImages(originalImage, recordedImage), "Compare original and saved amplitude image"); picFileReader->SetFileName(intensityFileName); picFileReader->Update(); originalImage = picFileReader->GetOutput(); picFileReader->SetFileName(intensityTestFileName); picFileReader->Update(); recordedImage = picFileReader->GetOutput(); MITK_TEST_CONDITION_REQUIRED(originalImage->GetDimension(0) == tofImageRecorder->GetCaptureWidth(), "Testing capture width"); MITK_TEST_CONDITION_REQUIRED(originalImage->GetDimension(1) == tofImageRecorder->GetCaptureHeight(), "Testing capture height"); MITK_TEST_CONDITION_REQUIRED(originalImage->GetDimension(2) == recordedImage->GetDimension(2), "Testing number of frames"); MITK_TEST_CONDITION_REQUIRED(CompareImages(originalImage, recordedImage), "Compare original and saved intensity image"); //clean up and delete saved image files if( remove( "test_distance.pic" ) != 0 ) { MITK_ERROR<<"File: test_distance.pic not successfully deleted!"; } if( remove( "test_amplitude.pic" ) != 0 ) { MITK_ERROR<<"File: test_amplitude.pic not successfully deleted!"; } if( remove( "test_intensity.pic" ) != 0 ) { MITK_ERROR<<"File: test_intensity.pic not successfully deleted!"; } MITK_TEST_END(); } diff --git a/Modules/ToFHardware/mitkToFCameraMITKPlayerController.cpp b/Modules/ToFHardware/mitkToFCameraMITKPlayerController.cpp index 55d1220d53..d474c669de 100644 --- a/Modules/ToFHardware/mitkToFCameraMITKPlayerController.cpp +++ b/Modules/ToFHardware/mitkToFCameraMITKPlayerController.cpp @@ -1,373 +1,373 @@ /*========================================================================= 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 #include // mitk includes #include "mitkItkImageFileReader.h" #include "mitkPicFileReader.h" #include namespace mitk { ToFCameraMITKPlayerController::ToFCameraMITKPlayerController():m_PixelNumber(0),m_NumberOfBytes(0), m_CaptureWidth(0),m_CaptureHeight(0),m_ConnectionCheck(false),m_InputFileName(""), m_ToFImageType(ToFImageType3D), m_IntensityArray(NULL),m_DistanceArray(NULL),m_AmplitudeArray(NULL), m_DistanceImageFileName(""),m_AmplitudeImageFileName(""),m_IntensityImageFileName(""), m_Extension(""), m_CurrentFrame(-1),m_NumOfFrames(0), m_DistanceImage(0), m_AmplitudeImage(0),m_IntensityImage(0), m_PixelStartInFile(0), m_DistanceInfile(NULL),m_AmplitudeInfile(NULL),m_IntensityInfile(NULL) { m_ImageStatus = std::vector(3,true); } ToFCameraMITKPlayerController::~ToFCameraMITKPlayerController() { this->CleanUp(); } void ToFCameraMITKPlayerController::CleanUp() { if(m_DistanceImage.IsNotNull()) { m_DistanceImage->ReleaseData(); m_DistanceImage = NULL; } if(m_AmplitudeImage.IsNotNull()) { m_AmplitudeImage->ReleaseData(); m_AmplitudeImage = NULL; } if(m_IntensityImage.IsNotNull()) { m_IntensityImage->ReleaseData(); m_IntensityImage = NULL; } delete[] this->m_DistanceArray; this->m_DistanceArray = NULL; delete[] this->m_AmplitudeArray; this->m_AmplitudeArray = NULL; delete[] this->m_IntensityArray; this->m_IntensityArray = NULL; } bool ToFCameraMITKPlayerController::CheckCurrentFileType() { if(!this->m_DistanceImageFileName.empty()) { if(ItkImageFileReader::CanReadFile(m_DistanceImageFileName,"",".nrrd")) { m_Extension = ".nrrd"; return true; } else if (PicFileReader::CanReadFile(m_DistanceImageFileName,"",".pic")) { m_Extension = ".pic"; return true; } } if(!this->m_AmplitudeImageFileName.empty()) { if(ItkImageFileReader::CanReadFile(m_AmplitudeImageFileName,"",".nrrd")) { m_Extension = ".nrrd"; return true; } else if (PicFileReader::CanReadFile(m_AmplitudeImageFileName,"",".pic")) { m_Extension = ".pic"; return true; } } if(!this->m_IntensityImageFileName.empty()) { if(ItkImageFileReader::CanReadFile(m_IntensityImageFileName,"",".nrrd")) { m_Extension = ".nrrd"; return true; } else if (PicFileReader::CanReadFile(m_IntensityImageFileName,"",".pic")) { m_Extension = ".pic"; return true; } } return false; } bool ToFCameraMITKPlayerController::OpenCameraConnection() { if(!this->m_ConnectionCheck) { try { // Check for file type, only .nrrd and .pic files are supported! if( this->CheckCurrentFileType()) { if(m_Extension == ".nrrd") { this->OpenNrrdImageFile(this->m_DistanceImageFileName, m_DistanceImage); this->OpenNrrdImageFile(this->m_AmplitudeImageFileName, m_AmplitudeImage); this->OpenNrrdImageFile(this->m_IntensityImageFileName, m_IntensityImage); } else if(m_Extension == ".pic") { this->OpenPicImageFile(this->m_DistanceImageFileName, m_DistanceImage); this->OpenPicImageFile(this->m_AmplitudeImageFileName, m_AmplitudeImage); this->OpenPicImageFile(this->m_IntensityImageFileName, m_IntensityImage); } } else { - throw std::logic_error("Please check image type, currently only .nrrd files are supported (.pic files are depracated!)"); + throw std::logic_error("Please check image type, currently only .nrrd files are supported (.pic files are deprecated!)"); } // check if the opened files contained data if(m_DistanceImage.IsNull()) { m_ImageStatus.at(0) = false; } if(m_AmplitudeImage.IsNull()) { m_ImageStatus.at(1) = false; } if(m_IntensityImage.IsNull()) { m_ImageStatus.at(2) = false; } // Check for dimension type mitk::Image::Pointer infoImage = NULL; if(m_ImageStatus.at(0)) { infoImage = m_DistanceImage; } else if (m_ImageStatus.at(1)) { infoImage = m_AmplitudeImage; } else if(m_ImageStatus.at(2)) { infoImage = m_IntensityImage; } if (infoImage->GetDimension() == 2) this->m_ToFImageType = ToFImageType2DPlusT; else if (infoImage->GetDimension() == 3) this->m_ToFImageType = ToFImageType3D; else if (infoImage->GetDimension() == 4) this->m_ToFImageType = ToFImageType2DPlusT; else throw std::logic_error("Error opening ToF data file: Invalid dimension."); this->m_CaptureWidth = infoImage->GetDimension(0); this->m_CaptureHeight = infoImage->GetDimension(1); this->m_PixelNumber = this->m_CaptureWidth*this->m_CaptureHeight; this->m_NumberOfBytes = this->m_PixelNumber * sizeof(float); if (this->m_ToFImageType == ToFImageType2DPlusT) { this->m_NumOfFrames = infoImage->GetDimension(3); } else { this->m_NumOfFrames = infoImage->GetDimension(2); } // allocate buffer this->m_DistanceArray = new float[this->m_PixelNumber]; for(int i=0; im_PixelNumber; i++) {this->m_DistanceArray[i]=0.0;} this->m_AmplitudeArray = new float[this->m_PixelNumber]; for(int i=0; im_PixelNumber; i++) {this->m_AmplitudeArray[i]=0.0;} this->m_IntensityArray = new float[this->m_PixelNumber]; for(int i=0; im_PixelNumber; i++) {this->m_IntensityArray[i]=0.0;} // mitkIpPicDescriptor* pic = NULL; // mitkIpPicDescriptor* info = NULL; // pic = mitkIpPicGetHeader(const_cast(this->m_DistanceImageFileName.c_str()), pic); // if (pic==NULL) // { // MITK_ERROR << "Error opening ToF data file " << this->m_InputFileName; // return false; // } // info = mitkIpPicGetTags(const_cast(this->m_DistanceImageFileName.c_str()), pic); // this->m_PixelStartInFile = info->info->pixel_start_in_file; // OpenPicFileToData(&(this->m_DistanceInfile), this->m_DistanceImageFileName.c_str()); // OpenPicFileToData(&(this->m_AmplitudeInfile), this->m_AmplitudeImageFileName.c_str()); // OpenPicFileToData(&(this->m_IntensityInfile), this->m_IntensityImageFileName.c_str()); MITK_INFO << "NumOfFrames: " << this->m_NumOfFrames; this->m_ConnectionCheck = true; return this->m_ConnectionCheck; } catch(std::exception& e) { MITK_ERROR << "Error opening ToF data file " << this->m_InputFileName << " " << e.what(); throw std::logic_error("Error opening ToF data file"); return false; } } else return this->m_ConnectionCheck; } void ToFCameraMITKPlayerController::OpenNrrdImageFile( const std::string outfileName, Image::Pointer &image) { if(!outfileName.empty()) { if(image.IsNotNull()) { image->ReleaseData(); image = NULL; } ItkImageFileReader::Pointer nrrdReader = ItkImageFileReader::New(); nrrdReader->SetFileName(outfileName); nrrdReader->Update(); image = nrrdReader->GetOutput()->Clone(); } else { MITK_ERROR << "Error opening ToF data file " << outfileName; } } void ToFCameraMITKPlayerController::OpenPicImageFile( const std::string outfileName, Image::Pointer &image) { if(!outfileName.empty()) { if(image.IsNotNull()) { image->ReleaseData(); image = NULL; } PicFileReader::Pointer picReader = PicFileReader::New(); picReader->SetFileName(outfileName); picReader->Update(); image = picReader->GetOutput()->Clone(); } else { MITK_ERROR << "Error opening ToF data file " << outfileName; } } //void ToFCameraMITKPlayerController::OpenPicFileToData(FILE** outfile, const char *outfileName) //{ // (*outfile) = fopen( outfileName, "rb" ); // if( (*outfile) == NULL ) // { // MITK_ERROR << "Error opening ToF data file: file is empty" << outfileName; // throw std::logic_error("Error opening ToF data file: file is empty"); // return; // } // fseek ( (*outfile), this->m_PixelStartInFile, SEEK_SET ); //} bool ToFCameraMITKPlayerController::CloseCameraConnection() { if (this->m_ConnectionCheck) { this->CleanUp(); this->m_ConnectionCheck = false; return true; } return false; } void ToFCameraMITKPlayerController::UpdateCamera() { this->m_CurrentFrame++; if(this->m_CurrentFrame >= this->m_NumOfFrames) { this->m_CurrentFrame = 0; } if(this->m_ImageStatus.at(0)) { this->AccessData(this->m_CurrentFrame, this->m_DistanceImage, this->m_DistanceArray); } if(this->m_ImageStatus.at(1)) { this->AccessData(this->m_CurrentFrame, this->m_AmplitudeImage, this->m_AmplitudeArray); } if(this->m_ImageStatus.at(2)) { this->AccessData(this->m_CurrentFrame, this->m_IntensityImage, this->m_IntensityArray); } itksys::SystemTools::Delay(50); //size_t distanceBytesReturn; //size_t amplitudeBytesReturn; //size_t intensityBytesReturn; //this->m_CurrentFrame++; //if (this->m_CurrentFrame >= this->m_NumOfFrames) //{ // // fseek ( this->m_DistanceInfile, this->m_PixelStartInFile, SEEK_SET ); // fseek ( this->m_AmplitudeInfile, this->m_PixelStartInFile, SEEK_SET ); // fseek ( this->m_IntensityInfile, this->m_PixelStartInFile, SEEK_SET ); //} //distanceBytesReturn = fread( this->m_DistanceArray, this->m_NumberOfBytes, 1, this->m_DistanceInfile ); //amplitudeBytesReturn = fread( this->m_AmplitudeArray, this->m_NumberOfBytes, 1, this->m_AmplitudeInfile ); //intensityBytesReturn = fread( this->m_IntensityArray, this->m_NumberOfBytes, 1, this->m_IntensityInfile ); } void ToFCameraMITKPlayerController::AccessData(int frame, Image::Pointer image, float* &data) { if(!this->m_ToFImageType) { memcpy(data, image->GetSliceData(frame)->GetData(),this->m_NumberOfBytes ); } else if(this->m_ToFImageType) { memcpy(data, image->GetVolumeData(frame)->GetData(), this->m_NumberOfBytes); } } void ToFCameraMITKPlayerController::GetAmplitudes(float* amplitudeArray) { memcpy(amplitudeArray, this->m_AmplitudeArray, this->m_NumberOfBytes); } void ToFCameraMITKPlayerController::GetIntensities(float* intensityArray) { memcpy(intensityArray, this->m_IntensityArray, this->m_NumberOfBytes); } void ToFCameraMITKPlayerController::GetDistances(float* distanceArray) { memcpy(distanceArray, this->m_DistanceArray, this->m_NumberOfBytes); } void ToFCameraMITKPlayerController::SetInputFileName(std::string inputFileName) { this->m_InputFileName = inputFileName; } } diff --git a/Modules/ToFHardware/mitkToFImageRecorder.cpp b/Modules/ToFHardware/mitkToFImageRecorder.cpp index e3b43cb631..c1ee923047 100644 --- a/Modules/ToFHardware/mitkToFImageRecorder.cpp +++ b/Modules/ToFHardware/mitkToFImageRecorder.cpp @@ -1,243 +1,247 @@ /*========================================================================= 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 "mitkToFImageRecorder.h" #include "mitkRealTimeClock.h" #include "itkMultiThreader.h" #include #pragma GCC visibility push(default) #include #pragma GCC visibility pop namespace mitk { ToFImageRecorder::ToFImageRecorder() { this->m_ToFCameraDevice = NULL; this->m_MultiThreader = itk::MultiThreader::New(); this->m_AbortMutex = itk::FastMutexLock::New(); this->m_ThreadID = 0; this->m_NumOfFrames = 0; this->m_ToFImageWriter = NULL; this->m_DistanceImageSelected = true; this->m_AmplitudeImageSelected = true; this->m_IntensityImageSelected = true; this->m_Abort = true; this->m_CaptureWidth = 0; this->m_CaptureHeight = 0; this->m_FileFormat = ""; this->m_PixelNumber = 0; this->m_SourceDataSize = 0; this->m_ToFImageType = ToFImageWriter::ToFImageType3D; this->m_RecordMode = ToFImageRecorder::PerFrames; this->m_DistanceImageFileName = ""; this->m_AmplitudeImageFileName = ""; this->m_IntensityImageFileName = ""; this->m_ImageSequence = 0; this->m_DistanceArray = NULL; this->m_AmplitudeArray = NULL; this->m_IntensityArray = NULL; this->m_SourceDataArray = NULL; } ToFImageRecorder::~ToFImageRecorder() { delete[] m_DistanceArray; delete[] m_AmplitudeArray; delete[] m_IntensityArray; delete[] m_SourceDataArray; } void ToFImageRecorder::StopRecording() { this->m_AbortMutex->Lock(); this->m_Abort = true; this->m_AbortMutex->Unlock(); } void ToFImageRecorder::StartRecording() { if (this->m_ToFCameraDevice.IsNull()) { throw std::invalid_argument("ToFCameraDevice is NULL."); return; } if (this->m_FileFormat.compare(".csv") == 0) { this->m_ToFImageWriter = ToFImageCsvWriter::New(); } else if(this->m_FileFormat.compare(".nrrd") == 0) { this->m_ToFImageWriter = ToFNrrdImageWriter::New(); this->m_ToFImageWriter->SetExtension(m_FileFormat); } else if(this->m_FileFormat.compare(".pic") == 0) { this->m_ToFImageWriter = ToFPicImageWriter::New(); this->m_ToFImageWriter->SetExtension(m_FileFormat); } + else + { + throw std::logic_error("No file format specified!"); + } this->m_CaptureWidth = this->m_ToFCameraDevice->GetCaptureWidth(); this->m_CaptureHeight = this->m_ToFCameraDevice->GetCaptureHeight(); this->m_PixelNumber = this->m_CaptureWidth * this->m_CaptureHeight; this->m_SourceDataSize = this->m_ToFCameraDevice->GetSourceDataSize(); // allocate buffer if(m_IntensityArray == NULL) { this->m_IntensityArray = new float[m_PixelNumber]; } if(this->m_DistanceArray == NULL) { this->m_DistanceArray = new float[m_PixelNumber]; } if(this->m_AmplitudeArray == NULL) { this->m_AmplitudeArray = new float[m_PixelNumber]; } if(this->m_SourceDataArray == NULL) { this->m_SourceDataArray = new char[m_SourceDataSize]; } this->m_ToFImageWriter->SetDistanceImageFileName(this->m_DistanceImageFileName); this->m_ToFImageWriter->SetAmplitudeImageFileName(this->m_AmplitudeImageFileName); this->m_ToFImageWriter->SetIntensityImageFileName(this->m_IntensityImageFileName); this->m_ToFImageWriter->SetCaptureWidth(this->m_CaptureWidth); this->m_ToFImageWriter->SetCaptureHeight(this->m_CaptureHeight); this->m_ToFImageWriter->SetToFImageType(this->m_ToFImageType); this->m_ToFImageWriter->SetDistanceImageSelected(this->m_DistanceImageSelected); this->m_ToFImageWriter->SetAmplitudeImageSelected(this->m_AmplitudeImageSelected); this->m_ToFImageWriter->SetIntensityImageSelected(this->m_IntensityImageSelected); this->m_ToFImageWriter->Open(); this->m_AbortMutex->Lock(); this->m_Abort = false; this->m_AbortMutex->Unlock(); this->m_ThreadID = this->m_MultiThreader->SpawnThread(this->RecordData, this); } ITK_THREAD_RETURN_TYPE ToFImageRecorder::RecordData(void* pInfoStruct) { 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; } ToFImageRecorder* toFImageRecorder = (ToFImageRecorder*)pInfo->UserData; if (toFImageRecorder!=NULL) { ToFCameraDevice::Pointer toFCameraDevice = toFImageRecorder->GetCameraDevice(); mitk::RealTimeClock::Pointer realTimeClock; realTimeClock = mitk::RealTimeClock::New(); int n = 100; double t1 = 0; double t2 = 0; t1 = realTimeClock->GetCurrentStamp(); bool overflow = false; bool printStatus = false; int requiredImageSequence = 0; int numOfFramesRecorded = 0; bool abort = false; toFImageRecorder->m_AbortMutex->Lock(); abort = toFImageRecorder->m_Abort; toFImageRecorder->m_AbortMutex->Unlock(); while ( !abort ) { if ( ((toFImageRecorder->m_RecordMode == ToFImageRecorder::PerFrames) && (numOfFramesRecorded < toFImageRecorder->m_NumOfFrames)) || (toFImageRecorder->m_RecordMode == ToFImageRecorder::Infinite) ) { toFCameraDevice->GetAllImages(toFImageRecorder->m_DistanceArray, toFImageRecorder->m_AmplitudeArray, toFImageRecorder->m_IntensityArray, toFImageRecorder->m_SourceDataArray, requiredImageSequence, toFImageRecorder->m_ImageSequence ); if (toFImageRecorder->m_ImageSequence >= requiredImageSequence) { if (toFImageRecorder->m_ImageSequence > requiredImageSequence) { MITK_INFO << "Problem! required: " << requiredImageSequence << " captured: " << toFImageRecorder->m_ImageSequence; } requiredImageSequence = toFImageRecorder->m_ImageSequence + 1; toFImageRecorder->m_ToFImageWriter->Add( toFImageRecorder->m_DistanceArray, toFImageRecorder->m_AmplitudeArray, toFImageRecorder->m_IntensityArray ); numOfFramesRecorded++; if (numOfFramesRecorded % n == 0) { printStatus = true; } if (printStatus) { t2 = realTimeClock->GetCurrentStamp() - t1; MITK_INFO << " Framerate (fps): " << n / (t2/1000) << " Sequence: " << toFImageRecorder->m_ImageSequence; t1 = realTimeClock->GetCurrentStamp(); printStatus = false; } } toFImageRecorder->m_AbortMutex->Lock(); abort = toFImageRecorder->m_Abort; toFImageRecorder->m_AbortMutex->Unlock(); } else { abort = true; } } // end of while loop toFImageRecorder->InvokeEvent(itk::AbortEvent()); toFImageRecorder->m_ToFImageWriter->Close(); } return ITK_THREAD_RETURN_VALUE; } void ToFImageRecorder::SetCameraDevice(ToFCameraDevice* aToFCameraDevice) { this->m_ToFCameraDevice = aToFCameraDevice; } ToFCameraDevice* ToFImageRecorder::GetCameraDevice() { return this->m_ToFCameraDevice; } ToFImageWriter::ToFImageType ToFImageRecorder::GetToFImageType() { return this->m_ToFImageType; } void ToFImageRecorder::SetToFImageType(ToFImageWriter::ToFImageType toFImageType) { this->m_ToFImageType = toFImageType; } ToFImageRecorder::RecordMode ToFImageRecorder::GetRecordMode() { return this->m_RecordMode; } void ToFImageRecorder::SetRecordMode(ToFImageRecorder::RecordMode recordMode) { this->m_RecordMode = recordMode; } } diff --git a/Modules/ToFHardware/mitkToFImageRecorderFilter.cpp b/Modules/ToFHardware/mitkToFImageRecorderFilter.cpp index d1715ceedf..06cc48af9d 100644 --- a/Modules/ToFHardware/mitkToFImageRecorderFilter.cpp +++ b/Modules/ToFHardware/mitkToFImageRecorderFilter.cpp @@ -1,142 +1,170 @@ /*========================================================================= Program: Medical Imaging & Interaction Toolkit Module: $RCSfile$ Language: C++ Date: $Date $ 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 #include #include +#include "mitkToFNrrdImageWriter.h" +#include "mitkToFPicImageWriter.h" +#include "mitkToFImageCsvWriter.h" +// itk includes +#include "itksys/SystemTools.hxx" -mitk::ToFImageRecorderFilter::ToFImageRecorderFilter(): m_RecordingStarted(false) + +mitk::ToFImageRecorderFilter::ToFImageRecorderFilter(): m_RecordingStarted(false), m_ToFImageWriter(0) { - m_ToFImageWriter = mitk::ToFImageWriter::New(); + m_FileExtension = ""; } mitk::ToFImageRecorderFilter::~ToFImageRecorderFilter() { } void mitk::ToFImageRecorderFilter::SetFileName(std::string fileName) { std::string name = fileName; + m_FileExtension = itksys::SystemTools::GetFilenameLastExtension( fileName ); + if(m_FileExtension == ".nrrd") + { + m_ToFImageWriter = mitk::ToFNrrdImageWriter::New(); + } + else if(m_FileExtension == ".pic") + { + m_ToFImageWriter = mitk::ToFPicImageWriter::New(); + } + else if(m_FileExtension == ".csv") + { + m_ToFImageWriter = mitk::ToFImageCsvWriter::New(); + } + else + { + throw std::logic_error("The specified file type is not supported, standard file type is .nrrd!"); + } int pos = name.find_last_of("."); name.insert(pos,"_DistanceImage"); m_ToFImageWriter->SetDistanceImageFileName(name); name = fileName; name.insert(pos,"_AmplitudeImage"); m_ToFImageWriter->SetAmplitudeImageFileName(name); name = fileName; name.insert(pos,"_IntensityImage"); m_ToFImageWriter->SetIntensityImageFileName(name); } void mitk::ToFImageRecorderFilter::SetImageType(mitk::ToFImageWriter::ToFImageType tofImageType) { m_ToFImageWriter->SetToFImageType(tofImageType); } void mitk::ToFImageRecorderFilter::GenerateData() { mitk::Image::Pointer distanceImageInput = this->GetInput(0); assert(distanceImageInput); mitk::Image::Pointer amplitudeImageInput = this->GetInput(1); assert(amplitudeImageInput); mitk::Image::Pointer intensityImageInput = this->GetInput(2); assert(intensityImageInput); // add current data to file stream float* distanceFloatData = (float*)distanceImageInput->GetSliceData(0, 0, 0)->GetData(); float* amplitudeFloatData = (float*)amplitudeImageInput->GetSliceData(0, 0, 0)->GetData(); float* intensityFloatData = (float*)intensityImageInput->GetSliceData(0, 0, 0)->GetData(); if (m_RecordingStarted) { m_ToFImageWriter->Add(distanceFloatData,amplitudeFloatData,intensityFloatData); } // set outputs to inputs this->SetNthOutput(0,distanceImageInput); this->SetNthOutput(1,amplitudeImageInput); this->SetNthOutput(2,intensityImageInput); } void mitk::ToFImageRecorderFilter::StartRecording() { + if(m_ToFImageWriter.IsNull()) + { + throw std::logic_error("ToFImageWriter is unitialized, set filename first!"); + return; + } m_ToFImageWriter->Open(); m_RecordingStarted = true; } void mitk::ToFImageRecorderFilter::StopRecording() { m_ToFImageWriter->Close(); m_RecordingStarted = false; } mitk::ToFImageWriter::Pointer mitk::ToFImageRecorderFilter::GetToFImageWriter() { return m_ToFImageWriter; } void mitk::ToFImageRecorderFilter::SetToFImageWriter(mitk::ToFImageWriter::Pointer tofImageWriter) { m_ToFImageWriter = tofImageWriter; } void mitk::ToFImageRecorderFilter::SetInput( mitk::Image* input ) { this->SetInput(0,input); } void mitk::ToFImageRecorderFilter::SetInput( unsigned int idx, mitk::Image* input ) { if ((input == NULL) && (idx == this->GetNumberOfInputs() - 1)) // if the last input is set to NULL, reduce the number of inputs by one { this->SetNumberOfInputs(this->GetNumberOfInputs() - 1); } else { this->ProcessObject::SetNthInput(idx, input); // Process object is not const-correct so the const_cast is required here unsigned int xDim = input->GetDimension(0); unsigned int yDim = input->GetDimension(1); m_ToFImageWriter->SetCaptureWidth(xDim); m_ToFImageWriter->SetCaptureWidth(yDim); } this->CreateOutputsForAllInputs(); } mitk::Image* mitk::ToFImageRecorderFilter::GetInput() { return this->GetInput(0); } mitk::Image* mitk::ToFImageRecorderFilter::GetInput( unsigned int idx ) { if (this->GetNumberOfInputs() < 1) return NULL; return static_cast< mitk::Image*>(this->ProcessObject::GetInput(idx)); } void mitk::ToFImageRecorderFilter::CreateOutputsForAllInputs() { this->SetNumberOfOutputs(this->GetNumberOfInputs()); // create outputs for all inputs for (unsigned int idx = 0; idx < this->GetNumberOfOutputs(); ++idx) if (this->GetOutput(idx) == NULL) { DataObjectPointer newOutput = this->MakeOutput(idx); this->SetNthOutput(idx, newOutput); } this->Modified(); } diff --git a/Modules/ToFHardware/mitkToFImageRecorderFilter.h b/Modules/ToFHardware/mitkToFImageRecorderFilter.h index b696da95a0..069d76f493 100644 --- a/Modules/ToFHardware/mitkToFImageRecorderFilter.h +++ b/Modules/ToFHardware/mitkToFImageRecorderFilter.h @@ -1,118 +1,119 @@ /*========================================================================= Program: Medical Imaging & Interaction Toolkit Module: $RCSfile$ Language: C++ Date: $Date $ 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. =========================================================================*/ #ifndef __mitkToFImageRecorderFilter_h #define __mitkToFImageRecorderFilter_h #include #include #include namespace mitk { /** * @brief Filter that allows recording of processed ToF images * Internally the ToFImageWriter is used for writing. * * @ingroup ToFProcessing */ class MITK_TOFHARDWARE_EXPORT ToFImageRecorderFilter : public ImageToImageFilter { public: mitkClassMacro( ToFImageRecorderFilter , ImageToImageFilter ); itkNewMacro( Self ); /*! \brief Set file name for writing image files This filename will be appended by "_DistanceImage", "_AmplitudeImage", or "_IntensityImage" for the single images \param fileName base file name to save image filtes */ void SetFileName(std::string fileName); /*! \brief Set image type for recording \param tofImageType either 3D Volume (ToFImageType3D) or temporal image stack (ToFImageType2DPlusT) */ void SetImageType(ToFImageWriter::ToFImageType tofImageType); /*! \brief Returns a pointer to the ToFImageWriter internally used \return ToFImageWriter */ ToFImageWriter::Pointer GetToFImageWriter(); /*! \brief Sets a pointer to the ToFImageWriter internally used \param tofImageWriter ToFImageWriter */ void SetToFImageWriter(ToFImageWriter::Pointer tofImageWriter); /*! \brief start recording of data */ void StartRecording(); /*! \brief stop recording of data */ void StopRecording(); /*! \brief sets the input of this filter \param distanceImage input is the distance image of e.g. a ToF camera */ virtual void SetInput( Image* input); /*! \brief sets the input of this filter at idx \param idx number of the current input \param distanceImage input is the distance image of e.g. a ToF camera */ virtual void SetInput(unsigned int idx, Image* input); /*! \brief returns the input of this filter */ Image* GetInput(); /*! \brief returns the input with id idx of this filter */ Image* GetInput(unsigned int idx); protected: /*! \brief standard constructor */ ToFImageRecorderFilter(); /*! \brief standard destructor */ ~ToFImageRecorderFilter(); /*! \brief method generating the output of this filter. Called in the updated process of the pipeline. This method generates the output of the ToFSurfaceSource: The generated surface of the 3d points */ virtual void GenerateData(); /** * \brief Create an output for each input * * This Method sets the number of outputs to the number of inputs * and creates missing outputs objects. * \warning any additional outputs that exist before the method is called are deleted */ void CreateOutputsForAllInputs(); ToFImageWriter::Pointer m_ToFImageWriter; ///< image writer used for streaming input data to file bool m_RecordingStarted; ///< flag indicating if filter is currently recording + std::string m_FileExtension; }; } //END mitk namespace #endif