Пример #1
0
  /**
   * Erases the ball.
   *
   * @param ballGraphic The graphics object to use.
   */
  public void erase(Graphics2D ballGraphic) {
    double upperLeftX = _position.x - (_pixelWidth / 2);
    double upperLeftY = _position.y - (_pixelHeight / 2);

    ballGraphic.setPaint(Color.WHITE);
    ballGraphic.fillOval((int) upperLeftX, (int) upperLeftY, _pixelWidth, _pixelHeight);
  }
Пример #2
0
 public void draw(Graphics2D g2, boolean shouldFlip) {
   Font font = new Font("Sans_Serif", Font.PLAIN, 30);
   g2.setColor(Color.orange);
   g2.fillOval((int) x - 10, (int) (FieldConstants.FIELD_HEIGHT - y - 10), 20, 20);
   font = new Font("Sans_Serif", Font.PLAIN, 18);
   g2.setFont(font);
   g2.drawString(Double.toString(confidence), x, FieldConstants.FIELD_HEIGHT - y + 60);
 }
Пример #3
0
  /**
   * Draws the ball.
   *
   * @param ballGraphic The graphics object to use.
   */
  public void draw(Graphics2D ballGraphic) {
    double upperLeftX = _position.x - (_pixelWidth / 2);
    double upperLeftY = _position.y - (_pixelHeight / 2);

    ballGraphic.setPaint(Color.BLACK);
    ballGraphic.fillOval((int) upperLeftX, (int) upperLeftY, _pixelWidth, _pixelHeight);

    updateCollisionRectangle(upperLeftX, upperLeftY, _pixelWidth, _pixelHeight);
  }
Пример #4
0
  public void drawCircle(int xpos, int ypos, double rot, double xscale, double yscale, int width) {
    g.translate(xpos, ypos);
    g.rotate(rot * Math.PI / 180.0);
    g.scale(xscale, yscale);

    g.fillOval(-width / 2, -width / 2, width, width);

    g.scale(1.0 / xscale, 1.0 / yscale);
    g.rotate(-rot * Math.PI / 180.0);
    g.translate(-xpos, -ypos);
  }
Пример #5
0
  public void drawStar(int xpos, int ypos, double rot, double xscale, double yscale) {
    g.translate(xpos, ypos);
    g.rotate(rot * Math.PI / 180.0);
    g.scale(xscale, yscale);

    g.fillOval(-10, -10, 20, 20);

    g.scale(1.0 / xscale, 1.0 / yscale);
    g.rotate(-rot * Math.PI / 180.0);
    g.translate(-xpos, -ypos);
  }
Пример #6
0
 void drawCircleFrom(Graphics2D g, int fx, int fy, int tx, int ty, Color color, int size) {
   Color col = g.getColor();
   g.setColor(color);
   int x, y;
   if (fx == tx) { // vertical line
     x = fx;
     if (ty > fy) y = fy + size / 2;
     else y = fy - size / 2;
   } else { // assume horizontal for now
     y = fy;
     if (tx > fx) x = fx + size / 2;
     else x = fx - size / 2;
   }
   // x and y are the centre of the circle
   // adjust to top left corner
   x -= size / 2;
   y -= size / 2;
   g.drawOval(x, y, size, size);
   g.fillOval(x, y, size, size);
   g.setColor(col);
 }
Пример #7
0
  void drawCircleTo(Graphics2D g, int fx, int fy, int tx, int ty, Color color, int size) {
    Color col = g.getColor();
    g.setColor(color);
    int x, y;
    x = tx;
    y = ty;
    if (color == Color.BLUE) {
      if (fx == tx) { // vertical line
        if (ty > fy) y = ty - size / 2;
        else y = ty + size / 2;
      } else {
        if (tx > fx) x = tx - size / 2;
        else x = tx + size / 2;
      }
    }
    // x and y are the centre of the circle
    // adjust to top left corner

    x -= size / 2;
    y -= size / 2;
    g.drawOval(x, y, size, size);
    g.fillOval(x, y, size, size);
    g.setColor(col);
  }
Пример #8
0
  public void paintComponent(Graphics g) {

    super.paintComponent(g);
    Graphics2D g2 = (Graphics2D) g;

    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

    // x-axis
    g2.drawLine(X_AXIS_FIRST_X_COORD, X_AXIS_Y_COORD, X_AXIS_SECOND_X_COORD, X_AXIS_Y_COORD);
    // y-axis
    g2.drawLine(Y_AXIS_X_COORD, Y_AXIS_FIRST_Y_COORD, Y_AXIS_X_COORD, Y_AXIS_SECOND_Y_COORD);

    // // x-axis arrow
    g2.drawLine(
        X_AXIS_SECOND_X_COORD - FIRST_LENGHT,
        X_AXIS_Y_COORD - SECOND_LENGHT,
        X_AXIS_SECOND_X_COORD,
        X_AXIS_Y_COORD);
    g2.drawLine(
        X_AXIS_SECOND_X_COORD - FIRST_LENGHT,
        X_AXIS_Y_COORD + SECOND_LENGHT,
        X_AXIS_SECOND_X_COORD,
        X_AXIS_Y_COORD);

    // // y-axis arrow
    g2.drawLine(
        Y_AXIS_X_COORD - SECOND_LENGHT,
        Y_AXIS_FIRST_Y_COORD + FIRST_LENGHT,
        Y_AXIS_X_COORD,
        Y_AXIS_FIRST_Y_COORD);
    g2.drawLine(
        Y_AXIS_X_COORD + SECOND_LENGHT,
        Y_AXIS_FIRST_Y_COORD + FIRST_LENGHT,
        Y_AXIS_X_COORD,
        Y_AXIS_FIRST_Y_COORD);

    // // draw origin Point
    g2.fillOval(
        X_AXIS_FIRST_X_COORD - (ORIGIN_COORDINATE_LENGHT / 2),
        Y_AXIS_SECOND_Y_COORD - (ORIGIN_COORDINATE_LENGHT / 2),
        ORIGIN_COORDINATE_LENGHT,
        ORIGIN_COORDINATE_LENGHT);

    // draw text "X" and draw text "Y"
    g2.drawString(
        "X",
        X_AXIS_SECOND_X_COORD - AXIS_STRING_DISTANCE / 2,
        X_AXIS_Y_COORD + AXIS_STRING_DISTANCE);
    g2.drawString(
        "Y",
        Y_AXIS_X_COORD - AXIS_STRING_DISTANCE,
        Y_AXIS_FIRST_Y_COORD + AXIS_STRING_DISTANCE / 2);
    g2.drawString(
        "(0, 0)",
        X_AXIS_FIRST_X_COORD - AXIS_STRING_DISTANCE,
        Y_AXIS_SECOND_Y_COORD + AXIS_STRING_DISTANCE);

    // numerate axis
    int xLength = (X_AXIS_SECOND_X_COORD - X_AXIS_FIRST_X_COORD) / xCoordNumbers;
    int yLength = (Y_AXIS_SECOND_Y_COORD - Y_AXIS_FIRST_Y_COORD) / yCoordNumbers;

    // draw x-axis numbers
    for (int i = 1; i < xCoordNumbers; i++) {
      g2.drawLine(
          X_AXIS_FIRST_X_COORD + (i * xLength),
          X_AXIS_Y_COORD - SECOND_LENGHT,
          X_AXIS_FIRST_X_COORD + (i * xLength),
          X_AXIS_Y_COORD + SECOND_LENGHT);
      g2.drawString(
          Integer.toString(i),
          X_AXIS_FIRST_X_COORD + (i * xLength) - 3,
          X_AXIS_Y_COORD + AXIS_STRING_DISTANCE);
    }

    // //draw y-axis numbers
    for (int i = 1; i < yCoordNumbers; i++) {
      g2.drawLine(
          Y_AXIS_X_COORD - SECOND_LENGHT,
          Y_AXIS_SECOND_Y_COORD - (i * yLength),
          Y_AXIS_X_COORD + SECOND_LENGHT,
          Y_AXIS_SECOND_Y_COORD - (i * yLength));
      g2.drawString(
          "0," + Integer.toString(i),
          Y_AXIS_X_COORD - AXIS_STRING_DISTANCE,
          Y_AXIS_SECOND_Y_COORD - (i * yLength));
    }
    for (int i = 0; i < jumlahGrafik; i++) {
      doDrawing(g, this.std[i], this.sig[i], i);
    }
    for (int i = 0; i < jumlahGrafik; i++) {
      alpaCut(g, this.alfa, i);
    }
  }
Пример #9
0
 // also clip, transform, composite,
 // public boolean isOpaque(){return false;}//theOpaque!=null&&theOpaque;}
 // ---------------------------------------------------------
 private void doPaint(Graphics2D g, int s, Object o) {
   // process an operation from the buffer
   // System.out.println(s);
   Object o1 = null,
       o2 = null,
       o3 = null,
       o4 = null,
       o5 = null,
       o6 = null,
       o7 = null,
       o8 = null,
       o9 = null,
       o10 = null,
       o11 = null;
   if (o instanceof Object[]) {
     Object[] a = (Object[]) o;
     if (a.length > 0) o1 = a[0];
     if (a.length > 1) o2 = a[1];
     if (a.length > 2) o3 = a[2];
     if (a.length > 3) o4 = a[3];
     if (a.length > 4) o5 = a[4];
     if (a.length > 5) o6 = a[5];
     if (a.length > 6) o7 = a[6];
     if (a.length > 7) o8 = a[7];
     if (a.length > 8) o9 = a[8];
     if (a.length > 9) o10 = a[9];
     if (a.length > 10) o11 = a[10];
   }
   switch (s) {
     case clear:
       paintBackground(g, theBackground);
       break;
       // public void addRenderingHints(Map<?,?> hints)
       // {toBuffer("addRenderingHints",hints );}
     case addRenderingHints:
       g.addRenderingHints((Map<?, ?>) o);
       break;
     case clip1:
       g.clip((Shape) o);
       break;
     case draw1:
       g.draw((Shape) o);
       break;
     case draw3DRect:
       g.draw3DRect((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Boolean) o5);
       break;
     case drawGlyphVector:
       g.drawGlyphVector((GlyphVector) o1, (Float) o2, (Float) o3);
       break;
     case drawImage1:
       g.drawImage((BufferedImage) o1, (BufferedImageOp) o2, (Integer) o3, (Integer) o4);
       break;
     case drawImage2:
       g.drawImage((Image) o1, (AffineTransform) o2, (ImageObserver) o3);
       break;
     case drawRenderableImage:
       g.drawRenderableImage((RenderableImage) o1, (AffineTransform) o2);
       break;
     case drawRenderedImage:
       g.drawRenderedImage((RenderedImage) o1, (AffineTransform) o2);
       break;
     case drawString1:
       g.drawString((AttributedCharacterIterator) o1, (Float) o2, (Float) o3);
       break;
     case drawString2:
       g.drawString((AttributedCharacterIterator) o1, (Integer) o2, (Integer) o3);
       break;
     case drawString3:
       g.drawString((String) o1, (Float) o2, (Float) o3);
       break;
     case drawString4:
       g.drawString((String) o1, (Integer) o2, (Integer) o3);
       break;
     case fill:
       g.fill((Shape) o);
       break;
     case fill3DRect:
       g.fill3DRect((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Boolean) o5);
       break;
     case rotate1:
       g.rotate((Double) o);
       break;
     case rotate2:
       g.rotate((Double) o1, (Double) o2, (Double) o3);
       break;
     case scale1:
       g.scale((Double) o1, (Double) o2);
       break;
     case setBackground:
       g.setBackground(
           (Color) o); // paintBackground(g,(Color)o); /*super.setBackground((Color)o) ;*/
       break;
     case setComposite:
       g.setComposite((Composite) o);
       break;
     case setPaint:
       g.setPaint((Paint) o);
       break;
     case setRenderingHint:
       g.setRenderingHint((RenderingHints.Key) o1, o2);
       break;
     case setRenderingHints:
       g.setRenderingHints((Map<?, ?>) o);
       break;
     case setStroke:
       g.setStroke((Stroke) o);
       break;
     case setTransform:
       g.setTransform(makeTransform(o));
       break;
     case shear:
       g.shear((Double) o1, (Double) o2);
       break;
     case transform1:
       g.transform(makeTransform(o));
       break;
     case translate1:
       g.translate((Double) o1, (Double) o2);
       break;
     case translate2:
       g.translate((Integer) o1, (Integer) o2);
       break;
     case clearRect:
       g.clearRect((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4);
       break;
     case copyArea:
       g.copyArea(
           (Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5, (Integer) o6);
       break;
     case drawArc:
       g.drawArc(
           (Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5, (Integer) o6);
       break;
     case drawBytes:
       g.drawBytes((byte[]) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5);
       break;
     case drawChars:
       g.drawChars((char[]) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5);
       break;
     case drawImage4:
       g.drawImage((Image) o1, (Integer) o2, (Integer) o3, (Color) o4, (ImageObserver) o5);
       break;
     case drawImage5:
       g.drawImage((Image) o1, (Integer) o2, (Integer) o3, (ImageObserver) o4);
       break;
     case drawImage6:
       g.drawImage(
           (Image) o1,
           (Integer) o2,
           (Integer) o3,
           (Integer) o4,
           (Integer) o5,
           (Color) o6,
           (ImageObserver) o7);
       break;
     case drawImage7:
       g.drawImage(
           (Image) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5, (ImageObserver) o6);
       break;
     case drawImage8:
       g.drawImage(
           (Image) o1,
           (Integer) o2,
           (Integer) o3,
           (Integer) o4,
           (Integer) o5,
           (Integer) o6,
           (Integer) o7,
           (Integer) o8,
           (Integer) o9,
           (Color) o10,
           (ImageObserver) o11);
       break;
     case drawImage9:
       g.drawImage(
           (Image) o1,
           (Integer) o2,
           (Integer) o3,
           (Integer) o4,
           (Integer) o5,
           (Integer) o6,
           (Integer) o7,
           (Integer) o8,
           (Integer) o9,
           (ImageObserver) o10);
       break;
     case drawLine:
       g.drawLine((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4);
       break;
     case drawOval:
       g.drawOval((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4);
       break;
     case drawPolygon1:
       g.drawPolygon((int[]) o1, (int[]) o2, (Integer) o3);
       break;
     case drawPolygon2:
       g.drawPolygon((Polygon) o);
       break;
     case drawPolyline:
       g.drawPolyline((int[]) o1, (int[]) o2, (Integer) o3);
       break;
     case drawRect:
       g.drawRect((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4);
       break;
     case drawRoundRect:
       g.drawRoundRect(
           (Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5, (Integer) o6);
       break;
     case fillArc:
       g.fillArc(
           (Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5, (Integer) o6);
       break;
     case fillOval:
       g.fillOval((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4);
       break;
       // {toBuffer("fillPolygon",mkArg(xPoints,  yPoints, nPoints) );}
     case fillPolygon1:
       g.fillPolygon((int[]) o1, (int[]) o2, (Integer) o3);
       break;
     case fillPolygon2:
       g.fillPolygon((Polygon) o);
       break;
     case fillRect:
       g.fillRect((Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4);
       break;
     case fillRoundRect:
       g.fillRoundRect(
           (Integer) o1, (Integer) o2, (Integer) o3, (Integer) o4, (Integer) o5, (Integer) o6);
       break;
     case setClip1:
       g.setClip((Shape) o);
       break;
     case setColor:
       g.setColor((Color) o);
       break;
     case setFont:
       g.setFont((Font) o);
       break;
     case setPaintMode:
       g.setPaintMode();
       break;
     case setXORMode:
       g.setXORMode((Color) o);
       break;
     case opaque:
       super.setOpaque((Boolean) o);
       break;
     case drawOutline: // g.drawString((String)o1, (Integer)o2, (Integer)o3) ;break;
       {
         FontRenderContext frc = g.getFontRenderContext();
         TextLayout tl = new TextLayout((String) o1, g.getFont(), frc);
         Shape s1 = tl.getOutline(null);
         AffineTransform af = g.getTransform();
         g.translate((Integer) o2, (Integer) o3);
         g.draw(s1);
         g.setTransform(af);
       }
       ;
       break;
     default:
       System.out.println("Unknown image operation " + s);
   }
 }