void mitk::Image::SetGeometry(Geometry3D* aGeometry3D)
{
// Please be aware of the 0.5 offset/pixel-center issue! See Geometry documentation for further information
if(aGeometry3D->GetImageGeometry()==false)
{
MITK_INFO << "WARNING: Applied a non-image geometry onto an image. Please be SURE that this geometry is pixel-center-based! If it is not, you need to call Geometry3D->ChangeImageGeometryConsideringOriginOffset(true) before calling image->setGeometry(..)\n";
}
Superclass::SetGeometry(aGeometry3D);
for (TimeStepType step = 0; step < GetTimeGeometry()->CountTimeSteps(); ++step)
GetTimeGeometry()->GetGeometryForTimeStep(step)->ImageGeometryOn();
}
void mitk::BoundingObject::FitGeometry(mitk::Geometry3D* aGeometry3D)
{
// Adjusted this function to fix
// BUG 6951 - Image Cropper - Bounding Box is strange
// Still, the behavior of the BoundingObject is really strange.
// One would think that writing "setGeometry(aGeometry3D)" here would do the job.
// But apparently the boundingObject can only be handled correctly, when it's
// indexBounds are from -1 to 1 in all axis (so it is only 2x2x2 Pixels big) and the spacing
// specifies it's actual bounds. This behavior needs to be analyzed and maybe changed.
// Check also BUG 11406
GetGeometry()->SetIdentity();
GetGeometry()->Compose(aGeometry3D->GetIndexToWorldTransform());
// Since aGeometry (which should actually be const), is an imagegeometry and boundingObject is NOT an image,
// we have to adjust the Origin by shifting it half pixel
mitk::Point3D myOrigin = aGeometry3D->GetCenter();
myOrigin[0] -= (aGeometry3D->GetSpacing()[0] / 2.0);
myOrigin[1] -= (aGeometry3D->GetSpacing()[1] / 2.0);
myOrigin[2] -= (aGeometry3D->GetSpacing()[2] / 2.0);
GetGeometry()->SetOrigin(myOrigin);
mitk::Vector3D size;
for(unsigned int i=0; i < 3; ++i)
size[i] = (aGeometry3D->GetExtentInMM(i)/2.0);
GetGeometry()->SetSpacing( size );
GetTimeGeometry()->Update();
}
bool mitk::SlicedData::VerifyRequestedRegion()
{
if(GetTimeGeometry() == NULL) return false;
unsigned int i;
// Is the requested region within the LargestPossibleRegion?
// Note that the test is indeed against the largest possible region
// rather than the buffered region; see DataObject::VerifyRequestedRegion.
const IndexType &requestedRegionIndex = m_RequestedRegion.GetIndex();
const IndexType &largestPossibleRegionIndex
= GetLargestPossibleRegion().GetIndex();
const SizeType& requestedRegionSize = m_RequestedRegion.GetSize();
const SizeType& largestPossibleRegionSize
= GetLargestPossibleRegion().GetSize();
for (i=0; i< RegionDimension; ++i)
{
if ( (requestedRegionIndex[i] < largestPossibleRegionIndex[i]) ||
((requestedRegionIndex[i] + static_cast<long>(requestedRegionSize[i]))
> (largestPossibleRegionIndex[i]+static_cast<long>(largestPossibleRegionSize[i]))))
{
return false;
}
}
return true;
}
void mitk::SlicedData::SetOrigin(const mitk::Point3D& origin)
{
TimeGeometry* timeGeometry = GetTimeGeometry();
assert(timeGeometry!=NULL);
mitk::SlicedGeometry3D* slicedGeometry;
unsigned int steps = timeGeometry->CountTimeSteps();
for(unsigned int timestep = 0; timestep < steps; ++timestep)
{
slicedGeometry = GetSlicedGeometry(timestep);
if(slicedGeometry != NULL)
{
slicedGeometry->SetOrigin(origin);
if(slicedGeometry->GetEvenlySpaced())
{
mitk::PlaneGeometry* geometry2D = slicedGeometry->GetPlaneGeometry(0);
geometry2D->SetOrigin(origin);
slicedGeometry->InitializeEvenlySpaced(geometry2D, slicedGeometry->GetSlices());
}
}
//ProportionalTimeGeometry* timeGeometry = dynamic_cast<ProportionalTimeGeometry *>(GetTimeGeometry());
//if(timeGeometry != NULL)
//{
// timeGeometry->Initialize(slicedGeometry, steps);
// break;
//}
}
}
mitk::ScalarType mitk::Cuboid::GetVolume()
{
TimeGeometry* geometry = GetTimeGeometry();
return geometry->GetExtentInWorld(0)
* geometry->GetExtentInWorld(1)
* geometry->GetExtentInWorld(2);
}
mitk::ScalarType mitk::Cylinder::GetVolume()
{
TimeGeometry* geometry = GetTimeGeometry();
return geometry->GetExtentInWorld(0) * 0.5
* geometry->GetExtentInWorld(2) * 0.5
* vnl_math::pi
* geometry->GetExtentInWorld(1);
}
mitk::BoundingObject::BoundingObject()
: Surface(), m_Positive(true)
{
// Initialize(1);
/* bounding box around the unscaled bounding object */
ScalarType bounds[6]={-1,1,-1,1,-1,1}; //{xmin,x_max, ymin,y_max,zmin,z_max}
GetGeometry()->SetBounds(bounds);
GetTimeGeometry()->Update();
}
void mitk::UnstructuredGrid::CalculateBoundingBox()
{
//
// first make sure, that the associated time sliced geometry has
// the same number of geometry 3d's as vtkUnstructuredGrids are present
//
TimeGeometry* timeGeometry = GetTimeGeometry();
if ( timeGeometry->CountTimeSteps() != m_GridSeries.size() )
{
itkExceptionMacro(<<"timeGeometry->CountTimeSteps() != m_GridSeries.size() -- use Initialize(timeSteps) with correct number of timeSteps!");
}
void mitk::UnstructuredGrid::UpdateOutputInformation()
{
if ( this->GetSource() )
{
this->GetSource()->UpdateOutputInformation();
}
if ( ( m_CalculateBoundingBox ) && ( m_GridSeries.size() > 0 ) )
CalculateBoundingBox();
else
GetTimeGeometry()->Update();
}
void mitk::PointSet::UpdateOutputInformation()
{
if ( this->GetSource( ) )
{
this->GetSource( )->UpdateOutputInformation( );
}
//
// first make sure, that the associated time sliced geometry has
// the same number of geometry 3d's as PointSets are present
//
TimeGeometry* timeGeometry = GetTimeGeometry();
if ( timeGeometry->CountTimeSteps() != m_PointSetSeries.size() )
{
itkExceptionMacro(<<"timeGeometry->CountTimeSteps() != m_PointSetSeries.size() -- use Initialize(timeSteps) with correct number of timeSteps!");
}
void mitk::SlicedData::SetSpacing(mitk::Vector3D aSpacing)
{
TimeGeometry *timeGeometry = GetTimeGeometry();
assert(timeGeometry != nullptr);
unsigned int steps = timeGeometry->CountTimeSteps();
for (unsigned int timestep = 0; timestep < steps; ++timestep)
{
mitk::SlicedGeometry3D *slicedGeometry = GetSlicedGeometry(timestep);
if (slicedGeometry != nullptr)
{
slicedGeometry->SetSpacing(aSpacing);
}
}
timeGeometry->Update();
}
void QmitkSemanticRelationsView::OpenInEditor(const mitk::DataNode* dataNode)
{
auto renderWindowPart = GetRenderWindowPart();
if (nullptr == renderWindowPart)
{
renderWindowPart = GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategy::BRING_TO_FRONT | mitk::WorkbenchUtil::IRenderWindowPartStrategy::OPEN);
if (nullptr == renderWindowPart)
{
// no render window available
return;
}
}
auto image = dynamic_cast<mitk::Image*>(dataNode->GetData());
if (nullptr != image)
{
mitk::RenderingManager::GetInstance()->InitializeViews(image->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
}
}
void QmitkSemanticRelationsView::JumpToPosition(const mitk::DataNode* dataNode)
{
if (nullptr == dataNode)
{
return;
}
mitk::LabelSetImage* labelSetImage = dynamic_cast<mitk::LabelSetImage*>(dataNode->GetData());
if (nullptr == labelSetImage)
{
return;
}
unsigned int activeLayer = labelSetImage->GetActiveLayer();
mitk::Label* activeLabel = labelSetImage->GetActiveLabel(activeLayer);
labelSetImage->UpdateCenterOfMass(activeLabel->GetValue(), activeLayer);
const mitk::Point3D& centerPosition = activeLabel->GetCenterOfMassCoordinates();
if (centerPosition.GetVnlVector().max_value() > 0.0)
{
auto renderWindowPart = GetRenderWindowPart();
if (nullptr == renderWindowPart)
{
renderWindowPart = GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategy::BRING_TO_FRONT | mitk::WorkbenchUtil::IRenderWindowPartStrategy::OPEN);
if (nullptr == renderWindowPart)
{
// no render window available
return;
}
}
auto segmentation = dynamic_cast<mitk::LabelSetImage*>(dataNode->GetData());
if (nullptr != segmentation)
{
renderWindowPart->SetSelectedPosition(centerPosition);
mitk::RenderingManager::GetInstance()->InitializeViews(segmentation->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
}
}
}
void mitk::ContourModelSet::UpdateOutputInformation()
{
if ( this->GetSource() )
{
this->GetSource()->UpdateOutputInformation();
}
if(this->m_UpdateBoundingBox)
{
//update the bounds of the geometry according to the stored vertices
mitk::ScalarType mitkBounds[6];
//calculate the boundingbox at each timestep
typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBoxType;
typedef BoundingBoxType::PointsContainer PointsContainer;
int timesteps = this->GetTimeSteps();
//iterate over the timesteps
for(int currenTimeStep = 0; currenTimeStep < timesteps; currenTimeStep++)
{
//only update bounds if the contour was modified
if (this->GetMTime() > this->GetGeometry(currenTimeStep)->GetBoundingBox()->GetMTime())
{
mitkBounds[0] = 0.0;
mitkBounds[1] = 0.0;
mitkBounds[2] = 0.0;
mitkBounds[3] = 0.0;
mitkBounds[4] = 0.0;
mitkBounds[5] = 0.0;
BoundingBoxType::Pointer boundingBox = BoundingBoxType::New();
PointsContainer::Pointer points = PointsContainer::New();
mitk::ContourModelSet::ContourModelSetIterator contoursIt = this->Begin();
mitk::ContourModelSet::ContourModelSetIterator contoursEnd = this->End();
while(contoursIt!=contoursEnd)
{
mitk::ContourModel::VertexIterator it = contoursIt->GetPointer()->Begin(currenTimeStep);
mitk::ContourModel::VertexIterator end = contoursIt->GetPointer()->End(currenTimeStep);
//fill the boundingbox with the points
while(it != end)
{
Point3D currentP = (*it)->Coordinates;
BoundingBoxType::PointType p;
p.CastFrom(currentP);
points->InsertElement(points->Size(), p);
it++;
}
++contoursIt;
}
//construct the new boundingBox
boundingBox->SetPoints(points);
boundingBox->ComputeBoundingBox();
BoundingBoxType::BoundsArrayType tmp = boundingBox->GetBounds();
mitkBounds[0] = tmp[0];
mitkBounds[1] = tmp[1];
mitkBounds[2] = tmp[2];
mitkBounds[3] = tmp[3];
mitkBounds[4] = tmp[4];
mitkBounds[5] = tmp[5];
//set boundingBox at current timestep
Geometry3D* geometry3d = this->GetGeometry(currenTimeStep);
geometry3d->SetBounds(mitkBounds);
}
}
this->m_UpdateBoundingBox = false;
}
GetTimeGeometry()->Update();
}
//const mitk::PlaneGeometry* mitk::SlicedData::GetPlaneGeometry(int s, int t) const
//{
// const_cast<SlicedData*>(this)->SetRequestedRegionToLargestPossibleRegion();
//
// const_cast<SlicedData*>(this)->UpdateOutputInformation();
//
// return GetSlicedGeometry(t)->GetPlaneGeometry(s);
//}
//
mitk::SlicedGeometry3D* mitk::SlicedData::GetSlicedGeometry(unsigned int t) const
{
if (GetTimeGeometry() == NULL)
return NULL;
return dynamic_cast<SlicedGeometry3D*>(GetTimeGeometry()->GetGeometryForTimeStep(t).GetPointer());
}
void mitk::ContourModel::UpdateOutputInformation()
{
if ( this->GetSource() )
{
this->GetSource()->UpdateOutputInformation();
}
if(this->m_UpdateBoundingBox)
{
//update the bounds of the geometry according to the stored vertices
ScalarType mitkBounds[6];
//calculate the boundingbox at each timestep
typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBoxType;
typedef BoundingBoxType::PointsContainer PointsContainer;
int timesteps = this->GetTimeSteps();
//iterate over the timesteps
for(int currenTimeStep = 0; currenTimeStep < timesteps; currenTimeStep++)
{
if( dynamic_cast< mitk::PlaneGeometry* >(this->GetGeometry(currenTimeStep)) )
{
//do not update bounds for 2D geometries, as they are unfortunately defined with min bounds 0!
return;
}
else
{//we have a 3D geometry -> let's update bounds
//only update bounds if the contour was modified
if (this->GetMTime() > this->GetGeometry(currenTimeStep)->GetBoundingBox()->GetMTime())
{
mitkBounds[0] = 0.0;
mitkBounds[1] = 0.0;
mitkBounds[2] = 0.0;
mitkBounds[3] = 0.0;
mitkBounds[4] = 0.0;
mitkBounds[5] = 0.0;
BoundingBoxType::Pointer boundingBox = BoundingBoxType::New();
PointsContainer::Pointer points = PointsContainer::New();
VertexIterator it = this->IteratorBegin(currenTimeStep);
VertexIterator end = this->IteratorEnd(currenTimeStep);
//fill the boundingbox with the points
while(it != end)
{
Point3D currentP = (*it)->Coordinates;
BoundingBoxType::PointType p;
p.CastFrom(currentP);
points->InsertElement(points->Size(), p);
it++;
}
//construct the new boundingBox
boundingBox->SetPoints(points);
boundingBox->ComputeBoundingBox();
BoundingBoxType::BoundsArrayType tmp = boundingBox->GetBounds();
mitkBounds[0] = tmp[0];
mitkBounds[1] = tmp[1];
mitkBounds[2] = tmp[2];
mitkBounds[3] = tmp[3];
mitkBounds[4] = tmp[4];
mitkBounds[5] = tmp[5];
//set boundingBox at current timestep
Geometry3D* geometry3d = this->GetGeometry(currenTimeStep);
geometry3d->SetBounds(mitkBounds);
}
}
}
this->m_UpdateBoundingBox = false;
}
GetTimeGeometry()->Update();
}
void Run(berry::IWorkbenchPartSite::Pointer workbenchPartSite, mitk::DataStorage::Pointer dataStorage, const QList<mitk::DataNode::Pointer>& selectedNodes /*= QList<mitk::DataNode::Pointer>()*/, mitk::BaseRenderer* baseRenderer /*= nullptr*/)
{
if (selectedNodes.empty())
{
return;
}
auto renderWindow = mitk::WorkbenchUtil::GetRenderWindowPart(workbenchPartSite->GetPage(), mitk::WorkbenchUtil::NONE);
if (nullptr == renderWindow)
{
renderWindow = mitk::WorkbenchUtil::OpenRenderWindowPart(workbenchPartSite->GetPage(), false);
if (nullptr == renderWindow)
{
// no render window available
return;
}
}
auto boundingBoxPredicate = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false), baseRenderer));
mitk::DataStorage::SetOfObjects::Pointer nodes = mitk::DataStorage::SetOfObjects::New();
for (const auto& dataNode : selectedNodes)
{
if (boundingBoxPredicate->CheckNode(dataNode))
{
nodes->InsertElement(nodes->Size(), dataNode);
}
}
if (nodes->empty())
{
return;
}
if (1 == nodes->Size()) // Special case: If exactly one ...
{
auto image = dynamic_cast<mitk::Image*>(nodes->ElementAt(0)->GetData());
if (nullptr != image) // ... image is selected, reinit is expected to rectify askew images.
{
if (nullptr == baseRenderer)
{
mitk::RenderingManager::GetInstance()->InitializeViews(image->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
}
else
{
mitk::RenderingManager::GetInstance()->InitializeView(baseRenderer->GetRenderWindow(), image->GetTimeGeometry(), true);
}
return;
}
}
auto boundingGeometry = dataStorage->ComputeBoundingGeometry3D(nodes, "visible", baseRenderer);
if (nullptr == baseRenderer)
{
mitk::RenderingManager::GetInstance()->InitializeViews(boundingGeometry);
}
else
{
mitk::RenderingManager::GetInstance()->InitializeView(baseRenderer->GetRenderWindow(), boundingGeometry);
}
}
