Hi
I am trying to implement my own 3D mapper and need a polydata objects of the 3
rectangles of the multi widget. So i found the Geometry2DDataToSurfaceFilter
and my workflow is like this:
-> Give the mapper a pointer to the datastorage as a member variable
-> On a generateData event i search for mitk::Geomentry2DData objects which
holds the geometry2d objects of these planes
-> Compare the geometry2d objects with the geometry objects of the 2d mappers
of my working 2d mappers
-> If they are the same: Get the image of the right 2d mapper, get the
geometry2ddata object from the data storage
(this works good)
So the only thing i should do is:
-> create a polydata with Geometry2DDataToSurfaceFilter
-> map texture of image on that geometry data
The problem is that the resulting drawings are not positioned corretly (they
were all planar), may someone can give me a hint, here my current
implementation:
MyDataObjectInheritedFromImage* poInput =
const_cast<MyDataObjectInheritedFromImage*>(this->GetInput());
mitk::DataNode* poNode = const_cast<mitk::DataNode*>(this->GetDataNode());
if (poInput && poNode)
{
My2DMapper* poMapper = dynamic_cast<My2DMapper* >(poNode->GetMapper(1));
if(poMapper)
{
My2DMapper::TRendererInfoMap::iterator oRenIt =
poMapper->m_oRendererInfo.begin();
for(; oRenIt!=poMapper->m_oRendererInfo.end(); ++oRenIt)
{
TVectorRendererMap::iterator oCurrent =
m_oVectorRenderers.find((*oRenIt).first);
if(oCurrent == m_oVectorRenderers.end())
{
SVectorRenderering oNew;
oNew.m_poTexture = vtkTexture::New();
oNew.m_poDSMapper = vtkDataSetMapper::New();
oNew.m_oSurfaceCreator =
mitk::Geometry2DDataToSurfaceFilter::New();
oNew.m_oSurfaceCreatorBoundingBox = mitk::BoundingBox::New();
oNew.m_oSurfaceCreatorPointsContainer =
mitk::BoundingBox::PointsContainer::New();
oNew.m_oSurfaceCreator->PlaceByGeometryOn();
oNew.m_oSurfaceCreatorBoundingBox->SetPoints(
oNew.m_oSurfaceCreatorPointsContainer );
oNew.m_poTexture->InterpolateOn();
oNew.m_poTexture->RepeatOff();
oNew.m_poDSMapper->ImmediateModeRenderingOn();
oNew.m_poActor = vtkActor::New();
m_oVectorRenderers.insert(std::pair<mitk::BaseRenderer*,SVectorRenderering>((*oRenIt).first,
oNew));
oCurrent = m_oVectorRenderers.find((*oRenIt).first);
}
mitk::BaseRenderer* poCurrent2DRenderer = oCurrent->first;
SVectorRenderering* poCurrentPipeline = &oCurrent->second;
m_poTransformAssembly->RemovePart(poCurrentPipeline->m_poActor);
//make unimportant things like color etc
My2DMapper::CRendererInfo* poRenderingInfo =
&poMapper->AccessRendererInfo(poCurrent2DRenderer);
mitk::Geometry2D::Pointer oWorldGeometry =
const_cast<mitk::Geometry2D*>(poCurrent2DRenderer->GetCurrentWorldGeometry2D());
mitk::NodePredicateDataType::Pointer oPred =
mitk::NodePredicateDataType::New("Geometry2DData");
mitk::DataStorage::SetOfObjects::ConstPointer oAll =
this->m_poDataStorage->GetSubset(oPred);
for(unsigned int iIndex = 0; iIndex < oAll->Size(); iIndex++)
{
mitk::DataNode* poCurrentNode = oAll->at(iIndex);
if(oWorldGeometry.GetPointer() ==
dynamic_cast<mitk::Geometry2DData*>(poCurrentNode->GetData())->GetGeometry2D())
{
mitk::SmartPointerProperty::Pointer oSurfacecreatorprop;
oSurfacecreatorprop = dynamic_cast< mitk::SmartPointerProperty
* >(poCurrentNode->GetProperty("surfacegeometry", poRenderer));
if ( (oSurfacecreatorprop.IsNull()) ||
(oSurfacecreatorprop->GetSmartPointer().IsNull()) ||
((poCurrentPipeline->m_oSurfaceCreator =
dynamic_cast<mitk::Geometry2DDataToSurfaceFilter*>(oSurfacecreatorprop->GetSmartPointer().GetPointer())).IsNull()
))
{
poCurrentPipeline->m_oSurfaceCreator->PlaceByGeometryOn();
oSurfacecreatorprop = mitk::SmartPointerProperty::New(
poCurrentPipeline->m_oSurfaceCreator );
poCurrentNode->SetProperty("surfacegeometry",
oSurfacecreatorprop);
}
int iRes;
if (poCurrentNode->GetIntProperty("xresolution", iRes,
poRenderer))
{
poCurrentPipeline->m_oSurfaceCreator->SetXResolution(iRes);
}
if (poCurrentNode->GetIntProperty("yresolution", iRes,
poRenderer))
{
poCurrentPipeline->m_oSurfaceCreator->SetYResolution(iRes);
}
if ( oWorldGeometry->HasReferenceGeometry())
{
std::cout << "using referenced geometry" << std::endl;
mitk::Geometry3D * poReferenceGeometry =
oWorldGeometry->GetReferenceGeometry();
mitk::BoundingBox::PointType oBoundingBoxMin,
oBoundingBoxMax;
oBoundingBoxMin =
poReferenceGeometry->GetBoundingBox()->GetMinimum();
oBoundingBoxMax =
poReferenceGeometry->GetBoundingBox()->GetMaximum();
if ( poReferenceGeometry->GetImageGeometry() )
{
for ( unsigned int i = 0; i < 3; ++i )
{
oBoundingBoxMin[i] -= 0.5;
oBoundingBoxMax[i] -= 0.5;
}
}
poCurrentPipeline->m_oSurfaceCreatorPointsContainer->CreateElementAt( 0 ) =
oBoundingBoxMin;
poCurrentPipeline->m_oSurfaceCreatorPointsContainer->CreateElementAt( 1 ) =
oBoundingBoxMax;
poCurrentPipeline->m_oSurfaceCreatorBoundingBox->ComputeBoundingBox();
poCurrentPipeline->m_oSurfaceCreator->SetBoundingBox(
poCurrentPipeline->m_oSurfaceCreatorBoundingBox );
}
poCurrentPipeline->m_oSurfaceCreator->Update();
poCurrentPipeline->m_poDSMapper->SetInput(poCurrentPipeline->m_oSurfaceCreator->GetOutput()->GetVtkPolyData());
poCurrentPipeline->m_poTexture->SetInput(poRenderingInfo->m_poMagnitudeFilter->GetOutput());
bool bTextureInterpolation = poNode->IsOn( "texture
interpolation", poCurrent2DRenderer );
poCurrentPipeline->m_poTexture->SetInterpolate(
bTextureInterpolation );
poCurrentPipeline->m_poActor->SetMapper(poCurrentPipeline->m_poDSMapper);
poCurrentPipeline->m_poActor->SetTexture(poCurrentPipeline->m_poTexture);
m_poTransformAssembly->AddPart(poCurrentPipeline->m_poActor);
m_poTransformAssembly->SetUserTransform(poNode->GetVtkTransform(this->GetTimestep())
);
return;
}
}
Gerald Lodron
Human-Centered Image Processing
Machine Vision Applications
DIGITAL - Institute of Information and Communication Technologies
JOANNEUM RESEARCH Forschungsgesellschaft mbH
Steyrergasse 17, 8010 Graz, AUSTRIA
phone: +43-316-876-1751 fax: +43-316-876-1751
web: http://www.joanneum.at/digital
e-mail: [email protected]<mailto:[email protected]>
------------------------------------------------------------------------------
Enable your software for Intel(R) Active Management Technology to meet the
growing manageability and security demands of your customers. Businesses
are taking advantage of Intel(R) vPro (TM) technology - will your software
be a part of the solution? Download the Intel(R) Manageability Checker
today! http://p.sf.net/sfu/intel-dev2devmar
_______________________________________________
mitk-users mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/mitk-users
