[vtkusers] Smooth out surface(interpolate)

[Bill Lorensen]

Try vtkLoopSubdivisionFilter. Experiment with SetNUmberOfSubdivisions:

 vtkSmartPointer<vtkLoopSubdivisionFilter> subdivide =
    vtkSmartPointer<vtkLoopSubdivisionFilter>::New();
  subdivide->SetNumberOfSubdivisions(4);
#if VTK_MAJOR_VERSION <= 5
  subdivide->SetInputConnection(outputPolyData->GetProducerPort());
#else
  subdivide->SetInputData(outputPolyData);
#endif

  // Create a mapper and actor
  vtkSmartPointer<vtkPolyDataMapper> mapper =
    vtkSmartPointer<vtkPolyDataMapper>::New();
  mapper->SetInputConnection(subdivide->GetOutputPort());


On Thu, Nov 21, 2013 at 5:21 AM, madz <madaramh at gmail.com> wrote:
> I'm trying to build a 3D surface plot like the below image,
>
> <http://vtk.1045678.n5.nabble.com/file/n5724545/delpeaks1.gif>
>
> The plot I was able to create looks the following image,
>
> <http://vtk.1045678.n5.nabble.com/file/n5724545/not_smooth.png>
>
> How do I smooth out the peaks of the grid, I want it to have an interpolated
> like quality as in the first image.
> My code so far is,
>
> #include <vtkVersion.h>
> #include <vtkSmartPointer.h>
> #include <vtkActor.h>
> #include <vtkDelaunay2D.h>
> #include <vtkLookupTable.h>
> #include <vtkMath.h>
> #include <vtkPointData.h>
> #include <vtkPoints.h>
> #include <vtkPolyData.h>
> #include <vtkPolyDataMapper.h>
> #include <vtkProperty.h>
> #include <vtkRenderWindow.h>
> #include <vtkRenderWindowInteractor.h>
> #include <vtkRenderer.h>
> #include <vtkVertexGlyphFilter.h>
> #include <vtkXMLPolyDataWriter.h>
> #include <vtkCubeAxesActor.h>
> #include <vtkInteractorStyleTrackballCamera.h>
> #include <vtkAxisActor.h>
> #include <vtkCamera.h>
>
> int main(int, char *[])
> {
>         // Create a grid of points (height/terrian map)
>         vtkSmartPointer<vtkPoints> points =
>                 vtkSmartPointer<vtkPoints>::New();
>
>         unsigned int GridSize = 5;
>         double xx, yy, zz;
>         for(unsigned int x = 0; x < GridSize; x++)
>         {
>                 for(unsigned int y = 0; y < GridSize; y++)
>                 {
>                         xx = x + vtkMath::Random(-.2, .2);
>                         yy = y + vtkMath::Random(-.2, .2);
>                         zz = vtkMath::Random(-4, 4);
>                         points->InsertNextPoint(xx, yy, zz);
>                 }
>         }
>
>         // Add the grid points to a polydata object
>         vtkSmartPointer<vtkPolyData> inputPolyData =
>                 vtkSmartPointer<vtkPolyData>::New();
>         inputPolyData->SetPoints(points);
>
>         // Triangulate the grid points
>         vtkSmartPointer<vtkDelaunay2D> delaunay =
>                 vtkSmartPointer<vtkDelaunay2D>::New();
> #if VTK_MAJOR_VERSION <= 5
>         delaunay->SetInput(inputPolyData);
> #else
>         delaunay->SetInputData(inputPolyData);
> #endif
>         delaunay->Update();
>         vtkPolyData* outputPolyData = delaunay->GetOutput();
>
>         double bounds[6];
>         outputPolyData->GetBounds(bounds);
>
>         // Find min and max z
>         double minz = bounds[4];
>         double maxz = bounds[5];
>
>         std::cout << "minz: " << minz << std::endl;
>         std::cout << "maxz: " << maxz << std::endl;
>
>         // Create the color map
>         vtkSmartPointer<vtkLookupTable> colorLookupTable =
>                 vtkSmartPointer<vtkLookupTable>::New();
>         colorLookupTable->SetTableRange(minz, maxz);
>         colorLookupTable->Build();
>
>         // Generate the colors for each point based on the color map
>         vtkSmartPointer<vtkUnsignedCharArray> colors =
>                 vtkSmartPointer<vtkUnsignedCharArray>::New();
>         colors->SetNumberOfComponents(3);
>         colors->SetName("Colors");
>
>         std::cout << "There are " << outputPolyData->GetNumberOfPoints()
>                 << " points." << std::endl;
>
>         for(int i = 0; i < outputPolyData->GetNumberOfPoints(); i++)
>         {
>                 double p[3];
>                 outputPolyData->GetPoint(i,p);
>
>                 double dcolor[3];
>                 colorLookupTable->GetColor(p[2], dcolor);
>                 unsigned char color[3];
>                 for(unsigned int j = 0; j < 3; j++)
>                 {
>                         color[j] = static_cast<unsigned char>(255.0 * dcolor[j]);
>                 }
>                 colors->InsertNextTupleValue(color);
>         }
>
>         outputPolyData->GetPointData()->SetScalars(colors);
>
>         // Create a mapper and actor
>         vtkSmartPointer<vtkPolyDataMapper> mapper =
>                 vtkSmartPointer<vtkPolyDataMapper>::New();
> #if VTK_MAJOR_VERSION <= 5
>         mapper->SetInputConnection(outputPolyData->GetProducerPort());
> #else
>         mapper->SetInputData(outputPolyData);
> #endif
>
>         vtkSmartPointer<vtkActor> actor =
>                 vtkSmartPointer<vtkActor>::New();
>         actor->SetMapper(mapper);
>
>         vtkSmartPointer<vtkCubeAxesActor> axes =
> vtkSmartPointer<vtkCubeAxesActor>::New();
>         axes->SetBounds(delaunay->GetOutput()->GetBounds());
>         axes->SetFlyModeToOuterEdges();
>         axes->XAxisMinorTickVisibilityOff();
>         axes->YAxisMinorTickVisibilityOff();
>         axes->ZAxisMinorTickVisibilityOff();
>         axes->SetXLabelFormat("%6.1f");
>
>         // Create a renderer, render window, and interactor
>         vtkSmartPointer<vtkRenderer> renderer =
>                 vtkSmartPointer<vtkRenderer>::New();
>         vtkSmartPointer<vtkRenderWindow> renderWindow =
>                 vtkSmartPointer<vtkRenderWindow>::New();
>         renderWindow->AddRenderer(renderer);
>         vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
>                 vtkSmartPointer<vtkRenderWindowInteractor>::New();
>         renderWindowInteractor->SetRenderWindow(renderWindow);
>
>         //prevents the pointer option from going haywire
>         vtkSmartPointer<vtkInteractorStyleTrackballCamera> style =
> vtkSmartPointer<vtkInteractorStyleTrackballCamera>::New();
>         renderWindowInteractor->SetInteractorStyle(style);
>
>         // Add the actor to the scene
>         renderer->AddActor(actor);
>         renderer->SetBackground(.1, .2, .3);
>
>         // Render and interact
>         renderWindow->Render();
>
>         renderer->GetActiveCamera()->Elevation(290);
>         renderer->AddViewProp(axes);
>         axes->SetCamera(renderer->GetActiveCamera());
>
>         renderWindowInteractor->Start();
>
>         return EXIT_SUCCESS;
> }
>
> Thank you.
>
>
>
>
> --
> View this message in context: http://vtk.1045678.n5.nabble.com/Smooth-out-surface-interpolate-tp5724545.html
> Sent from the VTK - Users mailing list archive at Nabble.com.
> _______________________________________________
> Powered by www.kitware.com
>
> Visit other Kitware open-source projects at http://www.kitware.com/opensource/opensource.html
>
> Please keep messages on-topic and check the VTK FAQ at: http://www.vtk.org/Wiki/VTK_FAQ
>
> Follow this link to subscribe/unsubscribe:
> http://www.vtk.org/mailman/listinfo/vtkusers



-- 
Unpaid intern in BillsBasement at noware dot com