/// <summary> /// Find the previous edge (clockwise) of the adjacent triangle. [rprev(abc) -> b**] /// </summary> public void Rprev(ref Otri ot) { //Sym(ref ot); ot.tri = tri.neighbors[orient].tri; ot.orient = tri.neighbors[orient].orient; //ot.LprevSelf(); ot.orient = minus1Mod3[ot.orient]; //ot.SymSelf(); int tmp = ot.orient; ot.orient = ot.tri.neighbors[tmp].orient; ot.tri = ot.tri.neighbors[tmp].tri; }
/// <summary> /// Find the next edge (counterclockwise) of the adjacent triangle. [rnext(abc) -> *a*] /// </summary> public void Rnext(ref Otri ot) { //Sym(ref ot); ot.tri = tri.neighbors[orient].tri; ot.orient = tri.neighbors[orient].orient; //ot.LnextSelf(); ot.orient = plus1Mod3[ot.orient]; //ot.SymSelf(); int tmp = ot.orient; ot.orient = ot.tri.neighbors[tmp].orient; ot.tri = ot.tri.neighbors[tmp].tri; }
/// <summary> Finds a triangle abutting a subsegment. </summary> internal void Pivot(ref Otri ot) { ot = seg.triangles[orient]; }
/// <summary> Find the next edge (counterclockwise) of a triangle. [lnext(abc) -> bca] </summary> public void Lnext(ref Otri ot) { ot.tri = tri; ot.orient = plus1Mod3[orient]; }
/// The following primitives are all described by Guibas and Stolfi. /// However, Guibas and Stolfi use an edge-based data structure, /// whereas I use a triangle-based data structure. /// /// lnext: finds the next edge (counterclockwise) of a triangle. /// /// onext: spins counterclockwise around a vertex; that is, it finds /// the next edge with the same origin in the counterclockwise direction. This /// edge is part of a different triangle. /// /// oprev: spins clockwise around a vertex; that is, it finds the /// next edge with the same origin in the clockwise direction. This edge is /// part of a different triangle. /// /// dnext: spins counterclockwise around a vertex; that is, it finds /// the next edge with the same destination in the counterclockwise direction. /// This edge is part of a different triangle. /// /// dprev: spins clockwise around a vertex; that is, it finds the /// next edge with the same destination in the clockwise direction. This edge /// is part of a different triangle. /// /// rnext: moves one edge counterclockwise about the adjacent /// triangle. (It's best understood by reading Guibas and Stolfi. It /// involves changing triangles twice.) /// /// rprev: moves one edge clockwise about the adjacent triangle. /// (It's best understood by reading Guibas and Stolfi. It involves /// changing triangles twice.) /// <summary> Find the abutting triangle; same edge. [sym(abc) -> ba*] </summary> /// <remarks> /// Note that the edge direction is necessarily reversed, because the handle specified /// by an oriented triangle is directed counterclockwise around the triangle. /// </remarks> public void Sym(ref Otri ot) { ot.tri = tri.neighbors[orient].tri; ot.orient = tri.neighbors[orient].orient; }
/// <summary> Test for equality of oriented triangles. </summary> internal bool Equal(Otri ot) { return((tri == ot.tri) && (orient == ot.orient)); }
/// <summary> Copy an oriented triangle. </summary> public void Copy(ref Otri ot) { ot.tri = tri; ot.orient = orient; }
/// <summary> Find the previous edge (clockwise) of a triangle. [lprev(abc) -> cab] </summary> public void Lprev(ref Otri ot) { ot.tri = tri; ot.orient = minus1Mod3[orient]; }