package org.newdawn.slick.geom;
import java.util.ArrayList;
/**
* A set of utilities to play with geometry
*
* @author kevin
*/
public class GeomUtil {
/** The tolerance for determining changes and steps */
public float EPSILON = 0.0001f;
/** The tolerance for determining direction change */
public float EDGE_SCALE = 1f;
/** The maximum number of points returned by an operation - prevents full lockups */
public int MAX_POINTS = 10000;
/** The listener to notify of operations */
public GeomUtilListener listener;
/**
* Subtract one shape from another - note this is experimental and doesn't
* currently handle islands
*
* @param target The target to be subtracted from
* @param missing The shape to subtract
* @return The newly created shapes
*/
public Shape[] subtract(Shape target, Shape missing) {
target = target.transform(new Transform());
missing = missing.transform(new Transform());
int count = 0;
for (int i=0;i<target.getPointCount();i++) {
if (missing.contains(target.getPoint(i)[0], target.getPoint(i)[1])) {
count++;
}
}
if (count == target.getPointCount()) {
return new Shape[0];
}
if (!target.intersects(missing)) {
return new Shape[] {target};
}
int found = 0;
for (int i=0;i<missing.getPointCount();i++) {
if (target.contains(missing.getPoint(i)[0], missing.getPoint(i)[1])) {
if (!onPath(target, missing.getPoint(i)[0], missing.getPoint(i)[1])) {
found++;
}
}
}
for (int i=0;i<target.getPointCount();i++) {
if (missing.contains(target.getPoint(i)[0], target.getPoint(i)[1])) {
if (!onPath(missing, target.getPoint(i)[0], target.getPoint(i)[1]))
{
found++;
}
}
}
if (found < 1) {
return new Shape[] {target};
}
return combine(target, missing, true);
}
/**
* Check if the given point is on the path
*
* @param path The path to check
* @param x The x coordinate of the point to check
* @param y The y coordiante of teh point to check
* @return True if the point is on the path
*/
private boolean onPath(Shape path, float x, float y) {
for (int i=0;i<path.getPointCount()+1;i++) {
int n = rationalPoint(path, i+1);
Line line = getLine(path, rationalPoint(path, i), n);
if (line.distance(new Vector2f(x,y)) < EPSILON*100) {
return true;
}
}
return false;
}
/**
* Set the listener to be notified of geometry based operations
*
* @param listener The listener to be notified of geometry based operations
*/
public void setListener(GeomUtilListener listener) {
this.listener = listener;
}
/**
* Join to shapes together. Note that the shapes must be touching
* for this method to work.
*
* @param target The target shape to union with
* @param other The additional shape to union
* @return The newly created shapes
*/
public Shape[] union(Shape target, Shape other) {
target = target.transform(new Transform());
other = other.transform(new Transform());
if (!target.intersects(other)) {
return new Shape[] {target, other};
}
// handle the case where intersects is true but really we're talking
// about edge points
boolean touches = false;
int buttCount = 0;
for (int i=0;i<target.getPointCount();i++) {
if (other.contains(target.getPoint(i)[0], target.getPoint(i)[1])) {
if (!other.hasVertex(target.getPoint(i)[0], target.getPoint(i)[1])) {
touches = true;
break;
}
}
if (other.hasVertex(target.getPoint(i)[0], target.getPoint(i)[1])) {
buttCount++;
}
}
for (int i=0;i<other.getPointCount();i++) {
if (target.contains(other.getPoint(i)[0], other.getPoint(i)[1])) {
if (!target.hasVertex(other.getPoint(i)[0], other.getPoint(i)[1])) {
touches = true;
break;
}
}
}
if ((!touches) && (buttCount < 2)) {
return new Shape[] {target, other};
}
// so they are definitely touching, consider the union
return combine(target, other, false);
}
/**
* Perform the combination
*
* @param target The target shape we're updating
* @param other The other shape in the operation
* @param subtract True if it's a subtract operation, otherwise it's union
* @return The set of shapes produced
*/
private Shape[] combine(Shape target, Shape other, boolean subtract) {
if (subtract) {
ArrayList shapes = new ArrayList();
ArrayList used = new ArrayList();
// remove any points that are contianed in the shape we're removing, these
// are implicitly used
for (int i=0;i<target.getPointCount();i++) {
float[] point = target.getPoint(i);
if (other.contains(point[0], point[1])) {
used.add(new Vector2f(point[0], point[1]));
if (listener != null) {
listener.pointExcluded(point[0], point[1]);
}
}
}
for (int i=0;i<target.getPointCount();i++) {
float[] point = target.getPoint(i);
Vector2f pt = new Vector2f(point[0], point[1]);
if (!used.contains(pt)) {
Shape result = combineSingle(target, other, true, i);
shapes.add(result);
for (int j=0;j<result.getPointCount();j++) {
float[] kpoint = result.getPoint(j);
Vector2f kpt = new Vector2f(kpoint[0], kpoint[1]);
used.add(kpt);
}
}
}
return (Shape[]) shapes.toArray(new Shape[0]);
} else {
for (int i=0;i<target.getPointCount();i++) {
if (!other.contains(target.getPoint(i)[0], target.getPoint(i)[1])) {
if (!other.hasVertex(target.getPoint(i)[0], target.getPoint(i)[1])) {
Shape shape = combineSingle(target, other, false, i);
return new Shape[] {shape};
}
}
}
return new Shape[] {other};
}
}
/**
* Combine two shapes
*
* @param target The target shape
* @param missing The second shape to apply
* @param subtract True if we should subtract missing from target, otherwise union
* @param start The point to start at
* @return The newly created shape
*/
private Shape combineSingle(Shape target, Shape missing, boolean subtract, int start) {
Shape current = target;
Shape other = missing;
int point = start;
int dir = 1;
Polygon poly = new Polygon();
boolean first = true;
int loop = 0;
// while we've not reached the same point
float px = current.getPoint(point)[0];
float py = current.getPoint(point)[1];
while (!poly.hasVertex(px, py) || (first) || (current != target)) {
first = false;
loop++;
if (loop > MAX_POINTS) {
break;
}
// add the current point to the result shape
poly.addPoint(px,py);
if (listener != null) {
listener.pointUsed(px,py);
}
// if the line between the current point and the next one intersect the
// other shape work out where on the other shape and start traversing it's
// path instead
Line line = getLine(current, px, py, rationalPoint(current, point+dir));
HitResult hit = intersect(other, line);
if (hit != null) {
Line hitLine = hit.line;
Vector2f pt = hit.pt;
px = pt.x;
py = pt.y;
if (listener != null) {
listener.pointIntersected(px,py);
}
if (other.hasVertex(px, py)) {
point = other.indexOf(pt.x,pt.y);
dir = 1;
px = pt.x;
py = pt.y;
Shape temp = current;
current = other;
other = temp;
continue;
}
float dx = hitLine.getDX() / hitLine.length();
float dy = hitLine.getDY() / hitLine.length();
dx *= EDGE_SCALE;
dy *= EDGE_SCALE;
if (current.contains(pt.x + dx, pt.y + dy)) {
// the point is the next one, we need to take the first and traverse
// the path backwards
if (subtract) {
if (current == missing) {
point = hit.p2;
dir = -1;
} else {
point = hit.p1;
dir = 1;
}
} else {
if (current == target) {
point = hit.p2;
dir = -1;
} else {
point = hit.p2;
dir = -1;
}
}
// swap the shapes over, we'll traverse the other one
Shape temp = current;
current = other;
other = temp;
} else if (current.contains(pt.x - dx, pt.y - dy)) {
if (subtract) {
if (current == target) {
point = hit.p2;
dir = -1;
} else {
point = hit.p1;
dir = 1;
}
} else {
if (current == missing) {
point = hit.p1;
dir = 1;
} else {
point = hit.p1;
dir = 1;
}
}
// swap the shapes over, we'll traverse the other one
Shape temp = current;
current = other;
other = temp;
} else {
// give up
if (subtract) {
break;
} else {
point = hit.p1;
dir = 1;
Shape temp = current;
current = other;
other = temp;
point = rationalPoint(current, point+dir);
px = current.getPoint(point)[0];
py = current.getPoint(point)[1];
}
}
} else {
// otherwise just move to the next point in the current shape
point = rationalPoint(current, point+dir);
px = current.getPoint(point)[0];
py = current.getPoint(point)[1];
}
}
poly.addPoint(px,py);
if (listener != null) {
listener.pointUsed(px,py);
}
return poly;
}
/**
* Intersect a line with a shape
*
* @param shape The shape to compare
* @param line The line to intersect against the shape
* @return The result describing the intersection or null if none
*/
public HitResult intersect(Shape shape, Line line) {
float distance = Float.MAX_VALUE;
HitResult hit = null;
for (int i=0;i<shape.getPointCount();i++) {
int next = rationalPoint(shape, i+1);
Line local = getLine(shape, i, next);
Vector2f pt = line.intersect(local, true);
if (pt != null) {
float newDis = pt.distance(line.getStart());
if ((newDis < distance) && (newDis > EPSILON)) {
hit = new HitResult();
hit.pt = pt;
hit.line = local;
hit.p1 = i;
hit.p2 = next;
distance = newDis;
}
}
}
return hit;
}
/**
* Rationalise a point in terms of a given shape
*
* @param shape The shape
* @param p The index of the point
* @return The index that is rational for the shape
*/
public static int rationalPoint(Shape shape, int p) {
while (p < 0) {
p += shape.getPointCount();
}
while (p >= shape.getPointCount()) {
p -= shape.getPointCount();
}
return p;
}
/**
* Get a line between two points in a shape
*
* @param shape The shape
* @param s The index of the start point
* @param e The index of the end point
* @return The line between the two points
*/
public Line getLine(Shape shape, int s, int e) {
float[] start = shape.getPoint(s);
float[] end = shape.getPoint(e);
Line line = new Line(start[0],start[1],end[0],end[1]);
return line;
}
/**
* Get a line between two points in a shape
*
* @param shape The shape
* @param sx The x coordinate of the start point
* @param sy The y coordinate of the start point
* @param e The index of the end point
* @return The line between the two points
*/
public Line getLine(Shape shape, float sx, float sy, int e) {
float[] end = shape.getPoint(e);
Line line = new Line(sx,sy,end[0],end[1]);
return line;
}
/**
* A lightweigtht description of a intersection between a shape and
* line.
*/
public class HitResult {
/** The line on the target shape that intersected */
public Line line;
/** The index of the first point on the target shape that forms the line */
public int p1;
/** The index of the second point on the target shape that forms the line */
public int p2;
/** The position of the intersection */
public Vector2f pt;
}
}