Implement Overlapping triangles loss

[martinnormark]

Background:

The Overlapping Triangles Loss (Lo) is designed to penalize triangles that overlap in space, particularly those with parallel planes. Overlapping triangles can result in mesh artifacts that compromise the visual and structural integrity of the simplified mesh. This loss is a critical component in maintaining the quality of the mesh during the simplification process.

Objective:

Implement the Overlapping Triangles Loss (Lo) as described in the paper. The loss should effectively detect and penalize triangles that overlap in space by sampling points from each triangle and ensuring that each point is uniquely associated with only one triangle. The penalty should be proportional to the degree of overlap.

Key Requirements:

1. Point Sampling from Triangles:

   • Implement a method to sample a sufficient number of points from each generated triangle (face) in the simplified mesh. The number of points sampled should be enough to reliably detect overlaps.

2. Overlap Detection:

   • For each sampled point, check whether it belongs to multiple triangles. This can be determined by checking if the point lies within the area of more than one triangle.
   • Compute the sum of the areas formed by the sampled point and the vertices of each of the k-nearest triangles. If a point can belong to more than one triangle, this indicates an overlap.

3. Loss Calculation:

   • For each triangle, calculate a penalty proportional to the number of faces that overlap with it.
   • Sum these penalties to obtain the total loss Lo.

4. Integration with Existing Framework:

   • The loss function should be implemented as a PyTorch module (nn.Module) to allow easy integration into the existing neural mesh simplification pipeline.
   • Ensure that the implementation is efficient, especially in handling large meshes and high-resolution point sampling, by leveraging GPU acceleration and vectorized operations in PyTorch.

5. Testing and Validation:

   • Develop unit tests to verify the correctness of the point sampling, overlap detection, and loss calculation.
   • Create synthetic test cases where the expected overlap is known, and validate that the loss function correctly penalizes overlapping triangles.

Challenges:

1. Efficiency in Point Sampling:

   • Efficiently sampling points from each triangle and ensuring that these points are uniformly distributed across the triangle’s surface.

2. Accurate Overlap Detection:

   • Developing a robust method to accurately detect when a point belongs to multiple triangles, especially in cases where triangles are nearly coplanar or have very small overlaps.

3. Handling Edge Cases:

   • Addressing scenarios where triangles are very close but do not overlap or where triangles have complex geometries that make overlap detection challenging.

4. Balancing Accuracy and Performance:

   • Ensuring that the loss function is computationally efficient without sacrificing accuracy, especially when dealing with large meshes that contain many triangles.

Expected Input:

• Simplified mesh data including vertices, faces, and face probabilities.
• Hyperparameters such as the number of nearest neighbors (k) and the number of points to sample from each triangle.

Expected Output:

• A scalar loss value representing the overlapping triangles penalty.

This implementation will be a crucial part of ensuring that the simplified mesh maintains its structural integrity by avoiding overlapping triangles, thereby improving the overall quality of the mesh.

Next Steps:

1. Design and implement the Lo loss function based on the above requirements.
2. Integrate the loss function into the existing mesh simplification pipeline.
3. Develop and run unit tests to validate the implementation.