/**
* Is the given sprite visible in the given area.
*
* @param sprite The sprite to check.
* @param X1 The min abscissa of the area.
* @param Y1 The min ordinate of the area.
* @param X2 The max abscissa of the area.
* @param Y2 The max ordinate of the area.
* @return True if the node lies in the given area.
*/
protected boolean isSpriteIn(GraphicSprite sprite, double X1, double Y1, double X2, double Y2) {
if (sprite.isAttachedToNode() && nodeInvisible.contains(sprite.getNodeAttachment().getId())) {
return false;
} else if (sprite.isAttachedToEdge() && !isEdgeVisible(sprite.getEdgeAttachment())) {
return false;
} else {
Values size = sprite.getStyle().getSize();
double w2 = metrics.lengthToPx(size, 0) / 2;
double h2 = size.size() > 1 ? metrics.lengthToPx(size, 1) / 2 : w2;
Point2D.Double src = spritePositionPx(sprite); // new Point2D.Double(
// sprite.getX(),
// sprite.getY() );
// Tx.transform( src, src );
double x1 = src.x - w2;
double x2 = src.x + w2;
double y1 = src.y - h2;
double y2 = src.y + h2;
if (x2 < X1) return false;
if (y2 < Y1) return false;
if (x1 > X2) return false;
if (y1 > Y2) return false;
return true;
}
}
/**
* Compute the position of a sprite if attached to a node.
*
* @param sprite The sprite.
* @param pos Where to stored the computed position, if null, the position is created.
* @param units The units the computed position must be given into.
* @return The same instance as pos, or a new one if pos was null.
*/
protected Point2D.Double getSpritePositionNode(
GraphicSprite sprite, Point2D.Double pos, Units units) {
if (pos == null) pos = new Point2D.Double();
GraphicNode node = sprite.getNodeAttachment();
pos.x = node.x + sprite.getX();
pos.y = node.y + sprite.getY();
if (units == Units.PX) Tx.transform(pos, pos);
return pos;
}
/**
* Compute the position of a sprite if attached to an edge.
*
* @param sprite The sprite.
* @param pos Where to stored the computed position, if null, the position is created.
* @param units The units the computed position must be given into.
* @return The same instance as pos, or a new one if pos was null.
*/
protected Point2D.Double getSpritePositionEdge(
GraphicSprite sprite, Point2D.Double pos, Units units) {
if (pos == null) pos = new Point2D.Double();
GraphicEdge edge = sprite.getEdgeAttachment();
if (edge.isCurve()) {
double ctrl[] = edge.getControlPoints();
Point2 p0 = new Point2(edge.from.getX(), edge.from.getY());
Point2 p1 = new Point2(ctrl[0], ctrl[1]);
Point2 p2 = new Point2(ctrl[1], ctrl[2]);
Point2 p3 = new Point2(edge.to.getX(), edge.to.getY());
Vector2 perp = CubicCurve.perpendicular(p0, p1, p2, p3, sprite.getX());
double y = metrics.lengthToGu(sprite.getY(), sprite.getUnits());
perp.normalize();
perp.scalarMult(y);
pos.x = CubicCurve.eval(p0.x, p1.x, p2.x, p3.x, sprite.getX()) - perp.data[0];
pos.y = CubicCurve.eval(p0.y, p1.y, p2.y, p3.y, sprite.getX()) - perp.data[1];
} else {
double x = ((GraphicNode) edge.getSourceNode()).x;
double y = ((GraphicNode) edge.getSourceNode()).y;
double dx = ((GraphicNode) edge.getTargetNode()).x - x;
double dy = ((GraphicNode) edge.getTargetNode()).y - y;
double d = sprite.getX(); // Percent on the edge.
double o = metrics.lengthToGu(sprite.getY(), sprite.getUnits());
// Offset from the position given by percent, perpendicular to the
// edge.
d = d > 1 ? 1 : d;
d = d < 0 ? 0 : d;
x += dx * d;
y += dy * d;
d = (double) Math.sqrt(dx * dx + dy * dy);
dx /= d;
dy /= d;
x += -dy * o;
y += dx * o;
pos.x = x;
pos.y = y;
if (units == Units.PX) {
Tx.transform(pos, pos);
}
}
return pos;
}
/**
* Compute the position of a sprite if it is not attached.
*
* @param sprite The sprite.
* @param pos Where to stored the computed position, if null, the position is created.
* @param units The units the computed position must be given into.
* @return The same instance as pos, or a new one if pos was null.
*/
protected Point2D.Double getSpritePositionFree(
GraphicSprite sprite, Point2D.Double pos, Units units) {
if (pos == null) pos = new Point2D.Double();
if (sprite.getUnits() == units) {
pos.x = sprite.getX();
pos.y = sprite.getY();
} else if (units == Units.GU && sprite.getUnits() == Units.PX) {
pos.x = sprite.getX();
pos.y = sprite.getY();
xT.transform(pos, pos);
} else if (units == Units.PX && sprite.getUnits() == Units.GU) {
pos.x = sprite.getX();
pos.y = sprite.getY();
Tx.transform(pos, pos);
} else if (units == Units.GU && sprite.getUnits() == Units.PERCENTS) {
pos.x = metrics.lo.x + (sprite.getX() / 100f) * metrics.graphWidthGU();
pos.y = metrics.lo.y + (sprite.getY() / 100f) * metrics.graphHeightGU();
} else if (units == Units.PX && sprite.getUnits() == Units.PERCENTS) {
pos.x = (sprite.getX() / 100f) * metrics.viewport[2];
pos.y = (sprite.getY() / 100f) * metrics.viewport[3];
} else {
throw new RuntimeException("Unhandled yet sprite positioning.");
}
return pos;
}
/**
* Compute the real position of a sprite according to its eventual attachment in graph units.
*
* @param sprite The sprite.
* @param pos Receiver for the sprite 2D position, can be null.
* @param units The units in which the position must be computed (the sprite already contains
* units).
* @return The same instance as the one given by parameter pos or a new one if pos was null,
* containing the computed position in the given units.
*/
public Point2D.Double getSpritePosition(GraphicSprite sprite, Point2D.Double pos, Units units) {
if (sprite.isAttachedToNode()) return getSpritePositionNode(sprite, pos, units);
else if (sprite.isAttachedToEdge()) return getSpritePositionEdge(sprite, pos, units);
else return getSpritePositionFree(sprite, pos, units);
}