# PolyDataExtractNormals

VTKExamples/Cxx/PolyData/PolyDataExtractNormals

### Description

This demo looks for multiple types of normals in a polydata and generates them if they do not exist.

### Code

PolyDataExtractNormals.cxx

    #include <vtkVersion.h>
    #include <vtkCellData.h>
    #include <vtkDoubleArray.h>
    #include <vtkFloatArray.h>
    #include <vtkPoints.h>
    #include <vtkPolyData.h>
    #include <vtkPolyDataNormals.h>
    #include <vtkPointData.h>
    #include <vtkSmartPointer.h>
    #include <vtkSphereSource.h>
    #include <vtkXMLPolyDataReader.h>

    void TestPointNormals(vtkPolyData* polydata);
    void TestCellNormals(vtkPolyData* polydata);

    bool GetPointNormals(vtkPolyData* polydata);
    bool GetCellNormals(vtkPolyData* polydata);

    int main(int argc, char *argv[])
    {
      vtkSmartPointer<vtkPolyData> polydata = vtkSmartPointer<vtkPolyData>::New();

      // If a file is provided, read it. Else, create a sphere.
      if(argc == 2)
      {

        // Read File
        std::string filename = argv[1]; //first command line argument
        std::cout << "Reading file " << filename << "..." << std::endl;

        vtkSmartPointer<vtkXMLPolyDataReader> reader = vtkSmartPointer<vtkXMLPolyDataReader>::New();
        std::cout << "Reading " << filename << std::endl;
        reader->SetFileName(filename.c_str());
        reader->Update();
        polydata->DeepCopy(reader->GetOutput());
      }
      else
      {
        std::cout << "Creating a sphere..." << std::endl;
        vtkSmartPointer<vtkSphereSource> sphereSource = vtkSmartPointer<vtkSphereSource>::New();
        sphereSource->Update();
        std::cout << "In main: " << sphereSource->GetOutput()->GetNumberOfPoints() << std::endl;
        polydata->DeepCopy(sphereSource->GetOutput());
      }

      std::cout << "PolyData address: " << polydata << std::endl;

      TestPointNormals(polydata);

      TestCellNormals(polydata);

      return EXIT_SUCCESS;
    }

    void TestPointNormals(vtkPolyData* polydata)
    {
      std::cout << "In TestPointNormals: " << polydata->GetNumberOfPoints() << std::endl;
      // Try to read normals directly
      bool hasPointNormals = GetPointNormals(polydata);

      if(!hasPointNormals)
      {
        std::cout << "No point normals were found. Computing normals..." << std::endl;

        // Generate normals
        vtkSmartPointer<vtkPolyDataNormals> normalGenerator = vtkSmartPointer<vtkPolyDataNormals>::New();
    #if VTK_MAJOR_VERSION <= 5
        normalGenerator->SetInput(polydata);
    #else
        normalGenerator->SetInputData(polydata);
    #endif
        normalGenerator->ComputePointNormalsOn();
        normalGenerator->ComputeCellNormalsOff();
        normalGenerator->Update();
        /*
        // Optional settings
        normalGenerator->SetFeatureAngle(0.1);
        normalGenerator->SetSplitting(1);
        normalGenerator->SetConsistency(0);
        normalGenerator->SetAutoOrientNormals(0);
        normalGenerator->SetComputePointNormals(1);
        normalGenerator->SetComputeCellNormals(0);
        normalGenerator->SetFlipNormals(0);
        normalGenerator->SetNonManifoldTraversal(1);
        */

        polydata = normalGenerator->GetOutput();

        // Try to read normals again
        hasPointNormals = GetPointNormals(polydata);

        std::cout << "On the second try, has point normals? " << hasPointNormals << std::endl;

      }
      else
      {
        std::cout << "Point normals were found!" << std::endl;
      }
    }

    void TestCellNormals(vtkPolyData* polydata)
    {
      // Try to read normals directly
      bool hasCellNormals = GetCellNormals(polydata);

      if(!hasCellNormals)
      {
        std::cout << "No cell normals were found. Computing normals..." << std::endl;

        // Generate normals
        vtkSmartPointer<vtkPolyDataNormals> normalGenerator = vtkSmartPointer<vtkPolyDataNormals>::New();
    #if VTK_MAJOR_VERSION <= 5
        normalGenerator->SetInput(polydata);
    #else
        normalGenerator->SetInputData(polydata);
    #endif
        normalGenerator->ComputePointNormalsOff();
        normalGenerator->ComputeCellNormalsOn();
        normalGenerator->Update();
        /*
        // Optional settings
        normalGenerator->SetFeatureAngle(0.1);
        normalGenerator->SetSplitting(1);
        normalGenerator->SetConsistency(0);
        normalGenerator->SetAutoOrientNormals(0);
        normalGenerator->SetComputePointNormals(1);
        normalGenerator->SetComputeCellNormals(0);
        normalGenerator->SetFlipNormals(0);
        normalGenerator->SetNonManifoldTraversal(1);
        */

        polydata = normalGenerator->GetOutput();

        // Try to read normals again
        hasCellNormals = GetCellNormals(polydata);

        std::cout << "On the second try, has cell normals? " << hasCellNormals << std::endl;

      }
      else
      {
        std::cout << "Cell normals were found!" << std::endl;
      }
    }

    bool GetPointNormals(vtkPolyData* polydata)
    {
      std::cout << "In GetPointNormals: " << polydata->GetNumberOfPoints() << std::endl;
      std::cout << "Looking for point normals..." << std::endl;

      // Count points
      vtkIdType numPoints = polydata->GetNumberOfPoints();
      std::cout << "There are " << numPoints << " points." << std::endl;

      // Count triangles
      vtkIdType numPolys = polydata->GetNumberOfPolys();
      std::cout << "There are " << numPolys << " polys." << std::endl;

      ////////////////////////////////////////////////////////////////
      // Double normals in an array
      vtkDoubleArray* normalDataDouble =
        vtkDoubleArray::SafeDownCast(polydata->GetPointData()->GetArray("Normals"));

      if(normalDataDouble)
      {
        int nc = normalDataDouble->GetNumberOfTuples();
        std::cout << "There are " << nc
                << " components in normalDataDouble" << std::endl;
        return true;
      }

      ////////////////////////////////////////////////////////////////
      // Double normals in an array
      vtkFloatArray* normalDataFloat =
        vtkFloatArray::SafeDownCast(polydata->GetPointData()->GetArray("Normals"));

      if(normalDataFloat)
      {
        int nc = normalDataFloat->GetNumberOfTuples();
        std::cout << "There are " << nc
                << " components in normalDataFloat" << std::endl;
        return true;
      }

      ////////////////////////////////////////////////////////////////
      // Point normals
      vtkDoubleArray* normalsDouble =
        vtkDoubleArray::SafeDownCast(polydata->GetPointData()->GetNormals());

      if(normalsDouble)
      {
        std::cout << "There are " << normalsDouble->GetNumberOfComponents()
                  << " components in normalsDouble" << std::endl;
        return true;
      }

      ////////////////////////////////////////////////////////////////
      // Point normals
      vtkFloatArray* normalsFloat =
        vtkFloatArray::SafeDownCast(polydata->GetPointData()->GetNormals());

      if(normalsFloat)
      {
        std::cout << "There are " << normalsFloat->GetNumberOfComponents()
                  << " components in normalsFloat" << std::endl;
        return true;
      }

      /////////////////////////////////////////////////////////////////////
      // Generic type point normals
      vtkDataArray* normalsGeneric = polydata->GetPointData()->GetNormals(); //works
      if(normalsGeneric)
      {
        std::cout << "There are " << normalsGeneric->GetNumberOfTuples()
                  << " normals in normalsGeneric" << std::endl;

        double testDouble[3];
        normalsGeneric->GetTuple(0, testDouble);

        std::cout << "Double: " << testDouble[0] << " "
                  << testDouble[1] << " " << testDouble[2] << std::endl;

        // Can't do this:
        /*
        float testFloat[3];
        normalsGeneric->GetTuple(0, testFloat);

        std::cout << "Float: " << testFloat[0] << " "
                  << testFloat[1] << " " << testFloat[2] << std::endl;
        */
        return true;
      }

      // If the function has not yet quit, there were none of these types of normals
      std::cout << "Normals not found!" << std::endl;
      return false;

    }

    bool GetCellNormals(vtkPolyData* polydata)
    {
      std::cout << "Looking for cell normals..." << std::endl;

      // Count points
      vtkIdType numCells = polydata->GetNumberOfCells();
      std::cout << "There are " << numCells << " cells." << std::endl;

      // Count triangles
      vtkIdType numPolys = polydata->GetNumberOfPolys();
      std::cout << "There are " << numPolys << " polys." << std::endl;

      ////////////////////////////////////////////////////////////////
      // Double normals in an array
      vtkDoubleArray* normalDataDouble =
        vtkDoubleArray::SafeDownCast(polydata->GetCellData()->GetArray("Normals"));

      if(normalDataDouble)
      {
        int nc = normalDataDouble->GetNumberOfTuples();
        std::cout << "There are " << nc
                << " components in normalDataDouble" << std::endl;
        return true;
      }

      ////////////////////////////////////////////////////////////////
      // Double normals in an array
      vtkFloatArray* normalDataFloat =
        vtkFloatArray::SafeDownCast(polydata->GetCellData()->GetArray("Normals"));

      if(normalDataFloat)
      {
        int nc = normalDataFloat->GetNumberOfTuples();
        std::cout << "There are " << nc
                << " components in normalDataFloat" << std::endl;
        return true;
      }

      ////////////////////////////////////////////////////////////////
      // Point normals
      vtkDoubleArray* normalsDouble =
        vtkDoubleArray::SafeDownCast(polydata->GetCellData()->GetNormals());

      if(normalsDouble)
      {
        std::cout << "There are " << normalsDouble->GetNumberOfComponents()
                  << " components in normalsDouble" << std::endl;
        return true;
      }

      ////////////////////////////////////////////////////////////////
      // Point normals
      vtkFloatArray* normalsFloat =
        vtkFloatArray::SafeDownCast(polydata->GetCellData()->GetNormals());

      if(normalsFloat)
      {
        std::cout << "There are " << normalsFloat->GetNumberOfComponents()
                  << " components in normalsFloat" << std::endl;
        return true;
      }

      /////////////////////////////////////////////////////////////////////
      // Generic type point normals
      vtkDataArray* normalsGeneric = polydata->GetCellData()->GetNormals(); //works
      if(normalsGeneric)
      {
        std::cout << "There are " << normalsGeneric->GetNumberOfTuples()
                  << " normals in normalsGeneric" << std::endl;

        double testDouble[3];
        normalsGeneric->GetTuple(0, testDouble);

        std::cout << "Double: " << testDouble[0] << " "
                  << testDouble[1] << " " << testDouble[2] << std::endl;

        // Can't do this:
        /*
        float testFloat[3];
        normalsGeneric->GetTuple(0, testFloat);

        std::cout << "Float: " << testFloat[0] << " "
                  << testFloat[1] << " " << testFloat[2] << std::endl;
        */
        return true;
      }

      // If the function has not yet quit, there were none of these types of normals
      std::cout << "Normals not found!" << std::endl;
      return false;

    }

### CMakeLists.txt

    cmake_minimum_required(VERSION 2.8)

    PROJECT(PolyDataExtractNormals)

    find_package(VTK REQUIRED)
    include(${VTK_USE_FILE})

    add_executable(PolyDataExtractNormals MACOSX_BUNDLE PolyDataExtractNormals.cxx )

    target_link_libraries(PolyDataExtractNormals ${VTK_LIBRARIES})

### Download and Build PolyDataExtractNormals

Click here to download PolyDataExtractNormals and its CMakeLists.txt file. Once the tarball PolyDataExtractNormals.tar has been downloaded and extracted,

    cd PolyDataExtractNormals/build

If VTK is installed:

    cmake ..

If VTK is not installed but compiled on your system, you will need to specify the path to your VTK build:

    cmake -DVTK_DIR:PATH=/home/me/vtk_build ..

Build the project:

    make

and run it:

    ./PolyDataExtractNormals

WINDOWS USERS PLEASE NOTE: Be sure to add the VTK bin directory to your path. This will resolve the VTK dll's at run time.