Package gov.nih.mipav.view.renderer.WildMagic.Poisson.Octree

Class OctNode

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

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)