void test3DSurfaceIn4DImage()
{
mitk::SurfaceToImageFilter::Pointer surfaceToImageFilter = mitk::SurfaceToImageFilter::New();
mitk::Image::Pointer additionalInputImage = mitk::Image::New();
unsigned int* dims = new unsigned int[4];
dims[0] = 32;
dims[1] = 32;
dims[2] = 32;
dims[3] = 2;
additionalInputImage->Initialize( mitk::MakeScalarPixelType<unsigned int>(),4,dims);
additionalInputImage->SetOrigin(m_Surface->GetGeometry()->GetOrigin());
additionalInputImage->GetGeometry()->SetIndexToWorldTransform(m_Surface->GetGeometry()->GetIndexToWorldTransform());
mitk::Image::Pointer secondStep = additionalInputImage->Clone();
unsigned int size = sizeof(unsigned char);
for (unsigned int i = 0; i < secondStep->GetDimension(); ++i)
size *= secondStep->GetDimension(i);
mitk::ImageWriteAccessor accessor( secondStep );
memset( accessor.GetData(), 1, size );
additionalInputImage->GetTimeGeometry()->Expand(2);
additionalInputImage->GetGeometry(1)->SetSpacing(secondStep->GetGeometry()->GetSpacing());
additionalInputImage->GetGeometry(1)->SetOrigin(secondStep->GetGeometry()->GetOrigin());
additionalInputImage->GetGeometry(1)->SetIndexToWorldTransform(secondStep->GetGeometry()->GetIndexToWorldTransform());
additionalInputImage->SetImportVolume(secondStep->GetData(),0);
additionalInputImage->SetImportVolume(secondStep->GetData(),1);
//Arrange the filter
surfaceToImageFilter->MakeOutputBinaryOn();
surfaceToImageFilter->SetInput(m_Surface);
surfaceToImageFilter->SetImage(additionalInputImage);
surfaceToImageFilter->Update();
mitk::ImagePixelReadAccessor<unsigned char,4> outputReader(surfaceToImageFilter->GetOutput());
itk::Index<4> idx;
bool valuesCorrect = true;
//Values outside the ball should be 0
idx[0] = 0; idx[1] = 0, idx[2] = 0; idx[3] = 0; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 0);
idx[0] = 0; idx[1] = 15, idx[2] = 15; idx[3] = 0; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 0);
idx[0] = 15; idx[1] = 15, idx[2] = 0; idx[3] = 0; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 0);
idx[0] = 15; idx[1] = 0, idx[2] = 15; idx[3] = 0; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 0);
idx[0] = 5; idx[1] = 9, idx[2] = 23; idx[3] = 0; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 0);
//Values inside the ball should be 1 hould be 1
idx[0] = 15; idx[1] = 15, idx[2] = 15; idx[3] = 0; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 1);
idx[0] = 31; idx[1] = 15, idx[2] = 15; idx[3] = 0; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 1);
idx[0] = 2; idx[1] = 15, idx[2] = 15; idx[3] = 0; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 1);
idx[0] = 15; idx[1] = 15, idx[2] = 2; idx[3] = 0; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 1);
idx[0] = 15; idx[1] = 2, idx[2] = 15; idx[3] = 0; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 1);
idx[0] = 6; idx[1] = 9, idx[2] = 23; idx[3] = 0; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 1);
//Values inside the ball but in the second timestep hould be 0
idx[0] = 15; idx[1] = 15, idx[2] = 15; idx[3] = 1; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 0);
idx[0] = 31; idx[1] = 15, idx[2] = 15; idx[3] = 1; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 0);
idx[0] = 2; idx[1] = 15, idx[2] = 15; idx[3] = 1; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 0);
idx[0] = 15; idx[1] = 15, idx[2] = 2; idx[3] = 1; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 0);
idx[0] = 15; idx[1] = 2, idx[2] = 15; idx[3] = 1; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 0);
idx[0] = 6; idx[1] = 9, idx[2] = 23; idx[3] = 1; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 0);
CPPUNIT_ASSERT_MESSAGE("SurfaceToImageFilter_BallSurfaceAsInput_Output4DCorrect", valuesCorrect == true);
}
/**
* @brief Setup Always call this method before each Test-case to ensure correct and new intialization of the used members for a new test case. (If the members are not used in a test, the method does not need to be called).
*/
void setUp() override
{
//generate two sets of points
m_PointsOne = vtkSmartPointer<vtkPoints>::New();
m_PointsOne->InsertNextPoint( 0.0, 0.0, 0.0 );
m_PointsOne->InsertNextPoint( 1.0, 0.0, 0.0 );
m_PointsOne->InsertNextPoint( 0.0, 1.0, 0.0 );
m_PointsOne->InsertNextPoint( 1.0, 1.0, 0.0 );
m_PointsTwo = vtkSmartPointer<vtkPoints>::New();
m_PointsTwo->InsertNextPoint( 0.0, 0.0, 0.0 );
m_PointsTwo->InsertNextPoint( 0.0, 0.0, 2.0 );
m_PointsTwo->InsertNextPoint( 0.0, 1.0, 0.0 );
m_PointsTwo->InsertNextPoint( 0.0, 1.0, 2.0 );
//generate two polygons
vtkSmartPointer<vtkPolygon> polygonOne = vtkSmartPointer<vtkPolygon>::New();
polygonOne->GetPointIds()->SetNumberOfIds(4);
polygonOne->GetPointIds()->SetId(0,0);
polygonOne->GetPointIds()->SetId(1,1);
polygonOne->GetPointIds()->SetId(2,2);
polygonOne->GetPointIds()->SetId(3,3);
vtkSmartPointer<vtkPolygon> polygonTwo = vtkSmartPointer<vtkPolygon>::New();
polygonTwo->GetPointIds()->SetNumberOfIds(4);
polygonTwo->GetPointIds()->SetId(0,3);
polygonTwo->GetPointIds()->SetId(1,2);
polygonTwo->GetPointIds()->SetId(2,0);
polygonTwo->GetPointIds()->SetId(3,1);
//generate polydatas
vtkSmartPointer<vtkCellArray> polygonArrayOne = vtkSmartPointer<vtkCellArray>::New();
polygonArrayOne->InsertNextCell(polygonOne);
m_PolyDataOne = vtkSmartPointer<vtkPolyData>::New();
m_PolyDataOne->SetPoints(m_PointsOne);
m_PolyDataOne->SetPolys(polygonArrayOne);
m_PolygonArrayTwo = vtkSmartPointer<vtkCellArray>::New();
m_PolygonArrayTwo->InsertNextCell(polygonTwo);
vtkSmartPointer<vtkPolyData> polyDataTwo = vtkSmartPointer<vtkPolyData>::New();
polyDataTwo->SetPoints(m_PointsOne);
polyDataTwo->SetPolys(m_PolygonArrayTwo);
//generate surfaces
m_Surface3D = mitk::Surface::New();
m_Surface3D->SetVtkPolyData( m_PolyDataOne );
m_Surface3DTwoTimeSteps = mitk::Surface::New();
m_Surface3DTwoTimeSteps->SetVtkPolyData( m_PolyDataOne, 0 );
m_Surface3DTwoTimeSteps->SetVtkPolyData( polyDataTwo, 1 );
}
mitk::SurfaceInterpolationController::ContourPositionInformation CreateContourPositionInformation(mitk::Surface::Pointer contour)
{
mitk::SurfaceInterpolationController::ContourPositionInformation contourInfo;
contourInfo.contour = contour;
double n[3];
double p[3];
contour->GetVtkPolyData()->GetPoints()->GetPoint(0, p);
vtkPolygon::ComputeNormal(contour->GetVtkPolyData()->GetPoints(), n);
contourInfo.contourNormal = n;
contourInfo.contourPoint = p;
return contourInfo;
}
void Equal_DifferentPoints_ReturnsFalse()
{
mitk::Surface::Pointer surfaceWithADifferentPoint = m_Surface3D->Clone();
//modify points. m_Surface3D contains m_PointsOne
surfaceWithADifferentPoint->GetVtkPolyData()->SetPoints( m_PointsTwo );
MITK_ASSERT_NOT_EQUAL( m_Surface3D, surfaceWithADifferentPoint, "A surface with a single timestep and different points should not be equal.");
}
mitk::Surface::Pointer mitk::SurfaceModifier::DeepCopy(mitk::Surface::Pointer originalSurface)
{
mitk::Surface::Pointer clonedSurface = mitk::Surface::New();
vtkSmartPointer<vtkPolyData> clonedPolyData = vtkPolyData::New();
clonedPolyData->DeepCopy(originalSurface->GetVtkPolyData());
clonedSurface->SetVtkPolyData(clonedPolyData);
return clonedSurface;
}
void mitk::SurfaceInterpolationController::AddNewContour (mitk::Surface::Pointer newContour)
{
if( newContour->GetVtkPolyData()->GetNumberOfPoints() > 0)
{
ContourPositionInformation contourInfo = CreateContourPositionInformation(newContour);
this->AddToInterpolationPipeline(contourInfo);
this->Modified();
}
}
bool CompareSurfacePointPositions(mitk::Surface::Pointer s1, mitk::Surface::Pointer s2)
{
vtkPoints* p1 = s1->GetVtkPolyData()->GetPoints();
vtkPoints* p2 = s2->GetVtkPolyData()->GetPoints();
if(p1->GetNumberOfPoints() != p2->GetNumberOfPoints())
return false;
for(int i = 0; i < p1->GetNumberOfPoints(); ++i)
{
if(p1->GetPoint(i)[0] != p2->GetPoint(i)[0] ||
p1->GetPoint(i)[1] != p2->GetPoint(i)[1] ||
p1->GetPoint(i)[2] != p2->GetPoint(i)[2] )
{
return true;
}
}
return false;
}
bool mitk::SurfaceModifier::AddOutlierToSurface(mitk::Surface::Pointer surface, double varianceX, double varianceY, double varianceZ, double outlierChance)
{
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
points->ShallowCopy(surface->GetVtkPolyData()->GetPoints());
for(unsigned int i = 0; i < points->GetNumberOfPoints(); i++)
{
double p[3];
points->GetPoint(i, p);
mitk::Point3D point;
point[0] = p[0];
point[1] = p[1];
point[2] = p[2];
if((outlierChance-vtkMath::Random(0,1))>0) point = PerturbePoint(point,varianceX,varianceY,varianceZ);
p[0] = point[0];
p[1] = point[1];
p[2] = point[2];
points->SetPoint(i, p);
}
surface->GetVtkPolyData()->SetPoints(points);
return true;
}
void test3DSurfaceCorrect()
{
mitk::SurfaceToImageFilter::Pointer surfaceToImageFilter = mitk::SurfaceToImageFilter::New();
//todo I don't know if this image is always needed. There is no documentation of the filter. Use git blame and ask the author.
mitk::Image::Pointer additionalInputImage = mitk::Image::New();
unsigned int* dims = new unsigned int[3];
dims[0] = 32;
dims[1] = 32;
dims[2] = 32;
additionalInputImage->Initialize( mitk::MakeScalarPixelType<unsigned int>(),3,dims);
additionalInputImage->SetOrigin(m_Surface->GetGeometry()->GetOrigin());
additionalInputImage->GetGeometry()->SetIndexToWorldTransform(m_Surface->GetGeometry()->GetIndexToWorldTransform());
//Arrange the filter
//The docu does not really tell if this is always needed. Could we skip SetImage in any case?
surfaceToImageFilter->MakeOutputBinaryOn();
surfaceToImageFilter->SetInput(m_Surface);
surfaceToImageFilter->SetImage(additionalInputImage);
surfaceToImageFilter->Update();
mitk::ImagePixelReadAccessor<unsigned char,3> outputReader(surfaceToImageFilter->GetOutput());
itk::Index<3> idx;
bool valuesCorrect = true;
//Values outside the ball should be 0
idx[0] = 0; idx[1] = 0, idx[2] = 0; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 0);
idx[0] = 0; idx[1] = 15, idx[2] = 15; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 0);
idx[0] = 15; idx[1] = 15, idx[2] = 0; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 0);
idx[0] = 15; idx[1] = 0, idx[2] = 15; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 0);
idx[0] = 5; idx[1] = 9, idx[2] = 23; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 0);
//Values inside the ball should be 1
idx[0] = 15; idx[1] = 15, idx[2] = 15; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 1);
idx[0] = 31; idx[1] = 15, idx[2] = 15; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 1);
idx[0] = 2; idx[1] = 15, idx[2] = 15; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 1);
idx[0] = 15; idx[1] = 15, idx[2] = 2; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 1);
idx[0] = 15; idx[1] = 2, idx[2] = 15; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 1);
idx[0] = 6; idx[1] = 9, idx[2] = 23; valuesCorrect = valuesCorrect && (outputReader.GetPixelByIndex(idx) == 1);
CPPUNIT_ASSERT_MESSAGE("SurfaceToImageFilter_BallSurfaceAsInput_OutputCorrect", valuesCorrect == true);
}
bool mitk::SurfaceModifier::PerturbeSurface(mitk::Surface::Pointer surface, double varianceX, double varianceY, double varianceZ, double maxNoiseVectorLenght)
{
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
points->ShallowCopy(surface->GetVtkPolyData()->GetPoints());
for(unsigned int i = 0; i < points->GetNumberOfPoints(); i++)
{
double p[3];
points->GetPoint(i, p);
mitk::Point3D point;
point[0] = p[0];
point[1] = p[1];
point[2] = p[2];
point = PerturbePoint(point,varianceX,varianceY,varianceZ,maxNoiseVectorLenght);
p[0] = point[0];
p[1] = point[1];
p[2] = point[2];
points->SetPoint(i, p);
}
surface->GetVtkPolyData()->SetPoints(points);
return true;
}
void test3DSurfaceValidOutput()
{
mitk::SurfaceToImageFilter::Pointer surfaceToImageFilter = mitk::SurfaceToImageFilter::New();
mitk::Image::Pointer additionalInputImage = mitk::Image::New();
additionalInputImage->Initialize( mitk::MakeScalarPixelType<unsigned int>(), *m_Surface->GetTimeGeometry());
//Arrange the filter
surfaceToImageFilter->MakeOutputBinaryOn();
surfaceToImageFilter->SetInput(m_Surface);
surfaceToImageFilter->SetImage(additionalInputImage);
surfaceToImageFilter->Update();
CPPUNIT_ASSERT_MESSAGE("SurfaceToImageFilter_AnyInputImageAndModeSetToBinary_ResultIsImageWithUCHARPixelType", surfaceToImageFilter->GetOutput()->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR);
}
bool mitk::SurfaceModifier::TransformSurface(mitk::Surface::Pointer surface, itk::Matrix<double,3,3> TransformationR, itk::Vector<double,3> TransformationT)
{
//apply transformation
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
points->ShallowCopy(surface->GetVtkPolyData()->GetPoints());
for(unsigned int i = 0; i < points->GetNumberOfPoints(); i++)
{
double p[3];
points->GetPoint(i, p);
mitk::Point3D point;
point[0] = p[0];
point[1] = p[1];
point[2] = p[2];
point = TransformPoint(point,TransformationR,TransformationT);
p[0] = point[0];
p[1] = point[1];
p[2] = point[2];
points->SetPoint(i, p);
}
surface->GetVtkPolyData()->SetPoints(points);
return true;
}
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;
}
static void TestRead2()
{
mitk::NavigationToolReader::Pointer myReader = mitk::NavigationToolReader::New();
mitk::NavigationTool::Pointer readTool = myReader->DoRead("TestTool2.tool");
MITK_TEST_OUTPUT(<<"---- Testing navigation tool reader with second tool (aurora tool) ----");
//Test if the surfaces do have the same number of vertexes (it would be better to test for real equality of the surfaces!)
MITK_TEST_CONDITION_REQUIRED(dynamic_cast<mitk::Surface*>(readTool->GetDataNode()->GetData())->GetSizeOfPolyDataSeries()==m_testSurface->GetSizeOfPolyDataSeries(),"Test if surface was restored correctly ...");
//Test if the tool type is the same
MITK_TEST_CONDITION_REQUIRED(readTool->GetType()==mitk::NavigationTool::Instrument,"Testing Tool Type");
MITK_TEST_CONDITION_REQUIRED(readTool->GetTrackingDeviceType()==mitk::NDIAurora,"Testing Tracking Device Type");
MITK_TEST_CONDITION_REQUIRED(readTool->GetSerialNumber()=="0816","Testing Serial Number");
MITK_TEST_CONDITION_REQUIRED(readTool->GetCalibrationFile()=="none","Testing Calibration File");
}
void mitk::SurfaceInterpolationController::ReinitializeInterpolation(mitk::Surface::Pointer contours)
{
// 1. detect coplanar contours
// 2. merge coplanar contours into a single surface
// 4. add contour to pipeline
// Split the surface into separate polygons
vtkSmartPointer<vtkCellArray> existingPolys;
vtkSmartPointer<vtkPoints> existingPoints;
existingPolys = contours->GetVtkPolyData()->GetPolys();
existingPoints = contours->GetVtkPolyData()->GetPoints();
existingPolys->InitTraversal();
vtkSmartPointer<vtkIdList> ids = vtkSmartPointer<vtkIdList>::New();
typedef std::pair<mitk::Vector3D, mitk::Point3D> PointNormalPair;
std::vector<ContourPositionInformation> list;
std::vector<vtkSmartPointer<vtkPoints> > pointsList;
int count (0);
for( existingPolys->InitTraversal(); existingPolys->GetNextCell(ids);)
{
// Get the points
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
existingPoints->GetPoints(ids, points);
++count;
pointsList.push_back(points);
PointNormalPair p_n;
double n[3];
vtkPolygon::ComputeNormal(points, n);
p_n.first = n;
double p[3];
existingPoints->GetPoint(ids->GetId(0), p);
p_n.second = p;
ContourPositionInformation p_info;
p_info.contourNormal = n;
p_info.contourPoint = p;
list.push_back(p_info);
continue;
}
// Detect and sort coplanar polygons
auto outer = list.begin();
std::vector< std::vector< vtkSmartPointer<vtkPoints> > > relatedPoints;
while (outer != list.end())
{
auto inner = outer;
++inner;
std::vector< vtkSmartPointer<vtkPoints> > rel;
auto pointsIter = pointsList.begin();
rel.push_back((*pointsIter));
pointsIter = pointsList.erase(pointsIter);
while (inner != list.end())
{
if(ContoursCoplanar((*outer),(*inner)))
{
inner = list.erase(inner);
rel.push_back((*pointsIter));
pointsIter = pointsList.erase(pointsIter);
}
else
{
++inner;
++pointsIter;
}
}
relatedPoints.push_back(rel);
++outer;
}
// Build the separate surfaces again
std::vector<mitk::Surface::Pointer> finalSurfaces;
for (unsigned int i = 0; i < relatedPoints.size(); ++i)
{
vtkSmartPointer<vtkPolyData> contourSurface = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> polygons = vtkSmartPointer<vtkCellArray>::New();
unsigned int pointId (0);
for (unsigned int j = 0; j < relatedPoints.at(i).size(); ++j)
{
unsigned int numPoints = relatedPoints.at(i).at(j)->GetNumberOfPoints();
vtkSmartPointer<vtkPolygon> polygon = vtkSmartPointer<vtkPolygon>::New();
polygon->GetPointIds()->SetNumberOfIds(numPoints);
polygon->GetPoints()->SetNumberOfPoints(numPoints);
vtkSmartPointer<vtkPoints> currentPoints = relatedPoints.at(i).at(j);
for (unsigned k = 0; k < numPoints; ++k)
{
points->InsertPoint(pointId, currentPoints->GetPoint(k));
polygon->GetPointIds()->SetId(k, pointId);
++pointId;
}
polygons->InsertNextCell(polygon);
}
contourSurface->SetPoints(points);
contourSurface->SetPolys(polygons);
contourSurface->BuildLinks();
mitk::Surface::Pointer surface = mitk::Surface::New();
surface->SetVtkPolyData(contourSurface);
finalSurfaces.push_back(surface);
}
// Add detected contours to interpolation pipeline
this->AddNewContours(finalSurfaces);
}
mitk::Surface::Pointer mitk::ACVD::Remesh(mitk::Surface::Pointer surface, int numVertices, double gradation, int subsampling, double edgeSplitting, int optimizationLevel, bool forceManifold, bool boundaryFixing)
{
MITK_INFO << "Start remeshing...";
vtkSmartPointer<vtkPolyData> surfacePolyData = vtkSmartPointer<vtkPolyData>::New();
surfacePolyData->DeepCopy(surface->GetVtkPolyData());
vtkSmartPointer<vtkSurface> mesh = vtkSmartPointer<vtkSurface>::New();
mesh->CreateFromPolyData(surfacePolyData);
mesh->GetCellData()->Initialize();
mesh->GetPointData()->Initialize();
mesh->DisplayMeshProperties();
if (edgeSplitting != 0.0)
mesh->SplitLongEdges(edgeSplitting);
vtkSmartPointer<vtkIsotropicDiscreteRemeshing> remesher = vtkSmartPointer<vtkIsotropicDiscreteRemeshing>::New();
remesher->GetMetric()->SetGradation(gradation);
remesher->SetBoundaryFixing(boundaryFixing);
remesher->SetConsoleOutput(1);
remesher->SetForceManifold(forceManifold);
remesher->SetInput(mesh);
remesher->SetNumberOfClusters(numVertices);
remesher->SetNumberOfThreads(vtkMultiThreader::GetGlobalDefaultNumberOfThreads());
remesher->SetSubsamplingThreshold(subsampling);
remesher->Remesh();
if (optimizationLevel != 0)
{
ClustersQuadrics clustersQuadrics(numVertices);
vtkSmartPointer<vtkIdList> faceList = vtkSmartPointer<vtkIdList>::New();
vtkSmartPointer<vtkIntArray> clustering = remesher->GetClustering();
vtkSmartPointer<vtkSurface> remesherInput = remesher->GetInput();
int clusteringType = remesher->GetClusteringType();
int numItems = remesher->GetNumberOfItems();
int numMisclassifiedItems = 0;
for (int i = 0; i < numItems; ++i)
{
int cluster = clustering->GetValue(i);
if (cluster >= 0 && cluster < numVertices)
{
if (clusteringType != 0)
{
remesherInput->GetVertexNeighbourFaces(i, faceList);
int numIds = static_cast<int>(faceList->GetNumberOfIds());
for (int j = 0; j < numIds; ++j)
vtkQuadricTools::AddTriangleQuadric(clustersQuadrics.Elements[cluster], remesherInput, faceList->GetId(j), false);
}
else
{
vtkQuadricTools::AddTriangleQuadric(clustersQuadrics.Elements[cluster], remesherInput, i, false);
}
}
else
{
++numMisclassifiedItems;
}
}
if (numMisclassifiedItems != 0)
std::cout << numMisclassifiedItems << " items with wrong cluster association" << std::endl;
vtkSmartPointer<vtkSurface> remesherOutput = remesher->GetOutput();
double point[3];
for (int i = 0; i < numVertices; ++i)
{
remesherOutput->GetPoint(i, point);
vtkQuadricTools::ComputeRepresentativePoint(clustersQuadrics.Elements[i], point, optimizationLevel);
remesherOutput->SetPointCoordinates(i, point);
}
std::cout << "After quadrics post-processing:" << std::endl;
remesherOutput->DisplayMeshProperties();
}
vtkSmartPointer<vtkPolyDataNormals> normals = vtkSmartPointer<vtkPolyDataNormals>::New();
normals->SetInput(remesher->GetOutput());
normals->AutoOrientNormalsOn();
normals->ComputeCellNormalsOff();
normals->ComputePointNormalsOn();
normals->ConsistencyOff();
normals->FlipNormalsOff();
normals->NonManifoldTraversalOff();
normals->SplittingOff();
normals->Update();
Surface::Pointer remeshedSurface = Surface::New();
remeshedSurface->SetVtkPolyData(normals->GetOutput());
MITK_INFO << "Finished remeshing";
return remeshedSurface;
}
static void TestInstantiation()
{
// let's create an object of our class
mitk::TrackingVolumeGenerator::Pointer myTVGenerator = mitk::TrackingVolumeGenerator::New();
MITK_TEST_CONDITION_REQUIRED(myTVGenerator.IsNotNull(),"Testing instantiation");
}
static void TestTrackingSystemNotSpecified()
{
MITK_TEST_OUTPUT(<<"---- Testing Trackingsystem not specified ----");
mitk::TrackingVolumeGenerator::Pointer myTVGenerator = mitk::TrackingVolumeGenerator::New();
MITK_TEST_CONDITION((myTVGenerator->GetTrackingDeviceType() == mitk::TrackingSystemNotSpecified), "Tracking System not specified:");
myTVGenerator->Update();
mitk::Surface::Pointer volume = myTVGenerator->GetOutput();
MITK_TEST_CONDITION((volume->IsEmptyTimeStep(0) == false),"Output contains data");
}
static void TestClaronTrackingVolume()
{
MITK_TEST_OUTPUT(<< "---- Testing MicronTracker 2 Tracking Volume ----");
mitk::TrackingVolumeGenerator::Pointer myTVGenerator = mitk::TrackingVolumeGenerator::New ();
myTVGenerator->SetTrackingDeviceType(mitk::ClaronMicron);
MITK_TEST_CONDITION((myTVGenerator->GetTrackingDeviceType() == mitk::ClaronMicron),"loading MicronTracker Volume data:");
myTVGenerator->Update();
mitk::Surface::Pointer volume = myTVGenerator->GetOutput();
MITK_TEST_CONDITION((volume->IsEmptyTimeStep(0) == false),"Output contains data");
}
static void TestNDIAuroraTrackingVolume()
static void TestRead()
{
mitk::NavigationToolReader::Pointer myReader = mitk::NavigationToolReader::New();
mitk::NavigationTool::Pointer readTool = myReader->DoRead("TestTool.tool");
MITK_TEST_OUTPUT(<<"---- Testing navigation tool reader with first test tool (claron tool) ----");
//Test if the surfaces do have the same number of vertexes (it would be better to test for real equality of the surfaces!)
MITK_TEST_CONDITION_REQUIRED(dynamic_cast<mitk::Surface*>(readTool->GetDataNode()->GetData())->GetSizeOfPolyDataSeries()==m_testSurface->GetSizeOfPolyDataSeries(),"Test if surface was restored correctly ...");
MITK_TEST_CONDITION_REQUIRED(readTool->GetType()==mitk::NavigationTool::Fiducial,"Testing Tool Type");
MITK_TEST_CONDITION_REQUIRED(readTool->GetTrackingDeviceType()==mitk::ClaronMicron,"Testing Tracking Device Type");
MITK_TEST_CONDITION_REQUIRED(readTool->GetSerialNumber()=="0815","Testing Serial Number");
std::ifstream TestFile(readTool->GetCalibrationFile().c_str());
MITK_TEST_CONDITION_REQUIRED(TestFile,"Testing If Calibration File Exists");
}
void Equal_CloneAndOriginalTwoTimesteps_ReturnsTrue()
{
MITK_ASSERT_EQUAL( m_Surface3DTwoTimeSteps, m_Surface3DTwoTimeSteps->Clone(), "A two timestep clone should be equal to its original.");
}
void Equal_CloneAndOriginalOneTimestep_ReturnsTrue()
{
MITK_ASSERT_EQUAL( m_Surface3D, m_Surface3D->Clone(), "A one timestep clone should be equal to its original.");
}