diff --git a/src/Cxx/Points/CompareExtractSurface.md b/src/Cxx/Points/CompareExtractSurface.md
index bcaef9334d12b410db7488578dc00bea2c0358a4..1e68a5dc5db4e61b846bf519bd93fbdb34c5e554 100644
--- a/src/Cxx/Points/CompareExtractSurface.md
+++ b/src/Cxx/Points/CompareExtractSurface.md
@@ -2,9 +2,9 @@
This example compares three surface reconstruction algorithms:
-1. [ExtractSurface](/Cxx/Points/ExtractSurface)
-2. [PoissonReconstruction](/Cxx/Points/PoissonExtractSurface)
-3. [Powercrust](/Cxx/Points/PowercrustExtractSurface)
+1. [ExtractSurface](../ExtractSurface)
+2. [PoissonReconstruction](../PoissonExtractSurface)
+3. [Powercrust](../PowercrustExtractSurface)
We usually try to keep examples short, but this example teaches several concepts.
@@ -18,7 +18,7 @@ We usually try to keep examples short, but this example teaches several concepts
This example runs longer than most. Be patient.
!!! info
- See [PoissonReconstruction Remote Module](/Cxx/Points/PoissonExtractSurface) to configure.
+ See [PoissonReconstruction Remote Module](../PoissonExtractSurface) to configure.
!!! info
- See [Powercrust Remote Module](/Cxx/Points/PowercrustExtractSurface) to configure.
+ See [Powercrust Remote Module](../PowercrustExtractSurface) to configure.
diff --git a/src/Cxx/Points/DensifyPoints.cxx b/src/Cxx/Points/DensifyPoints.cxx
index dee9e0a6121e29535dd92a88e5a5314c3f299ea7..4010434d53e728590a2aa92e66fa49ec4bd8b0f0 100644
--- a/src/Cxx/Points/DensifyPoints.cxx
+++ b/src/Cxx/Points/DensifyPoints.cxx
@@ -1,111 +1,102 @@
-#include <vtkSmartPointer.h>
+#include <vtkCamera.h>
#include <vtkDensifyPointCloudFilter.h>
-
-#include <vtkBYUReader.h>
-#include <vtkOBJReader.h>
-#include <vtkPLYReader.h>
-#include <vtkPolyDataReader.h>
-#include <vtkSTLReader.h>
-#include <vtkXMLPolyDataReader.h>
-
-#include <vtkPointSource.h>
-#include <vtkSphereSource.h>
#include <vtkGlyph3DMapper.h>
-
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
+#include <vtkPointSource.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
-#include <vtkCamera.h>
-#include <vtkNamedColors.h>
+#include <vtkSmartPointer.h>
+#include <vtkSphereSource.h>
#include <vtksys/SystemTools.hxx>
+#include <vtkMinimalStandardRandomSequence.h>
-namespace
-{
-vtkSmartPointer<vtkPolyData> ReadPolyData(const char *fileName);
+#include <vtkBYUReader.h>
+#include <vtkOBJReader.h>
+#include <vtkPLYReader.h>
+#include <vtkPolyDataReader.h>
+#include <vtkSTLReader.h>
+#include <vtkXMLPolyDataReader.h>
+
+namespace {
+vtkSmartPointer<vtkPolyData> ReadPolyData(const char* fileName);
}
-int main (int argc, char *argv[])
+int main(int argc, char* argv[])
{
- vtkSmartPointer<vtkPolyData> polyData = ReadPolyData(argc > 1 ? argv[1] : "");;
+ auto polyData = ReadPolyData(argc > 1 ? argv[1] : "");
double bounds[6];
polyData->GetBounds(bounds);
double range[3];
for (int i = 0; i < 3; ++i)
{
- range[i] = bounds[2*i + 1] - bounds[2*i];
+ range[i] = bounds[2 * i + 1] - bounds[2 * i];
}
- std::cout << "Range: "
- << range[0] << ", "
- << range[1] << ", "
- << range[2] << std::endl;
+ std::cout << "Range: " << range[0] << ", " << range[1] << ", " << range[2]
+ << std::endl;
double maxRange = std::max(std::max(range[0], range[1]), range[2]);
- std::cout << "# of original points: " << polyData->GetNumberOfPoints() << std::endl;
- vtkSmartPointer<vtkDensifyPointCloudFilter> densify =
- vtkSmartPointer<vtkDensifyPointCloudFilter>::New();
+ std::cout << "# of original points: " << polyData->GetNumberOfPoints()
+ << std::endl;
+ vtkNew<vtkDensifyPointCloudFilter> densify;
densify->SetInputData(polyData);
densify->SetMaximumNumberOfIterations(5);
densify->SetTargetDistance(maxRange * .03);
densify->SetNumberOfClosestPoints(10);
densify->Update();
- std::cout << "# of densified points: " << densify->GetOutput()->GetNumberOfPoints() << std::endl;
+ std::cout << "# of densified points: "
+ << densify->GetOutput()->GetNumberOfPoints() << std::endl;
- vtkSmartPointer<vtkNamedColors> colors =
- vtkSmartPointer<vtkNamedColors>::New();
-///
+ vtkNew<vtkNamedColors> colors;
+ ///
double radius = maxRange * .01;
- vtkSmartPointer<vtkSphereSource> sphereSource1 =
- vtkSmartPointer<vtkSphereSource>::New();
+ vtkNew<vtkSphereSource> sphereSource1;
sphereSource1->SetRadius(radius);
- vtkSmartPointer<vtkGlyph3DMapper> glyph3D1 =
- vtkSmartPointer<vtkGlyph3DMapper>::New();
+ vtkNew<vtkGlyph3DMapper> glyph3D1;
glyph3D1->SetInputData(polyData);
glyph3D1->SetSourceConnection(sphereSource1->GetOutputPort());
glyph3D1->ScalarVisibilityOff();
glyph3D1->ScalingOff();
- vtkSmartPointer<vtkActor> glyph3DActor1 =
- vtkSmartPointer<vtkActor>::New();
+ vtkNew<vtkActor> glyph3DActor1;
glyph3DActor1->SetMapper(glyph3D1);
- glyph3DActor1->GetProperty()->SetColor(colors->GetColor3d("Banana").GetData());
+ glyph3DActor1->GetProperty()->SetColor(
+ colors->GetColor3d("Banana").GetData());
-////
- vtkSmartPointer<vtkSphereSource> sphereSource2 =
- vtkSmartPointer<vtkSphereSource>::New();
+ ////
+ vtkNew<vtkSphereSource> sphereSource2;
sphereSource2->SetRadius(radius * .75);
- vtkSmartPointer<vtkGlyph3DMapper> glyph3D2 =
- vtkSmartPointer<vtkGlyph3DMapper>::New();
+ vtkNew<vtkGlyph3DMapper> glyph3D2;
glyph3D2->SetInputConnection(densify->GetOutputPort());
glyph3D2->SetSourceConnection(sphereSource2->GetOutputPort());
glyph3D2->ScalarVisibilityOff();
glyph3D2->ScalingOff();
- vtkSmartPointer<vtkActor> glyph3DActor2 =
- vtkSmartPointer<vtkActor>::New();
+ vtkNew<vtkActor> glyph3DActor2;
glyph3DActor2->SetMapper(glyph3D2);
- glyph3DActor2->GetProperty()->SetColor(colors->GetColor3d("Tomato").GetData());
+ glyph3DActor2->GetProperty()->SetColor(
+ colors->GetColor3d("Tomato").GetData());
// Create graphics stuff
//
- vtkSmartPointer<vtkRenderer> ren1 =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> ren1;
ren1->SetBackground(colors->GetColor3d("SlateGray").GetData());
- vtkSmartPointer<vtkRenderWindow> renWin =
- vtkSmartPointer<vtkRenderWindow>::New();
+ vtkNew<vtkRenderWindow> renWin;
renWin->AddRenderer(ren1);
- renWin->SetSize(512,512);
+ renWin->SetSize(512, 512);
+ renWin->SetWindowName("DensifyPoints");
- vtkSmartPointer<vtkRenderWindowInteractor> iren =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
+ vtkNew<vtkRenderWindowInteractor> iren;
iren->SetRenderWindow(renWin);
-
+
// Add the actors to the renderer, set the background and size
//
ren1->AddActor(glyph3DActor1);
@@ -113,9 +104,9 @@ int main (int argc, char *argv[])
// Generate an interesting view
//
- ren1->GetActiveCamera()->SetPosition (1, 0, 0);
- ren1->GetActiveCamera()->SetFocalPoint (0, 1, 0);
- ren1->GetActiveCamera()->SetViewUp (0, 0, 1);
+ ren1->GetActiveCamera()->SetPosition(1, 0, 0);
+ ren1->GetActiveCamera()->SetFocalPoint(0, 1, 0);
+ ren1->GetActiveCamera()->SetViewUp(0, 0, 1);
ren1->ResetCamera();
ren1->GetActiveCamera()->Dolly(1.0);
ren1->ResetCameraClippingRange();
@@ -127,73 +118,75 @@ int main (int argc, char *argv[])
return EXIT_SUCCESS;
}
-namespace
-{
-vtkSmartPointer<vtkPolyData> ReadPolyData(const char *fileName)
+namespace {
+vtkSmartPointer<vtkPolyData> ReadPolyData(const char* fileName)
{
vtkSmartPointer<vtkPolyData> polyData;
- std::string extension = vtksys::SystemTools::GetFilenameExtension(std::string(fileName));
+ std::string extension =
+ vtksys::SystemTools::GetFilenameExtension(std::string(fileName));
if (extension == ".ply")
{
- vtkSmartPointer<vtkPLYReader> reader =
- vtkSmartPointer<vtkPLYReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkPLYReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".vtp")
{
- vtkSmartPointer<vtkXMLPolyDataReader> reader =
- vtkSmartPointer<vtkXMLPolyDataReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkXMLPolyDataReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".vtk")
{
- vtkSmartPointer<vtkPolyDataReader> reader =
- vtkSmartPointer<vtkPolyDataReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkPolyDataReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".obj")
{
- vtkSmartPointer<vtkOBJReader> reader =
- vtkSmartPointer<vtkOBJReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkOBJReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".stl")
{
- vtkSmartPointer<vtkSTLReader> reader =
- vtkSmartPointer<vtkSTLReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkSTLReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".g")
{
- vtkSmartPointer<vtkBYUReader> reader =
- vtkSmartPointer<vtkBYUReader>::New();
- reader->SetGeometryFileName (fileName);
+ vtkNew<vtkBYUReader> reader;
+ reader->SetGeometryFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else
{
- vtkSmartPointer<vtkPointSource> points =
- vtkSmartPointer<vtkPointSource>::New();
+ vtkNew<vtkMinimalStandardRandomSequence> randomSequence;
+ randomSequence->SetSeed(8775070);
+
+ vtkNew<vtkPointSource> points;
points->SetNumberOfPoints(100000);
points->SetRadius(10.0);
- points->SetCenter(vtkMath::Random(-100, 100),
- vtkMath::Random(-100, 100),
- vtkMath::Random(-100, 100));
+ double x, y, z;
+ // random position
+ x = randomSequence->GetRangeValue(-100, 100);
+ randomSequence->Next();
+ y = randomSequence->GetRangeValue(-100, 100);
+ randomSequence->Next();
+ z = randomSequence->GetRangeValue(-100, 100);
+ randomSequence->Next();
+ points->SetCenter(x, y, z);
points->SetDistributionToShell();
points->Update();
polyData = points->GetOutput();
}
return polyData;
}
-}
+} // namespace
diff --git a/src/Cxx/Points/DensifyPoints.md b/src/Cxx/Points/DensifyPoints.md
index f19a97e94228cc168e8a6c3fa5186521e1c64811..25f72ec3b38850c1ae97cfe09d16aec872d1137f 100644
--- a/src/Cxx/Points/DensifyPoints.md
+++ b/src/Cxx/Points/DensifyPoints.md
@@ -1,4 +1,5 @@
### Description
+
In this example, the original points are yellow and the added points are red.
The image was produced using [this torso dataset](https://github.com/lorensen/VTKWikiExamples/raw/master/Testing/Data/Torso.vtp)
diff --git a/src/Cxx/Points/ExtractClusters.cxx b/src/Cxx/Points/ExtractClusters.cxx
index c90e09367e50f1920959d2e742c00991bb3e61a3..d2d0683b1bc6650dde65fc8aacd4c6f9c3ac52b8 100644
--- a/src/Cxx/Points/ExtractClusters.cxx
+++ b/src/Cxx/Points/ExtractClusters.cxx
@@ -1,45 +1,52 @@
-#include <vtkSmartPointer.h>
-
-#include <vtkEuclideanClusterExtraction.h>
-#include <vtkPointSource.h>
#include <vtkAppendPolyData.h>
-#include <vtkSphereSource.h>
+#include <vtkCamera.h>
+#include <vtkEuclideanClusterExtraction.h>
#include <vtkGlyph3D.h>
-
#include <vtkLookupTable.h>
-
-#include <vtkMath.h>
+#include <vtkMinimalStandardRandomSequence.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
+#include <vtkPointSource.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
-#include <vtkCamera.h>
+#include <vtkSphereSource.h>
-int main (int, char *[])
+int main(int, char*[])
{
- vtkMath::RandomSeed(4355412); // for test result consistency
+ vtkNew<vtkNamedColors> colors;
+
+ vtkNew<vtkMinimalStandardRandomSequence> randomSequence;
+ // randomSequence->SetSeed(8775070);
+ randomSequence->SetSeed(4355412);
+
double limits = 10;
- double radius = .5;
+ double radius = 0.5;
- vtkSmartPointer<vtkAppendPolyData> append =
- vtkSmartPointer<vtkAppendPolyData>::New();
+ vtkNew<vtkAppendPolyData> append;
for (unsigned i = 0; i < 30; ++i)
{
- vtkSmartPointer<vtkPointSource> points =
- vtkSmartPointer<vtkPointSource>::New();
+ vtkNew<vtkPointSource> points;
+
points->SetNumberOfPoints(800);
points->SetRadius(2.5 * radius);
- points->SetCenter(vtkMath::Random(-limits, limits),
- vtkMath::Random(-limits, limits),
- vtkMath::Random(-limits, limits));
+ double x, y, z;
+ // random position
+ x = randomSequence->GetRangeValue(-limits, limits);
+ randomSequence->Next();
+ y = randomSequence->GetRangeValue(-limits, limits);
+ randomSequence->Next();
+ z = randomSequence->GetRangeValue(-limits, limits);
+ randomSequence->Next();
+ points->SetCenter(x, y, z);
points->SetDistributionToShell();
append->AddInputConnection(points->GetOutputPort());
}
- vtkSmartPointer<vtkEuclideanClusterExtraction> cluster =
- vtkSmartPointer<vtkEuclideanClusterExtraction>::New();
+ vtkNew<vtkEuclideanClusterExtraction> cluster;
cluster->SetInputConnection(append->GetOutputPort());
cluster->SetExtractionModeToAllClusters();
cluster->SetRadius(radius);
@@ -50,8 +57,7 @@ int main (int, char *[])
<< " clusters within radius " << radius << std::endl;
// Create a lookup table to map point data to colors
- vtkSmartPointer<vtkLookupTable> lut =
- vtkSmartPointer<vtkLookupTable>::New();
+ vtkNew<vtkLookupTable> lut;
int tableSize = cluster->GetNumberOfExtractedClusters();
lut->SetNumberOfTableValues(tableSize);
lut->Build();
@@ -59,47 +65,44 @@ int main (int, char *[])
// Fill in the lookup table
for (unsigned int i = 0; static_cast<int>(i) < tableSize; ++i)
{
- lut->SetTableValue(i,
- vtkMath::Random(.25, 1.0),
- vtkMath::Random(.25, 1.0),
- vtkMath::Random(.25, 1.0),
- 1.0);
+ double r, g, b;
+ r = randomSequence->GetRangeValue(0.25, 1.0);
+ randomSequence->Next();
+ g = randomSequence->GetRangeValue(0.25, 1.0);
+ randomSequence->Next();
+ b = randomSequence->GetRangeValue(0.25, 1.0);
+ randomSequence->Next();
+ lut->SetTableValue(i, r, g, b, 1.0);
}
- vtkSmartPointer<vtkSphereSource> sphere =
- vtkSmartPointer<vtkSphereSource>::New();
+ vtkNew<vtkSphereSource> sphere;
sphere->SetRadius(radius / 2.0);
- vtkSmartPointer<vtkGlyph3D> glyphs =
- vtkSmartPointer<vtkGlyph3D>::New();
+ vtkNew<vtkGlyph3D> glyphs;
glyphs->SetInputConnection(cluster->GetOutputPort());
glyphs->SetSourceConnection(sphere->GetOutputPort());
glyphs->ScalingOff();
glyphs->Update();
- vtkSmartPointer<vtkPolyDataMapper> mapper =
- vtkSmartPointer<vtkPolyDataMapper>::New();
+ vtkNew<vtkPolyDataMapper> mapper;
mapper->SetInputConnection(glyphs->GetOutputPort());
mapper->SetScalarRange(0, tableSize - 1);
mapper->SetLookupTable(lut);
- vtkSmartPointer<vtkActor> actor =
- vtkSmartPointer<vtkActor>::New();
+ vtkNew<vtkActor> actor;
actor->SetMapper(mapper);
// Create graphics stuff
//
- vtkSmartPointer<vtkRenderer> ren1 =
- vtkSmartPointer<vtkRenderer>::New();
- ren1->SetBackground(.3, .4, .6);
+ vtkNew<vtkRenderer> ren1;
+ ren1->SetBackground(colors->GetColor3d("SlateGray").GetData());
- vtkSmartPointer<vtkRenderWindow> renWin =
- vtkSmartPointer<vtkRenderWindow>::New();
+ vtkNew<vtkRenderWindow> renWin;
renWin->AddRenderer(ren1);
renWin->SetSize(640, 512);
+ renWin->SetWindowName("ExtractClusters");
- vtkSmartPointer<vtkRenderWindowInteractor> iren =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
+ vtkNew<vtkRenderWindowInteractor> iren;
iren->SetRenderWindow(renWin);
// Add the actors to the renderer
diff --git a/src/Cxx/Points/ExtractClusters.md b/src/Cxx/Points/ExtractClusters.md
index cc54a44caa788681e49c0710e8ad79620eeb1dec..470e0a3482ce770ca7049473a52bca45e770dc74 100644
--- a/src/Cxx/Points/ExtractClusters.md
+++ b/src/Cxx/Points/ExtractClusters.md
@@ -1,4 +1,5 @@
### Description
+
This example extracts clusters of points. The points lie on spheres that are randomly placed. Each cluster has a different color. The number of extracted clusters may be less that the number of random spheres, if the points on one sphere are within the specified distance of points on another sphere.
!!! note
diff --git a/src/Cxx/Points/ExtractEnclosedPoints.cxx b/src/Cxx/Points/ExtractEnclosedPoints.cxx
index c4a9510bf76f2a77d97da6b81813d9f545b3c1a0..e26a7be9c23b75d17eaee37a7bfaed286788fee2 100644
--- a/src/Cxx/Points/ExtractEnclosedPoints.cxx
+++ b/src/Cxx/Points/ExtractEnclosedPoints.cxx
@@ -1,119 +1,105 @@
-#include <vtkSmartPointer.h>
-#include <vtkExtractEnclosedPoints.h>
-
+#include <vtkActor.h>
#include <vtkBYUReader.h>
+#include <vtkCamera.h>
+#include <vtkExtractEnclosedPoints.h>
+#include <vtkGlyph3DMapper.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
#include <vtkOBJReader.h>
#include <vtkPLYReader.h>
-#include <vtkPolyDataReader.h>
-#include <vtkSTLReader.h>
-#include <vtkXMLPolyDataReader.h>
-#include <vtkSphereSource.h>
-
-#include <vtkGlyph3DMapper.h>
#include <vtkPoints.h>
-#include <vtkActor.h>
#include <vtkPolyDataMapper.h>
+#include <vtkPolyDataReader.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
-#include <vtkCamera.h>
+#include <vtkSTLReader.h>
+#include <vtkSmartPointer.h>
+#include <vtkSphereSource.h>
+#include <vtkXMLPolyDataReader.h>
-#include <vtkNamedColors.h>
#include <vtksys/SystemTools.hxx>
+
#include <random>
-namespace
-{
-vtkSmartPointer<vtkPolyData> ReadPolyData(const char *fileName);
+namespace {
+vtkSmartPointer<vtkPolyData> ReadPolyData(const char* fileName);
}
-int main (int argc, char *argv[])
+int main(int argc, char* argv[])
{
- vtkSmartPointer<vtkPolyData> polyData = ReadPolyData(argc > 1 ? argv[1] : "");
- std::mt19937 mt(4355412); //Standard mersenne_twister_engine
+ auto polyData = ReadPolyData(argc > 1 ? argv[1] : "");
+ std::mt19937 mt(4355412); // Standard mersenne_twister_engine
double bounds[6];
polyData->GetBounds(bounds);
- std::cout << "Bounds: "
- << bounds[0] << ", " << bounds[1] << " "
- << bounds[2] << ", " << bounds[3] << " "
- << bounds[4] << ", " << bounds[5] << std::endl;
+ std::cout << "Bounds: " << bounds[0] << ", " << bounds[1] << " " << bounds[2]
+ << ", " << bounds[3] << " " << bounds[4] << ", " << bounds[5]
+ << std::endl;
// Generate random points within the bounding box of the polydata
std::uniform_real_distribution<double> distributionX(bounds[0], bounds[1]);
std::uniform_real_distribution<double> distributionY(bounds[2], bounds[3]);
std::uniform_real_distribution<double> distributionZ(bounds[4], bounds[5]);
- vtkSmartPointer<vtkPolyData> pointsPolyData =
- vtkSmartPointer<vtkPolyData>::New();
- vtkSmartPointer<vtkPoints> points =
- vtkSmartPointer<vtkPoints>::New();
+ vtkNew<vtkPolyData> pointsPolyData;
+ vtkNew<vtkPoints> points;
pointsPolyData->SetPoints(points);
points->SetNumberOfPoints(10000);
for (auto i = 0; i < 10000; ++i)
- {
- double point[3];
- point[0] = distributionX(mt);
- point[1] = distributionY(mt);
- point[2] = distributionZ(mt);
- points->SetPoint(i, point);
- }
-
- vtkSmartPointer<vtkExtractEnclosedPoints> extract =
- vtkSmartPointer<vtkExtractEnclosedPoints>::New();
+ {
+ double point[3];
+ point[0] = distributionX(mt);
+ point[1] = distributionY(mt);
+ point[2] = distributionZ(mt);
+ points->SetPoint(i, point);
+ }
+
+ vtkNew<vtkExtractEnclosedPoints> extract;
extract->SetSurfaceData(polyData);
extract->SetInputData(pointsPolyData);
extract->SetTolerance(.0001);
extract->CheckSurfaceOn();
- vtkSmartPointer<vtkNamedColors> colors =
- vtkSmartPointer<vtkNamedColors>::New();
+ vtkNew<vtkNamedColors> colors;
- vtkSmartPointer<vtkSphereSource> source =
- vtkSmartPointer<vtkSphereSource>::New();
+ vtkNew<vtkSphereSource> source;
source->SetRadius((bounds[1] - bounds[0]) * .005);
- vtkSmartPointer<vtkGlyph3DMapper> glyph3Dmapper =
- vtkSmartPointer<vtkGlyph3DMapper>::New();
+ vtkNew<vtkGlyph3DMapper> glyph3Dmapper;
glyph3Dmapper->SetSourceConnection(source->GetOutputPort());
glyph3Dmapper->SetInputConnection(extract->GetOutputPort());
- vtkSmartPointer<vtkActor> glyphActor =
- vtkSmartPointer<vtkActor>::New();
+ vtkNew<vtkActor> glyphActor;
glyphActor->SetMapper(glyph3Dmapper);
- glyphActor->GetProperty()->SetDiffuseColor(colors->GetColor3d("Crimson").GetData());
- glyphActor->GetProperty()->SetSpecular(.6);
+ glyphActor->GetProperty()->SetDiffuseColor(
+ colors->GetColor3d("Crimson").GetData());
+ glyphActor->GetProperty()->SetSpecular(0.6);
glyphActor->GetProperty()->SetSpecularPower(30);
-;
+ ;
// Visualize
- vtkSmartPointer<vtkPolyDataMapper> mapper =
- vtkSmartPointer<vtkPolyDataMapper>::New();
+ vtkNew<vtkPolyDataMapper> mapper;
mapper->SetInputData(polyData);
- vtkSmartPointer<vtkProperty> backProp =
- vtkSmartPointer<vtkProperty>::New();
+ vtkNew<vtkProperty> backProp;
backProp->SetDiffuseColor(colors->GetColor3d("Banana").GetData());
- backProp->SetSpecular(.6);
+ backProp->SetSpecular(0.6);
backProp->SetSpecularPower(30);
-;
- vtkSmartPointer<vtkActor> actor =
- vtkSmartPointer<vtkActor>::New();
+ vtkNew<vtkActor> actor;
actor->SetMapper(mapper);
actor->SetBackfaceProperty(backProp);
- actor->GetProperty()->SetDiffuseColor(colors->GetColor3d("Crimson").GetData());
- actor->GetProperty()->SetSpecular(.6);
+ actor->GetProperty()->SetDiffuseColor(
+ colors->GetColor3d("Crimson").GetData());
+ actor->GetProperty()->SetSpecular(0.6);
actor->GetProperty()->SetSpecularPower(30);
- actor->GetProperty()->SetOpacity(.3);
+ actor->GetProperty()->SetOpacity(0.3);
- vtkSmartPointer<vtkRenderer> renderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> renderer;
renderer->UseHiddenLineRemovalOn();
- vtkSmartPointer<vtkRenderWindow> renderWindow =
- vtkSmartPointer<vtkRenderWindow>::New();
+ vtkNew<vtkRenderWindow> renderWindow;
renderWindow->AddRenderer(renderer);
- vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
+ vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
renderWindowInteractor->SetRenderWindow(renderWindow);
renderer->AddActor(actor);
@@ -122,6 +108,7 @@ int main (int argc, char *argv[])
renderer->UseHiddenLineRemovalOn();
renderWindow->SetSize(640, 512);
+ renderWindow->SetWindowName("ExtractEnclosedPoints");
renderWindow->Render();
renderWindowInteractor->Start();
@@ -129,67 +116,60 @@ int main (int argc, char *argv[])
return EXIT_SUCCESS;
}
-namespace
-{
-vtkSmartPointer<vtkPolyData> ReadPolyData(const char *fileName)
+namespace {
+vtkSmartPointer<vtkPolyData> ReadPolyData(const char* fileName)
{
vtkSmartPointer<vtkPolyData> polyData;
- std::string extension = vtksys::SystemTools::GetFilenameLastExtension(std::string(fileName));
+ std::string extension =
+ vtksys::SystemTools::GetFilenameLastExtension(std::string(fileName));
if (extension == ".ply")
{
- vtkSmartPointer<vtkPLYReader> reader =
- vtkSmartPointer<vtkPLYReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkPLYReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".vtp")
{
- vtkSmartPointer<vtkXMLPolyDataReader> reader =
- vtkSmartPointer<vtkXMLPolyDataReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkXMLPolyDataReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".obj")
{
- vtkSmartPointer<vtkOBJReader> reader =
- vtkSmartPointer<vtkOBJReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkOBJReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".stl")
{
- vtkSmartPointer<vtkSTLReader> reader =
- vtkSmartPointer<vtkSTLReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkSTLReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".vtk")
{
- vtkSmartPointer<vtkPolyDataReader> reader =
- vtkSmartPointer<vtkPolyDataReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkPolyDataReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".g")
{
- vtkSmartPointer<vtkBYUReader> reader =
- vtkSmartPointer<vtkBYUReader>::New();
- reader->SetGeometryFileName (fileName);
+ vtkNew<vtkBYUReader> reader;
+ reader->SetGeometryFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else
{
- vtkSmartPointer<vtkSphereSource> source =
- vtkSmartPointer<vtkSphereSource>::New();
+ vtkNew<vtkSphereSource> source;
source->Update();
polyData = source->GetOutput();
}
return polyData;
}
-}
+} // namespace
diff --git a/src/Cxx/Points/ExtractEnclosedPoints.md b/src/Cxx/Points/ExtractEnclosedPoints.md
index 534e73abbcae0c1a9d1d298bbd0011c61e277901..8a8ebf98faf1f4d886169e4767bcc6eb72b94296 100644
--- a/src/Cxx/Points/ExtractEnclosedPoints.md
+++ b/src/Cxx/Points/ExtractEnclosedPoints.md
@@ -6,4 +6,3 @@ If the polydata is not closed or is non-manifold, the filter does not create an
!!! warning
Expect a warning message from the vtkExecutive is the enclosing polydata is not closed or non-manifold.
-
diff --git a/src/Cxx/Points/ExtractPointsDemo.cxx b/src/Cxx/Points/ExtractPointsDemo.cxx
index b75b45ee4874de82f60a1676420ba016326932fe..c08d1c373f33eaf7d213a82dad934133c96e078f 100644
--- a/src/Cxx/Points/ExtractPointsDemo.cxx
+++ b/src/Cxx/Points/ExtractPointsDemo.cxx
@@ -4,6 +4,8 @@
#include <vtkCylinder.h>
#include <vtkExtractPoints.h>
#include <vtkGlyph3DMapper.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
@@ -17,14 +19,16 @@
int main(int /*argc*/, char* /* argv */[])
{
+ vtkNew<vtkNamedColors> colors;
+
// Create implicit functions
- auto cone = vtkSmartPointer<vtkCone>::New();
+ vtkNew<vtkCone> cone;
cone->SetAngle(30.0);
- auto sphere = vtkSmartPointer<vtkSphere>::New();
- auto cylinder = vtkSmartPointer<vtkCylinder>::New();
- auto superquadric = vtkSmartPointer<vtkSuperquadric>::New();
+ vtkNew<vtkSphere> sphere;
+ vtkNew<vtkCylinder> cylinder;
+ vtkNew<vtkSuperquadric> superquadric;
superquadric->SetPhiRoundness(2.5);
- superquadric->SetThetaRoundness(.5);
+ superquadric->SetThetaRoundness(0.5);
// Store the functions
std::vector<vtkSmartPointer<vtkImplicitFunction>> functions;
@@ -33,7 +37,7 @@ int main(int /*argc*/, char* /* argv */[])
functions.push_back(cylinder);
functions.push_back(superquadric);
- auto pointSource = vtkSmartPointer<vtkBoundedPointSource>::New();
+ vtkNew<vtkBoundedPointSource> pointSource;
pointSource->SetNumberOfPoints(100000);
// Rows and columns
@@ -42,7 +46,7 @@ int main(int /*argc*/, char* /* argv */[])
// Need a renderer even if there is no actor
std::vector<vtkSmartPointer<vtkRenderer>> renderers;
- double background[6] = {.4, .5, .6, .6, .5, .4};
+ double background[6] = {0.4, 0.5, 0.6, 0.6, 0.5, 0.4};
for (size_t i = 0; i < gridXDimensions * gridYDimensions; i++)
{
renderers.push_back(vtkSmartPointer<vtkRenderer>::New());
@@ -51,15 +55,16 @@ int main(int /*argc*/, char* /* argv */[])
}
// Glyphs
- double radius = .02;
- auto sphereSource = vtkSmartPointer<vtkSphereSource>::New();
+ double radius = 0.02;
+ vtkNew<vtkSphereSource> sphereSource;
sphereSource->SetRadius(radius);
// One render window
- auto renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
+ vtkNew<vtkRenderWindow> renderWindow;
int rendererSize = 256;
renderWindow->SetSize(rendererSize * gridXDimensions,
rendererSize * gridYDimensions);
+ renderWindow->SetWindowName("ExtractPointsDemo");
// Create a pipeline for each function
for (int row = 0; row < static_cast<int>(gridYDimensions); row++)
@@ -85,17 +90,19 @@ int main(int /*argc*/, char* /* argv */[])
continue;
}
// Define the pipeline
- auto extract = vtkSmartPointer<vtkExtractPoints>::New();
+ vtkNew<vtkExtractPoints> extract;
extract->SetInputConnection(pointSource->GetOutputPort());
extract->SetImplicitFunction(functions[index]);
- auto glyph = vtkSmartPointer<vtkGlyph3DMapper>::New();
+ vtkNew<vtkGlyph3DMapper> glyph;
glyph->SetInputConnection(extract->GetOutputPort());
glyph->SetSourceConnection(sphereSource->GetOutputPort());
glyph->ScalingOff();
- auto glyphActor = vtkSmartPointer<vtkActor>::New();
+ vtkNew<vtkActor> glyphActor;
glyphActor->SetMapper(glyph);
+ glyphActor->GetProperty()->SetColor(
+ colors->GetColor3d("MistyRose").GetData());
renderers[index]->AddActor(glyphActor);
renderers[index]->ResetCamera();
@@ -105,7 +112,7 @@ int main(int /*argc*/, char* /* argv */[])
renderers[index]->ResetCameraClippingRange();
}
}
- auto iren = vtkSmartPointer<vtkRenderWindowInteractor>::New();
+ vtkNew<vtkRenderWindowInteractor> iren;
iren->SetRenderWindow(renderWindow);
renderWindow->Render();
diff --git a/src/Cxx/Points/ExtractSurface.cxx b/src/Cxx/Points/ExtractSurface.cxx
index fb795d17a9ec829cb57eabef7e1dc5edba99d867..0171d85459039feb28e47be96f1cad095af15c17 100644
--- a/src/Cxx/Points/ExtractSurface.cxx
+++ b/src/Cxx/Points/ExtractSurface.cxx
@@ -1,36 +1,36 @@
-#include <vtkSmartPointer.h>
-
-#include <vtkBYUReader.h>
-#include <vtkPLYReader.h>
-#include <vtkXMLPolyDataReader.h>
-#include <vtkPolyDataReader.h>
-#include <vtkOBJReader.h>
-#include <vtkSTLReader.h>
-
-#include <vtkPointSource.h>
-#include <vtkPCANormalEstimation.h>
-#include <vtkSignedDistance.h>
+#include <vtkCamera.h>
#include <vtkExtractSurface.h>
+#include <vtkMinimalStandardRandomSequence.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
+#include <vtkPCANormalEstimation.h>
#include <vtkPointData.h>
-
+#include <vtkPointSource.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
-#include <vtkCamera.h>
+#include <vtkSignedDistance.h>
+#include <vtkSmartPointer.h>
-#include <vtkNamedColors.h>
#include <vtksys/SystemTools.hxx>
-namespace
-{
-vtkSmartPointer<vtkPolyData> ReadPolyData(const char *fileName);
+#include <vtkBYUReader.h>
+#include <vtkOBJReader.h>
+#include <vtkPLYReader.h>
+#include <vtkPolyDataReader.h>
+#include <vtkSTLReader.h>
+#include <vtkXMLPolyDataReader.h>
+
+namespace {
+vtkSmartPointer<vtkPolyData> ReadPolyData(const char* fileName);
}
-int main (int argc, char *argv[])
+int main(int argc, char* argv[])
{
- vtkSmartPointer<vtkPolyData> polyData = ReadPolyData(argc > 1 ? argv[1] : "");;
+ auto polyData = ReadPolyData(argc > 1 ? argv[1] : "");
+
std::cout << "# of points: " << polyData->GetNumberOfPoints() << std::endl;
double bounds[6];
@@ -38,90 +38,75 @@ int main (int argc, char *argv[])
double range[3];
for (int i = 0; i < 3; ++i)
{
- range[i] = bounds[2*i + 1] - bounds[2*i];
+ range[i] = bounds[2 * i + 1] - bounds[2 * i];
}
- int sampleSize = polyData->GetNumberOfPoints() * .00005;
+ int sampleSize = polyData->GetNumberOfPoints() * 0.00005;
if (sampleSize < 10)
{
sampleSize = 10;
}
std::cout << "Sample size is: " << sampleSize << std::endl;
// Do we need to estimate normals?
- vtkSmartPointer<vtkSignedDistance> distance =
- vtkSmartPointer<vtkSignedDistance>::New();
+ vtkNew<vtkSignedDistance> distance;
if (polyData->GetPointData()->GetNormals())
{
std::cout << "Using normals from input file" << std::endl;
- distance->SetInputData (polyData);
+ distance->SetInputData(polyData);
}
else
{
std::cout << "Estimating normals using PCANormalEstimation" << std::endl;
- vtkSmartPointer<vtkPCANormalEstimation> normals =
- vtkSmartPointer<vtkPCANormalEstimation>::New();
- normals->SetInputData (polyData);
+ vtkNew<vtkPCANormalEstimation> normals;
+ normals->SetInputData(polyData);
normals->SetSampleSize(sampleSize);
normals->SetNormalOrientationToGraphTraversal();
normals->FlipNormalsOn();
- distance->SetInputConnection (normals->GetOutputPort());
+ distance->SetInputConnection(normals->GetOutputPort());
}
- std::cout << "Range: "
- << range[0] << ", "
- << range[1] << ", "
- << range[2] << std::endl;
+ std::cout << "Range: " << range[0] << ", " << range[1] << ", " << range[2]
+ << std::endl;
int dimension = 256;
double radius;
- radius = std::max(std::max(range[0], range[1]), range[2])
- / static_cast<double>(dimension) * 4; // ~4 voxels
+ radius = std::max(std::max(range[0], range[1]), range[2]) /
+ static_cast<double>(dimension) * 4; // ~4 voxels
std::cout << "Radius: " << radius << std::endl;
distance->SetRadius(radius);
distance->SetDimensions(dimension, dimension, dimension);
- distance->SetBounds(
- bounds[0] - range[0] * .1,
- bounds[1] + range[0] * .1,
- bounds[2] - range[1] * .1,
- bounds[3] + range[1] * .1,
- bounds[4] - range[2] * .1,
- bounds[5] + range[2] * .1);
-
- vtkSmartPointer<vtkExtractSurface> surface =
- vtkSmartPointer<vtkExtractSurface>::New();
- surface->SetInputConnection (distance->GetOutputPort());
+ distance->SetBounds(bounds[0] - range[0] * .1, bounds[1] + range[0] * .1,
+ bounds[2] - range[1] * .1, bounds[3] + range[1] * .1,
+ bounds[4] - range[2] * .1, bounds[5] + range[2] * .1);
+
+ vtkNew<vtkExtractSurface> surface;
+ surface->SetInputConnection(distance->GetOutputPort());
surface->SetRadius(radius * .99);
surface->Update();
- vtkSmartPointer<vtkPolyDataMapper> surfaceMapper =
- vtkSmartPointer<vtkPolyDataMapper>::New();
+ vtkNew<vtkPolyDataMapper> surfaceMapper;
surfaceMapper->SetInputConnection(surface->GetOutputPort());
- vtkSmartPointer<vtkNamedColors> colors =
- vtkSmartPointer<vtkNamedColors>::New();
+ vtkNew<vtkNamedColors> colors;
- vtkSmartPointer<vtkProperty> back =
- vtkSmartPointer<vtkProperty>::New();
- back->SetColor(colors->GetColor3d("banana").GetData());
+ vtkNew<vtkProperty> back;
+ back->SetColor(colors->GetColor3d("Banana").GetData());
- vtkSmartPointer<vtkActor> surfaceActor =
- vtkSmartPointer<vtkActor>::New();
+ vtkNew<vtkActor> surfaceActor;
surfaceActor->SetMapper(surfaceMapper);
surfaceActor->GetProperty()->SetColor(colors->GetColor3d("Tomato").GetData());
surfaceActor->SetBackfaceProperty(back);
// Create graphics stuff
//
- vtkSmartPointer<vtkRenderer> ren1 =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> ren1;
ren1->SetBackground(colors->GetColor3d("SlateGray").GetData());
- vtkSmartPointer<vtkRenderWindow> renWin =
- vtkSmartPointer<vtkRenderWindow>::New();
+ vtkNew<vtkRenderWindow> renWin;
renWin->AddRenderer(ren1);
- renWin->SetSize(512,512);
+ renWin->SetSize(512, 512);
+ renWin->SetWindowName("ExtractSurface");
- vtkSmartPointer<vtkRenderWindowInteractor> iren =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
+ vtkNew<vtkRenderWindowInteractor> iren;
iren->SetRenderWindow(renWin);
// Add the actors to the renderer, set the background and size
@@ -143,73 +128,75 @@ int main (int argc, char *argv[])
return EXIT_SUCCESS;
}
-namespace
-{
-vtkSmartPointer<vtkPolyData> ReadPolyData(const char *fileName)
+namespace {
+vtkSmartPointer<vtkPolyData> ReadPolyData(const char* fileName)
{
vtkSmartPointer<vtkPolyData> polyData;
- std::string extension = vtksys::SystemTools::GetFilenameExtension(std::string(fileName));
+ std::string extension =
+ vtksys::SystemTools::GetFilenameExtension(std::string(fileName));
if (extension == ".ply")
{
- vtkSmartPointer<vtkPLYReader> reader =
- vtkSmartPointer<vtkPLYReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkPLYReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".vtp")
{
- vtkSmartPointer<vtkXMLPolyDataReader> reader =
- vtkSmartPointer<vtkXMLPolyDataReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkXMLPolyDataReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".vtk")
{
- vtkSmartPointer<vtkPolyDataReader> reader =
- vtkSmartPointer<vtkPolyDataReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkPolyDataReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".obj")
{
- vtkSmartPointer<vtkOBJReader> reader =
- vtkSmartPointer<vtkOBJReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkOBJReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".stl")
{
- vtkSmartPointer<vtkSTLReader> reader =
- vtkSmartPointer<vtkSTLReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkSTLReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".g")
{
- vtkSmartPointer<vtkBYUReader> reader =
- vtkSmartPointer<vtkBYUReader>::New();
- reader->SetGeometryFileName (fileName);
+ vtkNew<vtkBYUReader> reader;
+ reader->SetGeometryFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else
{
- vtkSmartPointer<vtkPointSource> points =
- vtkSmartPointer<vtkPointSource>::New();
- points->SetNumberOfPoints(1000);
+ vtkNew<vtkMinimalStandardRandomSequence> randomSequence;
+ randomSequence->SetSeed(8775070);
+
+ vtkNew<vtkPointSource> points;
+ points->SetNumberOfPoints(1000);
points->SetRadius(1.0);
- points->SetCenter(vtkMath::Random(-1, 1),
- vtkMath::Random(-1, 1),
- vtkMath::Random(-1, 1));
+ double x, y, z;
+ // random position
+ x = randomSequence->GetRangeValue(-1.0, 1.0);
+ randomSequence->Next();
+ y = randomSequence->GetRangeValue(-1.0, 1.0);
+ randomSequence->Next();
+ z = randomSequence->GetRangeValue(-1.0, 1.0);
+ randomSequence->Next();
+ points->SetCenter(x, y, z);
points->SetDistributionToShell();
points->Update();
polyData = points->GetOutput();
}
return polyData;
}
-}
+} // namespace
diff --git a/src/Cxx/Points/ExtractSurface.md b/src/Cxx/Points/ExtractSurface.md
index b0ce8f880a5008df76b58aa6fad356739877d716..9a77b713842dd79d5ab1eb217a90c13dbad5af3f 100644
--- a/src/Cxx/Points/ExtractSurface.md
+++ b/src/Cxx/Points/ExtractSurface.md
@@ -7,10 +7,10 @@ The image was created using the [Armadillo dataset](https://github.com/lorensen/
!!! info
- [CompareExtractSurface](/Cxx/Points/CompareExtractSurface) compares three surface extraction algorithms.
+ [CompareExtractSurface](../CompareExtractSurface) compares three surface extraction algorithms.
!!! seealso
- [PowercrustExtractSurface](/Cxx/Points/PowercrustExtractSurface) reconstructs surfaces and is implemented as a VTK remote module. [PoissonExtractSurface](/Cxx/Points/PoissonExtractSurface) reconstructs surfaces and is implemented as a VTK remote module.
+ [PowercrustExtractSurface](../PowercrustExtractSurface) reconstructs surfaces and is implemented as a VTK remote module. [PoissonExtractSurface](../PoissonExtractSurface) reconstructs surfaces and is implemented as a VTK remote module.
!!! warning
If you experience extraneous lines in the reconstruction, update your VTK. A [patch](https://gitlab.kitware.com/vtk/vtk/merge_requests/3238) was made on September 5, 2017 to correct the issue.
diff --git a/src/Cxx/Points/ExtractSurfaceDemo.cxx b/src/Cxx/Points/ExtractSurfaceDemo.cxx
index cc05630674a7340c28da0c019f2b4a2916fd53c3..731f022c53d40d56227b74277fa74c6bf3e796a5 100644
--- a/src/Cxx/Points/ExtractSurfaceDemo.cxx
+++ b/src/Cxx/Points/ExtractSurfaceDemo.cxx
@@ -1,3 +1,20 @@
+#include <vtkArrowSource.h>
+#include <vtkCamera.h>
+#include <vtkExtractSurface.h>
+#include <vtkGlyph3D.h>
+#include <vtkMaskPoints.h>
+#include <vtkMinimalStandardRandomSequence.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
+#include <vtkPCANormalEstimation.h>
+#include <vtkPointData.h>
+#include <vtkPointSource.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkProperty.h>
+#include <vtkRenderWindow.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
+#include <vtkSignedDistance.h>
#include <vtkSmartPointer.h>
#include <vtkBYUReader.h>
@@ -7,69 +24,50 @@
#include <vtkSTLReader.h>
#include <vtkXMLPolyDataReader.h>
-#include <vtkPointSource.h>
-#include <vtkPCANormalEstimation.h>
-#include <vtkSignedDistance.h>
-#include <vtkExtractSurface.h>
-#include <vtkPointData.h>
-
-#include <vtkArrowSource.h>
-#include <vtkMaskPoints.h>
-#include <vtkGlyph3D.h>
+#include <vtksys/SystemTools.hxx>
-#include <vtkPolyDataMapper.h>
-#include <vtkProperty.h>
-#include <vtkRenderWindow.h>
-#include <vtkRenderWindowInteractor.h>
-#include <vtkRenderer.h>
-#include <vtkCamera.h>
+namespace {
+void MakeGlyphs(vtkPolyData* src, double size, vtkGlyph3D* glyph);
-#include <vtksys/SystemTools.hxx>
+vtkSmartPointer<vtkPolyData> ReadPolyData(const char* fileName);
+} // namespace
-namespace
+int main(int argc, char* argv[])
{
-void MakeGlyphs(vtkPolyData *src, double size, vtkGlyph3D *glyph);
-vtkSmartPointer<vtkPolyData> ReadPolyData(const char *fileName);
-}
+ vtkNew<vtkNamedColors> colors;
-int main (int argc, char *argv[])
-{
- vtkSmartPointer<vtkPolyData> polyData = ReadPolyData(argc > 1 ? argv[1] : "");;
+ auto polyData = ReadPolyData(argc > 1 ? argv[1] : "");
double bounds[6];
polyData->GetBounds(bounds);
double range[3];
for (int i = 0; i < 3; ++i)
{
- range[i] = bounds[2*i + 1] - bounds[2*i];
+ range[i] = bounds[2 * i + 1] - bounds[2 * i];
}
int sampleSize = 15;
std::cout << "Sample size is: " << sampleSize << std::endl;
// Do we need to estimate normals?
- vtkSmartPointer<vtkSignedDistance> distance =
- vtkSmartPointer<vtkSignedDistance>::New();
- vtkSmartPointer<vtkPCANormalEstimation> normals =
- vtkSmartPointer<vtkPCANormalEstimation>::New();
+ vtkNew<vtkSignedDistance> distance;
+ vtkNew<vtkPCANormalEstimation> normals;
if (polyData->GetPointData()->GetNormals())
{
std::cout << "Using normals from input file" << std::endl;
- distance->SetInputData (polyData);
+ distance->SetInputData(polyData);
}
else
{
std::cout << "Estimating normals using PCANormalEstimation" << std::endl;
- normals->SetInputData (polyData);
+ normals->SetInputData(polyData);
normals->SetSampleSize(sampleSize);
normals->SetNormalOrientationToGraphTraversal();
normals->FlipNormalsOn();
- distance->SetInputConnection (normals->GetOutputPort());
+ distance->SetInputConnection(normals->GetOutputPort());
}
- std::cout << "Range: "
- << range[0] << ", "
- << range[1] << ", "
- << range[2] << std::endl;
+ std::cout << "Range: " << range[0] << ", " << range[1] << ", " << range[2]
+ << std::endl;
int dimension = 512;
double radius;
radius = range[0] / static_cast<double>(dimension) * 3; // ~3 voxels
@@ -77,23 +75,17 @@ int main (int argc, char *argv[])
distance->SetRadius(radius);
distance->SetDimensions(dimension, dimension, dimension);
- distance->SetBounds(
- bounds[0] - range[0] * .1,
- bounds[1] + range[0] * .1,
- bounds[2] - range[1] * .1,
- bounds[3] + range[1] * .1,
- bounds[4] - range[2] * .1,
- bounds[5] + range[2] * .1);
+ distance->SetBounds(bounds[0] - range[0] * .1, bounds[1] + range[0] * .1,
+ bounds[2] - range[1] * .1, bounds[3] + range[1] * .1,
+ bounds[4] - range[2] * .1, bounds[5] + range[2] * .1);
- vtkSmartPointer<vtkExtractSurface> surface =
- vtkSmartPointer<vtkExtractSurface>::New();
- surface->SetInputConnection (distance->GetOutputPort());
+ vtkNew<vtkExtractSurface> surface;
+ surface->SetInputConnection(distance->GetOutputPort());
surface->SetRadius(radius * .99);
surface->HoleFillingOn();
surface->Update();
- vtkSmartPointer<vtkGlyph3D> glyph3D =
- vtkSmartPointer<vtkGlyph3D>::New();
+ vtkNew<vtkGlyph3D> glyph3D;
if (polyData->GetPointData()->GetNormals())
{
MakeGlyphs(polyData, radius * 2.0, glyph3D.GetPointer());
@@ -102,43 +94,37 @@ int main (int argc, char *argv[])
{
MakeGlyphs(normals->GetOutput(), radius * 2.0, glyph3D.GetPointer());
}
- vtkSmartPointer<vtkPolyDataMapper> surfaceMapper =
- vtkSmartPointer<vtkPolyDataMapper>::New();
+ vtkNew<vtkPolyDataMapper> surfaceMapper;
surfaceMapper->SetInputConnection(surface->GetOutputPort());
surfaceMapper->ScalarVisibilityOff();
- vtkSmartPointer<vtkProperty> backProp =
- vtkSmartPointer<vtkProperty>::New();
- backProp->SetColor(0.8900, 0.8100, 0.3400);
+ vtkNew<vtkProperty> backProp;
+ backProp->SetColor(colors->GetColor3d("Banana").GetData());
- vtkSmartPointer<vtkActor> surfaceActor =
- vtkSmartPointer<vtkActor>::New();
+ vtkNew<vtkActor> surfaceActor;
surfaceActor->SetMapper(surfaceMapper);
- surfaceActor->GetProperty()->SetColor(1.0000, 0.4900, 0.2500);
+ surfaceActor->GetProperty()->SetColor(colors->GetColor3d("Coral").GetData());
surfaceActor->SetBackfaceProperty(backProp);
- vtkSmartPointer<vtkPolyDataMapper> glyph3DMapper =
- vtkSmartPointer<vtkPolyDataMapper>::New();
+ vtkNew<vtkPolyDataMapper> glyph3DMapper;
glyph3DMapper->SetInputConnection(glyph3D->GetOutputPort());
- vtkSmartPointer<vtkActor> glyph3DActor =
- vtkSmartPointer<vtkActor>::New();
+ vtkNew<vtkActor> glyph3DActor;
glyph3DActor->SetMapper(glyph3DMapper);
- glyph3DActor->GetProperty()->SetColor(0.6902, 0.7686, 0.8706);
+ glyph3DActor->GetProperty()->SetColor(
+ colors->GetColor3d("MidnightBlue").GetData());
// Create graphics stuff
//
- vtkSmartPointer<vtkRenderer> ren1 =
- vtkSmartPointer<vtkRenderer>::New();
- ren1->SetBackground(.3, .4, .6);
+ vtkNew<vtkRenderer> ren1;
+ ren1->SetBackground(colors->GetColor3d("CornflowerBlue").GetData());
- vtkSmartPointer<vtkRenderWindow> renWin =
- vtkSmartPointer<vtkRenderWindow>::New();
+ vtkNew<vtkRenderWindow> renWin;
renWin->AddRenderer(ren1);
- renWin->SetSize(512,512);
+ renWin->SetSize(512, 512);
+ renWin->SetWindowName("ExtractSurfaceDemo");
- vtkSmartPointer<vtkRenderWindowInteractor> iren =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
+ vtkNew<vtkRenderWindowInteractor> iren;
iren->SetRenderWindow(renWin);
// Add the actors to the renderer, set the background and size
@@ -160,102 +146,98 @@ int main (int argc, char *argv[])
return EXIT_SUCCESS;
}
-namespace
-{
+namespace {
//-----------------------------------------------------------------------------
-void MakeGlyphs(vtkPolyData *src, double size, vtkGlyph3D *glyph)
+void MakeGlyphs(vtkPolyData* src, double size, vtkGlyph3D* glyph)
{
- vtkSmartPointer<vtkMaskPoints> maskPts =
- vtkSmartPointer<vtkMaskPoints>::New();
+ vtkNew<vtkMaskPoints> maskPts;
maskPts->SetOnRatio(20);
maskPts->RandomModeOn();
maskPts->SetInputData(src);
// Source for the glyph filter
- vtkSmartPointer<vtkArrowSource> arrow =
- vtkSmartPointer<vtkArrowSource>::New();
+ vtkNew<vtkArrowSource> arrow;
arrow->SetTipResolution(16);
- arrow->SetTipLength(.3);
- arrow->SetTipRadius(.1);
+ arrow->SetTipLength(0.3);
+ arrow->SetTipRadius(0.1);
glyph->SetSourceConnection(arrow->GetOutputPort());
glyph->SetInputConnection(maskPts->GetOutputPort());
glyph->SetVectorModeToUseNormal();
-// glyph->SetColorModeToColorByVector();
+ // glyph->SetColorModeToColorByVector();
glyph->SetScaleModeToScaleByVector();
glyph->SetScaleFactor(size);
glyph->OrientOn();
glyph->Update();
}
-}
-namespace
-{
-vtkSmartPointer<vtkPolyData> ReadPolyData(const char *fileName)
+vtkSmartPointer<vtkPolyData> ReadPolyData(const char* fileName)
{
vtkSmartPointer<vtkPolyData> polyData;
- std::string extension = vtksys::SystemTools::GetFilenameExtension(std::string(fileName));
+ std::string extension =
+ vtksys::SystemTools::GetFilenameExtension(std::string(fileName));
if (extension == ".ply")
{
- vtkSmartPointer<vtkPLYReader> reader =
- vtkSmartPointer<vtkPLYReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkPLYReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".vtp")
{
- vtkSmartPointer<vtkXMLPolyDataReader> reader =
- vtkSmartPointer<vtkXMLPolyDataReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkXMLPolyDataReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".vtk")
{
- vtkSmartPointer<vtkPolyDataReader> reader =
- vtkSmartPointer<vtkPolyDataReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkPolyDataReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".obj")
{
- vtkSmartPointer<vtkOBJReader> reader =
- vtkSmartPointer<vtkOBJReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkOBJReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".stl")
{
- vtkSmartPointer<vtkSTLReader> reader =
- vtkSmartPointer<vtkSTLReader>::New();
- reader->SetFileName (fileName);
+ vtkNew<vtkSTLReader> reader;
+ reader->SetFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else if (extension == ".g")
{
- vtkSmartPointer<vtkBYUReader> reader =
- vtkSmartPointer<vtkBYUReader>::New();
- reader->SetGeometryFileName (fileName);
+ vtkNew<vtkBYUReader> reader;
+ reader->SetGeometryFileName(fileName);
reader->Update();
polyData = reader->GetOutput();
}
else
{
- vtkSmartPointer<vtkPointSource> points =
- vtkSmartPointer<vtkPointSource>::New();
+ vtkNew<vtkMinimalStandardRandomSequence> randomSequence;
+ randomSequence->SetSeed(8775070);
+
+ vtkNew<vtkPointSource> points;
points->SetNumberOfPoints(100000);
points->SetRadius(10.0);
- points->SetCenter(vtkMath::Random(-100, 100),
- vtkMath::Random(-100, 100),
- vtkMath::Random(-100, 100));
+ double x, y, z;
+ // random position
+ x = randomSequence->GetRangeValue(-100, 100);
+ randomSequence->Next();
+ y = randomSequence->GetRangeValue(-100, 100);
+ randomSequence->Next();
+ z = randomSequence->GetRangeValue(-100, 100);
+ randomSequence->Next();
+ points->SetCenter(x, y, z);
points->SetDistributionToShell();
points->Update();
polyData = points->GetOutput();
}
return polyData;
}
-}
-
+} // namespace
diff --git a/src/Cxx/Points/ExtractSurfaceDemo.md b/src/Cxx/Points/ExtractSurfaceDemo.md
index bad45472680dea5330a8539c4c66bffdf3f197ec..94f772aa193c1366d702b89e22cde132e8f3e582 100644
--- a/src/Cxx/Points/ExtractSurfaceDemo.md
+++ b/src/Cxx/Points/ExtractSurfaceDemo.md
@@ -1,4 +1,5 @@
### Description
+
This example loosely follows the most excellent paper by Curless and
Levoy: ["A Volumetric Method for Building Complex Models from Range
Images."](https://graphics.stanford.edu/papers/volrange) First it
@@ -8,8 +9,7 @@ distance field.
The image was created using the [Armadillo dataset](https://github.com/lorensen/VTKExamples/blob/master/src/Testing/Data/Armadillo.ply?raw=true).
-This is a demo version of [ExtractSurface](ExtractSurface). It displays some a sampling of the normals with arrows. It also uses a different color for the front and back surfaces.
+This is a demo version of [ExtractSurface](../ExtractSurface). It displays some a sampling of the normals with arrows. It also uses a different color for the front and back surfaces.
!!! warning
The classes used in this example require vtk 7.1 or later.
-
diff --git a/src/Cxx/Points/FitImplicitFunction.cxx b/src/Cxx/Points/FitImplicitFunction.cxx
index 258cefde83d4d356a53284c2c5a0c4d8e17c3b8e..811f992e1daf6378af6f54eb1f919ce8335136de 100644
--- a/src/Cxx/Points/FitImplicitFunction.cxx
+++ b/src/Cxx/Points/FitImplicitFunction.cxx
@@ -1,78 +1,73 @@
-#include <vtkSmartPointer.h>
-#include <vtkFitImplicitFunction.h>
#include <vtkBoundedPointSource.h>
-
-#include <vtkSphere.h>
-#include <vtkSphereSource.h>
+#include <vtkCamera.h>
+#include <vtkFitImplicitFunction.h>
#include <vtkGlyph3D.h>
-#include <vtkMath.h>
-
+#include <vtkMinimalStandardRandomSequence.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
-#include <vtkCamera.h>
+#include <vtkSmartPointer.h>
+#include <vtkSphere.h>
+#include <vtkSphereSource.h>
-int main (int, char *[])
+int main(int, char*[])
{
- vtkMath::RandomSeed(4355412); // for test result consistency
+ vtkNew<vtkNamedColors> colors;
+
+ // vtkNew<vtkMinimalStandardRandomSequence> randomSequence;
+ // randomSequence->SetSeed(8775070);
double radius = 1.0;
- vtkSmartPointer<vtkBoundedPointSource> points =
- vtkSmartPointer<vtkBoundedPointSource>::New();
+ vtkNew<vtkBoundedPointSource> points;
points->SetNumberOfPoints(1000000);
points->SetBounds(-2.0, 2.0, -2.0, 2.0, -2.0, 2.0);
- vtkSmartPointer<vtkSphere> sphere =
- vtkSmartPointer<vtkSphere>::New();
+ vtkNew<vtkSphere> sphere;
sphere->SetRadius(radius);
- vtkSmartPointer<vtkFitImplicitFunction> fit =
- vtkSmartPointer<vtkFitImplicitFunction>::New();
+ vtkNew<vtkFitImplicitFunction> fit;
fit->SetInputConnection(points->GetOutputPort());
fit->SetImplicitFunction(sphere);
- fit->SetThreshold(.01);
+ fit->SetThreshold(0.01);
fit->Update();
std::cout << fit->GetOutput()->GetNumberOfPoints() << " out of "
<< points->GetNumberOfPoints() << " points are within "
<< fit->GetThreshold() << " of the implicit function" << std::endl;
- vtkSmartPointer<vtkSphereSource> sphereSource =
- vtkSmartPointer<vtkSphereSource>::New();
- sphereSource->SetRadius(radius * .05);
+ vtkNew<vtkSphereSource> sphereSource;
+ sphereSource->SetRadius(radius * 0.05);
- vtkSmartPointer<vtkGlyph3D> glyph3D =
- vtkSmartPointer<vtkGlyph3D>::New();
+ vtkNew<vtkGlyph3D> glyph3D;
glyph3D->SetInputConnection(fit->GetOutputPort());
glyph3D->SetSourceConnection(sphereSource->GetOutputPort());
glyph3D->ScalingOff();
glyph3D->Update();
- vtkSmartPointer<vtkPolyDataMapper> glyph3DMapper =
- vtkSmartPointer<vtkPolyDataMapper>::New();
+ vtkNew<vtkPolyDataMapper> glyph3DMapper;
glyph3DMapper->SetInputConnection(glyph3D->GetOutputPort());
- vtkSmartPointer<vtkActor> glyph3DActor =
- vtkSmartPointer<vtkActor>::New();
+ vtkNew<vtkActor> glyph3DActor;
glyph3DActor->SetMapper(glyph3DMapper);
- glyph3DActor->GetProperty()->SetColor(0.8900, 0.8100, 0.3400);
+ glyph3DActor->GetProperty()->SetColor(
+ colors->GetColor3d("Banana").GetData());
// Create graphics stuff
//
- vtkSmartPointer<vtkRenderer> ren1 =
- vtkSmartPointer<vtkRenderer>::New();
- ren1->SetBackground(.3, .4, .6);
+ vtkNew<vtkRenderer> ren1;
+ ren1->SetBackground(colors->GetColor3d("CornflowerBlue").GetData());
- vtkSmartPointer<vtkRenderWindow> renWin =
- vtkSmartPointer<vtkRenderWindow>::New();
+ vtkNew<vtkRenderWindow> renWin;
renWin->AddRenderer(ren1);
- renWin->SetSize(512,512);
+ renWin->SetSize(512, 512);
+ renWin->SetWindowName("FitImplicitFunction");
- vtkSmartPointer<vtkRenderWindowInteractor> iren =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
+ vtkNew<vtkRenderWindowInteractor> iren;
iren->SetRenderWindow(renWin);
-
+
// Add the actors to the renderer, set the background and size
//
ren1->AddActor(glyph3DActor);
@@ -88,6 +83,5 @@ int main (int, char *[])
renWin->Render();
iren->Initialize();
iren->Start();
-
return EXIT_SUCCESS;
}
diff --git a/src/Cxx/Points/MaskPointsFilter.cxx b/src/Cxx/Points/MaskPointsFilter.cxx
index 09a4c86ea53a83c3de09c2a285ed109408a8d9b0..ca3d985fedb2a00524acff8deb41d6eaf190bb98 100644
--- a/src/Cxx/Points/MaskPointsFilter.cxx
+++ b/src/Cxx/Points/MaskPointsFilter.cxx
@@ -1,25 +1,30 @@
-#include <vtkSmartPointer.h>
-#include <vtkMaskPointsFilter.h>
#include <vtkBoundedPointSource.h>
-#include <vtkImageData.h>
+#include <vtkCamera.h>
#include <vtkCone.h>
-#include <vtkSampleImplicitFunctionFilter.h>
+#include <vtkGlyph3D.h>
+#include <vtkImageData.h>
#include <vtkImageThreshold.h>
-#include <vtkBoundedPointSource.h>
+#include <vtkMaskPointsFilter.h>
#include <vtkMetaImageReader.h>
-#include <vtkSphereSource.h>
-#include <vtkGlyph3D.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
-#include <vtkCamera.h>
+#include <vtkSampleImplicitFunctionFilter.h>
+#include <vtkSmartPointer.h>
+#include <vtkSphereSource.h>
-static vtkSmartPointer<vtkImageData> CreatePoints();
+namespace {
+vtkSmartPointer<vtkImageData> CreatePoints();
+}
-int main (int argc, char *argv[])
+int main(int argc, char* argv[])
{
+ vtkNew<vtkNamedColors> colors;
+
vtkSmartPointer<vtkImageData> imageMask;
if (argc < 2)
{
@@ -32,14 +37,12 @@ int main (int argc, char *argv[])
{
upper = atoi(argv[2]);
}
- // Read the volume data
- vtkSmartPointer<vtkMetaImageReader> reader =
- vtkSmartPointer<vtkMetaImageReader>::New();
- reader->SetFileName (argv[1]);
+ // Read the volume data e.g. FullHead.mhd
+ vtkNew<vtkMetaImageReader> reader;
+ reader->SetFileName(argv[1]);
reader->Update();
- vtkSmartPointer<vtkImageThreshold> threshold =
- vtkSmartPointer<vtkImageThreshold>::New();
+ vtkNew<vtkImageThreshold> threshold;
threshold->SetInputConnection(reader->GetOutputPort());
threshold->ThresholdByUpper(upper);
threshold->SetOutputScalarTypeToUnsignedChar();
@@ -50,62 +53,54 @@ int main (int argc, char *argv[])
threshold->Update();
imageMask = dynamic_cast<vtkImageData*>(threshold->GetOutput());
}
- vtkSmartPointer<vtkBoundedPointSource> pointSource =
- vtkSmartPointer<vtkBoundedPointSource>::New();
+ vtkNew<vtkBoundedPointSource> pointSource;
pointSource->SetNumberOfPoints(100000);
pointSource->SetBounds(imageMask->GetBounds());
- vtkSmartPointer<vtkMaskPointsFilter> maskPoints =
- vtkSmartPointer<vtkMaskPointsFilter>::New();
+ vtkNew<vtkMaskPointsFilter> maskPoints;
maskPoints->SetInputConnection(pointSource->GetOutputPort());
maskPoints->SetMaskData(imageMask);
double radius = imageMask->GetSpacing()[0] * 4.0;
- vtkSmartPointer<vtkSphereSource> sphereSource =
- vtkSmartPointer<vtkSphereSource>::New();
+ vtkNew<vtkSphereSource> sphereSource;
sphereSource->SetRadius(radius);
- vtkSmartPointer<vtkGlyph3D> glyph =
- vtkSmartPointer<vtkGlyph3D>::New();
+ vtkNew<vtkGlyph3D> glyph;
glyph->SetInputConnection(maskPoints->GetOutputPort());
glyph->SetSourceConnection(sphereSource->GetOutputPort());
glyph->ScalingOff();
glyph->Update();
- vtkSmartPointer<vtkPolyDataMapper> glyphMapper =
- vtkSmartPointer<vtkPolyDataMapper>::New();
+ vtkNew<vtkPolyDataMapper> glyphMapper;
glyphMapper->SetInputConnection(glyph->GetOutputPort());
glyphMapper->ScalarVisibilityOff();
- vtkSmartPointer<vtkActor> glyphActor =
- vtkSmartPointer<vtkActor>::New();
+ vtkNew<vtkActor> glyphActor;
glyphActor->SetMapper(glyphMapper);
- glyphActor->GetProperty()->SetColor(0.8900, 0.8100, 0.3400);
+ glyphActor->GetProperty()->SetColor(colors->GetColor3d("Banana").GetData());
// Create graphics stuff
//
- vtkSmartPointer<vtkRenderer> ren1 =
- vtkSmartPointer<vtkRenderer>::New();
- ren1->SetBackground(.3, .4, .6);
+ vtkNew<vtkRenderer> ren1;
+ ren1->SetBackground(colors->GetColor3d("CornflowerBlue").GetData());
- vtkSmartPointer<vtkRenderWindow> renWin =
- vtkSmartPointer<vtkRenderWindow>::New();
+ vtkNew<vtkRenderWindow> renWin;
renWin->AddRenderer(ren1);
- renWin->SetSize(512,512);
+ renWin->SetSize(512, 512);
+ renWin->SetWindowName("MaskPointsFilter");
- vtkSmartPointer<vtkRenderWindowInteractor> iren =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
+ vtkNew<vtkRenderWindowInteractor> iren;
iren->SetRenderWindow(renWin);
-
+
// Add the actors to the renderer, set the background and size
//
ren1->AddActor(glyphActor);
// Generate an interesting view
//
- ren1->GetActiveCamera()->SetPosition (1, 0, 0);
- ren1->GetActiveCamera()->SetFocalPoint (0, 1, 0);
- ren1->GetActiveCamera()->SetViewUp (0, 0, -1);
+ ren1->GetActiveCamera()->SetPosition(1, 0, 0);
+ ren1->GetActiveCamera()->SetFocalPoint(0, 1, 0);
+ ren1->GetActiveCamera()->SetViewUp(0, 0, -1);
ren1->GetActiveCamera()->Azimuth(30);
ren1->GetActiveCamera()->Elevation(30);
ren1->ResetCamera();
@@ -119,25 +114,22 @@ int main (int argc, char *argv[])
return EXIT_SUCCESS;
}
-static vtkSmartPointer<vtkImageData> CreatePoints()
+namespace {
+vtkSmartPointer<vtkImageData> CreatePoints()
{
vtkSmartPointer<vtkImageData> imageMask;
- vtkSmartPointer<vtkImageData> image =
- vtkSmartPointer<vtkImageData>::New();
- image->SetDimensions(256,256,256);
- image->AllocateScalars(VTK_DOUBLE,1);
- image->SetSpacing(5.0/255.0, 5.0/255.0, 5.0/255.0);
+ vtkNew<vtkImageData> image;
+ image->SetDimensions(256, 256, 256);
+ image->AllocateScalars(VTK_DOUBLE, 1);
+ image->SetSpacing(5.0 / 255.0, 5.0 / 255.0, 5.0 / 255.0);
image->SetOrigin(-2.5, -2.5, -2.5);
- vtkSmartPointer<vtkCone> implicitFunction =
- vtkSmartPointer<vtkCone>::New();
- vtkSmartPointer<vtkSampleImplicitFunctionFilter> sample =
- vtkSmartPointer<vtkSampleImplicitFunctionFilter>::New();
+ vtkNew<vtkCone> implicitFunction;
+ vtkNew<vtkSampleImplicitFunctionFilter> sample;
sample->SetImplicitFunction(implicitFunction);
sample->SetInputData(image);
-
- vtkSmartPointer<vtkImageThreshold> threshold =
- vtkSmartPointer<vtkImageThreshold>::New();
+
+ vtkNew<vtkImageThreshold> threshold;
threshold->SetInputConnection(sample->GetOutputPort());
threshold->ThresholdByLower(.5);
threshold->SetOutputScalarTypeToUnsignedChar();
@@ -149,3 +141,4 @@ static vtkSmartPointer<vtkImageData> CreatePoints()
imageMask = dynamic_cast<vtkImageData*>(threshold->GetOutput());
return imageMask;
}
+} // namespace
diff --git a/src/Cxx/PolyData/MaskPoints.cxx b/src/Cxx/PolyData/MaskPoints.cxx
index ad27ccbeeed809f4f9ed2201a2ddd12c5f799814..dc9134d98c447d7956d9e8edd19b54eb59f124ca 100644
--- a/src/Cxx/PolyData/MaskPoints.cxx
+++ b/src/Cxx/PolyData/MaskPoints.cxx
@@ -1,5 +1,6 @@
-#include <vtkSmartPointer.h>
#include <vtkMaskPoints.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
#include <vtkPointSource.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
@@ -10,9 +11,10 @@
int main(int, char*[])
{
+ vtkNew<vtkNamedColors> colors;
+
// Create a set of points
- vtkSmartPointer<vtkPointSource> pointsSource =
- vtkSmartPointer<vtkPointSource>::New();
+ vtkNew<vtkPointSource> pointsSource;
pointsSource->SetNumberOfPoints(40);
pointsSource->Update();
@@ -20,42 +22,41 @@ int main(int, char*[])
<< " input points." << std::endl;
// Create a point set
- vtkSmartPointer<vtkMaskPoints> maskPoints =
- vtkSmartPointer<vtkMaskPoints>::New();
- maskPoints->SetOnRatio(2); //keep every 2nd point (half the number of points)
+ vtkNew<vtkMaskPoints> maskPoints;
+ maskPoints->SetOnRatio(2); // keep every 2nd point (half the number of points)
maskPoints->SetInputConnection(pointsSource->GetOutputPort());
maskPoints->Update();
- vtkSmartPointer<vtkVertexGlyphFilter> glyphFilter =
- vtkSmartPointer<vtkVertexGlyphFilter>::New();
+ vtkNew<vtkVertexGlyphFilter> glyphFilter;
glyphFilter->SetInputConnection(maskPoints->GetOutputPort());
glyphFilter->Update();
-
+
std::cout << "There are " << maskPoints->GetOutput()->GetNumberOfPoints()
<< " masked points." << std::endl;
- vtkSmartPointer<vtkPolyDataMapper> inputMapper =
- vtkSmartPointer<vtkPolyDataMapper>::New();
+ vtkNew<vtkPolyDataMapper> inputMapper;
inputMapper->SetInputConnection(pointsSource->GetOutputPort());
- vtkSmartPointer<vtkActor> inputActor =
- vtkSmartPointer<vtkActor>::New();
+ vtkNew<vtkActor> inputActor;
inputActor->SetMapper(inputMapper);
+ inputActor->GetProperty()->SetPointSize(5);
+ inputActor->GetProperty()->SetColor(
+ colors->GetColor3d("MistyRose").GetData());
- vtkSmartPointer<vtkPolyDataMapper> maskedMapper =
- vtkSmartPointer<vtkPolyDataMapper>::New();
+ vtkNew<vtkPolyDataMapper> maskedMapper;
maskedMapper->SetInputConnection(glyphFilter->GetOutputPort());
- vtkSmartPointer<vtkActor> maskedActor =
- vtkSmartPointer<vtkActor>::New();
+ vtkNew<vtkActor> maskedActor;
maskedActor->SetMapper(maskedMapper);
+ maskedActor->GetProperty()->SetPointSize(5);
+ maskedActor->GetProperty()->SetColor(
+ colors->GetColor3d("MistyRose").GetData());
// There will be one render window
- vtkSmartPointer<vtkRenderWindow> renderWindow =
- vtkSmartPointer<vtkRenderWindow>::New();
+ vtkNew<vtkRenderWindow> renderWindow;
renderWindow->SetSize(600, 300);
+ renderWindow->SetWindowName("MaskPoints");
// And one interactor
- vtkSmartPointer<vtkRenderWindowInteractor> interactor =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
+ vtkNew<vtkRenderWindowInteractor> interactor;
interactor->SetRenderWindow(renderWindow);
// Define viewport ranges
@@ -64,19 +65,16 @@ int main(int, char*[])
double rightViewport[4] = {0.5, 0.0, 1.0, 1.0};
// Setup both renderers
- vtkSmartPointer<vtkRenderer> leftRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> leftRenderer;
renderWindow->AddRenderer(leftRenderer);
leftRenderer->SetViewport(leftViewport);
- leftRenderer->SetBackground(.6, .5, .4);
+ leftRenderer->SetBackground(colors->GetColor3d("Chocolate").GetData());
- vtkSmartPointer<vtkRenderer> rightRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> rightRenderer;
renderWindow->AddRenderer(rightRenderer);
rightRenderer->SetViewport(rightViewport);
- rightRenderer->SetBackground(.4, .5, .6);
+ rightRenderer->SetBackground(colors->GetColor3d("SteelBlue").GetData());
- // Add the sphere to the left and the cube to the right
leftRenderer->AddActor(inputActor);
rightRenderer->AddActor(maskedActor);
@@ -85,6 +83,6 @@ int main(int, char*[])
renderWindow->Render();
interactor->Start();
-
+
return EXIT_SUCCESS;
}