Address MR comments.

Make point duplication user selectable
Make tolerance used for point duplication adjustable
User better name for test PNG.

Author: danlipsa

IO/PLY/Testing/CMakeLists.txt

@@ -5,7 +5,7 @@ vtk_module_test_data(
   Data/squareTextured.ply
   Data/squareTexturedFaces.ply
   Data/vtk.png
-  Data/2vtk.png)
+  Data/two_vtk_logos_stacked.png)
 
 add_subdirectory(Cxx)
 

IO/PLY/Testing/Cxx/CMakeLists.txt

@@ -11,6 +11,6 @@ vtk_add_test_cxx(vtkIOPLYCxxTests tests
 )
 vtk_add_test_cxx(vtkIOPLYCxxTests tests
   TestPLYReaderTextureUVFaces,TestPLYReaderTextureUV.cxx squareTexturedFaces.ply
-  2vtk.png
+  two_vtk_logos_stacked.png
 )
 vtk_test_cxx_executable(vtkIOPLYCxxTests tests)

IO/PLY/vtkPLYReader.cxx

@@ -98,6 +98,8 @@ namespace {
 vtkPLYReader::vtkPLYReader()
 {
   this->Comments = vtkStringArray::New();
+  this->FaceTextureTolerance = 0.000001;
+  this->DuplicatePointsForFaceTexture = true;
 }
 
 vtkPLYReader::~vtkPLYReader()
@@ -431,8 +433,7 @@ int vtkPLYReader::RequestData(
       pointIds.resize(output->GetNumberOfPoints());
       // Used to detect different texture values at a vertex.
       vtkNew<vtkIncrementalOctreePointLocator> texLocator;
-      float tolerance = 0.000001;
-      texLocator->SetTolerance(tolerance);
+      texLocator->SetTolerance(this->FaceTextureTolerance);
       double bounds[] = {0.0, 1.0, 0.0, 1.0, 0.0, 0.0};
       texLocator->InitPointInsertion(texCoords, bounds);
 
@@ -467,10 +468,13 @@ int vtkPLYReader::RequestData(
       {
         vtkPLY::ply_get_property(ply, elemName, &faceProps[6]);
         texCoordsPoints->SetNumberOfTuples(numPts);
-        // initialize texture coordinates with invalid value
-        for (int j = 0; j < numPts; ++j)
+        if (this->DuplicatePointsForFaceTexture)
         {
-          texCoordsPoints->SetTuple2(j, -1, -1);
+          // initialize texture coordinates with invalid value
+          for (int j = 0; j < numPts; ++j)
+          {
+            texCoordsPoints->SetTuple2(j, -1, -1);
+          }
         }
       }
 
@@ -512,82 +516,105 @@ int vtkPLYReader::RequestData(
           //Test to know if there is a texcoord for every vertex
           if (face.nverts == (face.ntexcoord / 2))
           {
-            for (int k = 0; k < face.nverts; k++)
+            if (this->DuplicatePointsForFaceTexture)
             {
-              // texture stored at vtkVerts[k] point
-              float currentTex[2];
-              texCoordsPoints->GetTypedTuple(vtkVerts[k], currentTex);
-              // new texture stored at the current face
-              float newTex[] = {face.texcoord[k * 2],
-                              face.texcoord[k * 2 + 1]};
-              double newTex3[] = {newTex[0], newTex[1], 0};
-              if (currentTex[0] == -1.0)
-              {
-                // newly seen texture coordinates for vertex
-                texCoordsPoints->SetTuple2(vtkVerts[k], newTex[0], newTex[1]);
-                 vtkIdType ti;
-                texLocator->InsertUniquePoint(newTex3, ti);
-                pointIds.resize(
-                  std::max(ti+1,
-                           static_cast<vtkIdType>(pointIds.size())));
-                pointIds[ti].push_back(vtkVerts[k]);
-              }
-              else
+              for (int k = 0; k < face.nverts; k++)
               {
-                if (! vtkMathUtilities::FuzzyCompare(
-                      currentTex[0], newTex[0], tolerance) ||
-                    ! vtkMathUtilities::FuzzyCompare(
-                      currentTex[1], newTex[1], tolerance))
+                // new texture stored at the current face
+                float newTex[] = {face.texcoord[k * 2],
+                                  face.texcoord[k * 2 + 1]};
+                // texture stored at vtkVerts[k] point
+                float currentTex[2];
+                texCoordsPoints->GetTypedTuple(vtkVerts[k], currentTex);
+                double newTex3[] = {newTex[0], newTex[1], 0};
+                if (currentTex[0] == -1.0)
                 {
-                  // different texture coordinate than stored at point vtkVerts[k]
+                  // newly seen texture coordinates for vertex
+                  texCoordsPoints->SetTuple2(
+                    vtkVerts[k], newTex[0], newTex[1]);
                   vtkIdType ti;
-                  int inserted = texLocator->InsertUniquePoint(newTex3, ti);
-                  if (inserted)
-                  {
-                    // newly seen texture coordinate for vertex which already has
-                    // some texture coordinates.
-                    vtkIdType dp = duplicateCellPoint(
-                      output, cell, k);
-                    texCoordsPoints->SetTuple2(dp, newTex[0], newTex[1]);
-                    pointIds.resize(
-                      std::max(ti+1, static_cast<vtkIdType>(pointIds.size())));
-                    pointIds[ti].push_back(dp);
-                  }
-                  else
+                  texLocator->InsertUniquePoint(newTex3, ti);
+                  pointIds.resize(
+                    std::max(ti+1,
+                             static_cast<vtkIdType>(pointIds.size())));
+                  pointIds[ti].push_back(vtkVerts[k]);
+                }
+                else
+                {
+                  if (! vtkMathUtilities::FuzzyCompare(
+                        currentTex[0], newTex[0],
+                        this->FaceTextureTolerance) ||
+                      ! vtkMathUtilities::FuzzyCompare(
+                        currentTex[1], newTex[1],
+                        this->FaceTextureTolerance))
                   {
-                    size_t sameTexIndex = 0;
-                    if (pointIds[ti].size() > 1)
+                    // different texture coordinate
+                    // than stored at point vtkVerts[k]
+                    vtkIdType ti;
+                    int inserted = texLocator->InsertUniquePoint(newTex3, ti);
+                    if (inserted)
                     {
-                      double first[3];
-                      output->GetPoint(vtkVerts[k], first);
-                      for (;sameTexIndex < pointIds[ti].size(); ++sameTexIndex)
+                      // newly seen texture coordinate for vertex
+                      // which already has some texture coordinates.
+                      vtkIdType dp = duplicateCellPoint(
+                        output, cell, k);
+                      texCoordsPoints->SetTuple2(dp, newTex[0], newTex[1]);
+                      pointIds.resize(
+                        std::max(
+                          ti+1, static_cast<vtkIdType>(pointIds.size())));
+                      pointIds[ti].push_back(dp);
+                    }
+                    else
+                    {
+                      size_t sameTexIndex = 0;
+                      if (pointIds[ti].size() > 1)
                       {
-                        double second[3];
-                        output->GetPoint(pointIds[ti][sameTexIndex],second);
-                        if (FuzzyEqual(first, second, tolerance))
+                        double first[3];
+                        output->GetPoint(vtkVerts[k], first);
+                        for (;sameTexIndex < pointIds[ti].size();
+                             ++sameTexIndex)
                         {
-                          break;
+                          double second[3];
+                          output->GetPoint(pointIds[ti][sameTexIndex],second);
+                          if (FuzzyEqual(first, second,
+                                         this->FaceTextureTolerance))
+                          {
+                            break;
+                          }
+                        }
+                        if (sameTexIndex == pointIds[ti].size())
+                        {
+                          // newly seen point for this texture coordinate
+                          vtkIdType dp = duplicateCellPoint(
+                            output, cell, k);
+                          texCoordsPoints->SetTuple2(dp, newTex[0], newTex[1]);
+                          pointIds[ti].push_back(dp);
                         }
                       }
-                      if (sameTexIndex == pointIds[ti].size())
-                      {
-                        // newly seen point for this texture coordinate
-                        vtkIdType dp = duplicateCellPoint(
-                          output, cell, k);
-                        texCoordsPoints->SetTuple2(dp, newTex[0], newTex[1]);
-                        pointIds[ti].push_back(dp);
-                      }
-                    }
 
-                    // texture coordinate already seen before, use the vertex
-                    // associated with these texture coordinates
-                    vtkIdType vi = pointIds[ti][sameTexIndex];
-                    setCellPoint(cell, k, vi);
+                      // texture coordinate already seen before, use the vertex
+                      // associated with these texture coordinates
+                      vtkIdType vi = pointIds[ti][sameTexIndex];
+                      setCellPoint(cell, k, vi);
+                    }
                   }
+                  // same texture coordinate, nothing to do.
                 }
-                // same texture coordinate, nothing to do.
               }
             }
+            else
+            {
+              // if we don't want point duplication we only need to set
+              // the texture coordinates
+              for (int k = 0; k < face.nverts; k++)
+              {
+              // new texture stored at the current face
+              float newTex[] = {face.texcoord[k * 2],
+                              face.texcoord[k * 2 + 1]};
+              texCoordsPoints->SetTuple2(vtkVerts[k], newTex[0], newTex[1]);
+              }
+            }
+
           }
           else
           {

IO/PLY/vtkPLYReader.h

@@ -27,9 +27,12 @@
  * to the output data.
  * If the "face" element has the property "texcoord" a new TCoords
  * point array is created and points are duplicated if they have 2 or
- * more different texture coordinates. This creates a polygonal data
- * that can be textured without artifacts. If unique points are
- * required use a vtkCleanPolyData filter after this reader.
+ * more different texture coordinates. Points are duplicated only if
+ * DuplicatePointsForFaceTexture is true (default).
+ * This creates a polygonal data that can be textured without
+ * artifacts. If unique points are required use a vtkCleanPolyData
+ * filter after this reader or use this reader with DuplicatePointsForFaceTexture
+ * set to false.
  *
  * @sa
  * vtkPLYWriter, vtkCleanPolyData
@@ -61,6 +64,23 @@ class VTKIOPLY_EXPORT vtkPLYReader : public vtkAbstractPolyDataReader
 
   vtkGetObjectMacro(Comments, vtkStringArray);
 
+  /**
+   * Tolerance used to detect different texture coordinates for shared
+   * points for faces.
+   */
+  vtkGetMacro(FaceTextureTolerance, float);
+  vtkSetMacro(FaceTextureTolerance, float);
+
+  /**
+   * If true (default) and the "face" element has the property "texcoord" duplicate
+   * face points if they have 2 or more different texture coordinates.
+   * Otherwise, each texture coordinate for a face point overwrites previously set
+   * texture coordinates for that point.
+   */
+  vtkGetMacro(DuplicatePointsForFaceTexture, bool);
+  vtkSetMacro(DuplicatePointsForFaceTexture, bool);
+
+
 protected:
   vtkPLYReader();
   ~vtkPLYReader() override;
@@ -71,6 +91,9 @@ class VTKIOPLY_EXPORT vtkPLYReader : public vtkAbstractPolyDataReader
 private:
   vtkPLYReader(const vtkPLYReader&) = delete;
   void operator=(const vtkPLYReader&) = delete;
+
+  float FaceTextureTolerance;
+  bool DuplicatePointsForFaceTexture;
 };
 
 #endif