void mitk::ContourModelWriter::Write()
{
std::ostream* out;
std::ofstream outStream;
if( this->GetOutputStream() )
{
out = this->GetOutputStream();
}
else
{
outStream.open( this->GetOutputLocation().c_str() );
out = &outStream;
}
if ( !out->good() )
{
mitkThrow() << "Stream not good.";
}
std::locale previousLocale(out->getloc());
std::locale I("C");
out->imbue(I);
/*+++++++++++ Here the actual xml writing begins +++++++++*/
/*++++ <?xml version="1.0" encoding="utf-8"?> ++++*/
WriteXMLHeader( *out );
//
// for each input object write its xml representation to
// the stream
//
mitk::ContourModel::ConstPointer contourModel = dynamic_cast<const mitk::ContourModel*>(this->GetInput());
assert( contourModel.IsNotNull() );
WriteXML( contourModel.GetPointer(), *out );
out->imbue(previousLocale);
if ( !out->good() ) // some error during output
{
throw std::ios_base::failure("Some error during contour writing.");
}
}
mitk::DataNode::Pointer
mitk::generateRegistrationResultNode(const std::string& nodeName, mitk::MAPRegistrationWrapper::Pointer resultReg, const std::string& algorithmUID, const std::string& movingNodeUID, const std::string& targetNodeUID)
{
if (resultReg.IsNull())
{
mitkThrow() << "Cannot generate registration result node. Passed registration wrapper points to NULL.";
}
mitk::DataNode::Pointer m_spRegNode = mitk::DataNode::New();
m_spRegNode->SetData(resultReg);
m_spRegNode->SetName(nodeName);
resultReg->SetProperty(mitk::Prop_RegAlgUsed, mitk::StringProperty::New(algorithmUID));
resultReg->SetProperty(mitk::Prop_RegAlgMovingData, mitk::StringProperty::New(movingNodeUID));
resultReg->SetProperty(mitk::Prop_RegAlgTargetData, mitk::StringProperty::New(targetNodeUID));
resultReg->SetProperty(mitk::Prop_RegUID, mitk::StringProperty::New(resultReg->GetRegistration()->getRegistrationUID()));
return m_spRegNode;
};
mitk::NodeUIDType mitk::EnsureUID(mitk::DataNode* node)
{
if (!node)
{
mitkThrow() << "Cannot ensure node UID. Passed node pointer is nullptr.";
}
std::string propUID = "";
if (!node->GetStringProperty(mitk::nodeProp_UID,propUID))
{
mitk::UIDGenerator generator;
propUID = generator.GetUID();
node->SetStringProperty(mitk::nodeProp_UID,propUID.c_str());
}
return propUID;
};
void mitk::SurfaceToSurfaceFilter::CreateOutputForInput(unsigned int idx)
{
if (this->GetNumberOfIndexedInputs() < idx || this->GetInput(idx) == NULL)
{
mitkThrow() << "Error creating output for input [" <<idx<< "]. Input does not exists!";
}
if (this->GetNumberOfIndexedOutputs() <= idx)
this->SetNumberOfIndexedOutputs( idx+1 );
if (this->GetOutput(idx) == NULL)
{
DataObjectPointer newOutput = this->MakeOutput(idx);
this->SetNthOutput(idx, newOutput);
}
this->GetOutput( idx )->Graft( this->GetInput( idx) );
this->Modified();
}
bool mitk::USCombinedModality::OnConnection()
{
if (m_UltrasoundDevice.IsNull())
{
MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
mitkThrow() << "UltrasoundDevice must not be null.";
}
// connect ultrasound device only if it is not already connected
if ( m_UltrasoundDevice->GetDeviceState() >= mitk::USDevice::State_Connected )
{
return true;
}
else
{
return m_UltrasoundDevice->Connect();
}
}
void mitk::LevelWindowManager::DataStorageRemovedNode( const mitk::DataNode* removedNode )
{
//first: check if deleted node is part of relevant nodes. If not, abort method because there is no need change anything.
if ((this->GetRelevantNodes()->size() == 0)) return;
bool removedNodeIsRelevant = false;
/* Iterator code: is crashing, don't know why... so using for loop
for (mitk::DataStorage::SetOfObjects::ConstIterator it = this->GetRelevantNodes()->Begin();
it != this->GetRelevantNodes()->End();
++it)
{if (it->Value() == removedNode) {removedNodeIsRelevant=true;}}*/
for (unsigned int i=0; i<this->GetRelevantNodes()->size(); i++)
{
if (this->GetRelevantNodes()->at(i) == removedNode) {removedNodeIsRelevant=true;}
}
if (!removedNodeIsRelevant) return;
//remember node which will be removed
m_NodeMarkedToDelete = removedNode;
//update observers
UpdateObservers();
/* search image than belongs to the property */
if (m_LevelWindowProperty.IsNull())
{
SetAutoTopMostImage(true, removedNode);
}
else
{
mitk::NodePredicateProperty::Pointer p2 = mitk::NodePredicateProperty::New("levelwindow", m_LevelWindowProperty);
mitk::DataNode* n = m_DataStorage->GetNode(p2);
if (n == NULL || m_AutoTopMost) // if node was deleted, change our behaviour to AutoTopMost, if AutoTopMost is true change level window to topmost node
{
SetAutoTopMostImage(true, removedNode);
}
}
//reset variable
m_NodeMarkedToDelete = NULL;
//check if everything is still ok
if ((m_PropObserverToNode.size() != m_PropObserverToNode2.size()) || (m_PropObserverToNode2.size() != (this->GetRelevantNodes()->size()-1)))
{mitkThrow() << "Wrong number of observers in Level Window Manager!";}
}
ItkImageIO::ItkImageIO(const CustomMimeType& mimeType, itk::ImageIOBase::Pointer imageIO, int rank)
: AbstractFileIO(Image::GetStaticNameOfClass(), mimeType, std::string("ITK ") + imageIO->GetNameOfClass())
, m_ImageIO(imageIO)
{
if (m_ImageIO.IsNull() )
{
mitkThrow() << "ITK ImageIOBase argument must not be NULL";
}
this->AbstractFileReader::SetMimeTypePrefix(IOMimeTypes::DEFAULT_BASE_NAME() + ".image.");
if (rank)
{
this->AbstractFileReader::SetRanking(rank);
this->AbstractFileWriter::SetRanking(rank);
}
this->RegisterService();
}
bool mitk::USCombinedModality::OnDeactivation()
{
if ( m_UltrasoundDevice.IsNull() )
{
MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
mitkThrow() << "UltrasoundDevice must not be null.";
}
mitk::TrackingDeviceSource::Pointer trackingDeviceSource = dynamic_cast<mitk::TrackingDeviceSource*>(m_TrackingDevice.GetPointer());
if ( trackingDeviceSource.IsNull() )
{
MITK_WARN("USCombinedModality")("USDevice") << "Cannot stop tracking as TrackingDeviceSource is null.";
}
trackingDeviceSource->StopTracking();
m_UltrasoundDevice->Deactivate();
return m_UltrasoundDevice->GetIsConnected();
}
void QmitkUSNavigationStepMarkerIntervention::OnUpdate()
{
// get navigation data source and make sure that it is not null
mitk::NavigationDataSource::Pointer navigationDataSource = this->GetCombinedModality()->GetNavigationDataSource();
if (navigationDataSource.IsNull())
{
MITK_ERROR("QmitkUSAbstractNavigationStep")
("QmitkUSNavigationStepMarkerIntervention") << "Navigation Data Source of Combined Modality must not be null.";
mitkThrow() << "Navigation Data Source of Combined Modality must not be null.";
}
ui->riskStructuresRangeWidget->UpdateDistancesToNeedlePosition(navigationDataSource->GetOutput(m_NeedleSensorIndex));
this->UpdateBodyMarkerStatus(navigationDataSource->GetOutput(m_ReferenceSensorIndex));
this->UpdateTargetColors();
this->UpdateTargetScore();
this->UpdateTargetViolationStatus();
}
std::vector<mitk::IFileWriter *> mitk::FileWriterRegistry::GetWriters(const mitk::BaseData *baseData,
const std::string &mimeType,
us::ModuleContext *context)
{
if (baseData == nullptr)
{
mitkThrow() << "FileWriterRegistry::GetReferences was called with null basedata.";
std::vector<mitk::IFileWriter *> emptyResult;
return emptyResult;
}
if (context == nullptr)
context = us::GetModuleContext();
std::vector<mitk::IFileWriter *> result;
std::vector<us::ServiceReference<IFileWriter>> refs;
if (mimeType.empty())
{
refs = GetReferences(baseData, context);
}
else
{
refs = GetReferences(baseData, mimeType, context);
}
std::sort(refs.begin(), refs.end());
result.reserve(refs.size());
// Translate List of ServiceRefs to List of Pointers
for (std::vector<us::ServiceReference<IFileWriter>>::const_reverse_iterator iter = refs.rbegin(), end = refs.rend();
iter != end;
++iter)
{
us::ServiceObjects<mitk::IFileWriter> serviceObjects = context->GetServiceObjects(*iter);
mitk::IFileWriter *writer = serviceObjects.GetService();
m_ServiceObjects.insert(std::make_pair(writer, serviceObjects));
result.push_back(writer);
}
return result;
}
void QmitkIGTLDeviceSourceManagementWidget::AdaptGUIToState()
{
if (this->m_IGTLDeviceSource.IsNotNull())
{
//check the state of the device
mitk::IGTLDevice::IGTLDeviceState state =
this->m_IGTLDeviceSource->GetIGTLDevice()->GetState();
switch (state) {
case mitk::IGTLDevice::Setup:
this->m_Controls->editSend->setEnabled(false);
this->m_Controls->butSend->setEnabled(false);
break;
case mitk::IGTLDevice::Ready:
this->m_Controls->editSend->setEnabled(false);
this->m_Controls->butSend->setEnabled(false);
break;
case mitk::IGTLDevice::Running:
if ( this->m_IGTLDevice->GetNumberOfConnections() == 0 )
{
//just a server can run and have 0 connections
this->m_Controls->editSend->setEnabled(false);
this->m_Controls->butSend->setEnabled(false);
}
else
{
this->m_Controls->editSend->setEnabled(true);
this->m_Controls->butSend->setEnabled(true);
}
break;
default:
mitkThrow() << "Invalid Device State";
break;
}
m_Controls->selectedSourceLabel->setText(
m_IGTLDeviceSource->GetName().c_str());
}
else
{
this->DisableSourceControls();
}
}
mitk::SemanticRelationsDataStorageAccess::DataNodeVector mitk::SemanticRelationsDataStorageAccess::GetAllSpecificSegmentations(const SemanticTypes::CaseID& caseID, const SemanticTypes::ControlPoint& controlPoint, const SemanticTypes::InformationType& informationType) const
{
if (m_DataStorage.IsExpired())
{
mitkThrow() << "Not a valid data storage.";
}
DataNodeVector allSpecificImages = GetAllSpecificImages(caseID, controlPoint, informationType);
DataNodeVector allSpecificSegmentations;
for (const auto& imageNode : allSpecificImages)
{
DataStorage::SetOfObjects::ConstPointer segmentationNodes = m_DataStorage.Lock()->GetDerivations(imageNode, NodePredicates::GetSegmentationPredicate(), false);
for (auto it = segmentationNodes->Begin(); it != segmentationNodes->End(); ++it)
{
allSpecificSegmentations.push_back(it->Value());
}
}
return allSpecificSegmentations;
}
void ImageVtkLegacyIO::Write()
{
ValidateOutputLocation();
const Image* input = dynamic_cast<const Image*>(this->GetInput());
vtkSmartPointer<vtkStructuredPointsWriter> writer = vtkSmartPointer<vtkStructuredPointsWriter>::New();
// The legacy vtk image writer cannot write to streams
LocalFile localFile(this);
writer->SetFileName(localFile.GetFileName().c_str());
ImageVtkReadAccessor vtkReadAccessor(Image::ConstPointer(input), NULL, input->GetVtkImageData());
writer->SetInputData(const_cast<vtkImageData*>(vtkReadAccessor.GetVtkImageData()));
if (writer->Write() == 0 || writer->GetErrorCode() != 0 )
{
mitkThrow() << "vtkStructuredPointesWriter error: " << vtkErrorCode::GetStringFromErrorCode(writer->GetErrorCode());
}
}
void mitk::USCombinedModality::OnFreeze(bool freeze)
{
if (m_UltrasoundDevice.IsNull())
{
MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
mitkThrow() << "UltrasoundDevice must not be null.";
}
m_UltrasoundDevice->SetIsFreezed(freeze);
mitk::TrackingDeviceSource::Pointer trackingDeviceSource = dynamic_cast<mitk::TrackingDeviceSource*>(m_TrackingDevice.GetPointer());
if ( trackingDeviceSource.IsNull() )
{
MITK_WARN("USCombinedModality")("USDevice") << "Cannot freeze tracking.";
}
else
{
if ( freeze ) { trackingDeviceSource->StopTracking(); }
else { trackingDeviceSource->StartTracking(); }
}
}
/** \brief Computes if there is an Overlap of the image part between this instantiation and another ImageAccessor object
* \throws mitk::Exception if memory area is incoherent (not supported yet)
*/
bool mitk::ImageAccessorBase::Overlap(const ImageAccessorBase* iAB)
{
if(m_CoherentMemory)
{
if((iAB->m_AddressBegin >= m_AddressBegin && iAB->m_AddressBegin < m_AddressEnd) ||
(iAB->m_AddressEnd > m_AddressBegin && iAB->m_AddressEnd <= m_AddressEnd))
{
return true;
}
if((m_AddressBegin >= iAB->m_AddressBegin && m_AddressBegin < iAB->m_AddressEnd) ||
(m_AddressEnd > iAB->m_AddressBegin && m_AddressEnd <= iAB->m_AddressEnd))
{
return true;
}
}
else mitkThrow() << "ImageAccessor: incoherent memory area is not supported yet";
return false;
}
mitk::PixelBasedParameterFitImageGenerator::ParameterImageMapType StoreResultImages( mitk::ModelFitFunctorBase::ParameterNamesType ¶mNames, itk::ImageSource<TImage>* source, mitk::ModelFitFunctorBase::ParameterNamesType::size_type startPos, mitk::ModelFitFunctorBase::ParameterNamesType::size_type& endPos )
{
mitk::PixelBasedParameterFitImageGenerator::ParameterImageMapType result;
for (mitk::ModelFitFunctorBase::ParameterNamesType::size_type j = 0; j < paramNames.size(); ++j)
{
if (source->GetNumberOfOutputs() < startPos+j)
{
mitkThrow() << "Error while generating fitted parameter images. Number of sources is too low and does not match expected parameter number. Output size: "<< source->GetNumberOfOutputs()<<"; number of param names: "<<paramNames.size()<<";source start pos: " << startPos;
}
mitk::Image::Pointer paramImage = mitk::Image::New();
typename TImage::ConstPointer outputImg = source->GetOutput(startPos+j);
mitk::CastToMitkImage(outputImg, paramImage);
result.insert(std::make_pair(paramNames[j],paramImage));
}
endPos = startPos + paramNames.size();
return result;
}
bool IOUtil::SaveImage(mitk::Image::Pointer image, const std::string path)
{
std::string dir = itksys::SystemTools::GetFilenamePath( path );
std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( path );
std::string extension = itksys::SystemTools::GetFilenameLastExtension( path );
std::string finalFileName = dir + "/" + baseFilename;
mitk::ImageWriter::Pointer imageWriter = mitk::ImageWriter::New();
//check if an extension is given, else use the defaul extension
if( extension == "" )
{
MITK_WARN << extension << " extension is not set. Extension set to default: " << finalFileName
<< DEFAULTIMAGEEXTENSION;
extension = DEFAULTIMAGEEXTENSION;
}
// check if extension is suitable for writing image data
if (!imageWriter->IsExtensionValid(extension))
{
MITK_WARN << extension << " extension is unknown. Extension set to default: " << finalFileName
<< DEFAULTIMAGEEXTENSION;
extension = DEFAULTIMAGEEXTENSION;
}
try
{
//write the data
imageWriter->SetInput(image);
imageWriter->SetFileName(finalFileName.c_str());
imageWriter->SetExtension(extension.c_str());
imageWriter->Write();
}
catch ( std::exception& e )
{
MITK_ERROR << " during attempt to write '" << finalFileName + extension << "' Exception says:";
MITK_ERROR << e.what();
mitkThrow() << "An exception occured during writing the file " << finalFileName << ". Exception says " << e.what();
}
return true;
}
void QmitkNavigationToolCreationAdvancedWidget::RetrieveAndInitializeDataForTooltipManipulation()
{
// we need the tooltip surface (point or stl)
emit RetrieveDataForManualToolTipManipulation();
if(m_ToolTipSurface.IsNotNull())
{
mitk::DataNode::Pointer toolTipNode = NULL;
if(m_SurfaceNodeName.empty())
{
m_SurfaceNodeName = "StandardToolTip";
}
if(!m_DataStorage->Exists(m_DataStorage->GetNamedNode(m_SurfaceNodeName)))
{
toolTipNode = mitk::DataNode::New();
toolTipNode->SetName(m_SurfaceNodeName);
toolTipNode->SetData(m_ToolTipSurface);
m_DataStorage->Add(toolTipNode);
}
else
{
toolTipNode = m_DataStorage->GetNamedNode(m_SurfaceNodeName);
toolTipNode->SetData(m_ToolTipSurface);
}
m_ManipulatedToolTip = m_ToolTipSurface->Clone();
mitk::BaseGeometry::Pointer defaultGeo = dynamic_cast<mitk::BaseGeometry*> (mitk::Geometry3D::New().GetPointer());
defaultGeo->SetIndexToWorldTransform(m_DefaultToolTip);
m_Controls->m_InteractiveTransformation->SetGeometry(m_ManipulatedToolTip->GetGeometry(),defaultGeo);
}
else
{
mitkThrow() << "No tooltip surface specified, operation aborted";
}
}
void QmitkUSNavigationStepPunctuationIntervention::OnUpdate()
{
// get navigation data source and make sure that it is not null
mitk::NavigationDataSource::Pointer navigationDataSource =
this->GetCombinedModality()->GetNavigationDataSource();
if ( navigationDataSource.IsNull() )
{
MITK_ERROR("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPunctuationIntervention")
<< "Navigation Data Source of Combined Modality must not be null.";
mitkThrow() << "Navigation Data Source of Combined Modality must not be null.";
}
// update body marker
this->UpdateBodyMarkerStatus(navigationDataSource->GetOutput(1));
// update critical structures
this->UpdateCriticalStructures(navigationDataSource->GetOutput(0),m_NeedleProjectionFilter->GetProjection());
//Update Distance to US image
mitk::Point3D point1 = m_NeedleProjectionFilter->GetProjection()->GetPoint(0);
mitk::Point3D point2 = m_NeedleProjectionFilter->GetProjection()->GetPoint(1);
double distance = point1.EuclideanDistanceTo(point2);
ui->m_DistanceToUSPlane->setText(QString::number(distance) + " mm");
}
mitk::DataNode::Pointer
mitk::generateMappedResultNode(const std::string& nodeName, mitk::BaseData::Pointer mappedData, const std::string& regUID, const std::string& inputNodeUID, const bool refinedGeometry, const std::string& interpolator)
{
if (mappedData.IsNull())
{
mitkThrow() << "Cannot generate mapping result node. Passed mapped data points to NULL.";
}
mitk::DataNode::Pointer mappedDataNode = mitk::DataNode::New();
mappedDataNode->SetData(mappedData);
mappedDataNode->SetName(nodeName);
if (!regUID.empty())
{
mappedData->SetProperty(mitk::Prop_RegUID, mitk::StringProperty::New(regUID));
}
mappedData->SetProperty(mitk::Prop_MappingInputData, mitk::StringProperty::New(inputNodeUID));
if (refinedGeometry)
{
mappedData->SetProperty(mitk::Prop_MappingInterpolator, mitk::StringProperty::New("None"));
mappedData->SetProperty(mitk::Prop_MappingRefinedGeometry, mitk::BoolProperty::New(true));
}
else
{
mitk::Image* image = dynamic_cast<mitk::Image*>(mappedData.GetPointer());
if(image)
{
mappedData->SetProperty(mitk::Prop_MappingInterpolator, mitk::StringProperty::New(interpolator));
}
else
{
mappedData->SetProperty(mitk::Prop_MappingInterpolator, mitk::StringProperty::New("None"));
mappedDataNode->SetColor(0.0, 0.0, 1.0);
}
}
return mappedDataNode;
};
void MitkImageToMitkLabelSetImage(itk::VectorImage< TPixel, VDimensions> * source, mitk::LabelSetImage::Pointer &output)
{
typedef itk::VectorImage< TPixel, VDimensions > VectorImageType;
typedef itk::Image< TPixel, VDimensions > ImageType;
typedef itk::VectorIndexSelectionCastImageFilter< VectorImageType, ImageType > VectorIndexSelectorType;
unsigned int numberOfComponents = source->GetVectorLength();
if (numberOfComponents < 1)
{
mitkThrow() << "At least one Component is required.";
}
typename VectorIndexSelectorType::Pointer vectorIndexSelector = VectorIndexSelectorType::New();
vectorIndexSelector->SetIndex(0);
vectorIndexSelector->SetInput(source);
vectorIndexSelector->Update();
mitk::Image::Pointer tempImage;
mitk::CastToMitkImage(vectorIndexSelector->GetOutput(), tempImage);
output = mitk::LabelSetImage::New();
output->InitializeByLabeledImage(tempImage);
for (unsigned int layer = 1; layer < numberOfComponents; ++layer)
{
typename VectorIndexSelectorType::Pointer vectorIndexSelectorLoop = VectorIndexSelectorType::New();
vectorIndexSelectorLoop->SetIndex(layer);
vectorIndexSelector->SetInput(source);
vectorIndexSelector->Update();
mitk::Image::Pointer loopImage;
mitk::CastToMitkImage(vectorIndexSelector->GetOutput(), loopImage);
output->AddLayer(loopImage);
}
}
std::vector<BaseData::Pointer> ImageVtkLegacyIO::Read()
{
// The legay vtk reader cannot work with input streams
const std::string fileName = this->GetLocalFileName();
vtkSmartPointer<vtkStructuredPointsReader> reader = vtkSmartPointer<vtkStructuredPointsReader>::New();
reader->SetFileName(fileName.c_str());
reader->Update();
if ( reader->GetOutput() != NULL )
{
mitk::Image::Pointer output = mitk::Image::New();
output->Initialize(reader->GetOutput());
output->SetVolume(reader->GetOutput()->GetScalarPointer());
std::vector<BaseData::Pointer> result;
result.push_back(output.GetPointer());
return result;
}
else
{
mitkThrow() << "vtkStructuredPointsReader error: " << vtkErrorCode::GetStringFromErrorCode(reader->GetErrorCode());
}
}
mitk::DataNode::Pointer QmitkUSNavigationStepPlacementPlanning::CalculatePlanningQuality(
mitk::Surface::Pointer targetSurface, mitk::PointSet::Pointer targetPoints)
{
if ( targetSurface.IsNull() )
{
mitkThrow() << "Target surface must not be null.";
}
m_PlacementQualityCalculator->SetTargetSurface(targetSurface);
m_PlacementQualityCalculator->SetTargetPoints(targetPoints);
m_PlacementQualityCalculator->Update();
mitk::DataNode::Pointer planningQualityResult = mitk::DataNode::New();
planningQualityResult->SetName("PlanningQuality");
double centersOfMassDistance = m_PlacementQualityCalculator->GetCentersOfMassDistance();
ui->centersOfMassValue->setText(QString::number(
centersOfMassDistance, 103, 2) + " mm");
planningQualityResult->SetFloatProperty("USNavigation::CentersOfMassDistance", centersOfMassDistance);
if ( m_PlannedTargetNodes.size() > 1 )
{
double meanAnglesDifference = m_PlacementQualityCalculator->GetMeanAngleDifference();
ui->angleDifferenceValue->setText(QString::number(
meanAnglesDifference, 103, 2) + QString::fromLatin1(" °"));
planningQualityResult->SetFloatProperty("USNavigation::MeanAngleDifference", meanAnglesDifference);
planningQualityResult->SetProperty("USNavigation::AngleDifferences",
mitk::GenericProperty<mitk::VnlVector>::New(m_PlacementQualityCalculator->GetAngleDifferences()));
}
else
{
ui->angleDifferenceValue->setText("not valid for one point");
}
return planningQualityResult;
}
bool IOUtil::SavePointSet(PointSet::Pointer pointset, const std::string path)
{
mitk::PointSetWriter::Pointer pointSetWriter = mitk::PointSetWriter::New();
std::string dir = itksys::SystemTools::GetFilenamePath( path );
std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( path );
std::string extension = itksys::SystemTools::GetFilenameLastExtension( path );
std::string finalFileName = dir + "/" + baseFilename;
if (extension == "") // if no extension has been entered manually into the filename
{
MITK_WARN << extension << " extension is not set. Extension set to default: " << finalFileName
<< DEFAULTPOINTSETEXTENSION;
extension = DEFAULTPOINTSETEXTENSION;
}
// check if extension is valid
if (!pointSetWriter->IsExtensionValid(extension))
{
MITK_WARN << extension << " extension is unknown. Extension set to default: " << finalFileName
<< DEFAULTPOINTSETEXTENSION;
extension = DEFAULTPOINTSETEXTENSION;
}
try
{
pointSetWriter->SetInput( pointset );
finalFileName += extension;
pointSetWriter->SetFileName( finalFileName.c_str() );
pointSetWriter->Update();
}
catch( std::exception& e )
{
MITK_ERROR << " during attempt to write '" << finalFileName << "' Exception says:";
MITK_ERROR << e.what();
mitkThrow() << "An exception occured during writing the file " << finalFileName << ". Exception says " << e.what();
}
return true;
}
int mitk::OclDataSet::TransferDataToGPU(cl_command_queue gpuComQueue)
{
cl_int clErr = 0;
// check whether an image present
if (m_Data == nullptr){
MITK_ERROR("ocl.DataSet") << "(mitk) No data present!\n";
return -1;
}
// there is a need for copy only if RAM-Data newer then GMEM data
if (m_cpuModified)
{
//check the buffer
if(m_gpuBuffer == nullptr)
{
CreateGPUBuffer();
}
if (m_gpuBuffer != nullptr)
{
clErr = clEnqueueWriteBuffer(gpuComQueue, m_gpuBuffer, CL_TRUE, 0, m_bufferSize * (size_t)m_BpE, m_Data, 0, NULL, NULL);
MITK_DEBUG << "Wrote Data to GPU Buffer Object.";
CHECK_OCL_ERR(clErr);
m_gpuModified = true;
if (clErr != CL_SUCCESS)
mitkThrow() << "openCL Error when writing Buffer";
}
else
{
MITK_ERROR << "No GPU buffer present!";
}
}
return clErr;
}
/// Save images according to file type
static void SaveImage(std::string fileName, mitk::Image* image, std::string fileType )
{
MITK_INFO << "----Save to " << fileName;
if (fileType == "dwi") // IOUtil does not handle dwi files properly Bug 15772
{
mitk::NrrdDiffusionImageWriter< short >::Pointer dwiwriter = mitk::NrrdDiffusionImageWriter< short >::New();
dwiwriter->SetInput( dynamic_cast<mitk::DiffusionImage<short>* > (image));
dwiwriter->SetFileName( fileName );
try
{
dwiwriter->Update();
}
catch( const itk::ExceptionObject& e)
{
MITK_ERROR << "Caught exception: " << e.what();
mitkThrow() << "Failed with exception from subprocess!";
}
}
else
{
mitk::IOUtil::SaveImage(image, fileName);
}
}
std::vector<itk::SmartPointer<BaseData>> SurfaceVtkLegacyIO::Read()
{
mitk::Surface::Pointer output = mitk::Surface::New();
// The legay vtk reader cannot work with input streams
const std::string fileName = this->GetLocalFileName();
vtkSmartPointer<vtkPolyDataReader> reader = vtkSmartPointer<vtkPolyDataReader>::New();
reader->SetFileName(fileName.c_str());
reader->Update();
if (reader->GetOutput() != nullptr)
{
output->SetVtkPolyData(reader->GetOutput());
}
else
{
mitkThrow() << "vtkPolyDataReader error: " << vtkErrorCode::GetStringFromErrorCode(reader->GetErrorCode());
}
std::vector<BaseData::Pointer> result;
result.push_back(output.GetPointer());
return result;
}
mitk::NodePredicateBase::ConstPointer mitk::ImageStatisticsContainerManager::GetPredicateForSources(const mitk::BaseData* image, const mitk::BaseData* mask)
{
if (!image) {
mitkThrow() << "Image is nullptr";
}
auto imageRule = mitk::StatisticsToImageRelationRule::New();
mitk::NodePredicateBase::ConstPointer predicate = imageRule->GetSourcesDetector(image);
auto maskRule = mitk::StatisticsToMaskRelationRule::New();
if (mask)
{
auto maskPredicate = maskRule->GetSourcesDetector(mask);
predicate = mitk::NodePredicateAnd::New(predicate, maskPredicate);
}
else
{
auto maskPredicate = mitk::NodePredicateNot::New(maskRule->GetConnectedSourcesDetector());
predicate = mitk::NodePredicateAnd::New(predicate, maskPredicate);
}
return predicate;
}
void SurfaceVtkLegacyIO::Write()
{
ValidateOutputLocation();
const Surface *input = dynamic_cast<const Surface *>(this->GetInput());
const unsigned int timesteps = input->GetTimeGeometry()->CountTimeSteps();
for (unsigned int t = 0; t < timesteps; ++t)
{
std::string fileName;
vtkSmartPointer<vtkPolyData> polyData = this->GetPolyData(t, fileName);
vtkSmartPointer<vtkPolyDataWriter> writer = vtkSmartPointer<vtkPolyDataWriter>::New();
writer->SetInputData(polyData);
if (us::any_cast<bool>(GetWriterOption("Save as binary file")))
{
writer->SetFileTypeToBinary();
}
// The legacy vtk poly data writer cannot write to streams
LocalFile localFile(this);
writer->SetFileName(localFile.GetFileName().c_str());
if (writer->Write() == 0 || writer->GetErrorCode() != 0)
{
mitkThrow() << "Error during surface writing"
<< (writer->GetErrorCode() ?
std::string(": ") + vtkErrorCode::GetStringFromErrorCode(writer->GetErrorCode()) :
std::string());
}
if (this->GetOutputStream() && input->GetTimeGeometry()->CountTimeSteps() > 1)
{
MITK_WARN << "Writing multiple time-steps to output streams is not supported. "
<< "Only the first time-step will be written";
break;
}
}
}
mitk::NodeUIDType mitk::EnsureUID(mitk::BaseData* data)
{
if (!data)
{
mitkThrow() << "Cannot ensure node UID. Passed node pointer is nullptr.";
}
BaseProperty::Pointer uidProp = data->GetProperty(mitk::Prop_UID);
std::string propUID = "";
if (uidProp.IsNotNull())
{
propUID = uidProp->GetValueAsString();
}
else
{
mitk::UIDGenerator generator;
propUID = generator.GetUID();
data->SetProperty(mitk::Prop_UID, mitk::StringProperty::New(propUID));
}
return propUID;
};
