added methods for expanding trees to include points outside current bounds

This commit is contained in:
BuildTools 2017-02-22 17:53:44 -05:00
parent ba8a2eee0a
commit 5ece1f35eb
3 changed files with 802 additions and 93 deletions

View file

@ -4,6 +4,9 @@ import java.io.DataInputStream;
import java.io.File; import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.io.OutputStream; import java.io.OutputStream;
import java.util.BitSet;
import regions.Tree.Node;
public class Octree extends Tree public class Octree extends Tree
{ {
@ -25,16 +28,16 @@ public class Octree extends Tree
return a == -1 || b == -1 ? return a == -1 || b == -1 ?
new Node( false ) : new Node( false ) :
new Node( new Node[] { parseBytes(input, (a >>> 6 & 3)), new Node( parseBytes(input, (a >>> 6 & 3)),
parseBytes(input, (a >>> 4 & 3)), parseBytes(input, (a >>> 4 & 3)),
parseBytes(input, (a >>> 2 & 3)), parseBytes(input, (a >>> 2 & 3)),
parseBytes(input, (a & 3)), parseBytes(input, (a & 3)),
parseBytes(input, (b >>> 6 & 3)), parseBytes(input, (b >>> 6 & 3)),
parseBytes(input, (b >>> 4 & 3)), parseBytes(input, (b >>> 4 & 3)),
parseBytes(input, (b >>> 2 & 3)), parseBytes(input, (b >>> 2 & 3)),
parseBytes(input, (b & 3)) parseBytes(input, (b & 3))
}); );
} }
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
@ -46,17 +49,17 @@ public class Octree extends Tree
@Override @Override
public void writeBytes(Node node, OutputStream output) throws IOException public void writeBytes(Node node, OutputStream output) throws IOException
{ {
output.write( getByte( node.children[0], output.write( getByte( node.children[0],
node.children[1], node.children[1],
node.children[2], node.children[2],
node.children[3] node.children[3]
)); ));
output.write( getByte( node.children[4], output.write( getByte( node.children[4],
node.children[5], node.children[5],
node.children[6], node.children[6],
node.children[7] node.children[7]
)); ));
for (Node child : node.children) for (Node child : node.children)
if (child.children.length > 0) if (child.children.length > 0)
@ -75,27 +78,336 @@ public class Octree extends Tree
} }
/*------------------------------------- /*
Methods used by constructors.
-------------------------------------*/
EVALUATE
*/
@Override @Override
protected final TreeEditor<Octree> newEditor() public boolean contains(int... coords)
{ {
return new TreeEditor<Octree>(this, min[0], min[1], min[2]);
} }
/*
ADD VOLUME
*/
/*----------------------------------------------------------------------------
------------------------------------------------------------------------------
expand()
------------------------------------------------------------------------------
----------------------------------------------------------------------------*/
/**
*
* @param xMinExpansion
* @param zMinExpansion
* @param yMinExpansion
* @param xMaxExpansion
* @param zMaxExpansion
* @param yMaxExpansion
*/
protected void expand(double xMinExpansion, double zMinExpansion, double yMinExpansion,
double xMaxExpansion, double zMaxExpansion, double yMaxExpansion
)
{
int xMinRounded = (int) Math.ceil(xMinExpansion),
zMinRounded = (int) Math.ceil(zMinExpansion),
yMinRounded = (int) Math.ceil(yMinExpansion),
xMaxRounded = (int) Math.ceil(xMaxExpansion),
zMaxRounded = (int) Math.ceil(zMaxExpansion),
yMaxRounded = (int) Math.ceil(yMaxExpansion),
size = nextPowerOfTwo( xMinRounded + xMaxRounded + 1,
zMinRounded + zMaxRounded + 1,
yMinRounded + yMaxRounded + 1
),
xMargin = size - (xMinRounded + xMaxRounded + 1),
zMargin = size - (zMinRounded + zMaxRounded + 1),
yMargin = size - (yMinRounded + yMaxRounded + 1),
xMarginHalf = xMargin / 2,
zMarginHalf = zMargin / 2,
yMarginHalf = yMargin / 2;
xMinRounded += xMarginHalf;
zMinRounded += zMarginHalf;
yMinRounded += yMarginHalf;
xMaxRounded += xMarginHalf;
zMaxRounded += zMarginHalf;
yMaxRounded += yMarginHalf;
/* if margin is odd, add 1
* to the more close-fitting side
*/
if (xMargin % 2 == 1)
if (xMinRounded - xMinExpansion > xMaxRounded - xMaxExpansion) xMinRounded++; else xMaxRounded++;
if (zMargin % 2 == 1)
if (zMinRounded - zMinExpansion > zMaxRounded - zMaxExpansion) zMinRounded++; else zMaxRounded++;
if (yMargin % 2 == 1)
if (yMinRounded - yMinExpansion > yMaxRounded - yMaxExpansion) yMinRounded++; else yMaxRounded++;
int index;
Node[] children;
Node[] newRootChildren = children = Node.emptyNodeArray(8);
while(true)
{
size >>>= 1;
index = 0;
if (xMinRounded >= size)
xMinRounded -= size;
else
{
xMaxRounded -= size;
index += 1;
}
if (zMinRounded >= size)
zMinRounded -= size;
else
{
zMaxRounded -= size;
index += 2;
}
if (yMinRounded >= size)
yMinRounded -= size;
else
{
yMaxRounded -= size;
index += 4;
}
if (size > 1)
children[index].children = children = Node.emptyNodeArray(8);
else
{
children[index].children = root.children;
break;
}
}
root.children = newRootChildren;
}
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
------------------------------------------------------------------------------ ------------------------------------------------------------------------------
CALCULATIONS expandAsNeeded()
------------------------------------------------------------------------------ ------------------------------------------------------------------------------
----------------------------------------------------------------------------*/ ----------------------------------------------------------------------------*/
@Override @Override
public Node[] getNodes(Node parentNode, int[][] regionBounds) protected void expandAsNeeded(int... coords)
{
int sideLength = max[0] - min[0] + 1;
double xMinExpansion = 0,
zMinExpansion = 0,
yMinExpansion = 0,
xMaxExpansion = 0,
zMaxExpansion = 0,
yMaxExpansion = 0;
if (coords[0] < min[0]) xMinExpansion = (min[0] - coords[0]) / sideLength;
else if (coords[0] > max[0]) xMaxExpansion = (coords[0] - max[0]) / sideLength;
if (coords[1] < min[1]) xMinExpansion = (min[1] - coords[1]) / sideLength;
else if (coords[1] > max[1]) xMaxExpansion = (coords[1] - max[1]) / sideLength;
if (coords[2] < min[2]) xMinExpansion = (min[2] - coords[2]) / sideLength;
else if (coords[2] > max[2]) xMaxExpansion = (coords[2] - max[2]) / sideLength;
if (xMinExpansion != 0 ||
zMinExpansion != 0 ||
yMinExpansion != 0 ||
xMaxExpansion != 0 ||
zMaxExpansion != 0 ||
yMaxExpansion != 0
)
expand(xMinExpansion,
zMinExpansion,
yMinExpansion,
xMaxExpansion,
zMaxExpansion,
yMaxExpansion);
}
@Override
public void expandAsNeeded(int[]... bounds)
{
int sideLength = max[0] - min[0] + 1;
double xMinExpansion = 0,
zMinExpansion = 0,
yMinExpansion = 0,
xMaxExpansion = 0,
zMaxExpansion = 0,
yMaxExpansion = 0;
if (bounds[0][0] < min[0]) xMinExpansion = (min[0] - bounds[0][0]) / sideLength;
if (bounds[0][1] > max[0]) xMaxExpansion = (bounds[0][1] - max[0]) / sideLength;
if (bounds[1][0] < min[1]) xMinExpansion = (min[1] - bounds[1][0]) / sideLength;
if (bounds[1][1] > max[1]) xMaxExpansion = (bounds[1][1] - max[1]) / sideLength;
if (bounds[2][0] < min[2]) xMinExpansion = (min[2] - bounds[2][0]) / sideLength;
if (bounds[2][1] > max[2]) xMaxExpansion = (bounds[2][1] - max[2]) / sideLength;
if (xMinExpansion != 0 ||
zMinExpansion != 0 ||
yMinExpansion != 0 ||
xMaxExpansion != 0 ||
zMaxExpansion != 0 ||
yMaxExpansion != 0
)
expand(xMinExpansion,
zMinExpansion,
yMinExpansion,
xMaxExpansion,
zMaxExpansion,
yMaxExpansion);
}
/*----------------------------------------------------------------------------
------------------------------------------------------------------------------
add()
------------------------------------------------------------------------------
----------------------------------------------------------------------------*/
@Override
public void add(int... coords)
{
expandAsNeeded(coords);
Node node = root;
int[] min = this.min;
int[] max = this.max;
int size = max[0] - min[0] + 1;
int half = size / 2;
int index = 0;
outerloop:
while (true)
{
if (node.full) return;
if (node.children.length == 0) node.children = Node.emptyNodeArray(8);
if ((min[0] + half) > coords[0])
max[0] -= half;
else
{
min[0] += half;
index += 1;
}
if ((min[1] + half) > coords[1])
max[1] -= half;
else
{
min[1] += half;
index += 2;
}
if ((min[2] + half) > coords[2])
max[2] -= half;
else
{
min[2] += half;
index += 4;
}
if ((size >>>= 1) > 1)
{
node = node.children[index];
half = size / 2;
}
else
{
node.children[index].full = true;
for (Node child : node.children)
{
if (!child.full)
{
break outerloop;
}
}
node.full = true;
node.children = new Node[0];
}
}
}
@Override
public void add(int[]... bounds)
{
expandAsNeeded(bounds);
}
@Override
public void add(BitSet blocks, int[]... bounds)
{
expandAsNeeded(bounds);
}
/*
REMOVE VOLUME
*/
@Override
public void trimAsNeeded()
{
// TODO Auto-generated method stub
}
@Override
public void remove(int... coords)
{
// TODO Auto-generated method stub
}
@Override
public void remove(int[]... bounds)
{
// TODO Auto-generated method stub
}
@Override
public void remove(BitSet blocks, int[]... bounds)
{ {
// TODO Auto-generated method stub // TODO Auto-generated method stub
return null;
} }
} }

View file

@ -4,6 +4,7 @@ import java.io.DataInputStream;
import java.io.File; import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.io.OutputStream; import java.io.OutputStream;
import java.util.BitSet;
public class Quadtree extends Tree public class Quadtree extends Tree
{ {
@ -24,11 +25,11 @@ public class Quadtree extends Tree
return a == -1 ? return a == -1 ?
new Node( false ) : new Node( false ) :
new Node( new Node[] { parseBytes(input, (a >>> 6 & 3)), new Node( parseBytes(input, (a >>> 6 & 3)),
parseBytes(input, (a >>> 4 & 3)), parseBytes(input, (a >>> 4 & 3)),
parseBytes(input, (a >>> 2 & 3)), parseBytes(input, (a >>> 2 & 3)),
parseBytes(input, (a & 3)) parseBytes(input, (a & 3))
}); );
} }
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
@ -40,11 +41,11 @@ public class Quadtree extends Tree
@Override @Override
public void writeBytes(Node node, OutputStream output) throws IOException public void writeBytes(Node node, OutputStream output) throws IOException
{ {
output.write( getByte( node.children[0], output.write( getByte( node.children[0],
node.children[1], node.children[1],
node.children[2], node.children[2],
node.children[3] node.children[3]
)); ));
for (Node child : node.children) for (Node child : node.children)
if (child.children.length > 0) if (child.children.length > 0)
@ -64,27 +65,287 @@ public class Quadtree extends Tree
} }
/*------------------------------------- /*
Methods used by constructors.
-------------------------------------*/
EVALUATE
*/
@Override @Override
protected final TreeEditor<Quadtree> newEditor() public boolean contains(int... coords)
{ {
return new TreeEditor<Quadtree>(this, min[0], min[1]);
} }
/*
ADD VOLUME
*/
/*----------------------------------------------------------------------------
------------------------------------------------------------------------------
expand()
------------------------------------------------------------------------------
----------------------------------------------------------------------------*/
/**
*
* @param xMinExpansion
* @param zMinExpansion
* @param xMaxExpansion
* @param zMaxExpansion
*/
protected void expand(double xMinExpansion, double zMinExpansion, double xMaxExpansion, double zMaxExpansion)
{
int xMinRounded = (int) Math.ceil(xMinExpansion),
zMinRounded = (int) Math.ceil(zMinExpansion),
xMaxRounded = (int) Math.ceil(xMaxExpansion),
zMaxRounded = (int) Math.ceil(zMaxExpansion),
size = nextPowerOfTwo( xMinRounded + xMaxRounded + 1,
zMinRounded + zMaxRounded + 1
),
xMargin = size - (xMinRounded + xMaxRounded + 1),
zMargin = size - (zMinRounded + zMaxRounded + 1),
xMarginHalf = xMargin / 2,
zMarginHalf = zMargin / 2;
xMinRounded += xMarginHalf;
zMinRounded += zMarginHalf;
xMaxRounded += xMarginHalf;
zMaxRounded += zMarginHalf;
/* if margin is odd, add 1
* to the more close-fitting side
*/
if (xMargin % 2 == 1)
if (xMinRounded - xMinExpansion > xMaxRounded - xMaxExpansion) xMinRounded++; else xMaxRounded++;
if (zMargin % 2 == 1)
if (zMinRounded - zMinExpansion > zMaxRounded - zMaxExpansion) zMinRounded++; else zMaxRounded++;
int index;
Node[] children;
Node[] newRootChildren = children = Node.emptyNodeArray(4);
while(true)
{
size >>>= 1;
index = 0;
if (xMinRounded >= size)
xMinRounded -= size;
else
{
xMaxRounded -= size;
index += 1;
}
if (zMinRounded >= size)
zMinRounded -= size;
else
{
zMaxRounded -= size;
index += 2;
}
if (size > 1)
children[index].children = children = Node.emptyNodeArray(4);
else
{
children[index].children = root.children;
break;
}
}
root.children = newRootChildren;
}
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
------------------------------------------------------------------------------ ------------------------------------------------------------------------------
CALCULATIONS expandAsNeeded()
------------------------------------------------------------------------------ ------------------------------------------------------------------------------
----------------------------------------------------------------------------*/ ----------------------------------------------------------------------------*/
@Override @Override
public Node[] getNodes(Node parentNode, int[][] regionBounds) protected void expandAsNeeded(int... coords)
{
int sideLength = max[0] - min[0] + 1;
double xMinExpansion = 0,
zMinExpansion = 0,
xMaxExpansion = 0,
zMaxExpansion = 0;
if (coords[0] < min[0]) xMinExpansion = (min[0] - coords[0]) / sideLength;
else if (coords[0] > max[0]) xMaxExpansion = (coords[0] - max[0]) / sideLength;
if (coords[1] < min[1]) xMinExpansion = (min[1] - coords[1]) / sideLength;
else if (coords[1] > max[1]) xMaxExpansion = (coords[1] - max[1]) / sideLength;
if (xMinExpansion != 0 ||
zMinExpansion != 0 ||
xMaxExpansion != 0 ||
zMaxExpansion != 0
)
expand(xMinExpansion,
zMinExpansion,
xMaxExpansion,
zMaxExpansion);
}
@Override
public void expandAsNeeded(int[]... bounds)
{
int sideLength = max[0] - min[0] + 1;
double xMinExpansion = 0,
zMinExpansion = 0,
xMaxExpansion = 0,
zMaxExpansion = 0;
if (bounds[0][0] < min[0]) xMinExpansion = (min[0] - bounds[0][0]) / sideLength;
if (bounds[0][1] > max[0]) xMaxExpansion = (bounds[0][1] - max[0]) / sideLength;
if (bounds[1][0] < min[1]) xMinExpansion = (min[1] - bounds[1][0]) / sideLength;
if (bounds[1][1] > max[1]) xMaxExpansion = (bounds[1][1] - max[1]) / sideLength;
if (xMinExpansion != 0 ||
zMinExpansion != 0 ||
xMaxExpansion != 0 ||
zMaxExpansion != 0
)
expand(xMinExpansion,
zMinExpansion,
xMaxExpansion,
zMaxExpansion);
}
/*----------------------------------------------------------------------------
------------------------------------------------------------------------------
add()
------------------------------------------------------------------------------
----------------------------------------------------------------------------*/
@Override
public void add(int... coords)
{
expandAsNeeded(coords);
Node node = root;
int[] min = this.min;
int[] max = this.max;
int size = max[0] - min[0] + 1;
int half = size / 2;
int index = 0;
outerloop:
while (true)
{
if (node.full) return;
if (node.children.length == 0) node.children = Node.emptyNodeArray(4);
if ((min[0] + half) > coords[0])
max[0] -= half;
else
{
min[0] += half;
index += 1;
}
if ((min[1] + half) > coords[1])
max[1] -= half;
else
{
min[1] += half;
index += 2;
}
if ((size >>>= 1) > 1)
{
node = node.children[index];
half = size / 2;
}
else
{
node.children[index].full = true;
for (Node child : node.children)
{
if (!child.full)
{
break outerloop;
}
}
node.full = true;
node.children = new Node[0];
}
}
}
@Override
public void add(int[]... bounds)
{
expandAsNeeded(bounds);
}
@Override
public void add(BitSet blocks, int[]... bounds)
{
expandAsNeeded(bounds);
}
/*-------------------------------------
REMOVE VOLUME
-------------------------------------*/
@Override
public void trimAsNeeded()
{
// TODO Auto-generated method stub
}
@Override
public void remove(int... coords)
{
// TODO Auto-generated method stub
}
@Override
public void remove(int[]... bounds)
{
// TODO Auto-generated method stub
}
@Override
public void remove(BitSet blocks, int[]... bounds)
{ {
// TODO Auto-generated method stub // TODO Auto-generated method stub
return null;
} }
} }

View file

@ -7,27 +7,23 @@ import java.io.FileInputStream;
import java.io.FileOutputStream; import java.io.FileOutputStream;
import java.io.IOException; import java.io.IOException;
import java.io.OutputStream; import java.io.OutputStream;
import java.util.BitSet;
/** /**
* This is a superclass for octrees, quadtrees, and any other spatial trees.<p> * A superclass for octrees and quadtrees. Concept credit to Don Meagher, who first named and
* described Octrees in his 1980 paper, "Octree Encoding: A New Technique for the Representation,
* Manipulation and Display of Arbitrary 3-D Objects by Computer."<p>
* *
* concept credit to Don Meagher, who first named and described Octrees in his 1980 paper, * Octree application can be visualized like this:<p>
* "Octree Encoding: A New Technique for the Representation, Manipulation and Display of
* Arbitrary 3-D Objects by Computer."<p>
* *
* The idea works like this:<p> * For any arbitrary 3-D object, find the bounding cube of the shape (or the smallest cube it will
* fit inside of). Divide this bounding cube into 8 sub-cubes, or octants.<p>
* *
* For some arbitrary shape, you first define the bounding box of the shape (or the * With the space thus divided, evaluate which octants the object fills, which it avoids, and which
* smallest box your shape will fit inside of). This box outlines the minimum and maximum * it intersects. Divide intersected octants again. Continue dividing until no partial octants remain,
* x, y, and z dimensions of the shape.<p> * or until the desired resolution is reached.<p>
* *
* Next, you divide this cube evenly into 8 more cubes, determining which of these cubes * Useful for testing whether an arbitrary 3-D object contains any given point.
* your shape fills, which it leaves empty, and which it intersects. Intersected cubes are
* divided again into 8 more cubes, and the process repeats until only completely full
* (<tt>true</tt>) and completely empty (<tt>false</tt>) cubes remain.<p>
*
* With this tree, you can quickly determine whether any arbitrary point is inside or outside
* your shape by navigating the tree to reach the smallest cube containing your point.
* *
* @author Kevin Mathewson * @author Kevin Mathewson
* *
@ -47,11 +43,28 @@ public abstract class Tree
this.full = full; this.full = full;
this.children = new Node[0]; this.children = new Node[0];
} }
public Node(Node[] nodes) public Node(Node... nodes)
{ {
this.full = false; this.full = false;
this.children = nodes; this.children = nodes;
} }
/**
* Returns an array containing the given number of empty, childless nodes
*
* @param length desired size of array
*/
public static Node[] emptyNodeArray(int length)
{
Node[] array = new Node[length];
for (int i = 0; i < length; i++)
{
array[i] = new Node(false);
}
return array;
}
} }
@ -170,14 +183,12 @@ public abstract class Tree
/** /**
* Parses the tree below this node, appending in depth-first order the result of invoking * Appends to the OutputStream the result of invoking <tt>{@link #getByte(Node, Node, Node, Node)
* <tt>{@link #getByte(Node, Node, Node, Node) getByte(children)}</tt> for each encountered * getByte(children)}</tt> for each node, skipping childless nodes. Assumes an OutputStream that
* node in the tree, skipping childless nodes.<p> * appends with each write. Traverses depth-first.
*
* Assumes an OutputStream that appends with each write.
* *
* @param node the node to be parsed * @param node the node to be parsed
* @return a byte array representing the node and all its child nodes * @param output the OutputStream to write to
* @throws IOException * @throws IOException
*/ */
public abstract void writeBytes(Node node, OutputStream output) throws IOException; public abstract void writeBytes(Node node, OutputStream output) throws IOException;
@ -266,7 +277,6 @@ public abstract class Tree
public final File file; public final File file;
public final Node root; public final Node root;
public final TreeEditor<? extends Tree> editor;
/** /**
* Create a Tree from the given binary file. Invokes {@link #parseBytes(File)} * Create a Tree from the given binary file. Invokes {@link #parseBytes(File)}
@ -280,7 +290,19 @@ public abstract class Tree
this.file = file; this.file = file;
this.root = parseBytes(file); this.root = parseBytes(file);
this.editor = newEditor(); }
/**
*
*
* @param file The source file, and save destination, for this Tree
* @param blocks BitSet representing all <tt>true</tt> points in the given volume
* @param bounds Min and max coordinates of the bounding box
*/
public Tree(File file, BitSet blocks, int[][] bounds)
{
this.file = file;
this.root = null;
} }
@ -298,21 +320,12 @@ public abstract class Tree
* *
* @param file the source file to examine * @param file the source file to examine
*/ */
private static void setBoundsFromFilename(File file) private void setBoundsFromFilename(File file)
{ {
//TODO finish setBoundsFromFilename() method //TODO finish setBoundsFromFilename() method
} }
/**
* Abstract method, returns a new object
* extending the abstract class TreeEditor
*
* @return a new TreeEditor
*/
abstract TreeEditor<? extends Tree> newEditor();
/* /*
@ -323,23 +336,146 @@ public abstract class Tree
*/ */
/*----------------------------------------------------------------------------
------------------------------------------------------------------------------
STATIC CALCULATIONS
------------------------------------------------------------------------------
----------------------------------------------------------------------------*/
/*-------------------------------------
OVERLOADS : nextPowerOfTwo()
-------------------------------------*/
/** /**
* *
* @param parentNode * @param a
* @param regionBounds
* @return * @return
*/ */
public abstract Node[] getNodes(Node parentNode, int[][] regionBounds); public static int nextPowerOfTwo(int a)
/**
*
* @param regionBounds
* @return
*/
public Node[] getNodes(int[][] regionBounds)
{ {
return getNodes(root, regionBounds); return java.lang.Integer.highestOneBit(a) << 1;
} }
/**
*
* @param a
* @param b
* @return
*/
public static int nextPowerOfTwo(int a, int b)
{
return java.lang.Integer.highestOneBit(Math.max(a, b)) << 1;
}
/**
*
* @param a
* @param b
* @param c
* @return
*/
public static int nextPowerOfTwo(int a, int b, int c)
{
return java.lang.Integer.highestOneBit(Math.max(Math.max(a, b), c)) << 1;
}
/*----------------------------------------------------------------------------
------------------------------------------------------------------------------
EVALUATE
------------------------------------------------------------------------------
----------------------------------------------------------------------------*/
/**
*
* @param coords
* @return
*/
public abstract boolean contains(int... coords);
/*----------------------------------------------------------------------------
------------------------------------------------------------------------------
ADD VOLUME
------------------------------------------------------------------------------
----------------------------------------------------------------------------*/
/**
*
* @param coordinates
*/
protected abstract void expandAsNeeded(int...coords);
/**
*
* @param bounds
*/
protected abstract void expandAsNeeded(int[]...bounds);
/**
*
* @param coordinates
* @return
*/
public abstract void add(int...coords);
/**
*
* @param bounds
* @return
*/
public abstract void add(int[]...bounds);
/**
*
* @param blocks
* @param bounds
* @return
*/
public abstract void add(BitSet blocks, int[]...bounds);
/*----------------------------------------------------------------------------
------------------------------------------------------------------------------
REMOVE VOLUME
------------------------------------------------------------------------------
----------------------------------------------------------------------------*/
/**
*
*/
public abstract void trimAsNeeded();
/**
*
* @param coordinates
* @return
*/
public abstract void remove(int...coords);
/**
*
* @param bounds
* @return
*/
public abstract void remove(int[]...bounds);
/**
*
* @param blocks
* @param bounds
* @return
*/
public abstract void remove(BitSet blocks, int[]...bounds);
} }