예제 #1
0
  /**
   * 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;
    }
  }
예제 #2
0
  /**
   * 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;
  }