Package org.jmol.util

Class MeshCapper


  • public class MeshCapper
    extends Object
    A class to properly cap a convoluted, closed slice of an isosurface inspired by: Computational Geometry: Algorithms and Applications Mark de Berg, Marc van Kreveld, Mark Overmars, and Otfried Schwarzkopf Springer-Verlag, Berlin Heidelberg 1997 Chapter 3. Polygon Triangulation Thanks given to Olaf Hall-Holt for pointing me to this reference. Extensively modified: - quaternion transform from 3D plane to XY plane for best precision - using directional edges -- no angle measurements necessary - continuous splitting off of triangles - independent dynamic monotonic regions created and processed as one stream - no need for vertex typing - no push/pop stacks INPUT: stream of [a b] ordered-vertex edges such that triangle a-b-c is interior if (ab.cross.ac).dot.planeNormal > 0 (right-hand rule; counter-clockwise edge flow) Bob Hanson - Jan 11, 2015
    Author:
    Bob Hanson, hansonr@stolaf.edu
    • Field Detail

      • slicer

        private MeshSlicer slicer
        source of edges; consumer of triangles
      • dumping

        private boolean dumping
        for debugging
      • lstRegions

        private javajs.util.Lst<MeshCapper.CapVertex[]> lstRegions
        dynamic region processing. These are just [DESCENDER, ASCENDER, LAST] for each region
      • nTriangles

        private int nTriangles
        informational only
      • nRegions

        private int nRegions
        informational only
      • lstTriangles

        private javajs.util.Lst<int[]> lstTriangles
      • nPoints

        private int nPoints
      • m3

        javajs.util.M3 m3
      • m3inv

        javajs.util.M3 m3inv
    • Constructor Detail

      • MeshCapper

        public MeshCapper()
    • Method Detail

      • clear

        void clear()
      • triangulateFaces

        public int[][] triangulateFaces​(int[][] faces,
                                        javajs.util.P3[] vertices,
                                        int[][] faceTriangles)
        generic entry for a set of faces
        Parameters:
        faces - array of pointers into points
        vertices -
        faceTriangles - optional return list by face
        Returns:
        array of triangles [a b c mask]
      • triangulatePolygon

        public int[][] triangulatePolygon​(javajs.util.P3[] points,
                                          int nPoints)
        generic entry for a polygon
        Parameters:
        points -
        nPoints - number of points or -1
        Returns:
        int[][i j k mask]
      • addEdge

        void addEdge​(int ipt1,
                     int ipt2,
                     int thisSet)
        Input method from MeshSlicer. Pointers are into MeshSlicer.m.vs[]
        Parameters:
        ipt1 -
        ipt2 -
        thisSet -
      • addPoint

        private MeshCapper.CapVertex addPoint​(int thisSet,
                                              int i)
        The MeshSlicer class manages all introduction of vertices; we must pass on to it the subset of vertices from the original Jmol isosurface being capped.
        Parameters:
        thisSet -
        i -
        Returns:
        a CapVertex pointing to this new point in the isosurface or one we already have
      • getInputPoint

        private javajs.util.T3 getInputPoint​(MeshCapper.CapVertex v)
        for debugging
        Parameters:
        v -
        Returns:
        external point or test point
      • outputTriangle

        private void outputTriangle​(int ipt1,
                                    int ipt2,
                                    int ipt3)
        Export triangle to MeshSlicer
        Parameters:
        ipt1 -
        ipt2 -
        ipt3 -
      • isEdge

        private boolean isEdge​(int i,
                               int j)
      • createCap

        void createCap​(javajs.util.V3 norm)
        Entry point when finished generating edges.
        Parameters:
        norm -
      • fixEndsAndSortVertices

        private void fixEndsAndSortVertices​(MeshCapper.CapVertex[] vs)
        Generate yxNext links based on scanning Y large to small and if Y1==Y2, then X small to large
        Parameters:
        vs -
      • processMonotonic

        private void processMonotonic​(MeshCapper.CapVertex v,
                                      boolean isDescending)
        Process a standard monotonic region, cleaving off as many triangles as possible.
        Parameters:
        v -
        isDescending -
      • processSplit

        private MeshCapper.CapVertex processSplit​(MeshCapper.CapVertex v,
                                                  MeshCapper.CapVertex last)
        Process what M3O refer to as a "split" vertex, which we handle differently here, cloning the "helper" point and the "split" point, creating a new region if necessary, and then swapping pointers.
        Parameters:
        v -
        last - "helper" or left edge
        Returns:
        new point clone of this
      • newRegion

        private void newRegion​(MeshCapper.CapVertex v)
        Add a new region to the list of regions.
        Parameters:
        v -
      • getLastPoint

        private MeshCapper.CapVertex getLastPoint​(MeshCapper.CapVertex v)
        Find the lowest ascender or descender above scan line bounding the region for this point. In the case of a region that consists of a single edge with descender above ascender, this will return the ascender. In the case where there are two independent regions, it is possible for the lowest to be missed, but to no import. [This is MOST confusing in the M3O book.]
        Parameters:
        v -
        Returns:
        pt