Base class of all vtk-based 2D-Mappers. More...
#include <mitkOdfVtkMapper2D.h>
Classes | |
| struct | OdfDisplayGeometry |
Public Types | |
| typedef OdfVtkMapper2D | Self |
| typedef VtkMapper2D | Superclass |
| typedef itk::SmartPointer< Self > | Pointer |
| typedef itk::SmartPointer < const Self > | ConstPointer |
Public Member Functions | |
| virtual const char * | GetClassName () const |
| virtual vtkProp * | GetProp (mitk::BaseRenderer *renderer) |
| virtual void | MitkRenderOverlay (mitk::BaseRenderer *renderer) |
| virtual void | MitkRenderOpaqueGeometry (mitk::BaseRenderer *renderer) |
| virtual void | MitkRenderTranslucentGeometry (mitk::BaseRenderer *renderer) |
| OdfDisplayGeometry * | MeasureDisplayedGeometry (mitk::BaseRenderer *renderer) |
| void | AdaptCameraPosition (mitk::BaseRenderer *renderer, OdfDisplayGeometry *dispGeo) |
| void | AdaptOdfScalingToImageSpacing (int index) |
| void | SetRendererLightSources (mitk::BaseRenderer *renderer) |
| void | ApplyPropertySettings () |
| virtual void | Slice (mitk::BaseRenderer *renderer, OdfDisplayGeometry *dispGeo) |
| virtual int | GetIndex (mitk::BaseRenderer *renderer) |
| virtual void | GenerateData () |
| Generate the data needed for rendering (independent of a specific renderer) | |
| virtual void | GenerateData (mitk::BaseRenderer *renderer) |
| Generate the data needed for rendering into renderer. | |
| virtual bool | IsLODEnabled (BaseRenderer *) const |
Static Public Member Functions | |
| static Pointer | New () |
| static void | SetDefaultProperties (DataNode *node, BaseRenderer *renderer=NULL, bool overwrite=false) |
| Set default values of properties used by this mapper to node. | |
Protected Member Functions | |
| OdfVtkMapper2D () | |
| virtual | ~OdfVtkMapper2D () |
Static Protected Member Functions | |
| static void | GlyphMethod (void *arg) |
Base class of all vtk-based 2D-Mappers.
Those must implement the abstract method vtkProp* GetProp().
Definition at line 47 of file mitkOdfVtkMapper2D.h.
| typedef itk::SmartPointer<const Self> mitk::OdfVtkMapper2D< TPixelType, NrOdfDirections >::ConstPointer |
Reimplemented from mitk::VtkMapper2D.
Definition at line 75 of file mitkOdfVtkMapper2D.h.
| typedef itk::SmartPointer<Self> mitk::OdfVtkMapper2D< TPixelType, NrOdfDirections >::Pointer |
Reimplemented from mitk::VtkMapper2D.
Definition at line 75 of file mitkOdfVtkMapper2D.h.
| typedef OdfVtkMapper2D mitk::OdfVtkMapper2D< TPixelType, NrOdfDirections >::Self |
Reimplemented from mitk::VtkMapper2D.
Definition at line 75 of file mitkOdfVtkMapper2D.h.
| typedef VtkMapper2D mitk::OdfVtkMapper2D< TPixelType, NrOdfDirections >::Superclass |
Reimplemented from mitk::VtkMapper2D.
Definition at line 75 of file mitkOdfVtkMapper2D.h.
| mitk::OdfVtkMapper2D< T, N >::OdfVtkMapper2D | ( | ) | [protected] |
Definition at line 134 of file mitkOdfVtkMapper2D.txx.
References itk::OrientationDistributionFunction< TComponent, NOdfDirections >::GetBaseMesh(), and vtkThickPlane::New().
{
m_VtkBased = true;
m_LastDisplayGeometry = 0;
m_PropAssemblies.push_back(vtkPropAssembly::New());
m_PropAssemblies.push_back(vtkPropAssembly::New());
m_PropAssemblies.push_back(vtkPropAssembly::New());
m_OdfsPlanes.push_back(vtkAppendPolyData::New());
m_OdfsPlanes.push_back(vtkAppendPolyData::New());
m_OdfsPlanes.push_back(vtkAppendPolyData::New());
m_OdfsPlanes[0]->AddInput(vtkPolyData::New());
m_OdfsPlanes[1]->AddInput(vtkPolyData::New());
m_OdfsPlanes[2]->AddInput(vtkPolyData::New());
m_OdfsActors.push_back(vtkActor::New());
m_OdfsActors.push_back(vtkActor::New());
m_OdfsActors.push_back(vtkActor::New());
m_OdfsActors[0]->GetProperty()->SetInterpolationToGouraud();
m_OdfsActors[1]->GetProperty()->SetInterpolationToGouraud();
m_OdfsActors[2]->GetProperty()->SetInterpolationToGouraud();
m_OdfsMappers.push_back(vtkPolyDataMapper::New());
m_OdfsMappers.push_back(vtkPolyDataMapper::New());
m_OdfsMappers.push_back(vtkPolyDataMapper::New());
vtkLookupTable *lut = vtkLookupTable::New();
//lut->SetMinimumTableValue(0,0,1,1);
//lut->SetMaximumTableValue(1,0,0,1);
//lut->SetWindow(0.1);
//lut->SetLevel(0.05); <== not recognized or reset by mapper ??
//lut->Build();
m_OdfsMappers[0]->SetLookupTable(lut);
m_OdfsMappers[1]->SetLookupTable(lut);
m_OdfsMappers[2]->SetLookupTable(lut);
m_OdfsActors[0]->SetMapper(m_OdfsMappers[0]);
m_OdfsActors[1]->SetMapper(m_OdfsMappers[1]);
m_OdfsActors[2]->SetMapper(m_OdfsMappers[2]);
m_Planes.push_back(vtkPlane::New());
m_Planes.push_back(vtkPlane::New());
m_Planes.push_back(vtkPlane::New());
m_Cutters.push_back(vtkCutter::New());
m_Cutters.push_back(vtkCutter::New());
m_Cutters.push_back(vtkCutter::New());
m_Cutters[0]->SetCutFunction( m_Planes[0] );
m_Cutters[0]->GenerateValues( 1, 0, 1 );
m_Cutters[1]->SetCutFunction( m_Planes[1] );
m_Cutters[1]->GenerateValues( 1, 0, 1 );
m_Cutters[2]->SetCutFunction( m_Planes[2] );
m_Cutters[2]->GenerateValues( 1, 0, 1 );
// Windowing the cutted planes in direction 1
m_ThickPlanes1.push_back(vtkThickPlane::New());
m_ThickPlanes1.push_back(vtkThickPlane::New());
m_ThickPlanes1.push_back(vtkThickPlane::New());
m_Clippers1.push_back(vtkClipPolyData::New());
m_Clippers1.push_back(vtkClipPolyData::New());
m_Clippers1.push_back(vtkClipPolyData::New());
m_Clippers1[0]->SetClipFunction( m_ThickPlanes1[0] );
m_Clippers1[1]->SetClipFunction( m_ThickPlanes1[1] );
m_Clippers1[2]->SetClipFunction( m_ThickPlanes1[2] );
// Windowing the cutted planes in direction 2
m_ThickPlanes2.push_back(vtkThickPlane::New());
m_ThickPlanes2.push_back(vtkThickPlane::New());
m_ThickPlanes2.push_back(vtkThickPlane::New());
m_Clippers2.push_back(vtkClipPolyData::New());
m_Clippers2.push_back(vtkClipPolyData::New());
m_Clippers2.push_back(vtkClipPolyData::New());
m_Clippers2[0]->SetClipFunction( m_ThickPlanes2[0] );
m_Clippers2[1]->SetClipFunction( m_ThickPlanes2[1] );
m_Clippers2[2]->SetClipFunction( m_ThickPlanes2[2] );
m_TemplateOdf = itk::OrientationDistributionFunction<T,N>::GetBaseMesh();
//vtkPoints* points = m_TemplateOdf->GetPoints();
m_OdfVals->Allocate(N);
m_OdfSource->SetTemplateOdf(m_TemplateOdf);
m_OdfSource->SetOdfVals(m_OdfVals);
m_ShowMaxNumber = 500;
//vtkMapper::GlobalImmediateModeRenderingOn();
}
| mitk::OdfVtkMapper2D< T, N >::~OdfVtkMapper2D | ( | ) | [protected, virtual] |
Definition at line 235 of file mitkOdfVtkMapper2D.txx.
{
m_PropAssemblies[0]->Delete();
m_PropAssemblies[1]->Delete();
m_PropAssemblies[2]->Delete();
m_OdfsPlanes[0]->Delete();
m_OdfsPlanes[1]->Delete();
m_OdfsPlanes[2]->Delete();
m_OdfsActors[0]->Delete();
m_OdfsActors[1]->Delete();
m_OdfsActors[2]->Delete();
m_OdfsMappers[0]->Delete();
m_OdfsMappers[1]->Delete();
m_OdfsMappers[2]->Delete();
m_Planes[0]->Delete();
m_Planes[1]->Delete();
m_Planes[2]->Delete();
m_Cutters[0]->Delete();
m_Cutters[1]->Delete();
m_Cutters[2]->Delete();
m_ThickPlanes1[0]->Delete();
m_ThickPlanes1[1]->Delete();
m_ThickPlanes1[2]->Delete();
m_ThickPlanes2[0]->Delete();
m_ThickPlanes2[1]->Delete();
m_ThickPlanes2[2]->Delete();
m_Clippers1[0]->Delete();
m_Clippers1[1]->Delete();
m_Clippers1[2]->Delete();
m_Clippers2[0]->Delete();
m_Clippers2[1]->Delete();
m_Clippers2[2]->Delete();
}
| void mitk::OdfVtkMapper2D< T, N >::AdaptCameraPosition | ( | mitk::BaseRenderer * | renderer, |
| OdfDisplayGeometry * | dispGeo | ||
| ) |
Definition at line 397 of file mitkOdfVtkMapper2D.txx.
References QuadProgPP::dist(), mitk::BaseRenderer::GetVtkRenderer(), and ODF_MAPPER_PI.
{
double viewAngle = renderer->GetVtkRenderer()->GetActiveCamera()->GetViewAngle();
viewAngle = viewAngle * (ODF_MAPPER_PI/180.0);
viewAngle /= 2;
double dist = dispGeo->d/tan(viewAngle);
mitk::Point3D mfoc;
mfoc[0]=dispGeo->M3D[0];
mfoc[1]=dispGeo->M3D[1];
mfoc[2]=dispGeo->M3D[2];
mitk::Point3D mpos;
mpos[0]=mfoc[0]+dist*dispGeo->normal[0];
mpos[1]=mfoc[1]+dist*dispGeo->normal[1];
mpos[2]=mfoc[2]+dist*dispGeo->normal[2];
mitk::Point3D mup;
mup[0]=dispGeo->O3D[0]-dispGeo->M3D[0];
mup[1]=dispGeo->O3D[1]-dispGeo->M3D[1];
mup[2]=dispGeo->O3D[2]-dispGeo->M3D[2];
renderer->GetVtkRenderer()->GetActiveCamera()->SetParallelProjection(true);
renderer->GetVtkRenderer()->GetActiveCamera()->SetParallelScale(dist/3.74);
vtkCamera* camera = renderer->GetVtkRenderer()->GetActiveCamera();
if (camera)
{
camera->SetPosition(mpos[0],mpos[1],mpos[2]);
camera->SetFocalPoint(mfoc[0], mfoc[1],mfoc[2]);
camera->SetViewUp(mup[0],mup[1],mup[2]);
}
renderer->GetVtkRenderer()->ResetCameraClippingRange();
}
| void mitk::OdfVtkMapper2D< T, N >::AdaptOdfScalingToImageSpacing | ( | int | index ) |
Definition at line 937 of file mitkOdfVtkMapper2D.txx.
References min.
{
// Spacing adapted scaling
double spacing[3];
m_VtkImage->GetSpacing(spacing);
double min;
if(index==0)
{
min = spacing[0];
min = min > spacing[1] ? spacing[1] : min;
}
if(index==1)
{
min = spacing[1];
min = min > spacing[2] ? spacing[2] : min;
}
if(index==2)
{
min = spacing[0];
min = min > spacing[2] ? spacing[2] : min;
}
m_OdfSource->SetScale(min);
}
| void mitk::OdfVtkMapper2D< T, N >::ApplyPropertySettings | ( | ) |
Definition at line 1004 of file mitkOdfVtkMapper2D.txx.
References mitk::OdfNormalizationMethodProperty::GetNormalization(), and mitk::OdfScaleByProperty::GetScaleBy().
{
this->GetDataNode()->GetFloatProperty( "Scaling", m_Scaling );
this->GetDataNode()->GetIntProperty( "ShowMaxNumber", m_ShowMaxNumber );
OdfNormalizationMethodProperty* nmp = dynamic_cast
<OdfNormalizationMethodProperty*>(
this->GetDataNode()->GetProperty( "Normalization" ));
if(nmp)
{
m_Normalization = nmp->GetNormalization();
}
OdfScaleByProperty* sbp = dynamic_cast
<OdfScaleByProperty*>(
this->GetDataNode()->GetProperty( "ScaleBy" ));
if(sbp)
{
m_ScaleBy = sbp->GetScaleBy();
}
this->GetDataNode()->GetFloatProperty( "IndexParam1", m_IndexParam1);
this->GetDataNode()->GetFloatProperty( "IndexParam2", m_IndexParam2);
}
| void mitk::OdfVtkMapper2D< T, N >::GenerateData | ( | mitk::BaseRenderer * | renderer ) | [virtual] |
Generate the data needed for rendering into renderer.
Reimplemented from mitk::Mapper.
Definition at line 1031 of file mitkOdfVtkMapper2D.txx.
References mitk::TimeSlicedGeometry::GetTimeSteps(), and mitk::TimeSlicedGeometry::IsValidTime().
{
if(!m_VtkImage)
{
itkWarningMacro( << "m_VtkImage is NULL!" );
return ;
}
int index = GetIndex(renderer);
if(IsVisible(renderer, "VisibleOdfs")==false)
{
m_OdfsActors[0]->VisibilityOff();
m_OdfsActors[1]->VisibilityOff();
m_OdfsActors[2]->VisibilityOff();
return;
}
else
{
m_OdfsActors[0]->VisibilityOn();
m_OdfsActors[1]->VisibilityOn();
m_OdfsActors[2]->VisibilityOn();
OdfDisplayGeometry* dispGeo =
MeasureDisplayedGeometry( renderer);
if(!m_LastDisplayGeometry || !dispGeo->Equals(m_LastDisplayGeometry))
{
AdaptOdfScalingToImageSpacing(index);
SetRendererLightSources(renderer);
ApplyPropertySettings();
AdaptCameraPosition(renderer, dispGeo);
Slice(renderer, dispGeo);
m_LastDisplayGeometry = dispGeo;
}
}
// Get the TimeSlicedGeometry of the input object
mitk::Image::Pointer input = const_cast<mitk::Image*>(this->GetInput());
const TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
if (( inputTimeGeometry == NULL ) || ( inputTimeGeometry->GetTimeSteps() == 0 ))
{
m_PropAssemblies[0]->VisibilityOff();
m_PropAssemblies[1]->VisibilityOff();
m_PropAssemblies[2]->VisibilityOff();
return;
}
if( inputTimeGeometry->IsValidTime( this->GetTimestep() ) == false )
{
m_PropAssemblies[0]->VisibilityOff();
m_PropAssemblies[1]->VisibilityOff();
m_PropAssemblies[2]->VisibilityOff();
return;
}
}
| void mitk::OdfVtkMapper2D< T, N >::GenerateData | ( | ) | [virtual] |
Generate the data needed for rendering (independent of a specific renderer)
Reimplemented from mitk::Mapper.
Definition at line 886 of file mitkOdfVtkMapper2D.txx.
Referenced by mitk::CompositeMapper::GenerateData().
{
mitk::Image::Pointer input = const_cast<mitk::Image*>( this->GetInput() );
if ( input.IsNull() ) return ;
std::string classname("TensorImage");
if(classname.compare(input->GetNameOfClass())==0)
{
m_VtkImage = dynamic_cast<mitk::TensorImage*>( this->GetInput() )->GetNonRgbVtkImageData();
}
std::string qclassname("QBallImage");
if(qclassname.compare(input->GetNameOfClass())==0)
{
m_VtkImage = dynamic_cast<mitk::QBallImage*>( this->GetInput() )->GetNonRgbVtkImageData();
}
if( m_VtkImage )
{
// make sure, that we have point data with more than 1 component (as vectors)
vtkPointData* pointData = m_VtkImage->GetPointData();
if ( pointData == NULL )
{
itkWarningMacro( << "m_VtkImage->GetPointData() returns NULL!" );
return ;
}
if ( pointData->GetNumberOfArrays() == 0 )
{
itkWarningMacro( << "m_VtkImage->GetPointData()->GetNumberOfArrays() is 0!" );
return ;
}
else if ( pointData->GetArray(0)->GetNumberOfComponents() != N
&& pointData->GetArray(0)->GetNumberOfComponents() != 6 /*for tensor visualization*/)
{
itkWarningMacro( << "number of components != number of directions in ODF!" );
return;
}
else if ( pointData->GetArrayName( 0 ) == NULL )
{
m_VtkImage->GetPointData()->GetArray(0)->SetName("vector");
}
}
else
{
itkWarningMacro( << "m_VtkImage is NULL!" );
return ;
}
}
| virtual const char* mitk::OdfVtkMapper2D< TPixelType, NrOdfDirections >::GetClassName | ( | ) | const [virtual] |
Reimplemented from mitk::VtkMapper2D.
| int mitk::OdfVtkMapper2D< T, N >::GetIndex | ( | mitk::BaseRenderer * | renderer ) | [virtual] |
Definition at line 285 of file mitkOdfVtkMapper2D.txx.
References mitk::BaseRenderer::GetName().
| vtkProp * mitk::OdfVtkMapper2D< T, N >::GetProp | ( | mitk::BaseRenderer * | renderer ) | [virtual] |
Implements mitk::VtkMapper2D.
Definition at line 278 of file mitkOdfVtkMapper2D.txx.
Referenced by mitk::CompositeMapper::GetProp().
{
return m_PropAssemblies[GetIndex(renderer)];
}
| void mitk::OdfVtkMapper2D< T, N >::GlyphMethod | ( | void * | arg ) | [static, protected] |
Definition at line 301 of file mitkOdfVtkMapper2D.txx.
References vtkMaskedProgrammableGlyphFilter::GetGeometry(), mitk::ODFN_GLOBAL_MAX, mitk::ODFN_MAX, mitk::ODFN_MINMAX, mitk::ODFN_NONE, mitk::ODFSB_GFA, mitk::ODFSB_NONE, and mitk::ODFSB_PC.
{
vtkMaskedProgrammableGlyphFilter
*pfilter=(vtkMaskedProgrammableGlyphFilter*)arg;
double point[3];
double debugpoint[3];
pfilter->GetPoint(point);
pfilter->GetPoint(debugpoint);
itk::Point<double,3> p(point);
Point3D origin = pfilter->GetGeometry()->GetOrigin();
Vector3D spacing = pfilter->GetGeometry()->GetSpacing();
p[0] += origin[0];//+spacing[0]*0.5;
p[1] += origin[1];//+spacing[1]*0.5;
p[2] += origin[2];//+spacing[2]*0.5;
mitk::Point3D p2;
pfilter->GetGeometry()->ItkPhysicalPointToWorld( p, p2 );
point[0] = p2[0];
point[1] = p2[1];
point[2] = p2[2];
vtkPointData* data = pfilter->GetPointData();
vtkDataArray* odfvals = data->GetArray("vector");
vtkIdType id = pfilter->GetPointId();
m_OdfTransform->Identity();
m_OdfTransform->Translate(point[0],point[1],point[2]);
typedef itk::OrientationDistributionFunction<float,N> OdfType;
OdfType odf;
if(odfvals->GetNumberOfComponents()==6)
{
float tensorelems[6] = {
(float)odfvals->GetComponent(id,0),
(float)odfvals->GetComponent(id,1),
(float)odfvals->GetComponent(id,2),
(float)odfvals->GetComponent(id,3),
(float)odfvals->GetComponent(id,4),
(float)odfvals->GetComponent(id,5),
};
itk::DiffusionTensor3D<float> tensor(tensorelems);
odf.InitFromTensor(tensor);
}
else
{
for(int i=0; i<N; i++)
odf[i] = (double)odfvals->GetComponent(id,i);
}
switch(m_Normalization)
{
case ODFN_MINMAX:
odf = odf.MinMaxNormalize();
break;
case ODFN_MAX:
odf = odf.MaxNormalize();
break;
case ODFN_NONE:
// nothing
break;
case ODFN_GLOBAL_MAX:
// global max not implemented yet
break;
default:
odf = odf.MinMaxNormalize();
}
switch(m_ScaleBy)
{
case ODFSB_NONE:
break;
case ODFSB_GFA:
odf = odf * odf.GetGeneralizedGFA(m_IndexParam1, m_IndexParam2);
break;
case ODFSB_PC:
odf = odf * odf.GetPrincipleCurvature(m_IndexParam1, m_IndexParam2, 0);
break;
}
for(int i=0; i<N; i++)
m_OdfVals->SetComponent(0,i,0.5*odf[i]*m_Scaling);
//double max = -100000;
//double min = 100000;
//for( unsigned int i=0; i<N; i++)
//{
// max = odf[i] > max ? odf[i] : max;
// min = odf[i] < min ? odf[i] : min;
//}
m_OdfSource->Modified();
}
| virtual bool mitk::OdfVtkMapper2D< TPixelType, NrOdfDirections >::IsLODEnabled | ( | BaseRenderer * | ) | const [inline, virtual] |
Returns true if this Mapper currently allows for Level-of-Detail rendering. This reflects whether this Mapper currently invokes StartEvent, EndEvent, and ProgressEvent on BaseRenderer.
Reimplemented from mitk::Mapper.
Definition at line 102 of file mitkOdfVtkMapper2D.h.
Referenced by mitk::CompositeMapper::IsLODEnabled().
{ return true; }
| mitk::OdfVtkMapper2D< T, N >::OdfDisplayGeometry * mitk::OdfVtkMapper2D< T, N >::MeasureDisplayedGeometry | ( | mitk::BaseRenderer * | renderer ) |
Definition at line 435 of file mitkOdfVtkMapper2D.txx.
References mitk::BaseRenderer::GetCurrentWorldGeometry2D(), mitk::BaseRenderer::GetDisplayGeometry(), mitk::Geometry3D::GetOrigin(), mitk::DisplayGeometry::GetSizeInMM(), and QuadProgPP::sqrt().
{
//vtkLinearTransform * vtktransform = this->GetDataNode()->GetVtkTransform(this->GetTimestep());
Geometry2D::ConstPointer worldGeometry =
renderer->GetCurrentWorldGeometry2D();
PlaneGeometry::ConstPointer worldPlaneGeometry =
dynamic_cast<const PlaneGeometry*>( worldGeometry.GetPointer() );
// set up the cutter orientation according to the current geometry of
// the renderers plane
vtkFloatingPointType vp[ 3 ], vnormal[ 3 ];
Point3D point = worldPlaneGeometry->GetOrigin();
Vector3D normal = worldPlaneGeometry->GetNormal(); normal.Normalize();
vnl2vtk( point.Get_vnl_vector(), vp );
vnl2vtk( normal.Get_vnl_vector(), vnormal );
mitk::DisplayGeometry::Pointer dispGeometry = renderer->GetDisplayGeometry();
mitk::Vector2D size = dispGeometry->GetSizeInMM();
mitk::Vector2D origin = dispGeometry->GetOriginInMM();
//
// |------O------|
// | d2 |
// L d1 M |
// | |
// |-------------|
//
mitk::Vector2D M;
mitk::Vector2D L;
mitk::Vector2D O;
M[0] = origin[0] + size[0]/2;
M[1] = origin[1] + size[1]/2;
L[0] = origin[0];
L[1] = origin[1] + size[1]/2;
O[0] = origin[0] + size[0]/2;
O[1] = origin[1] + size[1];
mitk::Point2D point1;
point1[0] = M[0]; point1[1] = M[1]; point1[2] = M[2];
mitk::Point3D M3D;
dispGeometry->Map(point1, M3D);
point1[0] = L[0]; point1[1] = L[1]; point1[2] = L[2];
mitk::Point3D L3D;
dispGeometry->Map(point1, L3D);
point1[0] = O[0]; point1[1] = O[1]; point1[2] = O[2];
mitk::Point3D O3D;
dispGeometry->Map(point1, O3D);
double d1 = sqrt((M3D[0]-L3D[0])*(M3D[0]-L3D[0])
+ (M3D[1]-L3D[1])*(M3D[1]-L3D[1])
+ (M3D[2]-L3D[2])*(M3D[2]-L3D[2]));
double d2 = sqrt((M3D[0]-O3D[0])*(M3D[0]-O3D[0])
+ (M3D[1]-O3D[1])*(M3D[1]-O3D[1])
+ (M3D[2]-O3D[2])*(M3D[2]-O3D[2]));
double d = d1>d2 ? d1 : d2;
d = d2;
OdfDisplayGeometry* retval = new OdfDisplayGeometry();
retval->vp[0] = vp[0];
retval->vp[1] = vp[1];
retval->vp[2] = vp[2];
retval->vnormal[0] = vnormal[0];
retval->vnormal[1] = vnormal[1];
retval->vnormal[2] = vnormal[2];
retval->normal[0] = normal[0];
retval->normal[1] = normal[1];
retval->normal[2] = normal[2];
retval->d = d;
retval->d1 = d1;
retval->d2 = d2;
retval->M3D[0] = M3D[0];
retval->M3D[1] = M3D[1];
retval->M3D[2] = M3D[2];
retval->L3D[0] = L3D[0];
retval->L3D[1] = L3D[1];
retval->L3D[2] = L3D[2];
retval->O3D[0] = O3D[0];
retval->O3D[1] = O3D[1];
retval->O3D[2] = O3D[2];
retval->vp_original[0] = vp[0];
retval->vp_original[1] = vp[1];
retval->vp_original[2] = vp[2];
retval->vnormal_original[0] = vnormal[0];
retval->vnormal_original[1] = vnormal[1];
retval->vnormal_original[2] = vnormal[2];
retval->size[0] = size[0];
retval->size[1] = size[1];
retval->origin[0] = origin[0];
retval->origin[1] = origin[1];
return retval;
}
| void mitk::OdfVtkMapper2D< T, N >::MitkRenderOpaqueGeometry | ( | mitk::BaseRenderer * | renderer ) | [virtual] |
Implements mitk::Mapper.
Definition at line 799 of file mitkOdfVtkMapper2D.txx.
References mitk::BaseRenderer::GetVtkRenderer(), GL_LIGHT0, GL_LIGHT1, GL_LIGHT2, GL_LIGHT3, GL_LIGHT4, GL_LIGHT5, GL_LIGHT6, GL_LIGHT7, GL_MODELVIEW, GL_POSITION, GL_PROJECTION, glLightfv(), glLoadIdentity(), glMatrixMode(), glPopMatrix(), and glPushMatrix().
Referenced by mitk::CompositeMapper::MitkRenderOpaqueGeometry().
{
//std::cout << "MitkRenderOpaqueGeometry(" << renderer->GetName() << ")" << std::endl;
if ( this->IsVisible( renderer, "VisibleOdfs" )==false )
return;
if ( this->GetProp(renderer)->GetVisibility() )
{
// adapt cam pos
OdfDisplayGeometry* dispGeo = MeasureDisplayedGeometry( renderer);
AdaptCameraPosition(renderer, dispGeo);
if(this->GetDataNode()->IsOn("DoRefresh",NULL))
{
glMatrixMode( GL_PROJECTION );
glPushMatrix();
glLoadIdentity();
glMatrixMode( GL_MODELVIEW );
glPushMatrix();
glLoadIdentity();
renderer->GetVtkRenderer()->SetErase(false);
renderer->GetVtkRenderer()->GetActiveCamera()->Render(renderer->GetVtkRenderer());
renderer->GetVtkRenderer()->SetErase(true);
//GLfloat matrix[16];
//glGetFloatv(GL_MODELVIEW_MATRIX, matrix);
float LightPos[4] = {0,0,0,0};
int index = GetIndex(renderer);
if(index==0)
{
LightPos[2] = -1000;
}
if(index==1)
{
LightPos[0] = 1000;
}
if(index==2)
{
LightPos[1] = -1000;
}
glLightfv(GL_LIGHT0,GL_POSITION,LightPos);
glLightfv(GL_LIGHT1,GL_POSITION,LightPos);
glLightfv(GL_LIGHT2,GL_POSITION,LightPos);
glLightfv(GL_LIGHT3,GL_POSITION,LightPos);
glLightfv(GL_LIGHT4,GL_POSITION,LightPos);
glLightfv(GL_LIGHT5,GL_POSITION,LightPos);
glLightfv(GL_LIGHT6,GL_POSITION,LightPos);
glLightfv(GL_LIGHT7,GL_POSITION,LightPos);
}
this->GetProp(renderer)->RenderOpaqueGeometry( renderer->GetVtkRenderer() );
if(this->GetDataNode()->IsOn("DoRefresh",NULL))
{
glMatrixMode( GL_PROJECTION );
glPopMatrix();
glMatrixMode( GL_MODELVIEW );
glPopMatrix();
}
}
}
| void mitk::OdfVtkMapper2D< T, N >::MitkRenderOverlay | ( | mitk::BaseRenderer * | renderer ) | [virtual] |
Implements mitk::Mapper.
Definition at line 785 of file mitkOdfVtkMapper2D.txx.
References mitk::BaseRenderer::GetVtkRenderer().
Referenced by mitk::CompositeMapper::MitkRenderOverlay().
{
//std::cout << "MitkRenderOverlay(" << renderer->GetName() << ")" << std::endl;
if ( this->IsVisible(renderer, "VisibleOdfs")==false )
return;
if ( this->GetProp(renderer)->GetVisibility() )
{
this->GetProp(renderer)->RenderOverlay(renderer->GetVtkRenderer());
}
}
| void mitk::OdfVtkMapper2D< T, N >::MitkRenderTranslucentGeometry | ( | mitk::BaseRenderer * | renderer ) | [virtual] |
Implements mitk::Mapper.
Definition at line 869 of file mitkOdfVtkMapper2D.txx.
References mitk::BaseRenderer::GetVtkRenderer().
Referenced by mitk::CompositeMapper::MitkRenderTranslucentGeometry().
{
//std::cout << "MitkRenderTranslucentGeometry(" << renderer->GetName() << ")" << std::endl;
if ( this->IsVisible(renderer, "VisibleOdfs")==false )
return;
if ( this->GetProp(renderer)->GetVisibility() )
//BUG (#1551) changed VTK_MINOR_VERSION FROM 3 to 2 cause RenderTranslucentGeometry was changed in minor version 2
#if ( ( VTK_MAJOR_VERSION >= 5 ) && ( VTK_MINOR_VERSION>=2) )
this->GetProp(renderer)->RenderTranslucentPolygonalGeometry(renderer->GetVtkRenderer());
#else
this->GetProp(renderer)->RenderTranslucentGeometry(renderer->GetVtkRenderer());
#endif
}
| static Pointer mitk::OdfVtkMapper2D< TPixelType, NrOdfDirections >::New | ( | ) | [static] |
| void mitk::OdfVtkMapper2D< T, N >::SetDefaultProperties | ( | mitk::DataNode * | node, |
| mitk::BaseRenderer * | renderer = NULL, |
||
| bool | overwrite = false |
||
| ) | [static] |
Set default values of properties used by this mapper to node.
| node | The node for which the properties are set |
| overwrite | overwrite existing properties (default: false) |
| renderer | defines which property list of node is used (default: NULL, i.e. default property list) |
Reimplemented from mitk::Mapper.
Definition at line 1092 of file mitkOdfVtkMapper2D.txx.
References mitk::BoolProperty::New(), mitk::OdfScaleByProperty::New(), mitk::OdfNormalizationMethodProperty::New(), mitk::FloatProperty::New(), mitk::IntProperty::New(), and mitk::DataNode::SetProperty().
{
node->SetProperty( "ShowMaxNumber", mitk::IntProperty::New( 150 ) );
node->SetProperty( "Scaling", mitk::FloatProperty::New( 1.0 ) );
node->SetProperty( "Normalization", mitk::OdfNormalizationMethodProperty::New());
node->SetProperty( "ScaleBy", mitk::OdfScaleByProperty::New());
node->SetProperty( "IndexParam1", mitk::FloatProperty::New(2));
node->SetProperty( "IndexParam2", mitk::FloatProperty::New(1));
node->SetProperty( "visible", mitk::BoolProperty::New( true ) );
node->SetProperty( "VisibleOdfs", mitk::BoolProperty::New( false ) );
node->SetProperty ("layer", mitk::IntProperty::New(100));
node->SetProperty( "DoRefresh", mitk::BoolProperty::New( true ) );
//node->SetProperty( "opacity", mitk::FloatProperty::New(1.0f) );
}
| void mitk::OdfVtkMapper2D< T, N >::SetRendererLightSources | ( | mitk::BaseRenderer * | renderer ) |
Definition at line 963 of file mitkOdfVtkMapper2D.txx.
References mitk::BaseRenderer::GetVtkRenderer().
{
// Light Sources
vtkCollectionSimpleIterator sit;
vtkLight* light;
for(renderer->GetVtkRenderer()->GetLights()->InitTraversal(sit);
(light = renderer->GetVtkRenderer()->GetLights()->GetNextLight(sit)); )
{
renderer->GetVtkRenderer()->RemoveLight(light);
}
light = vtkLight::New();
light->SetFocalPoint(0,0,0);
light->SetLightTypeToSceneLight();
light->SwitchOn();
light->SetIntensity(1.0);
light->PositionalOff();
itk::Point<float> p;
int index = GetIndex(renderer);
if(index==0)
{
p[0] = 0; p[1] = 0; p[2] = 10000;
}
if(index==1)
{
p[0] = 0; p[1] = 10000; p[2] = 0;
}
if(index==2)
{
p[0] = 10000; p[1] = 0; p[2] = 0;
}
mitk::Point3D p2;
this->GetInput()->GetGeometry()->IndexToWorld(p,p2);
light->SetPosition(p2[0],p2[1],p2[2]);
renderer->GetVtkRenderer()->AddLight(light);
}
| void mitk::OdfVtkMapper2D< T, N >::Slice | ( | mitk::BaseRenderer * | renderer, |
| OdfDisplayGeometry * | dispGeo | ||
| ) | [virtual] |
Definition at line 537 of file mitkOdfVtkMapper2D.txx.
References vtkMaskedProgrammableGlyphFilter::New(), vtkMaskedProgrammableGlyphFilter::SetGeometry(), vtkMaskedProgrammableGlyphFilter::SetInput(), and vtkMaskedProgrammableGlyphFilter::SetRandomMode().
{
vtkLinearTransform * vtktransform =
this->GetDataNode()->GetVtkTransform(this->GetTimestep());
int index = GetIndex(renderer);
vtkTransform* inversetransform = vtkTransform::New();
inversetransform->Identity();
inversetransform->Concatenate(vtktransform->GetLinearInverse());
double myscale[3];
((vtkTransform*)vtktransform)->GetScale(myscale);
inversetransform->PostMultiply();
inversetransform->Scale(1*myscale[0],1*myscale[1],1*myscale[2]);
inversetransform->TransformPoint( dispGeo->vp, dispGeo->vp );
inversetransform->TransformNormalAtPoint( dispGeo->vp, dispGeo->vnormal, dispGeo->vnormal );
// vtk works in axis align coords
// thus the normal also must be axis align, since
// we do not allow arbitrary cutting through volume
//
// vnormal should already be axis align, but in order
// to get rid of precision effects, we set the two smaller
// components to zero here
int dims[3];
m_VtkImage->GetDimensions(dims);
double spac[3];
m_VtkImage->GetSpacing(spac);
if(fabs(dispGeo->vnormal[0]) > fabs(dispGeo->vnormal[1])
&& fabs(dispGeo->vnormal[0]) > fabs(dispGeo->vnormal[2]) )
{
if(fabs(dispGeo->vp[0]/spac[0]) < 0.4)
dispGeo->vp[0] = 0.4*spac[0];
if(fabs(dispGeo->vp[0]/spac[0]) > (dims[0]-1)-0.4)
dispGeo->vp[0] = ((dims[0]-1)-0.4)*spac[0];
dispGeo->vnormal[1] = 0;
dispGeo->vnormal[2] = 0;
}
if(fabs(dispGeo->vnormal[1]) > fabs(dispGeo->vnormal[0]) && fabs(dispGeo->vnormal[1]) > fabs(dispGeo->vnormal[2]) )
{
if(fabs(dispGeo->vp[1]/spac[1]) < 0.4)
dispGeo->vp[1] = 0.4*spac[1];
if(fabs(dispGeo->vp[1]/spac[1]) > (dims[1]-1)-0.4)
dispGeo->vp[1] = ((dims[1]-1)-0.4)*spac[1];
dispGeo->vnormal[0] = 0;
dispGeo->vnormal[2] = 0;
}
if(fabs(dispGeo->vnormal[2]) > fabs(dispGeo->vnormal[1]) && fabs(dispGeo->vnormal[2]) > fabs(dispGeo->vnormal[0]) )
{
if(fabs(dispGeo->vp[2]/spac[2]) < 0.4)
dispGeo->vp[2] = 0.4*spac[2];
if(fabs(dispGeo->vp[2]/spac[2]) > (dims[2]-1)-0.4)
dispGeo->vp[2] = ((dims[2]-1)-0.4)*spac[2];
dispGeo->vnormal[0] = 0;
dispGeo->vnormal[1] = 0;
}
m_Planes[index]->SetTransform( (vtkAbstractTransform*)NULL );
m_Planes[index]->SetOrigin( dispGeo->vp );
m_Planes[index]->SetNormal( dispGeo->vnormal );
vtkPoints* points = NULL;
vtkPoints* tmppoints = NULL;
vtkPolyData* polydata = NULL;
vtkFloatArray* pointdata = NULL;
vtkDelaunay2D *delaunay = NULL;
vtkPolyData* cuttedPlane = NULL;
if(!( (dims[0] == 1 && dispGeo->vnormal[0] != 0) ||
(dims[1] == 1 && dispGeo->vnormal[1] != 0) ||
(dims[2] == 1 && dispGeo->vnormal[2] != 0) ))
{
m_Cutters[index]->SetCutFunction( m_Planes[index] );
m_Cutters[index]->SetInput( m_VtkImage );
m_Cutters[index]->Update();
cuttedPlane = m_Cutters[index]->GetOutput();
}
else
{
// cutting of a 2D-Volume does not work,
// so we have to build up our own polydata object
cuttedPlane = vtkPolyData::New();
points = vtkPoints::New();
points->SetNumberOfPoints(m_VtkImage->GetNumberOfPoints());
for(int i=0; i<m_VtkImage->GetNumberOfPoints(); i++)
{
points->SetPoint(i, m_VtkImage->GetPoint(i));
}
cuttedPlane->SetPoints(points);
pointdata = vtkFloatArray::New();
int comps = m_VtkImage->GetPointData()->GetScalars()->GetNumberOfComponents();
pointdata->SetNumberOfComponents(comps);
int tuples = m_VtkImage->GetPointData()->GetScalars()->GetNumberOfTuples();
pointdata->SetNumberOfTuples(tuples);
for(int i=0; i<tuples; i++)
pointdata->SetTuple(i,m_VtkImage->GetPointData()->GetScalars()->GetTuple(i));
pointdata->SetName( "vector" );
cuttedPlane->GetPointData()->AddArray(pointdata);
int nZero1, nZero2;
if(dims[0]==1)
{
nZero1 = 1; nZero2 = 2;
}
else if(dims[1]==1)
{
nZero1 = 0; nZero2 = 2;
}
else
{
nZero1 = 0; nZero2 = 1;
}
tmppoints = vtkPoints::New();
for(int j=0; j<m_VtkImage->GetNumberOfPoints(); j++){
double pt[3];
m_VtkImage->GetPoint(j,pt);
tmppoints->InsertNextPoint(pt[nZero1],pt[nZero2],0);
}
polydata = vtkPolyData::New();
polydata->SetPoints( tmppoints );
delaunay = vtkDelaunay2D::New();
delaunay->SetInput( polydata );
delaunay->Update();
vtkCellArray* polys = delaunay->GetOutput()->GetPolys();
cuttedPlane->SetPolys(polys);
}
if(cuttedPlane->GetNumberOfPoints())
{
// WINDOWING HERE
inversetransform = vtkTransform::New();
inversetransform->Identity();
inversetransform->Concatenate(vtktransform->GetLinearInverse());
double myscale[3];
((vtkTransform*)vtktransform)->GetScale(myscale);
inversetransform->PostMultiply();
inversetransform->Scale(1*myscale[0],1*myscale[1],1*myscale[2]);
dispGeo->vnormal[0] = dispGeo->M3D[0]-dispGeo->O3D[0];
dispGeo->vnormal[1] = dispGeo->M3D[1]-dispGeo->O3D[1];
dispGeo->vnormal[2] = dispGeo->M3D[2]-dispGeo->O3D[2];
vtkMath::Normalize(dispGeo->vnormal);
dispGeo->vp[0] = dispGeo->M3D[0];
dispGeo->vp[1] = dispGeo->M3D[1];
dispGeo->vp[2] = dispGeo->M3D[2];
inversetransform->TransformPoint( dispGeo->vp, dispGeo->vp );
inversetransform->TransformNormalAtPoint( dispGeo->vp, dispGeo->vnormal, dispGeo->vnormal );
m_ThickPlanes1[index]->count = 0;
m_ThickPlanes1[index]->SetTransform((vtkAbstractTransform*)NULL );
m_ThickPlanes1[index]->SetPose( dispGeo->vnormal, dispGeo->vp );
m_ThickPlanes1[index]->SetThickness(dispGeo->d2);
m_Clippers1[index]->SetClipFunction( m_ThickPlanes1[index] );
m_Clippers1[index]->SetInput( cuttedPlane );
m_Clippers1[index]->SetInsideOut(1);
m_Clippers1[index]->Update();
dispGeo->vnormal[0] = dispGeo->M3D[0]-dispGeo->L3D[0];
dispGeo->vnormal[1] = dispGeo->M3D[1]-dispGeo->L3D[1];
dispGeo->vnormal[2] = dispGeo->M3D[2]-dispGeo->L3D[2];
vtkMath::Normalize(dispGeo->vnormal);
dispGeo->vp[0] = dispGeo->M3D[0];
dispGeo->vp[1] = dispGeo->M3D[1];
dispGeo->vp[2] = dispGeo->M3D[2];
inversetransform->TransformPoint( dispGeo->vp, dispGeo->vp );
inversetransform->TransformNormalAtPoint( dispGeo->vp, dispGeo->vnormal, dispGeo->vnormal );
m_ThickPlanes2[index]->count = 0;
m_ThickPlanes2[index]->SetTransform((vtkAbstractTransform*)NULL );
m_ThickPlanes2[index]->SetPose( dispGeo->vnormal, dispGeo->vp );
m_ThickPlanes2[index]->SetThickness(dispGeo->d1);
m_Clippers2[index]->SetClipFunction( m_ThickPlanes2[index] );
m_Clippers2[index]->SetInput( m_Clippers1[index]->GetOutput() );
m_Clippers2[index]->SetInsideOut(1);
m_Clippers2[index]->Update();
cuttedPlane = m_Clippers2[index]->GetOutput ();
if(cuttedPlane->GetNumberOfPoints())
{
m_OdfsPlanes[index]->RemoveAllInputs();
vtkPolyDataNormals* normals = vtkPolyDataNormals::New();
normals->SetInputConnection( m_OdfSource->GetOutputPort() );
normals->SplittingOff();
normals->ConsistencyOff();
normals->AutoOrientNormalsOff();
normals->ComputePointNormalsOn();
normals->ComputeCellNormalsOff();
normals->FlipNormalsOff();
normals->NonManifoldTraversalOff();
vtkTransformPolyDataFilter* trans = vtkTransformPolyDataFilter::New();
trans->SetInputConnection( normals->GetOutputPort() );
trans->SetTransform(m_OdfTransform);
vtkMaskedProgrammableGlyphFilter* glyphGenerator = vtkMaskedProgrammableGlyphFilter::New();
glyphGenerator->SetMaximumNumberOfPoints(m_ShowMaxNumber);
glyphGenerator->SetRandomMode(1);
glyphGenerator->SetUseMaskPoints(1);
glyphGenerator->SetSource( trans->GetOutput() );
glyphGenerator->SetInput(cuttedPlane);
glyphGenerator->SetColorModeToColorBySource();
glyphGenerator->SetInputArrayToProcess(0,0,0, vtkDataObject::FIELD_ASSOCIATION_POINTS , "vector");
glyphGenerator->SetGeometry(this->GetDataNode()->GetData()->GetGeometry());
glyphGenerator->SetGlyphMethod(&(GlyphMethod),(void *)glyphGenerator);
try
{
glyphGenerator->Update();
}
catch( itk::ExceptionObject& err )
{
std::cout << err << std::endl;
}
m_OdfsPlanes[index]->AddInput(glyphGenerator->GetOutput());
trans->Delete();
glyphGenerator->Delete();
normals->Delete();
m_OdfsPlanes[index]->Update();
}
}
m_PropAssemblies[index]->VisibilityOn();
if(m_PropAssemblies[index]->GetParts()->IsItemPresent(m_OdfsActors[index]))
m_PropAssemblies[index]->RemovePart(m_OdfsActors[index]);
m_OdfsMappers[index]->SetInput(m_OdfsPlanes[index]->GetOutput());
m_PropAssemblies[index]->AddPart(m_OdfsActors[index]);
if(inversetransform) inversetransform->Delete();
if(points) points->Delete();
if(pointdata) pointdata->Delete();
if(tmppoints) tmppoints->Delete();
if(polydata) polydata->Delete();
if(delaunay) delaunay->Delete();
}
1.7.2