htm.core

Class Convex

java.lang.Object

htm.core.Sign

htm.core.Convex

public class Convex
extends Sign

The Convex class encapsulates all the code for intersection and lookup. It represents a convex on the unit sphere (see Domain).

  Current Version
  ===============
  ID:   $Id: Convex.java,v 1.3 2003/02/19 15:46:11 womullan Exp $
  Revision:     $Revision: 1.3 $
  Date/time:    $Date: 2003/02/19 15:46:11 $
 

Version:

$Revision: 1.3 $

Field Summary

Fields

Modifier and Type	Field and Description
(package private) Constraint	boundingCircle_
(package private) List	constraints_
(package private) List	corners_
protected int	olevel

Fields inherited from class htm.core.Sign

mIXED, nEG, pOS, sign_, zERO

Constructor Summary

Constructors

Constructor and Description
Convex() Default Constructor
Convex(Vector3d v1, Vector3d v2, Vector3d v3) Constructor from a triangle Initialize domain from a triangle.
Convex(Vector3d v1, Vector3d v2, Vector3d v3, Vector3d v4) Constructor from a rectangle Initialize convex from a rectangle.

Method Summary

Modifier and Type	Method and Description
void	add(Constraint c) Add a constraint.
boolean	contains(Vector3d p)
(package private) boolean	eSolve(Vector3d v1, Vector3d v2, int cIndex) eSolve: solve the quadratic equation for the edge v1,v2 of constraint[cIndex]
Constraint	getConstraint(int c)
Vector3d	getCorner(int c)
int	getNumberOfConstraints()
int	getOlevel()
void	intersect(HTMindexImp idx, HTMrange htmrange, boolean varlen) Intersect with index.
(package private) int	NC(HTMindexImp idx, int n, int m)
static String	printMark(short mark)
protected void	saveTrixel(long htmid, HTMrange hr, boolean varlen) adds the given trixel tot he HTMrange
void	setOlevel(int lev)
void	simplify() simplify: We have the following decision tree for the simplification of convexes: Always test two constraints against each other.
(package private) void	simplify0() simplify0: simplify zERO convexes.
(package private) boolean	testBoundingCircle(Vector3d v0, Vector3d v1, Vector3d v2) Test if bounding circle intersects with a constraint
(package private) boolean	testConstraintInside(Vector3d v0, Vector3d v1, Vector3d v2, int cIndex) Test for a constraint lying inside or outside of triangle
(package private) int	testConstraints(int i, int j) Test for constraint relative position; intersect, one in the other, disjoint.
(package private) boolean	testEdge(Vector3d v0, Vector3d v1, Vector3d v2) testEdge: look whether one of the constraints intersects with one of the edges of node with the corners v0,v1,v2.
(package private) boolean	testEdge0(Vector3d v0, Vector3d v1, Vector3d v2) testEdge0: test the edges of the triangle against the edges of the zERO convex.
(package private) boolean	testEdgeConstraint(Vector3d v0, Vector3d v1, Vector3d v2, int cIndex) Test if a constraint intersects the edges
(package private) boolean	testHole(Vector3d v0, Vector3d v1, Vector3d v2) testHole : look for 'holes', i.e.
(package private) short	testNode(int nodeIndex, HTMindexImp idx) the same routine as above, but for a given saved node
(package private) short	testNode(Vector3d v0, Vector3d v1, Vector3d v2) test each QuadNode for intersections.
(package private) int	testOtherPosNone(Vector3d v0, Vector3d v1, Vector3d v2) Look for any positive constraint that does not intersect the edges
(package private) void	testPartial(int level, long id, Vector3d v0, Vector3d v1, Vector3d v2, int PPrev, HTMindexImp idx, HTMrange range, boolean varlen) test a triangle's subtriangles whether they are partial.
(package private) short	testTriangle(Vector3d v0, Vector3d v1, Vector3d v2, int vsum) testTriangle: tests a triangle given by 3 vertices if it intersects the convex.
(package private) short	testTrixel(int id, HTMindexImp idx, HTMrange range, boolean varlen) TestTrixel: this is the main test of a trixel vs a Convex.
(package private) boolean	testVectorInside(Vector3d v0, Vector3d v1, Vector3d v2, Vector3d v) Test for a vector lying inside or outside of triangle For vectors abc, if (a ^ b * c) < 0, abc are ordered clockwise.
(package private) int	testVertex(Vector3d v) Test if vertices are inside the convex
String	toString()

Methods inherited from class htm.core.Sign

printSign

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

constraints_

List constraints_

corners_

List corners_

boundingCircle_

Constraint boundingCircle_

olevel

protected int olevel

Constructor Detail

Convex

public Convex()

Default Constructor

Convex

public Convex(Vector3d v1,
              Vector3d v2,
              Vector3d v3)

Constructor from a triangle Initialize domain from a triangle. The corners of these vectors form a triangle, so we just add three ZERO convexes to the domain where the direction is given by the cross product of the corners. Of course, the sign has to be determined (on which side of the triangle are we?) If the three points lie on one line, no convexes are added.

Convex

public Convex(Vector3d v1,
              Vector3d v2,
              Vector3d v3,
              Vector3d v4)

Constructor from a rectangle Initialize convex from a rectangle. The vectors that form a rectangle may be in any order, the code finds the edges by itself. If one of the vectors lies within the triangle formed by the other three vectors, the previous constructor is used.

Method Detail

add

public void add(Constraint c)

Add a constraint. Multiple contrains make up a complex area on the sphere. After adding a ne constraint the constraints are ordered by ascending opening angle. i

simplify0

void simplify0()

simplify0: simplify zERO convexes. calculate corners of convex and the bounding circle. zERO convexes are made up of constraints which are all great circles. It can happen that some of the constraints are redundant. For example, if 3 of the great circles define a triangle as the convex which lies fully inside the half sphere of the fourth constraint, that fourth constraint is redundant and will be removed. The algorithm is the following: zero-constraints are half-spheres, defined by a single normalized vector v, pointing in the direction of that half-sphere. Two zero-constraints intersect at i = +- v x v 1,2 1 2 the vector cross product of their two defining vectors. The two vectors i1,2 are tested against every other constraint in the convex if they lie within their half-spheres. Those intersections i which lie within every other constraint, are stored into corners_. Constraints that do not have a single corner on them, are dropped.

simplify

public void simplify()

simplify: We have the following decision tree for the simplification of convexes: Always test two constraints against each other. We have If both constraints are pOS If they intersect: keep both If one lies in the other: drop the larger one Else: disjunct. Empty convex, stop. If both constraints are nEG If they intersect or are disjunct: ok Else: one lies in the other, drop smaller 'hole' Mixed: one pOS, one nEG No intersection, disjunct: pOS is redundant Intersection: keep both pOS within nEG: empty convex, stop. nEG within pOS: keep both.

testConstraints

int testConstraints(int i,
                    int j)

Test for constraint relative position; intersect, one in the other, disjoint. testConstraints: Test for the relative position of two constraints. Returns 0 if they intersect Returns -1 if they are disjoint Returns 1 if j is in i Returns 2 if i is in j

intersect

public void intersect(HTMindexImp idx,
                      HTMrange htmrange,
                      boolean varlen)

Intersect with index. The HTMrange for the result must be given. Specifying varlen = true will use adaptive depth HTM for the result so ranges will be in the resolution best suited to the shape of the convex.

saveTrixel

protected void saveTrixel(long htmid,
                          HTMrange hr,
                          boolean varlen)

adds the given trixel tot he HTMrange

testTrixel

short testTrixel(int id,
                 HTMindexImp idx,
                 HTMrange range,
                 boolean varlen)

TestTrixel: this is the main test of a trixel vs a Convex.

testPartial

void testPartial(int level,
                 long id,
                 Vector3d v0,
                 Vector3d v1,
                 Vector3d v2,
                 int PPrev,
                 HTMindexImp idx,
                 HTMrange range,
                 boolean varlen)

test a triangle's subtriangles whether they are partial. If level is nonzero, recurse:

testNode

short testNode(int nodeIndex,
               HTMindexImp idx)

the same routine as above, but for a given saved node

testNode

short testNode(Vector3d v0,
               Vector3d v1,
               Vector3d v2)

test each QuadNode for intersections. Calls testTriangle after having tested the vertices using testVertex.

testTriangle

short testTriangle(Vector3d v0,
                   Vector3d v1,
                   Vector3d v2,
                   int vsum)

testTriangle: tests a triangle given by 3 vertices if it intersects the convex. Here the whole logic of deciding whether it is partial, full, swallowed or unknown is handled.

testVertex

int testVertex(Vector3d v)

Test if vertices are inside the convex

testHole

boolean testHole(Vector3d v0,
                 Vector3d v1,
                 Vector3d v2)

testHole : look for 'holes', i.e. negative constraints that have their centers inside the node with the three corners v0,v1,v2.

testEdge0

boolean testEdge0(Vector3d v0,
                  Vector3d v1,
                  Vector3d v2)

testEdge0: test the edges of the triangle against the edges of the zERO convex. The convex is stored in corners_ so that the convex is always on the left-hand-side of an edge corners_(i) - corners_(i+1). (just like the triangles). This makes testing for intersections with the edges easy.

testEdge

boolean testEdge(Vector3d v0,
                 Vector3d v1,
                 Vector3d v2)

testEdge: look whether one of the constraints intersects with one of the edges of node with the corners v0,v1,v2.

eSolve

boolean eSolve(Vector3d v1,
               Vector3d v2,
               int cIndex)

eSolve: solve the quadratic equation for the edge v1,v2 of constraint[cIndex]

testBoundingCircle

boolean testBoundingCircle(Vector3d v0,
                           Vector3d v1,
                           Vector3d v2)

Test if bounding circle intersects with a constraint

testEdgeConstraint

boolean testEdgeConstraint(Vector3d v0,
                           Vector3d v1,
                           Vector3d v2,
                           int cIndex)

Test if a constraint intersects the edges

testOtherPosNone

int testOtherPosNone(Vector3d v0,
                     Vector3d v1,
                     Vector3d v2)

Look for any positive constraint that does not intersect the edges

testConstraintInside

boolean testConstraintInside(Vector3d v0,
                             Vector3d v1,
                             Vector3d v2,
                             int cIndex)

Test for a constraint lying inside or outside of triangle

testVectorInside

boolean testVectorInside(Vector3d v0,
                         Vector3d v1,
                         Vector3d v2,
                         Vector3d v)

Test for a vector lying inside or outside of triangle For vectors abc, if (a ^ b * c) < 0, abc are ordered clockwise. -> center c not inside triangle, since vertices are ordered counter-clockwise.

getConstraint

public Constraint getConstraint(int c)

getNumberOfConstraints

public int getNumberOfConstraints()

getCorner

public Vector3d getCorner(int c)

NC

int NC(HTMindexImp idx,
       int n,
       int m)

toString

public String toString()

Overrides:

toString in class Object

printMark

public static String printMark(short mark)

setOlevel

public void setOlevel(int lev)

getOlevel

public int getOlevel()

contains

public boolean contains(Vector3d p)