Commit 7c233446 authored by Radek Ošlejšek's avatar Radek Ošlejšek
Browse files

Merge branch '273-introduce-shadow-casting-glyphs' into 'master' 

Resolve "Introduce shadow-casting glyphs"

Closes #273

See merge request grp-fidentis/analyst2!287
parents 8410844e f5529511

HumanFace/src/main/java/cz/fidentis/analyst/face/HumanFace.java

+30 −0
Original line number Diff line number Diff line
@@ -13,6 +13,9 @@ import cz.fidentis.analyst.feature.services.FeaturePointImportService; 
import cz.fidentis.analyst.kdtree.KdTree;

import cz.fidentis.analyst.mesh.BoundingBox;

import cz.fidentis.analyst.mesh.CurvatureCalculator;

import cz.fidentis.analyst.mesh.GlyphCalculator;

import cz.fidentis.analyst.mesh.core.Glyph;

import cz.fidentis.analyst.mesh.core.MeshFacet;

import cz.fidentis.analyst.mesh.core.MeshModel;

import cz.fidentis.analyst.mesh.io.MeshObjLoader;

import cz.fidentis.analyst.octree.Octree;
@@ -74,6 +77,8 @@ public class HumanFace implements Serializable { 
    

    private final transient SurfaceMask surfaceMask = new SurfaceMask();



    private List<Glyph> glyphs;



    /**

     * Fast (de)serialization handler

     */
@@ -509,6 +514,31 @@ public class HumanFace implements Serializable { 
        return new RelationToMesh(visitor.getDistance(), visitor.getNearestPoints());

    }



    /**

     * Gets the glyphs of the face; can be null.

     *

     * @return list of glyphs

     */

    public List<Glyph> getGlyphSamples() {

        return glyphs;

    }



    /**

     * Computes sample points and information used for shadow-casting glyphs

     *

     * @param force recompute the glyphs even if they were computed before

     * @param maxGlyphs maximum amount of glyphs to compute; used for sampling.

     */

    public void computeGlyphs(boolean force, int maxGlyphs) {

        if (force || glyphs == null) {

            GlyphCalculator glyphCalculator = new GlyphCalculator();

            for (MeshFacet facet : meshModel.getFacets()) {

                glyphCalculator.visitMeshFacet(facet);

            }

            glyphs = glyphCalculator.calculateGlyphSamples(maxGlyphs);

        }

    }



    @Override

    public int hashCode() {

        int hash = 7;

MeshAlgorithms/src/main/java/cz/fidentis/analyst/mesh/GlyphCalculator.java

0 → 100644
+147 −0
Original line number Diff line number Diff line 
package cz.fidentis.analyst.mesh;



import cz.fidentis.analyst.mesh.core.*;

import cz.fidentis.analyst.sampling.PoissonDiskSubSampling;



import javax.vecmath.*;

import java.util.ArrayList;

import java.util.List;



/**

 * Visitor, which chooses positions of glyphs via subsampling and then calculates the principle directions of these points.

 *

 * @author Ondrej Simecek

 */

public class GlyphCalculator extends MeshVisitor {

    private final List<MeshFacet> facets = new ArrayList<>();

    private final double NEIGHBOURHOOD_DISTANCE = 100; //squared for efficiency



    /**

     * Constructor

     */

    public GlyphCalculator() {

    }



    @Override

    public boolean isThreadSafe() {

        return false;

    }



    @Override

    public void visitMeshFacet(MeshFacet facet) {

        facets.add(facet);

    }



    /**

     * Chooses vertices to become glyphs and calculates their principal curvatures.

     * Based on

     * <a href="https://ieeexplore.ieee.org/document/597794">V. Interrante et al.: Conveying the 3D shape of smoothly curving transparent surfaces via texture</a>,

     * 1997, doi: 10.1109/2945.597794

     *

     * @param maxSamples maximum number of glyphs to be calculated, passed to a subsampler.

     * @return list of {@code Glyph}

     */

    public List<Glyph> calculateGlyphSamples(int maxSamples) {

        List<Glyph> glyphs = new ArrayList<>();



        List<MeshPoint> samples = new ArrayList<>();

        PoissonDiskSubSampling sampler = new PoissonDiskSubSampling(maxSamples, MeshTriangle.Smoothing.NONE);

        for (MeshFacet facet : facets) {

            sampler.visitMeshFacet(facet);

            samples.addAll(sampler.getSamples());

        }



        for (MeshPoint sample : samples) {

            PrincipalCurvature curvature = calculatePrincipalCurvatures(sample);

            if (curvature != null) {

                glyphs.add(new Glyph(sample.getPosition(), sample.getNormal(), curvature.maxCurvatureDir(),

                        curvature.minCurvatureDir()));

            } else {

                Vector3d temp = new Vector3d(1, 0, 0);

                if (sample.getNormal().y == 0 && sample.getNormal().z == 0) {

                    temp = new Vector3d(0, 1, 0);

                }

                Vector3d base3 = new Vector3d(sample.getNormal());

                base3.normalize();

                Vector3d base1 = new Vector3d();

                Vector3d base2 = new Vector3d();

                base1.cross(base3, temp);

                base2.cross(base3, base1);



                glyphs.add(new Glyph(sample.getPosition(), sample.getNormal(), base1, base2));

            }

        }

        return glyphs;

    }



    /**

     * Calculates principal curvatures and principal directions. If the calculation fails returns null.

     *

     * @param point of a surface the curvature is calculated of

     * @return a @PrincipalCurvature

     */

    public PrincipalCurvature calculatePrincipalCurvatures(MeshPoint point) {

        Vector3d temp = new Vector3d(1, 0, 0);

        if (point.getNormal().y == 0 && point.getNormal().z == 0) {

            temp = new Vector3d(0, 1, 0);

        }

        Vector3d base3 = new Vector3d(point.getNormal());

        base3.normalize();

        Vector3d base1 = new Vector3d();

        Vector3d base2 = new Vector3d();

        base1.cross(base3, temp);

        base2.cross(base3, base1);



        Vector4d secondFundamentalForm = new Vector4d(); //second fundamental form

        int facesCounted = 0;

        for (MeshFacet facet : facets) {

            List<MeshTriangle> triangles = facet.getTriangles();



            for (MeshTriangle triangle : triangles) {

                Vector4d planeCurvature = triangle.getCurvatureOfTrianglePlane(point.getPosition(),

                        NEIGHBOURHOOD_DISTANCE, base1, base2);

                if (planeCurvature != null) {

                    secondFundamentalForm.add(planeCurvature);

                    facesCounted++;

                }

            }

        }

        secondFundamentalForm.scale(1 / (double) facesCounted);

        double b = -secondFundamentalForm.w - secondFundamentalForm.x;

        double discriminant = b * b + 4 * (secondFundamentalForm.x * secondFundamentalForm.w -

                secondFundamentalForm.y * secondFundamentalForm.z);

        double eigenValue1;

        double eigenValue2;

        if (discriminant >= 0) {

            eigenValue1 = (-b + Math.sqrt(discriminant)) / 2;

            eigenValue2 = (-b - Math.sqrt(discriminant)) / 2;

            if (Math.abs(eigenValue1) < Math.abs(eigenValue2)) {

                double tempEigen = eigenValue1;

                eigenValue1 = eigenValue2;

                eigenValue2 = tempEigen;

            }

        } else {

            return null;

        }

        Vector4d sFFminusEigen = new Vector4d(secondFundamentalForm.x - eigenValue1, secondFundamentalForm.y,

                secondFundamentalForm.z, secondFundamentalForm.w - eigenValue1);

        double y = (sFFminusEigen.x + sFFminusEigen.z) / -(sFFminusEigen.y + sFFminusEigen.w);

        Vector2d eigenVector1 = new Vector2d(1, y);

        eigenVector1.normalize();



        //rotate base

        Vector3d tempBase1 = new Vector3d(base1);

        Vector3d tempBase2 = new Vector3d(base2);

        tempBase1.scale(eigenVector1.x);

        tempBase2.scale(eigenVector1.y);

        tempBase1.add(tempBase2);

        tempBase1.normalize();



        Vector3d maxCurvatureDir = new Vector3d(tempBase1);

        Vector3d minCurvatureDir = new Vector3d();

        minCurvatureDir.cross(maxCurvatureDir, point.getNormal());



        return new PrincipalCurvature(eigenValue1, eigenValue2, maxCurvatureDir, minCurvatureDir);

    }



}

MeshModel/src/main/java/cz/fidentis/analyst/mesh/core/Glyph.java

0 → 100644
+15 −0
Original line number Diff line number Diff line 
package cz.fidentis.analyst.mesh.core;



import javax.vecmath.Point3d;

import javax.vecmath.Vector3d;



/**

 * Information about a point selected to be a glyph. Needed for rendering shadow-casting glyphs.

 * @param samplePoint     position of the sample

 * @param sampleNormal    normal of the sample

 * @param maxCurvatureDir the maximal principal curvature at the sample point

 * @param minCurvatureDir the minimal principal curvature at the sample point

 *

 * @author Ondrej Simecek

 */

public record Glyph(Point3d samplePoint, Vector3d sampleNormal, Vector3d maxCurvatureDir, Vector3d minCurvatureDir) {}

MeshModel/src/main/java/cz/fidentis/analyst/mesh/core/MeshTriangle.java

+54 −2
Original line number Diff line number Diff line
@@ -5,6 +5,7 @@ import cz.fidentis.analyst.shapes.Ray; 
import javax.vecmath.Point3d;

import javax.vecmath.Tuple3d;

import javax.vecmath.Vector3d;

import javax.vecmath.Vector4d;

import java.io.Serial;

import java.io.Serializable;

import java.util.*;
@@ -228,7 +229,7 @@ public class MeshTriangle implements Iterable<MeshPoint>, Serializable { 


    /**

     * Computes the point laying on the triangle which is closest to

     * given 3D point. Return point is either one of the tringle's vertices,

     * given 3D point. Return point is either one of the triangle's vertices,

     * a point laying on triangles edge, or a point laying on the plane of

     * the triangle inside the triangle boundaries.

     *
@@ -328,7 +329,7 @@ public class MeshTriangle implements Iterable<MeshPoint>, Serializable { 


    /**

     * Return a center of circumcircle. This point represents the point

     * of Voronoi area used for Delaunay triangulation, for instence.

     * of Voronoi area used for Delaunay triangulation, for instance.

     *

     * @return the center of circumcircle

     */
@@ -804,4 +805,55 @@ public class MeshTriangle implements Iterable<MeshPoint>, Serializable { 
        double t = oa.dot(v) + ab.dot(v) * s;

        return (t >= 0);

    }



    /**

     * Function tests if the mesh triangle is closer to the sample point than a certain distance and if is, calculates

     * the second fundamental form of the sample point regarding the plane defined by the mesh triangle, otherwise

     * returns null.

     * <p>

     *     For more details, see:

     *     <a href="https://ieeexplore.ieee.org/document/597794">V. Interrante et al.: Conveying the 3D shape of smoothly curving transparent surfaces via texture</a>,

     *     1997, doi: 10.1109/2945.597794

     * </p>

     *

     * @param samplePosition position of a point on model's surface selected to be a glyph

     * @param distanceAccepted squared distance; the triangle needs to be closer to the sample point than this distance

     *                         to be taken into account

     * @param base1 first vector of orthogonal base; the base consists of three vectors: the normal of the sample point

     *              and two vectors(base1 and base2) defining the tangent plane of the model at the sample point

     * @param base2 second vector of orthogonal base; the base consists of three vectors: the normal of the sample point

     *              and two vectors(base1 and base2) defining the tangent plane of the model at the sample point

     * @return curvature of the sample point represented by the rate the surface normal tips in the directions of

     *         orthogonal base

     */

    public Vector4d getCurvatureOfTrianglePlane(Point3d samplePosition, double distanceAccepted, Vector3d base1, Vector3d base2) {

        if (getVertex1().distanceSquared(samplePosition) < distanceAccepted

                || getVertex2().distanceSquared(samplePosition) < distanceAccepted

                || getVertex3().distanceSquared(samplePosition) < distanceAccepted) {



            Vector3d normal = new Vector3d();

            normal.add(getPoint1().getNormal());

            normal.add(getPoint2().getNormal());

            normal.add(getPoint3().getNormal());

            normal.normalize();



            Vector3d middlePoint = new Vector3d();

            middlePoint.add(getPoint1().getPosition());

            middlePoint.add(getPoint2().getPosition());

            middlePoint.add(getPoint3().getPosition());

            middlePoint.scale(1 / (3.0f));



            Vector3d samplePoint = new Vector3d(samplePosition);

            Vector3d sampleToMiddle = new Vector3d();

            sampleToMiddle.sub(middlePoint, samplePoint);



            double omega11 = base1.dot(normal) / base1.dot(sampleToMiddle);

            double omega21 = base2.dot(normal) / base1.dot(sampleToMiddle);

            double omega12 = base1.dot(normal) / base2.dot(sampleToMiddle);

            double omega22 = base2.dot(normal) / base2.dot(sampleToMiddle);



            return new Vector4d(omega11, omega21, omega12, omega22);

        }

        return null;

    }

}

MeshModel/src/main/java/cz/fidentis/analyst/mesh/core/PrincipalCurvature.java

0 → 100644
+14 −0
Original line number Diff line number Diff line 
package cz.fidentis.analyst.mesh.core;



import javax.vecmath.Vector3d;



/**

 * Information about the curvature of a surface.

 *

 * @param maxCurvature maximum value of curvature of a surface point

 * @param minCurvature minimum value of curvature of a surface point

 * @param maxCurvatureDir direction of the maximum principal curvature

 * @param minCurvatureDir direction of the minimum principal curvature

 */

public record PrincipalCurvature(double maxCurvature, double minCurvature, Vector3d maxCurvatureDir, Vector3d minCurvatureDir) {

}