Beispiel #1
0
  static {
    defaultRenderingHints = new RenderingHints(null);
    defaultRenderingHints.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

    defaultRenderingHints.put(
        RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
  }
Beispiel #2
0
 public void paintComponent(Graphics g) {
   if (OSPRuntime.antiAliasText) {
     Graphics2D g2 = (Graphics2D) g;
     RenderingHints rh = g2.getRenderingHints();
     rh.put(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
     rh.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
   }
   super.paintComponent(g);
 }
Beispiel #3
0
 /**
  * Sets a rendering hint
  *
  * @param arg0
  * @param arg1
  */
 public void setRenderingHint(Key arg0, Object arg1) {
   if (arg1 != null) {
     rhints.put(arg0, arg1);
   } else {
     if (arg0 instanceof HyperLinkKey) {
       rhints.put(arg0, HyperLinkKey.VALUE_HYPERLINKKEY_OFF);
     } else {
       rhints.remove(arg0);
     }
   }
 }
 public void paintComponent(Graphics g) {
   super.paintComponent(g);
   Graphics2D g2 = (Graphics2D) g;
   RenderingHints hints = new RenderingHints(null);
   hints.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
   hints.put(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
   hints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
   g2.setRenderingHints(hints);
   g2.rotate(-Math.toRadians(degrees), w / 2, h / 2);
   g2.drawImage(dimg, 0, 0, this);
   g2.dispose();
 }
Beispiel #5
0
  @Override
  public void paint(Graphics g) {
    // init the paint
    super.paint(g);
    // cast g to a Graphics2D object so we can use its features
    Graphics2D g2 = (Graphics2D) g;
    // get a rendering hints object. not sure why.
    RenderingHints rh =
        new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    // pass it some parameters
    rh.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    // connect rh to the graphics object
    g2.setRenderingHints(rh);

    /** Lookup Table for which color to be 0 = dead, white 1 = alive, black */
    Color[] lookup = {Color.white, Color.black};

    int x, y, state;
    for (x = 0; x < sizex; x++) {
      for (y = 0; y < sizey; y++) {
        state = uni.getState(x, y);
        g2.setColor(lookup[state]);
        g2.fillRect(scale * x, scale * y, scale, scale);
      }
    }
  }
  public void paint(Graphics g) {
    super.paintComponent(g);

    Graphics2D g2d = (Graphics2D) g;

    Dimension size = getSize();
    Insets insets = getInsets();

    int w = size.width - insets.left - insets.right;
    int h = size.height - insets.top - insets.bottom;

    float scale = w / axis_size;

    RenderingHints rh =
        new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

    rh.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);

    g2d.setRenderingHints(rh);

    g2d.translate(w / 2, 3.5 * h / 8);

    g2d.setColor(Color.black);

    drawPoints(g2d, scale);
    drawTimeLines(g2d, scale);
    drawInitialGraph(g2d, scale);
    drawMessages(g2d, scale);
  }
  public PledgeDisplayPanel() {
    try {
      logo = ImageIO.read(getClass().getResource("pp-logo-large.png"));
    } catch (IOException e) {
      System.err.println("Could not load background image");
      e.printStackTrace();
    }

    tickerLabel = new TickerLabel();
    tickerLabel.setVisible(true);
    slidePane = new SlidePane();
    slidePane.setVisible(false);
    pledgePane = new PledgePane();
    readProperties();

    idleTimer = new Timer(idleTimeout, new IdleTimeout());
    idleTimer.start();
    setForeground(Color.black);
    setLayout(null);
    renderHints =
        new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    renderHints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    addComponentListener(this);
    add(tickerLabel);
    add(pledgePane);
    add(slidePane);
    addMouseListener(this);
  }
Beispiel #8
0
 public void paintComponent(Graphics g) {
   super.paintComponent(g);
   setBackground(new Color(219, 219, 72));
   Graphics2D g2d = (Graphics2D) g;
   RenderingHints rh =
       new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
   rh.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
   g2d.setRenderingHints(rh);
   Font fnt = new Font("STENCIL", Font.BOLD, 100);
   g2d.setColor(new Color(62, 11, 214));
   g2d.setFont(fnt);
   g2d.drawString("Hangman", 240, 100);
   fnt = new Font("STENCIL", Font.ITALIC, 30);
   g2d.setFont(fnt);
   g2d.setColor(new Color(11, 214, 201));
   g2d.drawString("created by Ashwin Gupta", 240, 125);
   /*g2d.setFont(new Font("Arial", Font.PLAIN, 75));
   g2d.drawString("PAINT BIG ", 100, 400);
   g2d.drawString("HANGMAN HERE", 100, 500);*/
   // int offset= 20;
   HangComponents dh = new HangComponents();
   g2d.setColor(Color.DARK_GRAY);
   for (int i = 0; i < 8; i++) {
     if (i == 7 || i == 6) {
       g2d.setStroke(new BasicStroke(45));
       g2d.draw(dh.hangman[i]);
     } else g2d.fill(dh.hangman[i]);
   }
 }
 private RenderedOp createScaledImage(
     RenderedImage sourceImage, S2Resolution resolution, int level) {
   int sourceWidth = sourceImage.getWidth();
   int sourceHeight = sourceImage.getHeight();
   int targetWidth = imageLayouts[0].width >> level;
   int targetHeight = imageLayouts[0].height >> level;
   float scaleX = (float) targetWidth / (float) sourceWidth;
   float scaleY = (float) targetHeight / (float) sourceHeight;
   float corrFactorX = resolution == S2Resolution.R20M ? R20M_X_FACTOR : R60M_X_FACTOR;
   float corrFactorY = resolution == S2Resolution.R20M ? R20M_Y_FACTOR : R60M_Y_FACTOR;
   final Dimension tileDim = getTileDim(targetWidth, targetHeight);
   ImageLayout imageLayout = new ImageLayout();
   imageLayout.setTileWidth(tileDim.width);
   imageLayout.setTileHeight(tileDim.height);
   RenderingHints renderingHints =
       new RenderingHints(
           JAI.KEY_BORDER_EXTENDER, BorderExtender.createInstance(BorderExtender.BORDER_ZERO));
   renderingHints.put(JAI.KEY_IMAGE_LAYOUT, imageLayout);
   RenderedOp scaledImage =
       ScaleDescriptor.create(
           sourceImage,
           scaleX * corrFactorX,
           scaleY * corrFactorY,
           0F,
           0F,
           Interpolation.getInstance(Interpolation.INTERP_NEAREST),
           renderingHints);
   if (scaledImage.getWidth() != targetWidth || scaledImage.getHeight() != targetHeight) {
     return CropDescriptor.create(
         scaledImage, 0.0F, 0.0F, (float) targetWidth, (float) targetHeight, null);
   } else {
     return scaledImage;
   }
 }
  private BufferedImage scale(BufferedImage image, int newWidth, int newHeight) {
    float width;
    float height;

    if (newWidth <= 0 || newHeight <= 0) {
      logger.warn("Invalid scale attempt aborted.");
      return null;
    }

    width = (float) newWidth / (float) image.getWidth();
    height = (float) newHeight / (float) image.getHeight();

    BufferedImage out = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_ARGB);
    Graphics2D g2 = out.createGraphics();
    RenderingHints qualityHints =
        new RenderingHints(
            RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ANTIALIAS_ON);
    qualityHints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    g2.setRenderingHints(qualityHints);
    AffineTransform at = AffineTransform.getScaleInstance(width, height);
    g2.drawImage(image, at, null);
    g2.dispose();

    return out;
  }
Beispiel #11
0
      /**
       * A paint class that will draw the needle, dots, and TO/FROM RenderingHints is IMPORTANT. It
       * will make sure that everything stays focused and not blurry whenever the image rotates. I
       * added an empty line between the 8 fillArcs, just so its easier to see that four of them
       * draw on the left side and four draw on the right side.
       */
      public void paintComponent(Graphics g) {
        Graphics2D g2 = (Graphics2D) g;
        RenderingHints hints = new RenderingHints(null);
        hints.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        hints.put(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
        hints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        g2.setRenderingHints(hints);
        g2.setStroke(new BasicStroke(3));
        // g2.drawString("TO", 190, 200);
        if (vor.isTo() == true) {
          if (vor.isAbeamed() == true) {
            // g2.setFont(new Font("default", Font.BOLD, 16));
            // g2.setColor(Color.red);
            // g2.drawString("BAD", 190, 200);
          } else {
            // g2.setFont(new Font("default", Font.BOLD, 16));
            g2.drawString("TO", 190, 200);
          }
        } else if (vor.isFrom() == true) {
          if (vor.isAbeamed() == true) {
            // g2.setFont(new Font("default", Font.BOLD, 16));
            // g2.setColor(Color.red);
            // g2.drawString("BAD", 190, 300);
          } else {
            // g2.setFont(new Font("default", Font.BOLD, 13));
            g2.drawString("FROM", 190, 300);
          }
        } else if (vor.isFrom() == false || vor.isTo() == false) {
          // is above the vor station no to or from
        }

        g2.fillArc(140, 240, 7, 7, 0, 360);
        g2.fillArc(125, 240, 7, 7, 0, 360);
        g2.fillArc(110, 240, 7, 7, 0, 360);
        g2.fillArc(95, 240, 7, 7, 0, 360);

        g2.fillArc(195, 240, 7, 7, 0, 360);
        g2.fillArc(210, 240, 7, 7, 0, 360);
        g2.fillArc(225, 240, 7, 7, 0, 360);
        g2.fillArc(240, 240, 7, 7, 0, 360);

        // g2.drawString("FROM",190, 300);
        g2.drawLine(x, y1, x, y2);
        super.paintComponent(g);
        g2.dispose();
      }
Beispiel #12
0
  /** Returns a RenderingHints parsed from the given Properties */
  public static RenderingHints parseRenderingHints(Properties preferences) {

    RenderingHints rh = new RenderingHints(null);
    String str;
    str = preferences.getProperty("rendering.antialiasing");
    if (str != null) {
      if (str.equals("on"))
        rh.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
      else if (str.equals("off"))
        rh.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
    }
    str = preferences.getProperty("rendering.text-antialiasing");
    if (str != null) {
      if (str.equals("on"))
        rh.put(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
      else if (str.equals("off"))
        rh.put(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
    }
    str = preferences.getProperty("rendering.render");
    if (str != null) {
      if (str.equals("speed"))
        rh.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
      else if (str.equals("quality"))
        rh.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    }
    str = preferences.getProperty("rendering.dither");
    if (str != null) {
      if (str.equals("on"))
        rh.put(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_ENABLE);
      else if (str.equals("off"))
        rh.put(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
    }
    str = preferences.getProperty("rendering.fractional-metrics");
    if (str != null) {
      if (str.equals("on"))
        rh.put(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON);
      else if (str.equals("off"))
        rh.put(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_OFF);
    }
    return rh;
  }
Beispiel #13
0
 static {
   hints = new RenderingHints(null);
   // fractional metrics distorts text spacing; not for this application!
   hints.put(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_OFF);
   hints.put(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB);
   hints.put(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
   // hints.put(RenderingHints.KEY_TEXT_ANTIALIASING,   RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
   hints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
   hints.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
   // hints.put(RenderingHints.KEY_ANTIALIASING ,       RenderingHints.VALUE_ANTIALIAS_OFF);
   hints.put(
       RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED);
   hints.put(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_SPEED);
   hints.put(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
 }
Beispiel #14
0
  public void setupRendering(Graphics2D g2, boolean quality, Stroke stroke, Color color) {
    RenderingHints qualityHints = new RenderingHints(null);

    if (quality) {
      qualityHints.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
      qualityHints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);

      AlphaComposite ac = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.7f);
      g2.setComposite(ac);

      g2.setStroke(stroke);
      g2.setColor(color);
    } else {
      qualityHints.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
      qualityHints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);

      g2.setStroke(new BasicStroke());
      // strip out alpha
      g2.setColor(new Color(color.getRed(), color.getGreen(), color.getBlue()));
    }

    g2.setRenderingHints(qualityHints);
  }
  protected void processRequest(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

    int width = 100;
    int height = 40;

    SecureRandom random = new SecureRandom();

    BufferedImage bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

    Graphics2D g2d = bufferedImage.createGraphics();

    Font font = new Font("Georgia", Font.BOLD, 15);
    g2d.setFont(font);

    RenderingHints rh =
        new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

    rh.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);

    g2d.setRenderingHints(rh);

    GradientPaint gp = new GradientPaint(0, 0, Color.blue, 0, height / 2, Color.pink, true);

    g2d.setPaint(gp);
    g2d.fillRect(0, 0, width, height);

    g2d.setColor(Color.RED);

    Random r = new Random();

    String captcha = new BigInteger(25, random).toString(32);
    request.getSession().setAttribute("real_captcha", captcha);

    int x = 0;
    int y = 0;

    for (int i = 0; i < captcha.length(); i++) {
      x += 10 + (Math.abs(r.nextInt()) % 15);
      y = 10 + Math.abs(r.nextInt()) % 20;
      g2d.drawChars(captcha.toCharArray(), i, 1, x, y);
    }

    g2d.dispose();

    response.setContentType("image/png");
    try (OutputStream os = response.getOutputStream()) {
      ImageIO.write(bufferedImage, "png", os);
    }
  }
  // init
  private static void init() {
    if (frame != null) frame.setVisible(false);

    frame = new JFrame();
    offscreenImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
    onscreenImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
    offscreen = offscreenImage.createGraphics();
    onscreen = onscreenImage.createGraphics();
    setXscale();
    setYscale();
    offscreen.setColor(DEFAULT_CLEAR_COLOR);
    offscreen.fillRect(0, 0, width, height);
    setPenColor();
    setPenRadius();
    setFont();
    clear();

    // add anti-aliasing
    RenderingHints hints =
        new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    hints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    offscreen.addRenderingHints(hints);

    // frame stuff
    ImageIcon icon = new ImageIcon(onscreenImage);
    JLabel draw = new JLabel(icon);

    draw.addMouseListener(std);
    draw.addMouseMotionListener(std);

    frame.setContentPane(draw);
    frame.addKeyListener(std); // JLabel cannot get keyboard focus
    frame.setResizable(false);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // closes all windows
    // frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // closes only current window
    frame.setTitle("Standard Draw");
    frame.setJMenuBar(createMenuBar());
    frame.pack();
    frame.requestFocusInWindow();
    frame.setVisible(true);
  }
Beispiel #17
0
  // Draw elements:
  @Override
  public void paint(Graphics g) {

    // Set up Graphics Enigne:
    Graphics2D g2d = (Graphics2D) g;

    // Antialiasing:
    if (antialiasing == true) {
      RenderingHints rh =
          new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
      rh.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);

      g2d.setRenderingHints(rh);
    }

    // Draw rendered image
    g2d.drawImage(
        renderImage, 0, 0, width, height, 0, 0, resolution.width, resolution.height, this);

    g2d.setColor(Color.yellow);

    g2d.drawString("FPS: " + fps, 20, 20);
  }
Beispiel #18
0
  static {
    ImageLayout layout = new ImageLayout();
    layout.setColorModel(ColorModel.getRGBdefault());

    RenderingHints screenHints = new RenderingHints(JAI.KEY_IMAGE_LAYOUT, layout);
    screenHints.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    screenHints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    screenHints.put(
        RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
    screenHints.put(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_QUALITY);
    screenHints.put(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
    screenHints.put(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_ENABLE);
    screenHints.put(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE);
    screenHints.put(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_GASP);

    screenContext = new RenderContext(AffineTransform.getTranslateInstance(0.0, 0.0), screenHints);

    RenderingHints draftHints = new RenderingHints(JAI.KEY_IMAGE_LAYOUT, layout);

    draftHints.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
    draftHints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
    draftHints.put(
        RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED);
    draftHints.put(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_SPEED);
    draftHints.put(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
    draftHints.put(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE);
    draftHints.put(
        RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
    draftHints.put(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);

    draftContext = new RenderContext(AffineTransform.getTranslateInstance(0.0, 0.0), draftHints);
  }
Beispiel #19
0
  public void paintComponent(Graphics g) {
    super.paintComponent(g);

    Graphics2D g2d = (Graphics2D) g;
    RenderingHints rh = g2d.getRenderingHints();
    rh.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    rh.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    g2d.setRenderingHints(rh);

    // Background.
    D = this.getSize();
    g.setColor(backgroundColor);
    g.fillRect(0, 0, D.width, D.height);
    Graphics2D g2 = (Graphics2D) g;
    g2.setStroke(lineStroke);

    // Axes, bounding box.
    g.setColor(Color.gray);
    g.drawLine(inset, D.height - inset, D.width - inset, D.height - inset);
    g.drawLine(D.width - inset, inset, D.width - inset, D.height - inset);
    g.drawLine(inset, inset, inset, D.height - inset);
    g.drawLine(inset, inset, D.width - inset, inset);

    double xDelta = (maxX - minX) / numIntervals;

    // X-ticks and labels.
    for (int i = 1; i <= numIntervals; i++) {
      double xTickd = i * xDelta;
      int xTick = (int) (xTickd / (maxX - minX) * (D.width - 2 * inset));
      g.drawLine(inset + xTick, D.height - inset - 5, inset + xTick, D.height - inset + 5);
      double x = minX + i * xDelta;
      g.drawString(df.format(x), xTick + inset - 5, D.height - inset + 20);
    }

    // Y-ticks
    double yDelta = (maxY - minY) / numIntervals;
    for (int i = 0; i < numIntervals; i++) {
      int yTick = (i + 1) * (int) ((D.height - 2 * inset) / (double) numIntervals);
      g.drawLine(inset - 5, D.height - yTick - inset, inset + 5, D.height - yTick - inset);
      double y = minY + (i + 1) * yDelta;
      g.drawString(df.format(y), 1, D.height - yTick - inset);
    }

    // Zoom+move
    Font savedFont = g.getFont();
    g.setFont(plusFont);
    g.drawString("+", D.width - 25, 20);
    g.setFont(minusFont);
    g.drawString("-", D.width - 25, 50);
    drawArrow(g2d, D.width - 70, 20, D.width - 70, 0, 1.0f, lineStroke); // Up
    drawArrow(g2d, D.width - 70, 30, D.width - 70, 50, 1.0f, lineStroke); // Down
    drawArrow(g2d, D.width - 65, 25, D.width - 45, 25, 1.0f, lineStroke); // Right
    drawArrow(g2d, D.width - 75, 25, D.width - 95, 25, 1.0f, lineStroke); // Left
    g.setFont(savedFont);

    // See if standard axes are in the middle.
    g.setColor(Color.gray);
    if ((minX < 0) && (maxX > 0) && (drawMiddleAxes)) {
      // Draw y-axis
      int x = (int) ((0 - minX) / (maxX - minX) * (D.width - 2 * inset));
      g.drawLine(inset + x, D.height - inset, inset + x, inset);
    }
    if ((minY < 0) && (maxY > 0) && (drawMiddleAxes)) {
      // Draw x-axis
      int y = (int) ((0 - minY) / (maxY - minY) * (D.height - 2.0 * inset));
      g.drawLine(inset, D.height - y - inset, D.width - inset, D.height - y - inset);
    }

    // Draw the objects.
    drawObjects(g, points, lines, ovals, rectangles, images, labels, eqnLines);
    if (animationMode) {
      drawObjects(g, animPoints, animLines, animOvals, animRectangles, null, labels, eqnLines);
      // No images in animation mode.
    }

    drawScribbles(g);
  }
Beispiel #20
0
 /**
  * Creates and returns the rendering hints for the GUI. Built from {@link #RENDER_HINTS}
  *
  * @return Hints to use when displaying the GUI.
  */
 public static RenderingHints getRenderingHints() {
   RenderingHints hints = new RenderingHints(null);
   for (int i = 0; i < RENDER_HINTS.length; i++) hints.put(RENDER_HINTS[i][0], RENDER_HINTS[i][1]);
   return hints;
 }
Beispiel #21
0
 /**
  * Sets a rendering hint
  *
  * @param arg0
  * @param arg1
  */
 public void setRenderingHint(Key arg0, Object arg1) {
   rhints.put(arg0, arg1);
 }
 static {
   _renderHints =
       new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
   _renderHints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
 }
Beispiel #23
0
  /**
   * Applies the band select operation to a grid coverage.
   *
   * @param cropEnvelope the target envelope; always not null
   * @param cropROI the target ROI shape; nullable
   * @param roiTolerance; as read from op's params
   * @param sourceCoverage is the source {@link GridCoverage2D} that we want to crop.
   * @param hints A set of rendering hints, or {@code null} if none.
   * @param sourceGridToWorldTransform is the 2d grid-to-world transform for the source coverage.
   * @return The result as a grid coverage.
   */
  private static GridCoverage2D buildResult(
      final GeneralEnvelope cropEnvelope,
      final Geometry cropROI,
      final double roiTolerance,
      final boolean forceMosaic,
      final Hints hints,
      final GridCoverage2D sourceCoverage,
      final AffineTransform sourceGridToWorldTransform) {

    //
    // Getting the source coverage and its child geolocation objects
    //
    final RenderedImage sourceImage = sourceCoverage.getRenderedImage();
    final GridGeometry2D sourceGridGeometry = ((GridGeometry2D) sourceCoverage.getGridGeometry());
    final GridEnvelope2D sourceGridRange = sourceGridGeometry.getGridRange2D();

    //
    // Now we try to understand if we have a simple scale and translate or a
    // more elaborated grid-to-world transformation n which case a simple
    // crop could not be enough, but we may need a more elaborated chain of
    // operation in order to do a good job. As an instance if we
    // have a rotation which is not multiple of PI/2 we have to use
    // the mosaic with a ROI
    //
    final boolean isSimpleTransform =
        CoverageUtilities.isSimpleGridToWorldTransform(sourceGridToWorldTransform, EPS);

    // Do we need to explode the Palette to RGB(A)?
    //
    int actionTaken = 0;

    // //
    //
    // Layout
    //
    // //
    final RenderingHints targetHints = new RenderingHints(null);
    if (hints != null) targetHints.add(hints);
    final ImageLayout layout = initLayout(sourceImage, targetHints);
    targetHints.put(JAI.KEY_IMAGE_LAYOUT, layout);

    //
    // prepare the processor to use for this operation
    //
    final JAI processor = OperationJAI.getJAI(targetHints);
    final boolean useProvidedProcessor = !processor.equals(JAI.getDefaultInstance());

    try {

      if (cropROI != null) {
        // replace the cropEnvelope with the envelope of the intersection
        // of the ROI and the cropEnvelope.
        // Remember that envelope(intersection(roi,cropEnvelope)) != intersection(cropEnvelope,
        // envelope(roi))
        final Polygon modelSpaceROI = FeatureUtilities.getPolygon(cropEnvelope, GFACTORY);
        Geometry intersection = IntersectUtils.intersection(cropROI, modelSpaceROI);
        Envelope2D e2d =
            JTS.getEnvelope2D(
                intersection.getEnvelopeInternal(), cropEnvelope.getCoordinateReferenceSystem());
        GeneralEnvelope ge = new GeneralEnvelope((org.opengis.geometry.Envelope) e2d);
        cropEnvelope.setEnvelope(ge);
      }

      // //
      //
      // Build the new range by keeping into
      // account translation of grid geometry constructor for respecting
      // OGC PIXEL-IS-CENTER ImageDatum assumption.
      //
      // //
      final AffineTransform sourceWorldToGridTransform = sourceGridToWorldTransform.createInverse();

      // //
      //
      // finalRasterArea will hold the smallest rectangular integer raster area that contains the
      // floating point raster
      // area which we obtain when applying the world-to-grid transform to the cropEnvelope. Note
      // that we need to intersect
      // such an area with the area covered by the source coverage in order to be sure we do not try
      // to crop outside the
      // bounds of the source raster.
      //
      // //
      final Rectangle2D finalRasterAreaDouble =
          XAffineTransform.transform(
              sourceWorldToGridTransform, cropEnvelope.toRectangle2D(), null);
      final Rectangle finalRasterArea = finalRasterAreaDouble.getBounds();

      // intersection with the original range in order to not try to crop outside the image bounds
      Rectangle.intersect(finalRasterArea, sourceGridRange, finalRasterArea);
      if (finalRasterArea.isEmpty())
        throw new CannotCropException(Errors.format(ErrorKeys.CANT_CROP));

      // //
      //
      // It is worth to point out that doing a crop the G2W transform
      // should not change while the envelope might change as
      // a consequence of the rounding of the underlying image datum
      // which uses integer factors or in case the G2W is very
      // complex. Note that we will always strive to
      // conserve the original grid-to-world transform.
      //
      // //

      // we do not have to crop in this case (should not really happen at
      // this time)
      if (finalRasterArea.equals(sourceGridRange) && isSimpleTransform && cropROI == null)
        return sourceCoverage;

      // //
      //
      // if I get here I have something to crop
      // using the world-to-grid transform for going from envelope to the
      // new grid range.
      //
      // //
      final double minX = finalRasterArea.getMinX();
      final double minY = finalRasterArea.getMinY();
      final double width = finalRasterArea.getWidth();
      final double height = finalRasterArea.getHeight();

      // //
      //
      // Check if we need to use mosaic or crop
      //
      // //
      final PlanarImage croppedImage;
      final ParameterBlock pbj = new ParameterBlock();
      pbj.addSource(sourceImage);
      java.awt.Polygon rasterSpaceROI = null;
      String operatioName = null;
      if (!isSimpleTransform || cropROI != null) {
        // /////////////////////////////////////////////////////////////////////
        //
        // We don't have a simple scale and translate transform, JAI
        // crop MAY NOT suffice. Let's decide whether or not we'll use
        // the Mosaic.
        //
        // /////////////////////////////////////////////////////////////////////
        Polygon modelSpaceROI = FeatureUtilities.getPolygon(cropEnvelope, GFACTORY);

        // //
        //
        // Now convert this polygon back into a shape for the source
        // raster space.
        //
        // //
        final List<Point2D> points = new ArrayList<Point2D>(5);
        rasterSpaceROI =
            FeatureUtilities.convertPolygonToPointArray(
                modelSpaceROI, ProjectiveTransform.create(sourceWorldToGridTransform), points);
        if (rasterSpaceROI == null || rasterSpaceROI.getBounds().isEmpty())
          if (finalRasterArea.isEmpty())
            throw new CannotCropException(Errors.format(ErrorKeys.CANT_CROP));
        final boolean doMosaic =
            forceMosaic
                ? true
                : decideJAIOperation(roiTolerance, rasterSpaceROI.getBounds2D(), points);
        if (doMosaic || cropROI != null) {
          // prepare the params for the mosaic
          final ROI[] roiarr;
          try {
            if (cropROI != null) {
              final LiteShape2 cropRoiLS2 =
                  new LiteShape2(
                      cropROI, ProjectiveTransform.create(sourceWorldToGridTransform), null, false);
              ROI cropRS = new ROIShape(cropRoiLS2);
              Rectangle2D rt = cropRoiLS2.getBounds2D();
              if (!hasIntegerBounds(rt)) {
                // Approximate Geometry
                Geometry geo = (Geometry) cropRoiLS2.getGeometry().clone();
                transformGeometry(geo);
                cropRS = new ROIShape(new LiteShape2(geo, null, null, false));
              }
              roiarr = new ROI[] {cropRS};
            } else {
              final ROIShape roi = new ROIShape(rasterSpaceROI);
              roiarr = new ROI[] {roi};
            }
          } catch (FactoryException ex) {
            throw new CannotCropException(Errors.format(ErrorKeys.CANT_CROP), ex);
          }
          pbj.add(MosaicDescriptor.MOSAIC_TYPE_OVERLAY);
          pbj.add(null);
          pbj.add(roiarr);
          pbj.add(null);
          pbj.add(CoverageUtilities.getBackgroundValues(sourceCoverage));

          // prepare the final layout
          final Rectangle bounds = rasterSpaceROI.getBounds2D().getBounds();
          Rectangle.intersect(bounds, sourceGridRange, bounds);
          if (bounds.isEmpty()) throw new CannotCropException(Errors.format(ErrorKeys.CANT_CROP));

          // we do not have to crop in this case (should not really happen at
          // this time)
          if (!doMosaic && bounds.getBounds().equals(sourceGridRange) && isSimpleTransform)
            return sourceCoverage;

          // nice trick, we use the layout to do the actual crop
          final Rectangle boundsInt = bounds.getBounds();
          layout.setMinX(boundsInt.x);
          layout.setWidth(boundsInt.width);
          layout.setMinY(boundsInt.y);
          layout.setHeight(boundsInt.height);
          operatioName = "Mosaic";
        }
      }

      // do we still have to set the operation name? If so that means we have to go for crop.
      if (operatioName == null) {
        // executing the crop
        pbj.add((float) minX);
        pbj.add((float) minY);
        pbj.add((float) width);
        pbj.add((float) height);
        operatioName = "GTCrop";
      }
      // //
      //
      // Apply operation
      //
      // //
      if (!useProvidedProcessor) {
        croppedImage = JAI.create(operatioName, pbj, targetHints);
      } else {
        croppedImage = processor.createNS(operatioName, pbj, targetHints);
      }

      // conserve the input grid to world transformation
      Map sourceProperties = sourceCoverage.getProperties();
      Map properties = null;
      if (sourceProperties != null && !sourceProperties.isEmpty()) {
        properties = new HashMap(sourceProperties);
      }
      if (rasterSpaceROI != null) {
        if (properties != null) {
          properties.put("GC_ROI", rasterSpaceROI);
        } else {
          properties = Collections.singletonMap("GC_ROI", rasterSpaceROI);
        }
      }

      return new GridCoverageFactory(hints)
          .create(
              sourceCoverage.getName(),
              croppedImage,
              new GridGeometry2D(
                  new GridEnvelope2D(croppedImage.getBounds()),
                  sourceGridGeometry.getGridToCRS2D(PixelOrientation.CENTER),
                  sourceCoverage.getCoordinateReferenceSystem()),
              (GridSampleDimension[])
                  (actionTaken == 1 ? null : sourceCoverage.getSampleDimensions().clone()),
              new GridCoverage[] {sourceCoverage},
              properties);

    } catch (TransformException e) {
      throw new CannotCropException(Errors.format(ErrorKeys.CANT_CROP), e);
    } catch (NoninvertibleTransformException e) {
      throw new CannotCropException(Errors.format(ErrorKeys.CANT_CROP), e);
    }
  }
  public void paint(Graphics g) {
    g2d = (Graphics2D) g;

    RenderingHints rh =
        new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

    rh.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);

    g2d.setRenderingHints(rh);

    // Set the font for displaying the text information on the screen.
    g2d.setFont(new Font("Purisa", Font.PLAIN, 14));

    // Set to gray and fill info window
    g2d.setColor(new Color(240, 240, 240));
    g2d.fillRect(0, 0, infoWidth, windowHeight);

    // Set to white and fill the plot window
    g2d.setColor(new Color(255, 255, 255));
    g2d.fillRect(infoWidth, 0, windowWidth, windowHeight);

    //  Draw the axes
    g2d.setColor(new Color(0, 0, 0));
    g2d.setStroke(new BasicStroke(3, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
    // y axis
    g2d.drawLine(
        infoWidth + (axesWidth * 3 / 4) - 5,
        windowHeight - axesWidth * 3 / 4,
        infoWidth + (axesWidth * 3 / 4) - 5,
        edgeBuffer);
    // x axis
    g2d.drawLine(
        infoWidth + (axesWidth * 3 / 4),
        windowHeight - axesWidth * 3 / 4,
        windowWidth - edgeBuffer,
        windowHeight - axesWidth * 3 / 4);

    // Draw the ticks
    g2d.setStroke(new BasicStroke(2, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
    for (int i = 0; i < numTicks; i++) {
      // Horizontal ticks on y axis
      int vertTickPoint = i * ((windowHeight - axesWidth * 3 / 4) - edgeBuffer) / (numTicks - 1);
      g2d.drawLine(
          infoWidth + (axesWidth * 3 / 4) - tickLength - 5,
          edgeBuffer + vertTickPoint,
          infoWidth + (axesWidth * 3 / 4) + tickLength - 5,
          edgeBuffer + vertTickPoint);
      g2d.drawString(
          (float) (numTicks - 1 - i) * ((float) numReqs / (float) (numTicks - 1)) + "",
          infoWidth + (axesWidth * 3 / 4) - 60,
          edgeBuffer + vertTickPoint + 5);

      // Vertical ticks on x axis
      int horTickPoint =
          i * ((windowWidth - edgeBuffer) - (infoWidth + (axesWidth * 3 / 4))) / (numTicks - 1);
      g2d.drawLine(
          horTickPoint + (infoWidth + (axesWidth * 3 / 4)),
          windowHeight - axesWidth * 3 / 4 - tickLength,
          horTickPoint + (infoWidth + (axesWidth * 3 / 4)),
          windowHeight - axesWidth * 3 / 4 + tickLength);
      g2d.drawString(
          (float) (i) * ((float) execTime / (float) (numTicks - 1)) + "",
          horTickPoint + (infoWidth + (axesWidth * 3 / 4)) - 22,
          windowHeight - axesWidth * 3 / 4 + tickLength + 15);
    }

    // Draw the stepfunctionlines
    for (StepFunctionLine l : randLines) {
      l.setGraphics(g2d);
      l.drawStep();
    }

    for (int i = 0; i < lines.size(); i++) {
      if (show[i] == true) {
        lines.get(i).setGraphics(g2d);
        lines.get(i).drawStep();
      }
    }

    // Draw the plot info
    g2d.setColor(new Color(0, 0, 0));
    g2d.drawString("Coverage: " + matrixFile, 17, 30);
    g2d.drawString("Timing: " + timeFile, 17, 50);
    g2d.drawString("Test Cases: " + lines.get(0).getNumTests(), 17, 70);
    // g2d.drawString("Execution Time: " + lines.get(0).getExecutionTime()+ " ms", 17, 70);

    // Draw a separator box
    g2d.drawRect(0, 0, infoWidth - 1, 85);

    ////////////////// Original and Reverse

    g2d.setStroke(new BasicStroke(2, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
    // Draw vert lines between to delimit original/reverse buttons
    for (int i = 0; i <= 1; i++) {
      g2d.drawLine(
          originalGridStartX + i * gridSpacingX,
          originalGridStartY,
          originalGridStartX + i * gridSpacingX,
          originalGridStartY + oTechniques.length * gridSpacingY);
    }

    // Draw hor lines between to delimit original/reverse button grids
    for (int i = 0; i <= oTechniques.length; i++) {
      g2d.drawLine(
          originalGridStartX,
          originalGridStartY + i * gridSpacingY,
          originalGridStartX + gridSpacingX,
          originalGridStartY + i * gridSpacingY);
    }

    // Draw the text labels for the technique buttons
    for (int i = 0; i < oTechniques.length; i++) {
      g2d.drawString(
          oTechniques[i],
          originalGridStartX - originalLabelsOffsetX,
          originalGridStartY + originalLabelsOffsetY + i * gridSpacingY);
    }

    // The buttons
    for (int i = 0; i < 2; i++) {
      if (show[i] == true) {
        int row = i / 1;
        int col = i % 1;

        g2d.fillRect(
            originalGridStartX + col * gridSpacingX + buttonInsetX / 2,
            originalGridStartY + row * gridSpacingY + buttonInsetY / 2,
            gridSpacingX - buttonInsetX,
            gridSpacingY - buttonInsetY);
      }
    }

    // Labels over the controls
    g2d.drawString("Prioritization Techniques", originalGridStartX - 46, originalGridStartY - 30);
    g2d.drawString("Random Prioritizations", scrollBarStartX + 65, scrollBarStartY - 30);

    ///////////////////////////  Big Button grid

    // Draw vert lines between to delimit buttons
    for (int i = 0; i <= gcm.length; i++) {
      g2d.drawLine(
          gridStartX + i * gridSpacingX,
          gridStartY,
          gridStartX + i * gridSpacingX,
          gridStartY + techniques.length * gridSpacingY);
    }

    // Draw hor lines between to delimit grids
    for (int i = 0; i <= techniques.length; i++) {
      g2d.drawLine(
          gridStartX,
          gridStartY + i * gridSpacingY,
          gridStartX + gcm.length * gridSpacingX,
          gridStartY + i * gridSpacingY);
    }

    // Draw the text labels for the technique buttons
    for (int i = 0; i < techniques.length; i++) {
      g2d.setColor(colors[i]);
      g2d.drawString(
          techniques[i],
          gridStartX - techniqueLabelsOffsetX,
          gridStartY + techniqueLabelsOffsetY + i * gridSpacingY);
    }

    g2d.setColor(Color.BLACK);
    // Draw the gcm labels for the technique buttons
    for (int i = 0; i < gcm.length; i++) {
      g2d.drawString(
          gcm[i], gridStartX + gcmLabelsOffsetX + i * gridSpacingX, gridStartY - gcmLabelsOffsetY);
    }

    // The buttons
    for (int i = 2; i < lines.size(); i++) {
      g2d.setColor(colors[(i - 2) / gcm.length]);
      if (show[i] == true) {
        int row = (i - 2) / gcm.length;
        int col = (i - 2) % gcm.length;

        g2d.fillRect(
            gridStartX + col * gridSpacingX + buttonInsetX / 2,
            gridStartY + row * gridSpacingY + buttonInsetY / 2,
            gridSpacingX - buttonInsetX,
            gridSpacingY - buttonInsetY);
      }
    }

    // Scroll Bar
    // g2d.drawLine(scrollBarStartX, scrollBarStartY, scrollBarStartX+scrollBarLength,
    // scrollBarStartY);
    g2d.setColor(Color.WHITE);
    g2d.fillRect(
        scrollBarStartX,
        scrollBarStartY - ((gridSpacingY - buttonInsetY) / 2),
        scrollBarLength,
        gridSpacingY - buttonInsetY);
    g2d.setColor(new Color(200, 200, 200));
    g2d.fillRect(
        scrollBoxX,
        scrollBoxY - ((gridSpacingY - buttonInsetY) / 2),
        gridSpacingX - buttonInsetX,
        gridSpacingY - buttonInsetY);
    g2d.setColor(Color.BLACK);
    g2d.setFont(new Font("Purisa", Font.PLAIN, 18));
    g2d.drawString(numRand + "", scrollBoxX + 26, scrollBoxY + 7);
    g2d.setFont(new Font("Purisa", Font.PLAIN, 14));

    // Stats for random
    g2d.drawString("Avg CE: " + aveRandCE, scrollBarStartX - 5, scrollBarStartY + 29);
    g2d.drawString(
        "Running Avg CE: " + runningAveRandCE, scrollBarStartX - 5, scrollBarStartY + 49);
    g2d.drawString("St. Dev.: " + randSTDev, scrollBarStartX - 5, scrollBarStartY + 69);
    g2d.drawString(
        "Running St. Dev. " + runningRandSTDev, scrollBarStartX - 5, scrollBarStartY + 89);

    // axis labels
    g2d.setColor(Color.black);
    g2d.drawString(
        "Execution Time (ms)",
        (windowWidth - infoWidth) / 2 + infoWidth - 35,
        windowHeight - axesWidth * 3 / 4 + 45);

    g2d.translate((infoWidth + 15), (windowHeight / 2));
    g2d.rotate(-Math.PI / 2);
    g2d.drawString("Covered Requirements", -55, -2);
    g2d.rotate(Math.PI / 2);
  }
 /**
  * Sets a given rendering hint.
  *
  * @param key hint key
  * @param hint to be associated with key
  */
 public void setRenderingHint(RenderingHints.Key key, Object hint) {
   // extra protection, failed on under MacOS X 10.2.6, jdk 1.4.1_01-39/14
   if ((key == null) || (hint == null)) return;
   hints.put(key, hint);
 }