java.lang.Object
- gov.nih.mipav.view.renderer.WildMagic.Poisson.Octree.OctNode

All Implemented Interfaces:: java.util.Comparator

public class OctNode
extends java.lang.Object
implements java.util.Comparator

Field Summary

Fields
Modifier and Type	Field	Description
`static Allocator<OctNode>`	`Allocator`
`OctNode[]`	`children`
`short[]`	`d`
`static int`	`DepthMask`
`static int`	`DepthShift`
`static int`	`DIMENSION`
`private Geometry`	`geo`
`TreeNodeData`	`nodeData`
`short[]`	`off`
`static int`	`OffsetMask`
`static int`	`OffsetShift`
`static int`	`OffsetShift1`
`static int`	`OffsetShift2`
`static int`	`OffsetShift3`
`OctNode`	`parent`
`private static int`	`UseAlloc`

Constructor Summary

Constructors
Constructor Description

OctNode()

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`OctNode`	`__edgeNeighbor(int[] o, int[] i, int[] idx)`
`OctNode`	`__edgeNeighbor(int[] o, int[] i, int[] idx, int forceChildren)`
`OctNode`	`__faceNeighbor(int dir, int off)`
`OctNode`	`__faceNeighbor(int dir, int off, int forceChildren)`
`static void`	`__ProcessFixedDepthNodeAdjacentNodes(int dx, int dy, int dz, OctNode node1, int radius1, OctNode node2, int radius2, int cWidth2, int depth, NodeAdjacencyFunction F)`
`static void`	`__ProcessMaxDepthNodeAdjacentNodes(int dx, int dy, int dz, OctNode node1, int radius1, OctNode node2, int radius2, int cWidth2, int depth, NodeAdjacencyFunction F)`
`static void`	`__ProcessNodeAdjacentNodes(int dx, int dy, int dz, OctNode node1, int radius1, OctNode node2, int radius2, int cWidth2, NodeAdjacencyFunction F)`
`void`	`__processNodeEdges(OctNode node, NodeAdjacencyFunction F, int[] cIndex1, int[] cIndex2)`
`void`	`__processNodeFaces(OctNode node, NodeAdjacencyFunction F, int[] cIndex1, int[] cIndex2, int[] cIndex3, int[] cIndex4)`
`void`	`__processNodeNodes(OctNode node, NodeAdjacencyFunction F)`
`static void`	`__ProcessPointAdjacentNodes(int dx, int dy, int dz, OctNode node2, int radius2, int cWidth2, PointAdjacencyFunction F)`
`static void`	`__ProcessTerminatingNodeAdjacentNodes(int dx, int dy, int dz, OctNode node1, int radius1, OctNode node2, int radius2, int cWidth2, TerminatingNodeAdjacencyFunction F)`
`void`	`centerAndWidth(Point3D center, float[] width)`
`static void`	`CenterAndWidth(long index, Point3D center, float[] width)`
`void`	`centerIndex(int maxDepth, int[] index)`
`static int`	`ChildOverlap(int dx, int dy, int dz, int d, int cRadius2)`
`static int`	`CommonEdge(OctNode node1, int eIndex1, OctNode node2, int eIndex2)`
`int`	`compare(java.lang.Object v1, java.lang.Object v2)`
`static int`	`CompareBackwardDepths(java.lang.Object v1, java.lang.Object v2)`
`static int`	`CompareBackwardPointerDepths(java.lang.Object v1, java.lang.Object v2)`
`static int`	`CompareForwardDepths(java.lang.Object v1, java.lang.Object v2)`
`static int`	`CompareForwardPointerDepths(java.lang.Object v1, java.lang.Object v2)`
`OctNode`	`copy()`
`static int`	`CornerIndex(Point3D center, Point3D p)`
`OctNode`	`cornerNeighbor(int cornerIndex)`
`OctNode`	`cornerNeighbor(int cornerIndex, int forceChildren)`
`int`	`depth()`
`static int`	`Depth(long index)`
`void`	`depthAndOffset(int[] depth, int[] offset)`
`static void`	`DepthAndOffset(long index, int[] depth, int[] offset)`
`void`	`dispose()`
`OctNode`	`edgeNeighbor(int edgeIndex)`
`OctNode`	`edgeNeighbor(int edgeIndex, int forceChildren)`
`OctNode`	`faceNeighbor(int faceIndex)`
`OctNode`	`faceNeighbor(int faceIndex, int forceChildren)`
`OctNode`	`getNearestLeaf(Point3D p)`
`static void`	`Index(int depth, int[] offset, short[] d, short[] off)`
`int`	`initChildren()`
`int`	`leaves()`
`int`	`maxDepth()`
`int`	`maxDepthLeaves(int maxDepth)`
`OctNode`	`nextBranch(OctNode current)`
`OctNode`	`nextLeaf(OctNode current)`
`OctNode`	`nextNode(OctNode current)`
`int`	`nodes()`
`static boolean`	`Overlap(int c1, int c2, int c3, int dWidth)`
`static boolean`	`Overlap2(int depth1, int[] offSet1, float multiplier1, int depth2, int[] offSet2, float multiplier2)`
`void`	`printRange()`
`static void`	`ProcessFixedDepthNodeAdjacentNodes(int dx, int dy, int dz, OctNode node1, int radius1, OctNode node2, int radius2, int width2, int depth, NodeAdjacencyFunction F, int processCurrent)`
`static void`	`ProcessFixedDepthNodeAdjacentNodes(int maxDepth, OctNode node1, int width1, OctNode node2, int width2, int depth, NodeAdjacencyFunction F, int processCurrent)`
`static void`	`ProcessMaxDepthNodeAdjacentNodes(int dx, int dy, int dz, OctNode node1, int radius1, OctNode node2, int radius2, int width2, int depth, NodeAdjacencyFunction F, int processCurrent)`
`static void`	`ProcessMaxDepthNodeAdjacentNodes(int maxDepth, OctNode node1, int width1, OctNode node2, int width2, int depth, NodeAdjacencyFunction F, int processCurrent)`
`static void`	`ProcessNodeAdjacentNodes(int dx, int dy, int dz, OctNode node1, int radius1, OctNode node2, int radius2, int width2, NodeAdjacencyFunction F, int processCurrent)`
`static void`	`ProcessNodeAdjacentNodes(int maxDepth, OctNode node1, int width1, OctNode node2, int width2, NodeAdjacencyFunction F, int processCurrent)`
`void`	`processNodeCorners(OctNode node, NodeAdjacencyFunction F, int cIndex, int processCurrent)`
`void`	`processNodeEdges(OctNode node, NodeAdjacencyFunction F, int eIndex, int processCurrent)`
`void`	`processNodeFaces(OctNode node, NodeAdjacencyFunction F, int fIndex, int processCurrent)`
`void`	`processNodeNodes(OctNode node, NodeAdjacencyFunction F, int processCurrent)`
`static void`	`ProcessPointAdjacentNodes(int maxDepth, int[] c1, OctNode node2, int width2, PointAdjacencyFunction F, int processCurrent)`
`static void`	`ProcessPointAdjacentNodes(int dx, int dy, int dz, OctNode node2, int radius2, int width2, PointAdjacencyFunction F, int processCurrent)`
`static void`	`ProcessTerminatingNodeAdjacentNodes(int dx, int dy, int dz, OctNode node1, int radius1, OctNode node2, int radius2, int width2, TerminatingNodeAdjacencyFunction F, int processCurrent)`
`static void`	`ProcessTerminatingNodeAdjacentNodes(int maxDepth, OctNode node1, int width1, OctNode node2, int width2, TerminatingNodeAdjacencyFunction F, int processCurrent)`
`OctNode`	`root()`
`OctNode`	`set(OctNode node)`
`static void`	`SetAllocator(int blockSize)`
`void`	`setFullDepth(int maxDepth)`
`static int`	`UseAllocator()`
`int`	`width(int maxDepth)`

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

Methods inherited from interface java.util.Comparator
equals, reversed, thenComparing, thenComparing, thenComparing, thenComparingDouble, thenComparingInt, thenComparingLong

Field Detail

UseAlloc
```
private static int UseAlloc
```

geo
```
private Geometry geo
```

DIMENSION
```
public static int DIMENSION
```

Allocator

public static Allocator<OctNode> Allocator

parent
```
public OctNode parent
```

children
```
public OctNode[] children
```

d
```
public short[] d
```

off
```
public short[] off
```

nodeData
```
public TreeNodeData nodeData
```

DepthShift
```
public static final int DepthShift
```
See Also:

Constant Field Values

OffsetShift
```
public static final int OffsetShift
```
See Also:

Constant Field Values

DepthMask
```
public static final int DepthMask
```
See Also:

Constant Field Values

OffsetMask
```
public static final int OffsetMask
```
See Also:

Constant Field Values

OffsetShift1
```
public static final int OffsetShift1
```
See Also:

Constant Field Values

OffsetShift2
```
public static final int OffsetShift2
```
See Also:

Constant Field Values

OffsetShift3
```
public static final int OffsetShift3
```
See Also:

Constant Field Values

Constructor Detail
- OctNode
```
public OctNode()
```

Method Detail

copy
```
public OctNode copy()
```

SetAllocator

public static void SetAllocator(int blockSize)

UseAllocator
```
public static int UseAllocator()
```

dispose
```
public void dispose()
```

setFullDepth

public void setFullDepth(int maxDepth)

initChildren
```
public int initChildren()
```

Index

public static final void Index(int depth,
                               int[] offset,
                               short[] d,
                               short[] off)

depthAndOffset

public final void depthAndOffset(int[] depth,
                                 int[] offset)

depth
```
public final int depth()
```

DepthAndOffset

public static final void DepthAndOffset(long index,
                                        int[] depth,
                                        int[] offset)

Depth

public static final int Depth(long index)

centerAndWidth

public final void centerAndWidth(Point3D center,
                                 float[] width)

CenterAndWidth

public static final void CenterAndWidth(long index,
                                        Point3D center,
                                        float[] width)

maxDepth
```
public final int maxDepth()
```

nodes
```
public final int nodes()
```

leaves
```
public final int leaves()
```

maxDepthLeaves

public final int maxDepthLeaves(int maxDepth)

root
```
public final OctNode root()
```

nextBranch

public final OctNode nextBranch(OctNode current)

nextLeaf

public final OctNode nextLeaf(OctNode current)

nextNode

public OctNode nextNode(OctNode current)

printRange
```
public void printRange()
```

processNodeNodes

public void processNodeNodes(OctNode node,
                             NodeAdjacencyFunction F,
                             int processCurrent)

processNodeFaces

public void processNodeFaces(OctNode node,
                             NodeAdjacencyFunction F,
                             int fIndex,
                             int processCurrent)

processNodeEdges

public void processNodeEdges(OctNode node,
                             NodeAdjacencyFunction F,
                             int eIndex,
                             int processCurrent)

processNodeCorners

public void processNodeCorners(OctNode node,
                               NodeAdjacencyFunction F,
                               int cIndex,
                               int processCurrent)

__processNodeNodes

public void __processNodeNodes(OctNode node,
                               NodeAdjacencyFunction F)

__processNodeEdges

public void __processNodeEdges(OctNode node,
                               NodeAdjacencyFunction F,
                               int[] cIndex1,
                               int[] cIndex2)

__processNodeFaces

public void __processNodeFaces(OctNode node,
                               NodeAdjacencyFunction F,
                               int[] cIndex1,
                               int[] cIndex2,
                               int[] cIndex3,
                               int[] cIndex4)

ProcessNodeAdjacentNodes

public static void ProcessNodeAdjacentNodes(int maxDepth,
                                            OctNode node1,
                                            int width1,
                                            OctNode node2,
                                            int width2,
                                            NodeAdjacencyFunction F,
                                            int processCurrent)

ProcessNodeAdjacentNodes

public static void ProcessNodeAdjacentNodes(int dx,
                                            int dy,
                                            int dz,
                                            OctNode node1,
                                            int radius1,
                                            OctNode node2,
                                            int radius2,
                                            int width2,
                                            NodeAdjacencyFunction F,
                                            int processCurrent)

ProcessTerminatingNodeAdjacentNodes

public static void ProcessTerminatingNodeAdjacentNodes(int maxDepth,
                                                       OctNode node1,
                                                       int width1,
                                                       OctNode node2,
                                                       int width2,
                                                       TerminatingNodeAdjacencyFunction F,
                                                       int processCurrent)

ProcessTerminatingNodeAdjacentNodes

public static void ProcessTerminatingNodeAdjacentNodes(int dx,
                                                       int dy,
                                                       int dz,
                                                       OctNode node1,
                                                       int radius1,
                                                       OctNode node2,
                                                       int radius2,
                                                       int width2,
                                                       TerminatingNodeAdjacencyFunction F,
                                                       int processCurrent)

ProcessPointAdjacentNodes

public static void ProcessPointAdjacentNodes(int maxDepth,
                                             int[] c1,
                                             OctNode node2,
                                             int width2,
                                             PointAdjacencyFunction F,
                                             int processCurrent)

ProcessPointAdjacentNodes

public static void ProcessPointAdjacentNodes(int dx,
                                             int dy,
                                             int dz,
                                             OctNode node2,
                                             int radius2,
                                             int width2,
                                             PointAdjacencyFunction F,
                                             int processCurrent)

ProcessFixedDepthNodeAdjacentNodes

public static void ProcessFixedDepthNodeAdjacentNodes(int maxDepth,
                                                      OctNode node1,
                                                      int width1,
                                                      OctNode node2,
                                                      int width2,
                                                      int depth,
                                                      NodeAdjacencyFunction F,
                                                      int processCurrent)

ProcessFixedDepthNodeAdjacentNodes

public static void ProcessFixedDepthNodeAdjacentNodes(int dx,
                                                      int dy,
                                                      int dz,
                                                      OctNode node1,
                                                      int radius1,
                                                      OctNode node2,
                                                      int radius2,
                                                      int width2,
                                                      int depth,
                                                      NodeAdjacencyFunction F,
                                                      int processCurrent)

ProcessMaxDepthNodeAdjacentNodes

public static void ProcessMaxDepthNodeAdjacentNodes(int maxDepth,
                                                    OctNode node1,
                                                    int width1,
                                                    OctNode node2,
                                                    int width2,
                                                    int depth,
                                                    NodeAdjacencyFunction F,
                                                    int processCurrent)

ProcessMaxDepthNodeAdjacentNodes

public static void ProcessMaxDepthNodeAdjacentNodes(int dx,
                                                    int dy,
                                                    int dz,
                                                    OctNode node1,
                                                    int radius1,
                                                    OctNode node2,
                                                    int radius2,
                                                    int width2,
                                                    int depth,
                                                    NodeAdjacencyFunction F,
                                                    int processCurrent)

__ProcessNodeAdjacentNodes

public static void __ProcessNodeAdjacentNodes(int dx,
                                              int dy,
                                              int dz,
                                              OctNode node1,
                                              int radius1,
                                              OctNode node2,
                                              int radius2,
                                              int cWidth2,
                                              NodeAdjacencyFunction F)

__ProcessTerminatingNodeAdjacentNodes

public static void __ProcessTerminatingNodeAdjacentNodes(int dx,
                                                         int dy,
                                                         int dz,
                                                         OctNode node1,
                                                         int radius1,
                                                         OctNode node2,
                                                         int radius2,
                                                         int cWidth2,
                                                         TerminatingNodeAdjacencyFunction F)

__ProcessPointAdjacentNodes

public static void __ProcessPointAdjacentNodes(int dx,
                                               int dy,
                                               int dz,
                                               OctNode node2,
                                               int radius2,
                                               int cWidth2,
                                               PointAdjacencyFunction F)

__ProcessFixedDepthNodeAdjacentNodes

public static void __ProcessFixedDepthNodeAdjacentNodes(int dx,
                                                        int dy,
                                                        int dz,
                                                        OctNode node1,
                                                        int radius1,
                                                        OctNode node2,
                                                        int radius2,
                                                        int cWidth2,
                                                        int depth,
                                                        NodeAdjacencyFunction F)

__ProcessMaxDepthNodeAdjacentNodes

public static void __ProcessMaxDepthNodeAdjacentNodes(int dx,
                                                      int dy,
                                                      int dz,
                                                      OctNode node1,
                                                      int radius1,
                                                      OctNode node2,
                                                      int radius2,
                                                      int cWidth2,
                                                      int depth,
                                                      NodeAdjacencyFunction F)

ChildOverlap

public static final int ChildOverlap(int dx,
                                     int dy,
                                     int dz,
                                     int d,
                                     int cRadius2)

getNearestLeaf

public OctNode getNearestLeaf(Point3D p)

CommonEdge

public static int CommonEdge(OctNode node1,
                             int eIndex1,
                             OctNode node2,
                             int eIndex2)

CornerIndex

public static int CornerIndex(Point3D center,
                              Point3D p)

set
```
public OctNode set(OctNode node)
```

CompareForwardDepths

public static int CompareForwardDepths(java.lang.Object v1,
                                       java.lang.Object v2)

CompareForwardPointerDepths

public static int CompareForwardPointerDepths(java.lang.Object v1,
                                              java.lang.Object v2)

compare

public int compare(java.lang.Object v1,
                   java.lang.Object v2)

Specified by:: compare in interface java.util.Comparator

CompareBackwardDepths

public static int CompareBackwardDepths(java.lang.Object v1,
                                        java.lang.Object v2)

CompareBackwardPointerDepths

public static int CompareBackwardPointerDepths(java.lang.Object v1,
                                               java.lang.Object v2)

Overlap2

public static final boolean Overlap2(int depth1,
                                     int[] offSet1,
                                     float multiplier1,
                                     int depth2,
                                     int[] offSet2,
                                     float multiplier2)

Overlap

public static final boolean Overlap(int c1,
                                    int c2,
                                    int c3,
                                    int dWidth)

faceNeighbor

public OctNode faceNeighbor(int faceIndex)

faceNeighbor

public OctNode faceNeighbor(int faceIndex,
                            int forceChildren)

__faceNeighbor

public OctNode __faceNeighbor(int dir,
                              int off,
                              int forceChildren)

__faceNeighbor

public final OctNode __faceNeighbor(int dir,
                                    int off)

edgeNeighbor

public OctNode edgeNeighbor(int edgeIndex,
                            int forceChildren)

edgeNeighbor

public final OctNode edgeNeighbor(int edgeIndex)

__edgeNeighbor

public final OctNode __edgeNeighbor(int[] o,
                                    int[] i,
                                    int[] idx)

__edgeNeighbor

public OctNode __edgeNeighbor(int[] o,
                              int[] i,
                              int[] idx,
                              int forceChildren)

cornerNeighbor

public final OctNode cornerNeighbor(int cornerIndex)

cornerNeighbor

public OctNode cornerNeighbor(int cornerIndex,
                              int forceChildren)

width

public final int width(int maxDepth)

centerIndex

public final void centerIndex(int maxDepth,
                              int[] index)

Class OctNode

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Comparator

Field Detail

UseAlloc

geo

DIMENSION

Allocator

parent

children

d

off

nodeData

DepthShift

OffsetShift

DepthMask

OffsetMask

OffsetShift1

OffsetShift2

OffsetShift3

Constructor Detail

OctNode

Method Detail

copy

SetAllocator

UseAllocator

dispose

setFullDepth

initChildren

Index

depthAndOffset

depth

DepthAndOffset

Depth

centerAndWidth

CenterAndWidth

maxDepth

nodes

leaves

maxDepthLeaves

root

nextBranch

nextLeaf

nextNode

printRange

processNodeNodes

processNodeFaces

processNodeEdges

processNodeCorners

__processNodeNodes

__processNodeEdges

__processNodeFaces

ProcessNodeAdjacentNodes

ProcessNodeAdjacentNodes

ProcessTerminatingNodeAdjacentNodes

ProcessTerminatingNodeAdjacentNodes

ProcessPointAdjacentNodes

ProcessPointAdjacentNodes

ProcessFixedDepthNodeAdjacentNodes

ProcessFixedDepthNodeAdjacentNodes

ProcessMaxDepthNodeAdjacentNodes

ProcessMaxDepthNodeAdjacentNodes

__ProcessNodeAdjacentNodes

__ProcessTerminatingNodeAdjacentNodes

__ProcessPointAdjacentNodes

__ProcessFixedDepthNodeAdjacentNodes

__ProcessMaxDepthNodeAdjacentNodes

ChildOverlap

getNearestLeaf

CommonEdge

CornerIndex

set

CompareForwardDepths

CompareForwardPointerDepths

compare

CompareBackwardDepths

CompareBackwardPointerDepths