コード例 #1
0
  // calculate the coordinates of the startpoint (endpoint) if parameter is
  // true (false) of the arrow when drawing this link
  private Point calcCoord(boolean startpoint) {
    if (!startpoint && (end == null)) return openEnd;

    int deltaX;
    int deltaY;

    if (end == null) {
      deltaX = start.getX() - openEnd.x;
      deltaY = start.getY() - openEnd.y;
    } else {
      deltaX = start.getX() - end.getX();
      deltaY = start.getY() - end.getY();
    }

    double dist = Math.sqrt(deltaX * deltaX + deltaY * deltaY);

    double prop = (Client.RADIUS) / dist;

    int offsetX = (int) Math.round(deltaX * prop);
    int offsetY = (int) Math.round(deltaY * prop);

    if (startpoint) {
      return new Point(start.getX() - offsetX, start.getY() - offsetY);
    } else return new Point(end.getX() + offsetX, end.getY() + offsetY);
  }
コード例 #2
0
  // returns the endpoint which is closer to (x,y) than the other one
  public Client getPointNear(int x, int y) {
    if (start == null || end == null)
      throw new RuntimeException("ERROR: getPointNear() not allowed on open links");

    int distToStart = (int) Math.pow(start.getX() - x, 2) + (int) Math.pow(start.getY() - y, 2);

    int distToEnd = (int) Math.pow(end.getX() - x, 2) + (int) Math.pow(end.getY() - y, 2);

    if (distToStart < distToEnd) {
      return start;
    } else {
      return end;
    }
  }
コード例 #3
0
  // get the delay of the next packet
  public int getDelay() {
    switch (delayType) {
      case NO_DELAY:
        return 0;

      case CONST_DELAY:
        return constDelayMs;

      case DIST_DELAY:
        // calculate distance between start and end node
        int x = start.getX() - end.getX();
        int y = start.getY() - end.getY();
        float dist = (float) Math.sqrt(x * x + y * y);
        return (int) (dist * distDelayFactor);

      default:
        throw new RuntimeException("ERROR: Illegal delay type " + delayType);
    }
  }
コード例 #4
0
  // returns true if (x,y) is close to the link
  public boolean intersects(int x0, int y0) {

    if (end == null) throw new RuntimeException("ERROR: intersect() not allowed on open links");

    int x1, x2, y1, y2;

    x1 = start.getX();
    x2 = end.getX();
    y1 = start.getY();
    y2 = end.getY();

    // calculate the distance between the direct start-end connection and the point
    double o = Math.abs((x2 - x1) * (y1 - y0) - (x1 - x0) * (y2 - y1));
    double u = Math.sqrt(Math.pow((x2 - x1), 2) + Math.pow((y2 - y1), 2));

    if ((o / u) < INTERSECTION_DISTANCE) {
      return true;
    }

    return false;
  }
コード例 #5
0
  // draw the link
  public void draw(Graphics g1D) {
    // don't draw an open link if the end is inside of its startpoint
    if ((end == null) && (openEnd.distance(start.getX(), start.getY()) < Client.RADIUS)) return;

    // activate anti aliasing
    Graphics2D g = (Graphics2D) g1D;
    g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

    // set correct color
    if ((end != null) && start.isRunning() && end.isRunning()) g.setColor(RUNNING_LINK_COLOR);
    else g.setColor(SLEEPING_LINK_COLOR);

    // calculate start- & endpoint and link length
    Point s = new Point();
    Point e = new Point();
    double dist;

    s.x = start.getX();
    s.y = start.getY();

    if (end == null) {
      e.x = openEnd.x;
      e.y = openEnd.y;
      dist = s.distance(e) + Client.RADIUS;
    } else {
      e.x = end.getX();
      e.y = end.getY();
      dist = s.distance(e);
    }

    int fact = 1; //  fact = +/- 1 (needed if s not on the left of e)

    if (s.x > e.x) fact = -1;

    // rotate g so that we can draw horizontally
    double theta = Math.atan(((float) (e.y - s.y)) / (e.x - s.x));
    g.rotate(theta, s.x, s.y);

    // draw the link
    Stroke old = g.getStroke();

    if (getErrorType() == NO_ERROR) {
      g.setStroke(normal);
    } else {
      g.setStroke(dashed);
    }
    if (this.isBidirectional) {
      g.drawLine(
          s.x + fact * (Client.RADIUS + ARROW_LENGTH),
          s.y,
          (s.x + fact * ((int) dist - Client.RADIUS - ARROW_LENGTH)),
          s.y);
    } else {
      g.drawLine(
          s.x + fact * Client.RADIUS,
          s.y,
          (s.x + fact * ((int) dist - Client.RADIUS - ARROW_LENGTH)),
          s.y);
    }
    g.setStroke(old);

    // draw the arrows
    //
    //  /| |\ ^ W = ARROW_WIDTH
    // < ------ > W L = ARROW_LENGTH
    //  \| |/ v
    //
    // <L>
    // <-- dist -->

    int arrowX[] = new int[3];
    int arrowY[] = new int[3];

    arrowX[0] = s.x + fact * (Client.RADIUS);
    arrowX[1] = s.x + fact * (Client.RADIUS + ARROW_LENGTH);
    arrowX[2] = s.x + fact * (Client.RADIUS + ARROW_LENGTH);

    arrowY[0] = s.y;
    arrowY[1] = s.y - ARROW_WIDTH / 2;
    arrowY[2] = s.y + ARROW_WIDTH / 2;

    if (this.isBidirectional) {
      if (flashingStart) {
        g.setColor(USED_LINK_COLOR);
        g.fillPolygon(arrowX, arrowY, 3);
        g.setColor(RUNNING_LINK_COLOR);
      } else {
        g.fillPolygon(arrowX, arrowY, 3);
      }
    } else {

    }

    arrowX[0] = s.x + fact * ((int) dist - Client.RADIUS);
    arrowX[1] = s.x + fact * ((int) dist - Client.RADIUS - ARROW_LENGTH);
    arrowX[2] = s.x + fact * ((int) dist - Client.RADIUS - ARROW_LENGTH);

    if (flashingEnd) {
      g.setColor(USED_LINK_COLOR);
      g.fillPolygon(arrowX, arrowY, 3);
      g.setColor(RUNNING_LINK_COLOR);
    } else {
      g.fillPolygon(arrowX, arrowY, 3);
    }

    // write delay & packet info to the link
    if (end != null) {
      // write delay above the link
      String delayText = Integer.toString(getDelay()) + " ms";

      if (delayText.equals("0 ms")) {
        delayText = "no delay";
      }

      int delayWidth = g.getFontMetrics().stringWidth(delayText);

      // draw the text only if there is enough space
      if (delayWidth < dist - 2 * Client.RADIUS)
        g.drawString(delayText, (int) (s.x + fact * dist / 2 - delayWidth / 2), s.y - 8);

      // write sent/lost packets below the link
      String packetText =
          "sent: " + Integer.toString(succCount) + " lost: " + Integer.toString(lostCount);

      String packetTextShort = Integer.toString(succCount) + " / " + Integer.toString(lostCount);

      int packetWidth = g.getFontMetrics().stringWidth(packetText);
      int packetWidthShort = g.getFontMetrics().stringWidth(packetTextShort);

      // draw the text only if there is enough space
      if (packetWidth < dist - 2 * Client.RADIUS)
        g.drawString(packetText, (int) (s.x + fact * dist / 2 - packetWidth / 2), s.y + 15);
      else if (packetWidthShort < dist - 2 * Client.RADIUS)
        g.drawString(
            packetTextShort, (int) (s.x + fact * dist / 2 - packetWidthShort / 2), s.y + 15);
    }

    // rotate g back
    g.rotate(-theta, s.x, s.y);
  }