pick barycoords in selection

Author: nmwsharp

include/polyscope/elementary_geometry.h

@@ -9,7 +9,13 @@
 
 namespace polyscope {
 
+// Compute t \in [0,1] for a point along hte line from lineStart -- lineEnd
 float computeTValAlongLine(glm::vec3 queryP, glm::vec3 lineStart, glm::vec3 lineEnd);
 
+// Project a point onto a plane. planeNormal must be unit
+glm::vec3 projectToPlane(glm::vec3 queryP, glm::vec3 planeNormal, glm::vec3 pointOnPlane);
+
+// Compute the signed area of triangle ABC which lies in the plane give by normal
+float signedTriangleArea(glm::vec3 normal, glm::vec3 pA, glm::vec3 pB, glm::vec3 pC);
 
 }

include/polyscope/surface_mesh.h

@@ -52,8 +52,9 @@ struct QuantityTypeHelper<SurfaceMesh> {
 };
 
 struct SurfaceMeshPickResult {
-  MeshElement elementType; // which kind of element did we click
-  int64_t index;           // index of the clicked element
+  MeshElement elementType;                        // which kind of element did we click
+  int64_t index;                                  // index of the clicked element
+  glm::vec3 baryCoords = glm::vec3{-1., -1., -1}; // coordinates in face, populated only for triangular face picks
 };
 
 // === The grand surface mesh class

src/elementary_geometry.cpp

@@ -19,4 +19,17 @@ float computeTValAlongLine(glm::vec3 queryP, glm::vec3 lineStart, glm::vec3 line
   return t;
 }
 
+glm::vec3 projectToPlane(glm::vec3 queryP, glm::vec3 planeNormal, glm::vec3 pointOnPlane) {
+  glm::vec3 pVec = queryP - pointOnPlane;
+  glm::vec3 pVecOrtho = glm::dot(pVec, planeNormal) * planeNormal;
+  return queryP - pVecOrtho;
+}
+
+float signedTriangleArea(glm::vec3 normal, glm::vec3 pA, glm::vec3 pB, glm::vec3 pC) {
+  glm::vec3 cross = glm::cross(pB - pA, pC - pA);
+  float sign = glm::sign(glm::dot(normal, cross));
+  float area = glm::length(cross) / 2.;
+  return sign * area;
+}
+
 } // namespace polyscope

src/surface_mesh.cpp

@@ -2,8 +2,8 @@
 
 #include "polyscope/surface_mesh.h"
 
-#include "glm/fwd.hpp"
 #include "polyscope/combining_hash_functions.h"
+#include "polyscope/elementary_geometry.h"
 #include "polyscope/pick.h"
 #include "polyscope/polyscope.h"
 #include "polyscope/render/engine.h"
@@ -1170,6 +1170,11 @@ void SurfaceMesh::buildFaceInfoGui(const SurfaceMeshPickResult& result) {
   size_t displayInd = fInd;
   ImGui::TextUnformatted(("Face #" + std::to_string(displayInd)).c_str());
 
+  if (result.baryCoords != glm::vec3{-1., -1., -1.}) {
+    ImGui::Text("selected barycoords = <%.3f, %.3f, %.3f>", result.baryCoords.x, result.baryCoords.y,
+                result.baryCoords.z);
+  }
+
   ImGui::Spacing();
   ImGui::Spacing();
   ImGui::Spacing();
@@ -1446,18 +1451,40 @@ SurfaceMeshPickResult SurfaceMesh::interpretPickResult(const PickResult& rawResu
     result.index = rawResult.localIndex - facePickIndStart;
 
     // TODO barycoords
+    size_t D = faceIndsStart[result.index + 1] - faceIndsStart[result.index];
+    if (D == 3) {
+
+      // gather values and project onto plane
+      size_t iStart = faceIndsStart[result.index];
+      uint32_t vA = faceIndsEntries[iStart];
+      uint32_t vB = faceIndsEntries[iStart + 1];
+      uint32_t vC = faceIndsEntries[iStart + 2];
+      glm::vec3 pA = vertexPositions.getValue(vA);
+      glm::vec3 pB = vertexPositions.getValue(vB);
+      glm::vec3 pC = vertexPositions.getValue(vC);
+      glm::vec3 normal = glm::normalize(glm::cross(pB - pA, pC - pA));
+      glm::vec3 x = projectToPlane(rawResult.position, normal, pA);
+
+      // compute barycentric coordinates as ratio of signed areas
+      float areaABC = signedTriangleArea(normal, pA, pB, pC);
+      float areaXBC = signedTriangleArea(normal, x, pB, pC);
+      float areaXCA = signedTriangleArea(normal, x, pC, pA);
+      float areaXAB = signedTriangleArea(normal, x, pA, pB);
+      glm::vec3 barycoord{areaXBC / areaABC, areaXCA / areaABC, areaXAB / areaABC};
+      result.baryCoords = barycoord;
+    }
+
   } else if (rawResult.localIndex < halfedgePickIndStart) {
     // Edge pick
     result.elementType = MeshElement::EDGE;
     result.index = rawResult.localIndex - edgePickIndStart;
 
-    // TODO tEdge
+
   } else if (rawResult.localIndex < cornerPickIndStart) {
     // Halfedge pick
     result.elementType = MeshElement::HALFEDGE;
     result.index = rawResult.localIndex - halfedgePickIndStart;
 
-    // TODO tEdge
   } else if (rawResult.localIndex < cornerPickIndStart + nCorners()) {
     // Corner pick
     result.elementType = MeshElement::CORNER;