void mitk::Image::Initialize(vtkImageData* vtkimagedata, int channels, int tDim, int sDim, int pDim)
{
if(vtkimagedata==nullptr) return;
m_Dimension=vtkimagedata->GetDataDimension();
unsigned int i, *tmpDimensions=new unsigned int[m_Dimension>4?m_Dimension:4];
for(i=0;i<m_Dimension;++i) tmpDimensions[i]=vtkimagedata->GetDimensions()[i];
if(m_Dimension<4)
{
unsigned int *p;
for(i=0,p=tmpDimensions+m_Dimension;i<4-m_Dimension;++i, ++p)
*p=1;
}
if(pDim>=0)
{
tmpDimensions[1]=pDim;
if(m_Dimension < 2)
m_Dimension = 2;
}
if(sDim>=0)
{
tmpDimensions[2]=sDim;
if(m_Dimension < 3)
m_Dimension = 3;
}
if(tDim>=0)
{
tmpDimensions[3]=tDim;
if(m_Dimension < 4)
m_Dimension = 4;
}
mitk::PixelType pixelType(MakePixelType(vtkimagedata));
Initialize(pixelType, m_Dimension, tmpDimensions, channels);
const double *spacinglist = vtkimagedata->GetSpacing();
Vector3D spacing;
FillVector3D(spacing, spacinglist[0], 1.0, 1.0);
if(m_Dimension>=2)
spacing[1]=spacinglist[1];
if(m_Dimension>=3)
spacing[2]=spacinglist[2];
// access origin of vtkImage
Point3D origin;
double vtkorigin[3];
vtkimagedata->GetOrigin(vtkorigin);
FillVector3D(origin, vtkorigin[0], 0.0, 0.0);
if(m_Dimension>=2)
origin[1]=vtkorigin[1];
if(m_Dimension>=3)
origin[2]=vtkorigin[2];
SlicedGeometry3D* slicedGeometry = GetSlicedGeometry(0);
// re-initialize PlaneGeometry with origin and direction
PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(slicedGeometry->GetPlaneGeometry(0));
planeGeometry->SetOrigin(origin);
// re-initialize SlicedGeometry3D
slicedGeometry->SetOrigin(origin);
slicedGeometry->SetSpacing(spacing);
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
SetTimeGeometry(timeGeometry);
delete [] tmpDimensions;
}
void SliceNavigationController::SelectSliceByPoint(const Point3D &point)
{
if (m_CreatedWorldGeometry.IsNull())
{
return;
}
//@todo add time to PositionEvent and use here!!
SlicedGeometry3D *slicedWorldGeometry = dynamic_cast<SlicedGeometry3D *>(
m_CreatedWorldGeometry->GetGeometryForTimeStep(this->GetTime()->GetPos()).GetPointer());
if (slicedWorldGeometry)
{
int bestSlice = -1;
double bestDistance = itk::NumericTraits<double>::max();
int s, slices;
slices = slicedWorldGeometry->GetSlices();
if (slicedWorldGeometry->GetEvenlySpaced())
{
mitk::PlaneGeometry *plane = slicedWorldGeometry->GetPlaneGeometry(0);
const Vector3D &direction = slicedWorldGeometry->GetDirectionVector();
Point3D projectedPoint;
plane->Project(point, projectedPoint);
// Check whether the point is somewhere within the slice stack volume;
// otherwise, the default slice (0) will be selected
if (direction[0] * (point[0] - projectedPoint[0]) + direction[1] * (point[1] - projectedPoint[1]) +
direction[2] * (point[2] - projectedPoint[2]) >=
0)
{
bestSlice = (int)(plane->Distance(point) / slicedWorldGeometry->GetSpacing()[2] + 0.5);
}
}
else
{
Point3D projectedPoint;
for (s = 0; s < slices; ++s)
{
slicedWorldGeometry->GetPlaneGeometry(s)->Project(point, projectedPoint);
const Vector3D distance = projectedPoint - point;
ScalarType currentDistance = distance.GetSquaredNorm();
if (currentDistance < bestDistance)
{
bestDistance = currentDistance;
bestSlice = s;
}
}
}
if (bestSlice >= 0)
{
this->GetSlice()->SetPos(bestSlice);
}
else
{
this->GetSlice()->SetPos(0);
}
this->SendCreatedWorldGeometryUpdate();
}
}
void mitk::Image::Initialize(vtkImageData* vtkimagedata, int channels, int tDim, int sDim, int pDim)
{
if(vtkimagedata==NULL) return;
m_Dimension=vtkimagedata->GetDataDimension();
unsigned int i, *tmpDimensions=new unsigned int[m_Dimension>4?m_Dimension:4];
for(i=0;i<m_Dimension;++i) tmpDimensions[i]=vtkimagedata->GetDimensions()[i];
if(m_Dimension<4)
{
unsigned int *p;
for(i=0,p=tmpDimensions+m_Dimension;i<4-m_Dimension;++i, ++p)
*p=1;
}
if(pDim>=0)
{
tmpDimensions[1]=pDim;
if(m_Dimension < 2)
m_Dimension = 2;
}
if(sDim>=0)
{
tmpDimensions[2]=sDim;
if(m_Dimension < 3)
m_Dimension = 3;
}
if(tDim>=0)
{
tmpDimensions[3]=tDim;
if(m_Dimension < 4)
m_Dimension = 4;
}
switch ( vtkimagedata->GetScalarType() )
{
case VTK_BIT:
case VTK_CHAR:
//pixelType.Initialize(typeid(char), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<char>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_UNSIGNED_CHAR:
//pixelType.Initialize(typeid(unsigned char), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<unsigned char>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_SHORT:
//pixelType.Initialize(typeid(short), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<short>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_UNSIGNED_SHORT:
//pixelType.Initialize(typeid(unsigned short), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<unsigned short>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_INT:
//pixelType.Initialize(typeid(int), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<int>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_UNSIGNED_INT:
//pixelType.Initialize(typeid(unsigned int), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<unsigned int>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_LONG:
//pixelType.Initialize(typeid(long), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<long>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_UNSIGNED_LONG:
//pixelType.Initialize(typeid(unsigned long), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<unsigned long>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_FLOAT:
//pixelType.Initialize(typeid(float), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<float>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_DOUBLE:
//pixelType.Initialize(typeid(double), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<double>(), m_Dimension, tmpDimensions, channels);
break;
default:
break;
}
/*
Initialize(pixelType,
m_Dimension,
tmpDimensions,
channels);
*/
const double *spacinglist = vtkimagedata->GetSpacing();
Vector3D spacing;
FillVector3D(spacing, spacinglist[0], 1.0, 1.0);
if(m_Dimension>=2)
spacing[1]=spacinglist[1];
if(m_Dimension>=3)
spacing[2]=spacinglist[2];
// access origin of vtkImage
Point3D origin;
double vtkorigin[3];
vtkimagedata->GetOrigin(vtkorigin);
FillVector3D(origin, vtkorigin[0], 0.0, 0.0);
if(m_Dimension>=2)
origin[1]=vtkorigin[1];
if(m_Dimension>=3)
origin[2]=vtkorigin[2];
SlicedGeometry3D* slicedGeometry = GetSlicedGeometry(0);
// re-initialize PlaneGeometry with origin and direction
PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(slicedGeometry->GetPlaneGeometry(0));
planeGeometry->SetOrigin(origin);
// re-initialize SlicedGeometry3D
slicedGeometry->SetOrigin(origin);
slicedGeometry->SetSpacing(spacing);
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
SetTimeGeometry(timeGeometry);
delete [] tmpDimensions;
}