@Override
  public void paint(Graphics g) {
    Area a = new Area();
    Shape orejad = new Ellipse2D.Double(450, 100, 300, 300);
    Shape orejai = new Ellipse2D.Double(950, 100, 300, 300);
    a.add(new Area(orejai));
    a.add(new Area(orejad));
    Shape cabeza = new Ellipse2D.Double(600, 200, 500, 500);
    a.add(new Area(cabeza));

    Shape ojoi = new Ellipse2D.Double(675, 300, 100, 100);
    a.subtract(new Area(ojoi));

    Shape ojod = new Ellipse2D.Double(925, 300, 100, 100);
    a.subtract(new Area(ojod));

    Shape clip4 = new Ellipse2D.Double(0, 0, 400, 200);
    // super.paint(g);
    Area b = new Area(new Rectangle2D.Double(0, 0, 4000, 4000));
    b.subtract(a);
    g.setClip(b);
    g.setColor(c);
    g.fillRect((int) x, (int) y, (int) (Math.random() * 200), (int) (Math.random() * 200));
    g.fillRect((int) x + 9, (int) y + 9, (int) (Math.random() * 200), (int) (Math.random() * 200));
    g.fillRect(
        (int) x + 18, (int) y + 18, (int) (Math.random() * 200), (int) (Math.random() * 200));
    g.fillRect(
        (int) x + 27, (int) y + 27, (int) (Math.random() * 200), (int) (Math.random() * 200));
    g.setClip(a);
    g.setColor(new Color(255, 123, 0, 5));
    g.fillRect(
        (int) x + 27, (int) y + 27, (int) (Math.random() * 200), (int) (Math.random() * 200));
    x = x + vx;
    y = y + vy;
    if (x < 0) {
      vx = 5.6689f;
      // setBackground(getColorRandom());
      c = getColorRandom();
    }
    if (y < 0) {
      vy = 0.5f;
      // setBackground(getColorRandom());
      c = getColorRandom();
    }
    if (x > 1900) {
      vx = -5.6689f;
      // setBackground(getColorRandom());
      c = getColorRandom();
    }
    if (y > 900) {
      vy = -0.5f;
      // setBackground(getColorRandom());
      c = getColorRandom();
    }

    repaint();
  }
 public void paint(Graphics g) {
   Graphics2D g_2d = (Graphics2D) g;
   Ellipse2D ellipse = new Ellipse2D.Double(0, 2, 80, 80);
   Rectangle2D rect = new Rectangle2D.Double(40, 2, 80, 80);
   Area a1 = new Area(ellipse);
   Area a2 = new Area(rect);
   a1.intersect(a2); // "Óë"
   g_2d.fill(a1);
   ellipse.setFrame(130, 2, 80, 80);
   rect.setFrame(170, 2, 80, 80);
   a1 = new Area(ellipse);
   a2 = new Area(rect);
   a1.add(a2); // "»ò"
   g_2d.draw(a1);
   ellipse.setFrame(0, 90, 80, 80);
   rect.setFrame(40, 90, 80, 80);
   a1 = new Area(ellipse);
   a2 = new Area(rect);
   a1.subtract(a2); // "²î"
   g_2d.draw(a1);
   ellipse.setFrame(130, 90, 80, 80);
   rect.setFrame(170, 90, 80, 80);
   a1 = new Area(ellipse);
   a2 = new Area(rect);
   a1.exclusiveOr(a2); // "Òì»ò"
   g_2d.fill(a1);
 }
Beispiel #3
0
  private static final Shape createMask(int width, int height) {
    Shape outside = new Rectangle2D.Double(0, 0, width, height);
    Shape inside = new RoundRectangle2D.Double(10, 10, width - 20, height - 20, 50, 50);

    Area area = new Area(outside);
    area.subtract(new Area(inside));

    return area;
  }
    public void paintBorder(final Graphics g, final int x, final int y, final int w, final int h) {
      ((Graphics2D) g)
          .setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

      g.setColor(focusColor);
      rect.setRoundRect(x + 0.6, y + 0.6, w - 1.2, h - 1.2, outsideRadius, outsideRadius);
      area.reset();
      area.add(new Area(rect));
      rect.setRoundRect(x + 2, y + 2, w - 4, h - 4, insideRadius, insideRadius);
      area.subtract(new Area(rect));
      ((Graphics2D) g).fill(area);
    }
Beispiel #5
0
    public void actionPerformed(ActionEvent ae) {
      Area area = null;
      List<Attribute> attrs = new ArrayList<Attribute>();
      boolean fill = false;
      for (Vector v : shapes) {
        Primitive vv = v;
        while (vv instanceof Proxy && !(vv instanceof PaintedPrimitive)) {
          vv = ((Proxy) vv).getProxiedPrimitive();
        }
        if (vv instanceof PaintedPrimitive) {
          PaintedPrimitive pp = (PaintedPrimitive) vv;
          List<Attribute> atts = pp.allAttributes();
          System.err.println("  include attributes " + atts);
          attrs.addAll(pp.allAttributes());
        }
        fill |= v instanceof Fillable && ((Fillable) v).isFill();
        if (area == null) {
          area = new Area(v.toShape());
        } else {
          Area other = new Area(v.toShape());
          switch (kind) {
            case UNION:
              area.add(other);
              break;
            case INTERSECTION:
              area.intersect(other);
              break;
            case SUBTRACTION:
              area.subtract(other);
              break;
            case XOR:
              area.exclusiveOr(other);
              break;
            default:
              throw new AssertionError();
          }
        }
      }
      if (area != null) {
        PathIteratorWrapper wrap =
            new PathIteratorWrapper(
                area.getPathIterator(AffineTransform.getTranslateInstance(0, 0)), fill);
        // XXX probably don't want all attributes, they may be
        // redundant
        PaintedPrimitive pp = PaintedPrimitive.create(wrap, attrs);

        stack.replace(shapes, pp);
        if (repainter != null) {
          repainter.requestRepaint();
          ;
        }
      }
    }
Beispiel #6
0
  /**
   * Draw all primitives in this layer but do not draw modified ones (they are drawn by the edit
   * layer). Draw nodes last to overlap the ways they belong to.
   */
  @Override
  public void paint(final Graphics g, final MapView mv) {
    boolean active = true;
    boolean inactive = false;
    boolean virtual = false;

    // draw the hatched area for non-downloaded region. only draw if we're
    // the active
    // and bounds are defined; don't draw for inactive layers or loaded GPX
    // files etc
    if (active
        && Main.pref.getBoolean("draw.data.downloaded_area", true)
        && !data.dataSources.isEmpty()) {
      // initialize area with current viewport
      Rectangle b = Main.map.mapView.getBounds();
      // on some platforms viewport bounds seem to be offset from the
      // left,
      // over-grow it just to be sure
      b.grow(100, 100);
      Area a = new Area(b);

      // now succesively subtract downloaded areas
      for (DataSource src : data.dataSources) {
        if (src.bounds != null && !src.bounds.min.equals(src.bounds.max)) {
          EastNorth en1 = Main.proj.latlon2eastNorth(src.bounds.min);
          EastNorth en2 = Main.proj.latlon2eastNorth(src.bounds.max);
          Point p1 = mv.getPoint(en1);
          Point p2 = mv.getPoint(en2);
          Rectangle r =
              new Rectangle(
                  Math.min(p1.x, p2.x),
                  Math.min(p1.y, p2.y),
                  Math.abs(p2.x - p1.x),
                  Math.abs(p2.y - p1.y));
          a.subtract(new Area(r));
        }
      }

      // paint remainder
      ((Graphics2D) g).setPaint(hatched);
      ((Graphics2D) g).fill(a);
    }

    SimplePaintVisitor painter;
    if (Main.pref.getBoolean("draw.wireframe")) painter = new SimplePaintVisitor();
    else painter = new MapPaintVisitor();
    painter.setGraphics(g);
    painter.setNavigatableComponent(mv);
    painter.inactive = inactive;
    painter.visitAll(data, virtual);
    // Main.map.conflictDialog.paintConflicts(g, mv);
  }
    @Override
    public Dialog show() {
      Dialog picker = super.show();
      myTimer.start();
      // it seems like it's the lowest value for opacity for mouse events to be processed correctly
      WindowManager.getInstance().setAlphaModeRatio(picker, SystemInfo.isMac ? 0.95f : 0.99f);

      if (SystemInfo.isJavaVersionAtLeast("1.7")) {
        Area area = new Area(new Rectangle(0, 0, DIALOG_SIZE, DIALOG_SIZE));
        area.subtract(new Area(new Rectangle(SIZE / 2 - 1, SIZE / 2 - 1, 3, 3)));
        picker.setShape(area);
      }
      return picker;
    }
Beispiel #8
0
  public final void paintShadow(FGEShapeGraphics g) {
    double deep = getGraphicalRepresentation().getShadowStyle().getShadowDepth();
    int blur = getGraphicalRepresentation().getShadowStyle().getShadowBlur();
    double viewWidth = getGraphicalRepresentation().getViewWidth(1.0);
    double viewHeight = getGraphicalRepresentation().getViewHeight(1.0);
    AffineTransform shadowTranslation =
        AffineTransform.getTranslateInstance(deep / viewWidth, deep / viewHeight);

    int darkness = getGraphicalRepresentation().getShadowStyle().getShadowDarkness();

    Graphics2D oldGraphics = g.cloneGraphics();

    Area clipArea =
        new Area(
            new java.awt.Rectangle(
                0,
                0,
                getGraphicalRepresentation().getViewWidth(g.getScale()),
                getGraphicalRepresentation().getViewHeight(g.getScale())));
    Area a = new Area(getGraphicalRepresentation().getShape().getShape());
    a.transform(
        getGraphicalRepresentation().convertNormalizedPointToViewCoordinatesAT(g.getScale()));
    clipArea.subtract(a);
    g.getGraphics().clip(clipArea);

    Color shadowColor = new Color(darkness, darkness, darkness);
    ForegroundStyle foreground = ForegroundStyle.makeStyle(shadowColor);
    foreground.setUseTransparency(true);
    foreground.setTransparencyLevel(0.5f);
    BackgroundStyle background = BackgroundStyle.makeColoredBackground(shadowColor);
    background.setUseTransparency(true);
    background.setTransparencyLevel(0.5f);
    g.setDefaultForeground(foreground);
    g.setDefaultBackground(background);

    for (int i = blur - 1; i >= 0; i--) {
      float transparency = 0.4f - i * 0.4f / blur;
      foreground.setTransparencyLevel(transparency);
      background.setTransparencyLevel(transparency);
      AffineTransform at =
          AffineTransform.getScaleInstance(
              (i + 1 + viewWidth) / viewWidth, (i + 1 + viewHeight) / viewHeight);
      at.concatenate(shadowTranslation);
      getShape().transform(at).paint(g);
    }

    g.releaseClonedGraphics(oldGraphics);
  }
Beispiel #9
0
  private void paintGenome(Graphics2D g) {
    g.setColor(Color.WHITE);
    g.fillRect(0, 0, viewRect.width, viewRect.height);
    g.setColor(new Color(0.9f, 0.9f, 1f));
    g.fill(
        new Ellipse2D.Double(
            context.getCenterX() - getRadiusInt(),
            context.getCenterY() - getRadiusInt(),
            getRadiusInt() * 2,
            getRadiusInt() * 2));

    for (int i = 0; i < this.context.getDictionary().getSequences().size(); ++i) {
      SAMSequenceRecord rec = this.context.getDictionary().getSequence(i);

      Arc2D outer = context.getArc(rec, 0, rec.getSequenceLength(), getRadiusExt(), Arc2D.PIE);
      if (outer.getAngleExtent() == 0) continue;
      Area area = new Area(outer);
      Ellipse2D.Double ed =
          new Ellipse2D.Double(
              context.getCenter().getX() - getRadiusInt(),
              context.getCenter().getY() - getRadiusInt(),
              getRadiusInt() * 2,
              getRadiusInt() * 2);
      area.subtract(new Area(ed));

      g.setColor(i % 2 == 0 ? Color.LIGHT_GRAY : Color.WHITE);
      g.fill(area);
      g.setColor(Color.BLACK);
      g.draw(area);

      if ((rec.getSequenceLength() / (double) this.context.getDictionary().getReferenceLength())
          < 0.01) continue;
      String title = rec.getSequenceName();
      double midangle = context.convertPositionToRadian(rec, rec.getSequenceLength() / 2);

      AffineTransform old = g.getTransform();
      AffineTransform tr = new AffineTransform(old);

      g.translate(context.getCenterX(), context.getCenterY());
      g.rotate(midangle);
      g.translate(getRadiusExt(), 0);

      g.drawString(title, 0, 0);
      g.setTransform(tr);
      g.setTransform(old);
    }
  }
Beispiel #10
0
  @Override
  public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {

    Graphics2D graph = (Graphics2D) g.create();
    RoundRectangle2D round = new RoundRectangle2D.Float(x, y, width - 1, height - 1, 30, 30);
    Container parent = c.getParent();

    if (parent != null) {
      graph.setColor(parent.getBackground());
      Area canto = new Area(new Rectangle2D.Float(x, y, width, height));
      canto.subtract(new Area(round));
      graph.fill(canto);
    }

    graph.draw(round);
    graph.dispose();
  }
 public Shape createStrokedShape(Shape shape) {
   Area area1 = new Area(stroke1.createStrokedShape(shape));
   Area area2 = new Area(stroke2.createStrokedShape(shape));
   switch (operation) {
     case ADD:
       area1.add(area2);
       break;
     case SUBSTRACT:
       area1.subtract(area2);
       break;
     case INTERSECT:
       area1.intersect(area2);
       break;
     case DIFFERENCE:
       area1.exclusiveOr(area2);
       break;
   }
   return area1;
 }
 @Override
 public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
   Graphics2D g2 = (Graphics2D) g.create();
   g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
   int r = 6;
   RoundRectangle2D round = new RoundRectangle2D.Float(x, y, width - 1, height - 1, r, r);
   Container parent = c.getParent();
   if (parent != null) {
     g2.setColor(parent.getBackground());
     Area corner = new Area(new Rectangle2D.Float(x, y, width, height));
     corner.subtract(new Area(round));
     g2.fill(corner);
   }
   if (isVisible) {
     g2.setColor(this.color);
   }
   g2.draw(round);
   g2.dispose();
 }
  public RoundedBorders(
      Insets aMargin, Insets aPadding, int aRadii, boolean aNoTopBevel, boolean aNoBottomBevel) {
    radii = aRadii;
    margin = aMargin;
    insets =
        new Insets(
            margin.top + aPadding.top,
            margin.left + aPadding.left,
            margin.bottom + aPadding.bottom,
            margin.right + aPadding.right);
    hints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    hints.add(new RenderingHints(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED));

    noTopBevel = aNoTopBevel;
    noBottomBevel = aNoBottomBevel;

    clipFull = new Area(new Rectangle(0, 0, 2 * radii, 2 * radii));
    clipFull.subtract(new Area(new Ellipse2D.Float(0, 0, 2 * radii, 2 * radii)));
  }
    @Override
    public void draw(Graphics2D g2, DialPlot plot, Rectangle2D frame, Rectangle2D view) {
      Shape window = getWindow(frame);

      Rectangle2D f = DialPlot.rectangleByRadius(frame, getRadius() + 0.02, getRadius() + 0.02);
      Ellipse2D e = new Ellipse2D.Double(f.getX(), f.getY(), f.getWidth(), f.getHeight());

      Area area = new Area(e);
      Area area2 = new Area(window);
      area.subtract(area2);
      g2.setPaint(getBackgroundPaint());
      g2.fill(area);

      g2.setStroke(getStroke());
      g2.setPaint(getInnerForegroundPaint());
      g2.draw(window);
      g2.setPaint(getForegroundPaint());
      g2.draw(e);
    }
  @Override
  public void draw(
      Graphics2D g2d,
      ComponentState componentState,
      boolean outlineMode,
      Project project,
      IDrawingObserver drawingObserver) {
    if (checkPointsClipped(g2d.getClip())) {
      return;
    }
    Area mainArea = getBody()[0];
    Composite oldComposite = g2d.getComposite();
    if (alpha < MAX_ALPHA) {
      g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f * alpha / MAX_ALPHA));
    }
    g2d.setColor(outlineMode ? Constants.TRANSPARENT_COLOR : getBodyColor());
    g2d.fill(mainArea);
    g2d.setComposite(oldComposite);

    if (!outlineMode) {
      int pinSize = (int) PIN_SIZE.convertToPixels() / 2 * 2;
      for (Point point : controlPoints) {
        g2d.setColor(PIN_COLOR);
        g2d.fillOval(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
        g2d.setColor(PIN_BORDER_COLOR);
        g2d.drawOval(point.x - pinSize / 2, point.y - pinSize / 2, pinSize, pinSize);
      }
    }

    Color finalBorderColor;
    if (outlineMode) {
      Theme theme =
          (Theme)
              ConfigurationManager.getInstance()
                  .readObject(IPlugInPort.THEME_KEY, Constants.DEFAULT_THEME);
      finalBorderColor =
          componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING
              ? SELECTION_COLOR
              : theme.getOutlineColor();
    } else {
      finalBorderColor =
          componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING
              ? SELECTION_COLOR
              : getBorderColor();
    }
    g2d.setColor(finalBorderColor);
    g2d.setStroke(ObjectCache.getInstance().fetchBasicStroke(1));
    if (outlineMode) {
      Area area = new Area(mainArea);
      area.subtract(getBody()[1]);
      g2d.draw(area);
    } else {
      g2d.draw(mainArea);
      if (getBody()[1] != null) {
        g2d.setColor(getIndentColor());
        g2d.fill(getBody()[1]);
      }
    }
    // Draw label.
    g2d.setFont(LABEL_FONT);
    Color finalLabelColor;
    if (outlineMode) {
      Theme theme =
          (Theme)
              ConfigurationManager.getInstance()
                  .readObject(IPlugInPort.THEME_KEY, Constants.DEFAULT_THEME);
      finalLabelColor =
          componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING
              ? LABEL_COLOR_SELECTED
              : theme.getOutlineColor();
    } else {
      finalLabelColor =
          componentState == ComponentState.SELECTED || componentState == ComponentState.DRAGGING
              ? LABEL_COLOR_SELECTED
              : getLabelColor();
    }
    g2d.setColor(finalLabelColor);
    FontMetrics fontMetrics = g2d.getFontMetrics(g2d.getFont());
    String label = display == Display.NAME ? getName() : getValue();
    Rectangle2D rect = fontMetrics.getStringBounds(label, g2d);
    int textHeight = (int) (rect.getHeight());
    int textWidth = (int) (rect.getWidth());
    // Center text horizontally and vertically
    Rectangle bounds = mainArea.getBounds();
    int x = bounds.x + (bounds.width - textWidth) / 2;
    int y = bounds.y + (bounds.height - textHeight) / 2 + fontMetrics.getAscent();
    g2d.drawString(label, x, y);
  }
Beispiel #16
0
  @Override
  public void paint(Graphics g) {
    Graphics2D g2d = (Graphics2D) g;
    int pad = 5;
    Polygon polyLeft =
        new Polygon(
            new int[] {pad, getWidth() / 2, getWidth() / 2, pad},
            new int[] {pad, pad, getHeight() - pad, getHeight() - pad},
            4);
    Polygon polyRight =
        new Polygon(
            new int[] {getWidth() / 2, getWidth() - pad, getWidth() - pad, getWidth() / 2},
            new int[] {pad, pad, getHeight() - pad, getHeight() - pad},
            4);
    g2d.setColor(Color.red.darker());
    if (isSelected()) g2d.setColor(new Color(172, 225, 175));
    else g2d.setColor(Color.gray);
    g2d.fill(polyLeft);
    if (isSelected()) g2d.setColor(Color.gray);
    else g2d.setColor(new Color(172, 225, 175));
    g2d.fill(polyRight);

    Area round1 =
        new Area(new RoundRectangle2D.Double(0, 0, getWidth() - 1, getHeight() - 1, 8, 8));
    Area round2 =
        new Area(new RoundRectangle2D.Double(4, 4, getWidth() - 1 - 8, getHeight() - 1 - 8, 6, 6));
    Area round3 =
        new Area(
            new RoundRectangle2D.Double(6, 6, getWidth() - 1 - 12, getHeight() - 1 - 12, 5, 5));
    Area round4 =
        new Area(
            new Ellipse2D.Float(
                -getWidth() / 2, -getHeight(), getWidth() * 2, getHeight() * 3 / 2));

    round4.intersect(round2);
    round1.exclusiveOr(round2);
    round2.exclusiveOr(round3);
    int width = getWidth();
    int height = getHeight();
    int d1 = 6;
    int d2 = 8;
    Area outBorder =
        new Area(
            new Polygon(
                new int[] {
                  d1,
                  width - 1 - d1,
                  width - 1 - d1,
                  width - 1,
                  width - 1,
                  width - 1 - d1,
                  width - 1 - d1,
                  d1,
                  d1,
                  0,
                  0,
                  d1
                },
                new int[] {
                  0,
                  0,
                  d1,
                  d1,
                  height - 1 - d1,
                  height - 1 - d1,
                  height - 1,
                  height - 1,
                  height - 1 - d1,
                  height - 1 - d1,
                  d1,
                  d1
                },
                12));
    outBorder.subtract(
        new Area(
            new Polygon(
                new int[] {
                  d2,
                  width - 1 - d2,
                  width - 1 - d2,
                  width - 1 - (d2 - d1),
                  width - 1 - (d2 - d1),
                  width - 1 - d2,
                  width - 1 - d2,
                  d2,
                  d2,
                  d2 - d1,
                  d2 - d1,
                  d2
                },
                new int[] {
                  d2 - d1,
                  d2 - d1,
                  d2,
                  d2,
                  height - 1 - d2,
                  height - 1 - d2,
                  height - 1 - (d2 - d1),
                  height - 1 - (d2 - d1),
                  height - 1 - d2,
                  height - 1 - d2,
                  d2,
                  d2
                },
                12)));
    g2d.setColor(new Color(0x993333));
    g2d.fill(outBorder);
    int d3 = 3;
    int d4 = 5;
    Area midBorder =
        new Area(new Rectangle2D.Double(d3, d3, width - 1 - d3 * 2, height - 1 - d3 * 2));
    midBorder.subtract(
        new Area(new Rectangle2D.Double(d4, d4, width - 1 - d4 * 2, height - 1 - d4 * 2)));
    g2d.fill(midBorder);
    GlyphVector glyphVectorLeft =
        new Font("宋体", Font.PLAIN, fontsize)
            .createGlyphVector(new FontRenderContext(null, true, true), onText);
    Shape shapeTextLeft =
        glyphVectorLeft.getOutline(
            -(float)
                (glyphVectorLeft.getVisualBounds().getMinX()
                    - d3
                    - (getWidth() / 2 - glyphVectorLeft.getVisualBounds().getWidth()) / 2
                    + 1),
            -(float)
                    (glyphVectorLeft.getVisualBounds().getMinY()
                        - (getHeight() - glyphVectorLeft.getVisualBounds().getHeight()) / 2)
                - 1);
    GlyphVector glyphVectorRight =
        new Font("宋体", Font.PLAIN, fontsize)
            .createGlyphVector(new FontRenderContext(null, true, true), offText);
    Shape shapeTextRight =
        glyphVectorRight.getOutline(
            -(float)
                (glyphVectorRight.getVisualBounds().getMinX()
                    + d3
                    - (getWidth() * 3 / 2 - glyphVectorRight.getVisualBounds().getWidth()) / 2
                    + 1),
            -(float)
                    (glyphVectorRight.getVisualBounds().getMinY()
                        - (getHeight() - glyphVectorRight.getVisualBounds().getHeight()) / 2)
                - 1);
    g2d.setColor(new Color(23, 54, 93));
    g2d.draw(shapeTextLeft);
    g2d.setColor(new Color(23, 54, 93));
    g2d.draw(shapeTextRight);
  }
  /**
   * Returns the bargraph track image with the given with and height.
   *
   * @param WIDTH
   * @param START_ANGLE
   * @param ANGLE_EXTEND
   * @param APEX_ANGLE
   * @param BARGRAPH_OFFSET
   * @param image
   * @return buffered image containing the bargraph track image
   */
  protected BufferedImage create_BARGRAPH_TRACK_Image(
      final int WIDTH,
      final double START_ANGLE,
      final double ANGLE_EXTEND,
      final double APEX_ANGLE,
      final double BARGRAPH_OFFSET,
      BufferedImage image) {
    if (WIDTH <= 0) {
      return null;
    }

    if (image == null) {
      image = UTIL.createImage(WIDTH, WIDTH, Transparency.TRANSLUCENT);
    }
    final Graphics2D G2 = image.createGraphics();
    G2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    //        G2.setRenderingHint(RenderingHints.KEY_RENDERING,
    // RenderingHints.VALUE_RENDER_QUALITY);
    //        G2.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_ENABLE);
    //        G2.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION,
    // RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
    //        G2.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING,
    // RenderingHints.VALUE_COLOR_RENDER_QUALITY);
    //        G2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
    // RenderingHints.VALUE_STROKE_NORMALIZE);

    final int IMAGE_WIDTH = image.getWidth();
    final int IMAGE_HEIGHT = image.getHeight();

    // Create led track
    final java.awt.geom.Arc2D BACK = new java.awt.geom.Arc2D.Double(java.awt.geom.Arc2D.PIE);
    BACK.setFrame(
        IMAGE_WIDTH * 0.1074766355,
        IMAGE_HEIGHT * 0.1074766355,
        IMAGE_WIDTH * 0.785046729,
        IMAGE_HEIGHT * 0.785046729);
    BACK.setAngleStart(START_ANGLE + 2);
    BACK.setAngleExtent(ANGLE_EXTEND - 5);

    final Ellipse2D BACK_SUB =
        new Ellipse2D.Double(
            IMAGE_WIDTH * 0.1822429907,
            IMAGE_HEIGHT * 0.1822429907,
            IMAGE_WIDTH * 0.6355140187,
            IMAGE_HEIGHT * 0.6355140187);

    final java.awt.geom.Area LED_TRACK_FRAME = new java.awt.geom.Area(BACK);
    LED_TRACK_FRAME.subtract(new java.awt.geom.Area(BACK_SUB));

    final Point2D LED_TRACK_FRAME_START =
        new Point2D.Double(0, LED_TRACK_FRAME.getBounds2D().getMinY());
    final Point2D LED_TRACK_FRAME_STOP =
        new Point2D.Double(0, LED_TRACK_FRAME.getBounds2D().getMaxY());
    final float[] LED_TRACK_FRAME_FRACTIONS = {0.0f, 0.22f, 0.76f, 1.0f};
    final Color[] LED_TRACK_FRAME_COLORS = {
      new Color(0, 0, 0, 255),
      new Color(51, 51, 51, 255),
      new Color(51, 51, 51, 255),
      new Color(100, 100, 100, 255)
    };
    final LinearGradientPaint LED_TRACK_FRAME_GRADIENT =
        new LinearGradientPaint(
            LED_TRACK_FRAME_START,
            LED_TRACK_FRAME_STOP,
            LED_TRACK_FRAME_FRACTIONS,
            LED_TRACK_FRAME_COLORS);
    G2.setPaint(LED_TRACK_FRAME_GRADIENT);
    G2.fill(LED_TRACK_FRAME);

    final java.awt.geom.Arc2D FRONT = new java.awt.geom.Arc2D.Double(java.awt.geom.Arc2D.PIE);
    FRONT.setFrame(
        IMAGE_WIDTH * 0.1121495327,
        IMAGE_HEIGHT * 0.1121495327,
        IMAGE_WIDTH * 0.7803738318,
        IMAGE_HEIGHT * 0.7803738318);
    FRONT.setAngleStart(START_ANGLE);
    FRONT.setAngleExtent(ANGLE_EXTEND);

    final Ellipse2D FRONT_SUB =
        new Ellipse2D.Double(
            IMAGE_WIDTH * 0.1822429907,
            IMAGE_HEIGHT * 0.1822429907,
            IMAGE_WIDTH * 0.6448598131,
            IMAGE_HEIGHT * 0.6448598131);

    final java.awt.geom.Area LED_TRACK_MAIN = new java.awt.geom.Area(BACK);
    LED_TRACK_MAIN.subtract(new java.awt.geom.Area(FRONT_SUB));

    final Point2D LED_TRACK_MAIN_START =
        new Point2D.Double(0, LED_TRACK_MAIN.getBounds2D().getMinY());
    final Point2D LED_TRACK_MAIN_STOP =
        new Point2D.Double(0, LED_TRACK_MAIN.getBounds2D().getMaxY());
    final float[] LED_TRACK_MAIN_FRACTIONS = {0.0f, 1.0f};
    final Color[] LED_TRACK_MAIN_COLORS = {new Color(17, 17, 17, 255), new Color(51, 51, 51, 255)};
    final LinearGradientPaint LED_TRACK_MAIN_GRADIENT =
        new LinearGradientPaint(
            LED_TRACK_MAIN_START,
            LED_TRACK_MAIN_STOP,
            LED_TRACK_MAIN_FRACTIONS,
            LED_TRACK_MAIN_COLORS);
    G2.setPaint(LED_TRACK_MAIN_GRADIENT);
    G2.fill(LED_TRACK_MAIN);

    // Draw the inactive leds
    final Point2D CENTER = new Point2D.Double(WIDTH / 2.0, WIDTH / 2.0);
    final Rectangle2D LED =
        new Rectangle2D.Double(
            WIDTH * 0.1168224299,
            WIDTH * 0.4859813084,
            WIDTH * 0.06074766355140187,
            WIDTH * 0.023364486);
    final Point2D LED_CENTER = new Point2D.Double(LED.getCenterX(), LED.getCenterY());

    final Color[] LED_COLORS = new Color[] {new Color(60, 60, 60, 255), new Color(50, 50, 50, 255)};
    final RadialGradientPaint LED_GRADIENT =
        new RadialGradientPaint(
            LED_CENTER, (float) (0.030373831775700934 * IMAGE_WIDTH), LED_FRACTIONS, LED_COLORS);
    G2.setPaint(LED_GRADIENT);

    final AffineTransform OLD_TRANSFORM = G2.getTransform();

    for (double angle = 0; angle <= APEX_ANGLE; angle += 5.0) {
      G2.rotate(Math.toRadians(angle + BARGRAPH_OFFSET), CENTER.getX(), CENTER.getY());
      G2.fill(LED);
      G2.setTransform(OLD_TRANSFORM);
    }

    G2.dispose();

    return image;
  }
Beispiel #18
0
  protected void cutTheArea(ArrayList<Point2D> sawtooth) {
    // TODO Auto-generated method stub

    int x = (int) pointList.get(0).getX() - (int) pointList.get(pointList.size() - 1).getX();
    int y = (int) pointList.get(0).getY() - (int) pointList.get(pointList.size() - 1).getY();

    int formerX = (int) pointList.get(pointList.size() - 1).getX();
    int formerY = (int) pointList.get(pointList.size() - 1).getY();

    // 切割添加的第一个点,为水滴离开时的点,延切割方向平移一大段距离
    Point2D firstPoint = new Point(formerX - 10 * x, formerY - 10 * y);
    sawtooth.add(firstPoint);

    // 假如方向为从左上穿过到右下, 先右移一个很大的值,再上移一个很大的值
    int xDirection = 1;
    int yDirection = 1;
    if (x < 0) { // 使其与x,y同号
      xDirection = -1;
    }

    sawtooth.add(new Point((int) firstPoint.getX() - xDirection * 1000, (int) firstPoint.getY()));
    sawtooth.add(
        new Point(
            (int) firstPoint.getX() - xDirection * 1000,
            (int) firstPoint.getY() - yDirection * 5000));
    sawtooth.add(
        new Point(
            (int) firstPoint.getX() + xDirection * 2000,
            (int) firstPoint.getY() - yDirection * 5000));

    formerX = (int) pointList.get(0).getX();
    formerY = (int) pointList.get(0).getY();

    // 切割添加的最后一个点,为水滴离开时的点,延切割反方向平移一大段距离
    Point2D lastPoint = new Point(formerX + 10 * x, formerY + 10 * y);
    sawtooth.add(lastPoint);

    xList = new int[sawtooth.size()];
    yList = new int[sawtooth.size()];

    // 为了多边形的声明,将x,y坐标都变成一个int[]
    for (int i = 0; i < sawtooth.size(); i++) {

      xList[i] = (int) sawtooth.get(i).getX();
      yList[i] = (int) sawtooth.get(i).getY();
    }

    // 开始切割
    Polygon cutPolygon = new Polygon(xList, yList, sawtooth.size());
    Area cutArea = new Area(cutPolygon);

    cutArea.intersect(area); // 这里cutArea是切下来的部分,永远靠上
    area.subtract(cutArea); // 这里area是剩下的部分,靠下

    // 如果被切下来部分的面积大于原面积的0.75,那么把cutArea1变为另一部分
    // ,把原area变为该area,假如两个都不大于原来面积的0.75,那么都变为cutArea(即将消失的部分)
    // 顺便把每一部分的速度改一下,速度是将水滴的速度方向向上旋转30°,和向下旋转30°,生成两个新的速度向量,叠加到原来的速度上。

    // 生成两个新向量,式子是通过方程推导出来的,index 0为靠下部分速度,1为靠上部分速度
    double[] deltavx = {
      Math.sqrt(3) * waterDrop_vx * 0.5
          - 0.5 * (Math.abs(waterDrop_vx) / waterDrop_vx) * waterDrop_vy,
      Math.sqrt(3) * waterDrop_vx * 0.5
          + 0.5 * (Math.abs(waterDrop_vx) / waterDrop_vx) * waterDrop_vy
    };

    double[] deltavy = {
      Math.sqrt(3) * waterDrop_vy * 0.5 + 0.5 * (Math.abs(waterDrop_vx)),
      Math.sqrt(3) * waterDrop_vy * 0.5 - 0.5 * (Math.abs(waterDrop_vx))
    };

    if ((computeArea(area.getBounds()) < formerArea * 0.3)
        && (computeArea(cutArea.getBounds())) > formerArea * 0.8) {
      cutArea1 = area;
      area = cutArea;
      vx[0] = vx[0] + deltavx[1];
      vy[0] = vy[0] + deltavy[1];
      vx[1] = vx[1] + deltavx[0];
      vy[1] = vy[1] + deltavy[0];

    } else if ((computeArea(cutArea.getBounds()) < formerArea * 0.3)
        && (computeArea(area.getBounds())) > formerArea * 0.8) {
      cutArea1 = cutArea;

      vx[1] = vx[1] + deltavx[1];
      vy[1] = vy[1] + deltavy[1];
      vx[0] = vx[0] + deltavx[0];
      vy[0] = vy[0] + deltavy[0];

    } else {

      cutArea1 = cutArea;
      cutArea2 = area;
      area = new Area();

      vx[1] = vx[1] + deltavx[1];
      vy[1] = vy[1] + deltavy[1];
      vx[2] = vx[2] + deltavx[0];
      vy[2] = vy[2] + deltavy[0];
    }

    pointList = new ArrayList<Point2D>();
    this.sawtooth = new ArrayList<Point2D>();
    isPassed = false;
    sawtoothIndex = 0;
  }
  protected final void compute() {

    ArrayList<Double> xcoord = new ArrayList<Double>();
    ArrayList<Double> ycoord = new ArrayList<Double>();
    double[] coords = new double[6];
    double[] oldCoords = new double[6];

    // Convert input polygons to Area objects
    Area a1 = getArea(inPoly0.getPoints());
    Area a2 = getArea(inPoly1.getPoints());

    // test for empty intersection
    Area testArea = getArea(inPoly0.getPoints());
    testArea.intersect(a2);
    if (testArea.isEmpty()) {
      poly.setUndefined();
    }
    // if intersection is non-empty perform operation
    else {
      switch (operationType) {
        case TYPE_INTERSECTION:
          a1.intersect(a2);
          break;
        case TYPE_UNION:
          a1.add(a2);
          break;
        case TYPE_DIFFERENCE:
          a1.subtract(a2);
          break;
      }

      // Iterate through the path of the result
      // and recover the polygon vertices.

      PathIterator it = a1.getPathIterator(null);

      int type = it.currentSegment(coords);
      it.next();
      oldCoords = coords.clone();
      double epsilon = 1E-10;

      while (!it.isDone()) {
        type = it.currentSegment(coords);
        if (type == PathIterator.SEG_CLOSE) {
          break;
        }
        // Sometimes the Path iterator gives two almost identical points and
        // we only want one of them.
        // TODO: Why does this happen???
        if ((double) Math.abs(oldCoords[0] - coords[0]) > epsilon
            || (double) Math.abs(oldCoords[1] - coords[1]) > epsilon) {
          xcoord.add(coords[0]);
          ycoord.add(coords[1]);
        }
        oldCoords = coords.clone();

        it.next();
      }
    }

    // Update the points array to the correct size
    int n = xcoord.size();
    // System.out.println("number of points: " + n);
    int oldPointNumber = points.length;
    if (n != oldPointNumber) {
      updatePointsArray(n);
      poly.setPoints(points);
      setOutput();
    }

    // Set the points to the new polygon vertices
    for (int k = 0; k < n; k++) {
      points[k].setCoords(xcoord.get(k), ycoord.get(k), 1);
      // System.out.println("vertices: " + xcoord.get(k) + " , " + ycoord.get(k));

    }

    // Compute area of poly (this will also set our poly geo to be defined)
    poly.calcArea();

    // update new points and segments
    if (n != oldPointNumber) {
      updateSegmentsAndPointsLabels(oldPointNumber);
    }
  }
Beispiel #20
0
  /**
   * Builds an Area configured with the polygon information defined in the file.
   *
   * @return A fully configured area.
   */
  public Area loadPolygon() {
    try {
      Area resultArea;
      BufferedReader bufferedReader;
      // Create a new area.
      resultArea = new Area();

      // Open the polygon file.
      bufferedReader = new BufferedReader(fileReader);

      // Read the file header.
      myPolygonName = bufferedReader.readLine();
      if (myPolygonName == null || myPolygonName.trim().length() == 0) {
        throw new OsmosisRuntimeException(
            "The file must begin with a header naming the polygon file.");
      }

      // We now loop until no more sections are available.
      while (true) {
        String sectionHeader;
        boolean positivePolygon;
        Area sectionArea;

        // Read until a non-empty line is obtained.
        do {
          // Read the section header.
          sectionHeader = bufferedReader.readLine();

          // It is invalid for the file to end without a global "END" record.
          if (sectionHeader == null) {
            throw new OsmosisRuntimeException(
                "File terminated prematurely without a section END record.");
          }

          // Remove any whitespace.
          sectionHeader = sectionHeader.trim();

        } while (sectionHeader.length() == 0);

        // Stop reading when the global END record is reached.
        if ("END".equals(sectionHeader)) {
          break;
        }

        // If the section header begins with a ! then the polygon is to
        // be subtracted from the result area.
        positivePolygon = (sectionHeader.charAt(0) != '!');

        // Create an area for this polygon.
        sectionArea = loadSectionPolygon(bufferedReader);

        // Add or subtract the section area from the overall area as
        // appropriate.
        if (positivePolygon) {
          resultArea.add(sectionArea);
        } else {
          resultArea.subtract(sectionArea);
        }
      }

      return resultArea;

    } catch (IOException e) {
      throw new OsmosisRuntimeException("Unable to read from polygon file " + polygonFile + ".", e);
    } finally {
      cleanup();
    }
  }
Beispiel #21
0
  public void paint(Graphics2D g) {
    g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

    g.setPaint(Color.black);

    // Rectangle
    g.drawString("Rectangle", 10, 20);
    Rectangle rect = new Rectangle(10, 30, 50, 40);
    g.draw(rect);

    g.translate(0, 90);

    // Round Rectangle
    g.drawString("RoundRectangle", 10, 20);
    RoundRectangle2D roundRect = new RoundRectangle2D.Double(10, 30, 50, 40, 10, 10);
    g.draw(roundRect);

    g.translate(0, 90);

    // Circle
    g.drawString("Circle", 10, 20);
    Ellipse2D circle = new Ellipse2D.Float(10, 30, 50, 50);
    g.draw(circle);

    g.translate(0, 90);

    // CubicCurve2D
    g.drawString("CubicCurve2D", 10, 20);
    CubicCurve2D curve = new CubicCurve2D.Float(10, 55, 22.5f, 00, 38.5f, 110, 60, 55);
    g.draw(curve);

    g.translate(150, -270);

    // Polygon
    g.drawString("Polygon", 10, 20);
    Polygon polygon = new Polygon(new int[] {30, 50, 10}, new int[] {30, 60, 60}, 3);
    g.draw(polygon);

    g.translate(0, 90);

    // General Path
    g.drawString("GeneralPath", 10, 20);
    GeneralPath path = new GeneralPath();
    path.moveTo(30, 30);
    path.quadTo(30, 50, 50, 60);
    path.quadTo(30, 50, 10, 60);
    path.quadTo(30, 50, 30, 30);
    path.closePath();
    g.draw(path);

    g.translate(0, 90);

    // Area
    g.drawString("Area", 10, 20);
    Area area = new Area(new Rectangle(10, 30, 50, 50));
    area.subtract(new Area(new Ellipse2D.Double(12, 32, 46, 46)));
    g.fill(area);

    g.translate(0, 90);

    // QuadCurve 2D
    g.drawString("QuadCurve2D", 10, 20);
    QuadCurve2D quad = new QuadCurve2D.Float(10, 55, 35, 105, 60, 55);
    g.draw(quad);

    g.translate(-75, 70);

    // Line
    g.drawString("Line2D", 10, 20);
    g.draw(new Line2D.Float(10, 30, 60, 30));
  }
Beispiel #22
0
 public Area createSelection() {
   Area res = new Area(getBorder().getShape());
   res.subtract(new Area(timerEvent.getShape()));
   return res;
 }