HTMindexImp

java.lang.Object
- htm.core.HTMindexImp

All Implemented Interfaces:

HTMindex
```
public class HTMindexImp
extends Object
implements HTMindex
```
HTMindex is the class for the the sky indexing routines. Author: Peter Z. Kunszt initial java port by William O'Mullane The Spatial Index is a quad tree of spherical triangles. The tree is built in the following way: Start out with 8 triangles on the sphere using the 3 main circles to determine them. Then, every triangle can be decomposed into 4 new triangles by drawing main circles between midpoints of its edges:
```
 .
 .                                          /\
 .                                         /  \
 .                                        /____\
 .                                       /\    /\
 .                                      /  \  /  \
 .                                     /____\/____\
 .
 
```
This is how the quad tree is built up to a certain level by decomposing every triangle again and again. For a complete descrption, please go to the HTM index website
This implementation builds the index up to a specified level (maxlevel) You can specify that it should keep the first few levels in memory with the second constructor argument (buildlevel). The default buildlevel is 5.
```
  Current Version
  ===============
  ID:   $Id: HTMindexImp.java,v 1.2 2003/02/19 15:46:11 womullan Exp $
  Revision:     $Revision: 1.2 $
  Date/time:    $Date: 2003/02/19 15:46:11 $
 
```
Version:

$Revision: 1.2 $

Author:

Peter Kunszt

Field Summary

Fields
Modifier and Type	Field and Description
`int`	`addlevel_`
`int`	`buildlevel_`
`protected int`	`index_`
`(package private) static int`	`IOFFSET`
`protected int`	`lastSavedLeafIndex_`
`protected List`	`layers_`
`protected int`	`leaves_`
`int`	`maxlevel_`
`protected int`	`nNodes_`
`protected List`	`nodes_`
`protected int`	`nVertices_`
`protected int`	`storedleaves_`
`protected List`	`vertices_`

Constructor Summary

Constructors
Constructor and Description
`HTMindexImp()` Constructor: depth 20 - keeping 5 levels in memory by default
`HTMindexImp(double degResolution)` COnstructor for index - pass your desired resolution in degrees this will contruct a HTM of level such that the triabgle widht is just less than the desired resolution.
`HTMindexImp(int maxlevel)` Constructor: give only the level to build - keeping 5 levels in memory by default
`HTMindexImp(int maxlevel, int buildlevel)` Constructor : give the level of the index and optionally the level to build - i.e.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`(package private) void`	`add(Vector3d v, int i)`
`double`	`area(String htmName)` The area in steradians for a given index ID
`double`	`area(Vector3d n0, Vector3d n1, Vector3d n2)` area: routine to precompute the area of a node using AREA = 4*arctan sqrt(tan(s/2)tan((s-a)/2)tan((s-b)/2)tan((s-c)/2)) with s = (a+b+c)/2 (with many thanks to Eduard Masana @ University of Barcelona)
`Domain`	`compliment(Domain d)` not implemented yet
`boolean`	`contains(Domain d, Vector3d p)` does the domain coaintain thie given point
`double`	`distance(long htmId1, long htmId2)` calls HTMfunc
`double`	`distance(String htmName1, String htmName2)` calls HTMfunc
`(package private) Layer`	`getLayer(int index)`
`(package private) QuadNode`	`getNode(int index)`
`(package private) Vector3d`	`getVertex(int x)`
`int`	`idByLeafNumber(int n)` return leaf id for a certain bitlist index.
`String`	`idToName(long id)` calls HTMfunc
`Vector3d`	`idToPoint(long htmId)` for the given id return the vector at the center of the triangle calls HTMfunc
`Vector3d`	`idToPoint(String htmName)` for the given id return the vector at the center of the triangle calls HTMfunc
`protected void`	`init(int maxlevel, int buildlevel)`
`HTMrange`	`intersect(Domain d)` performs the intersection by calling domain.intersect
`Domain`	`intersection(Domain d1, Domain d2)` not implemented yet
`(package private) boolean`	`isInside(Vector3d v, Vector3d v0, Vector3d v1, Vector3d v2)` Test whether a vector v is inside a triangle v0,v1,v2.
`(package private) boolean`	`isLeaf(int i)`
`int`	`leafCount()` leafCount: return number of leaf nodes
`int`	`leafNumberById(long id)` return leaf number in bitlist for a certain ID.
`String`	`lookup(double ra, double dec)` find a node by giving a ra,dec in degrees.
`String`	`lookup(Vector3d v)` find a node by giving a vector.
`long`	`lookupId(double ra, double dec)` find a node by giving a ra,dec in degrees.
`long`	`lookupId(Vector3d v)` find a node by giving a vector.
`(package private) void`	`makeNewLayer(int oldlayer)` makeNewLayer: generate a new layer and the nodes in it Here it is where the construction actually happens, generating new triangles out of old ones.
`String`	`nameByLeafNumber(int n)` return name for a certain leaf index This function is simply shorthand for nameById(n + leafCount()).
`long`	`nameToId(String name)` This calls HTMfunc .
`int`	`newNode(int v1, int v2, int v3, long id, int parent)` Make a new Node: insert a new node_[] into the list.
`Vector3d[]`	`nodeVertex(int leaf)` nodeVertex: return the vectors of the vertices, based on a bitlist leaf index
`int[]`	`nodeVertexIds(int idx)` nodeVertex: return index of vertices for a node
`(package private) int`	`noNodes()`
`(package private) int`	`noVertices()`
`int`	`nVertices()` nVertices: return number of vertices
`void`	`showVertices(PrintStream out)` showVertices: print every vertex to the output stream
`Domain`	`simplify(Domain d)` return a HTM id number for a given position
`Domain`	`smooth(Domain d)` not implemented yet
`(package private) void`	`sortIndex()` sortIndex: sort the index so that the first node is the invalid node (index 0), the next 8 nodes are the root nodes and then we put all the leaf nodes in the following block in ascending id-order.
`Domain`	`union(Domain d1, Domain d2)` creates a new domain which contains all convexces of d1 and d2
`(package private) Vector3d`	`V(int index, int x)`
`(package private) void`	`vMax()` vMax: compute the maximum number of vertices for the polyhedron after buildlevel of subdivisions and the total number of nodes that we store also, calculate the number of leaf nodes that we eventually have.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - maxlevel_
```
public int maxlevel_
```
  - buildlevel_
```
public int buildlevel_
```
  - addlevel_
```
public int addlevel_
```
  - leaves_
```
protected int leaves_
```
  - storedleaves_
```
protected int storedleaves_
```
  - nodes_
```
protected List nodes_
```
  - layers_
```
protected List layers_
```
  - vertices_
```
protected List vertices_
```
  - index_
```
protected int index_
```
  - nNodes_
```
protected int nNodes_
```
  - nVertices_
```
protected int nVertices_
```
  - lastSavedLeafIndex_
```
protected int lastSavedLeafIndex_
```
  - IOFFSET
```
static final int IOFFSET
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - HTMindexImp
```
public HTMindexImp(double degResolution)
            throws HTMException
```
    COnstructor for index - pass your desired resolution in degrees this will contruct a HTM of level such that the triabgle widht is just less than the desired resolution. Starts at level 5 2.8 degrees.
    
    Throws:
    
    HTMException
  - HTMindexImp
```
public HTMindexImp()
```
    Constructor: depth 20 - keeping 5 levels in memory by default
  - HTMindexImp
```
public HTMindexImp(int maxlevel)
```
    Constructor: give only the level to build - keeping 5 levels in memory by default
  - HTMindexImp
```
public HTMindexImp(int maxlevel,
                   int buildlevel)
```
    Constructor : give the level of the index and optionally the level to build - i.e. the depth to keep in memory. if maxlevel - buildlevel > 0 , that many levels are generated on the fly each time the index is called.
- Method Detail
  - init
```
protected void init(int maxlevel,
                    int buildlevel)
```
  - showVertices
```
public void showVertices(PrintStream out)
```
    showVertices: print every vertex to the output stream
  - nodeVertexIds
```
public int[] nodeVertexIds(int idx)
```
    nodeVertex: return index of vertices for a node
  - nodeVertex
```
public Vector3d[] nodeVertex(int leaf)
```
    nodeVertex: return the vectors of the vertices, based on a bitlist leaf index
  - makeNewLayer
```
void makeNewLayer(int oldlayer)
```
    makeNewLayer: generate a new layer and the nodes in it Here it is where the construction actually happens, generating new triangles out of old ones.
  - newNode
```
public int newNode(int v1,
                   int v2,
                   int v3,
                   long id,
                   int parent)
```
    Make a new Node: insert a new node_[] into the list. The vertex indices are given by v1,v2,v3 and the id of the node is set.
  - area
```
public double area(String htmName)
```
    The area in steradians for a given index ID
    
    Specified by:
    
    area in interface HTMindex
  - area
```
public double area(Vector3d n0,
                   Vector3d n1,
                   Vector3d n2)
```
    area: routine to precompute the area of a node using AREA = 4*arctan sqrt(tan(s/2)tan((s-a)/2)tan((s-b)/2)tan((s-c)/2)) with s = (a+b+c)/2 (with many thanks to Eduard Masana @ University of Barcelona)
  - vMax
```
void vMax()
```
    vMax: compute the maximum number of vertices for the polyhedron after buildlevel of subdivisions and the total number of nodes that we store also, calculate the number of leaf nodes that we eventually have.
  - sortIndex
```
void sortIndex()
```
    sortIndex: sort the index so that the first node is the invalid node (index 0), the next 8 nodes are the root nodes and then we put all the leaf nodes in the following block in ascending id-order. All the rest of the nodes is at the end.
  - nameToId
```
public long nameToId(String name)
              throws HTMException
```
    This calls HTMfunc .
    
    Specified by:
    
    nameToId in interface HTMindex
    
    Throws:
    
    HTMException
  - idToName
```
public String idToName(long id)
                throws HTMException
```
    calls HTMfunc
    
    Specified by:
    
    idToName in interface HTMindex
    
    Throws:
    
    HTMException
  - lookupId
```
public long lookupId(Vector3d v)
              throws HTMException
```
    find a node by giving a vector. The ID of the node is returned.
    
    Specified by:
    
    lookupId in interface HTMindex
    
    Throws:
    
    HTMException
  - lookup
```
public String lookup(Vector3d v)
              throws HTMException
```
    find a node by giving a vector. The Name of the node is returned.
    
    Specified by:
    
    lookup in interface HTMindex
    
    Throws:
    
    HTMException
  - isInside
```
boolean isInside(Vector3d v,
                 Vector3d v0,
                 Vector3d v1,
                 Vector3d v2)
```
    Test whether a vector v is inside a triangle v0,v1,v2. Input triangle has to be sorted in a counter-clockwise direction.
  - leafCount
```
public int leafCount()
```
    leafCount: return number of leaf nodes
  - nVertices
```
public int nVertices()
```
    nVertices: return number of vertices
  - leafNumberById
```
public int leafNumberById(long id)
```
    return leaf number in bitlist for a certain ID. Since the ID here means the number computed from the name, this is simply returning ID -leafCount().
  - idByLeafNumber
```
public int idByLeafNumber(int n)
```
    return leaf id for a certain bitlist index. Same as the function above
  - nameByLeafNumber
```
public String nameByLeafNumber(int n)
```
    return name for a certain leaf index This function is simply shorthand for nameById(n + leafCount()).
  - lookup
```
public String lookup(double ra,
                     double dec)
              throws HTMException
```
    find a node by giving a ra,dec in degrees.
    
    Specified by:
    
    lookup in interface HTMindex
    
    Throws:
    
    HTMException
  - lookupId
```
public long lookupId(double ra,
                     double dec)
              throws HTMException
```
    find a node by giving a ra,dec in degrees.
    
    Specified by:
    
    lookupId in interface HTMindex
    
    Throws:
    
    HTMException
  - getVertex
```
Vector3d getVertex(int x)
```
  - V
```
Vector3d V(int index,
           int x)
```
  - getNode
```
QuadNode getNode(int index)
```
  - getLayer
```
Layer getLayer(int index)
```
  - noNodes
```
int noNodes()
```
  - noVertices
```
int noVertices()
```
  - add
```
void add(Vector3d v,
         int i)
```
  - isLeaf
```
boolean isLeaf(int i)
```
  - idToPoint
```
public Vector3d idToPoint(long htmId)
                   throws HTMException
```
    for the given id return the vector at the center of the triangle calls HTMfunc
    
    Specified by:
    
    idToPoint in interface HTMindex
    
    Throws:
    
    HTMException
  - idToPoint
```
public Vector3d idToPoint(String htmName)
                   throws HTMException
```
    for the given id return the vector at the center of the triangle calls HTMfunc
    
    Specified by:
    
    idToPoint in interface HTMindex
    
    Throws:
    
    HTMException
  - simplify
```
public Domain simplify(Domain d)
```
    Description copied from interface: HTMindex
    
    return a HTM id number for a given position
    
    Specified by:
    
    simplify in interface HTMindex
  - contains
```
public boolean contains(Domain d,
                        Vector3d p)
```
    Description copied from interface: HTMindex
    
    does the domain coaintain thie given point
    
    Specified by:
    
    contains in interface HTMindex
  - distance
```
public double distance(long htmId1,
                       long htmId2)
                throws HTMException
```
    calls HTMfunc
    
    Specified by:
    
    distance in interface HTMindex
    
    Throws:
    
    HTMException
  - distance
```
public double distance(String htmName1,
                       String htmName2)
                throws HTMException
```
    calls HTMfunc
    
    Specified by:
    
    distance in interface HTMindex
    
    Throws:
    
    HTMException
  - intersect
```
public HTMrange intersect(Domain d)
```
    performs the intersection by calling domain.intersect
    
    Specified by:
    
    intersect in interface HTMindex
  - intersection
```
public Domain intersection(Domain d1,
                           Domain d2)
```
    not implemented yet
    
    Specified by:
    
    intersection in interface HTMindex
  - union
```
public Domain union(Domain d1,
                    Domain d2)
```
    creates a new domain which contains all convexces of d1 and d2
    
    Specified by:
    
    union in interface HTMindex
  - compliment
```
public Domain compliment(Domain d)
```
    not implemented yet
    
    Specified by:
    
    compliment in interface HTMindex
  - smooth
```
public Domain smooth(Domain d)
```
    not implemented yet
    
    Specified by:
    
    smooth in interface HTMindex

Class HTMindexImp

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

maxlevel_

buildlevel_

addlevel_

leaves_

storedleaves_

nodes_

layers_

vertices_

index_

nNodes_

nVertices_

lastSavedLeafIndex_

IOFFSET

Constructor Detail

HTMindexImp

HTMindexImp

HTMindexImp

HTMindexImp

Method Detail

init

showVertices

nodeVertexIds

nodeVertex

makeNewLayer

newNode

area

area

vMax

sortIndex

nameToId

idToName

lookupId

lookup

isInside

leafCount

nVertices

leafNumberById

idByLeafNumber

nameByLeafNumber

lookup

lookupId

getVertex

V

getNode

getLayer

noNodes

noVertices

add

isLeaf

idToPoint

idToPoint

simplify

contains

distance

distance

intersect

intersection

union

compliment

smooth