示例#1
0
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.");
    }

}
示例#2
0
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;
};
示例#3
0
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!";}
}
示例#7
0
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(); }
  }
}
示例#15
0
  /** \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 &paramNames, 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;
}
示例#17
0
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");
}
示例#20
0
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;
}
示例#24
0
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;
}
示例#25
0
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;
      }
    }
  }
示例#30
0
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;
};