private void captureScreen(IScreen scr) {
   ScreenImage simg = scr.capture();
   scr_img = simg.getImage();
   darker_factor = 0.6f;
   RescaleOp op = new RescaleOp(darker_factor, 0, null);
   scr_img_darker = op.filter(scr_img, null);
 }
  public static BufferedImage doContrast(BufferedImage img, float f) {
    float brightenFactor = 1 + f;

    RescaleOp op = new RescaleOp(brightenFactor, 0, null);
    img = op.filter(img, img);

    return img;
  }
 private static ImageIcon makeRolloverIcon(ImageIcon srcIcon) {
   RescaleOp op =
       new RescaleOp(new float[] {1.2f, 1.2f, 1.2f, 1f}, new float[] {0f, 0f, 0f, 0f}, null);
   BufferedImage img =
       new BufferedImage(
           srcIcon.getIconWidth(), srcIcon.getIconHeight(), BufferedImage.TYPE_INT_ARGB);
   Graphics g = img.getGraphics();
   // g.drawImage(srcIcon.getImage(), 0, 0, null);
   srcIcon.paintIcon(null, g, 0, 0);
   g.dispose();
   return new ImageIcon(op.filter(img, null));
 }
 private BufferedImage windowWithRasterOp(
     BufferedImage srcImg, float windowLocation, float windowWidth) {
   // final int windowedImageBandValuesCount = 256;  // for BufferedImage.TYPE_INT_RGB
   // final float windowedImageBandValuesCount = 1.0F;
   // final float windowedImageBandValuesCount = 65535F;
   // final float windowedImageBandValuesCount = 4095F;
   final float windowedImageBandValuesCount =
       (1 << srcImg.getColorModel().getComponentSize(0)) - 1;
   float scale = windowedImageBandValuesCount / windowWidth;
   float offset = (windowWidth / 2 - windowLocation) * scale;
   RescaleOp rescaleOp = new RescaleOp(scale, offset, null);
   return rescaleOp.filter(srcImg, null);
 }
 /** Takes a snapshot of the screen, fades it, and sets it as the background. */
 public static void snapshot() {
   Dimension dim = getInstance().component.getPreferredSize();
   java.awt.Rectangle rect = new java.awt.Rectangle(0, 0, dim.width, dim.height);
   BufferedImage image = new BufferedImage(rect.width, rect.height, BufferedImage.TYPE_INT_RGB);
   Graphics g = image.getGraphics();
   g.setColor(java.awt.Color.WHITE);
   g.fillRect(0, 0, rect.width, rect.height);
   g.setColor(java.awt.Color.BLACK);
   getInstance().component.paintComponent(g);
   float factor = 0.8f;
   float base = 255f * (1f - factor);
   RescaleOp op = new RescaleOp(factor, base, null);
   BufferedImage filteredImage =
       new BufferedImage(image.getWidth(), image.getHeight(), image.getType());
   op.filter(image, filteredImage);
   getInstance().background = filteredImage;
   getInstance().component.repaint();
 }
  /**
   * Creates BufferedImage for hwComponentType at path of size. If marked, the result image is
   * brighter by 50%.
   *
   * @param hwComponentType
   * @param path
   * @param width
   * @param marked
   * @return
   */
  protected BufferedImage createImage(
      HwTypeEnum hwComponentType, String path, Integer width, boolean marked) {

    BufferedImage bi = null;

    Image tmp = null;

    try {
      // loads image from path and scales it to desired size
      tmp = getScaledImage(path, width);
    } catch (IOException ex) {
      try {
        // load default image
        tmp = getScaledImage(getImagePath(hwComponentType), width);
      } catch (IOException ex1) {
        // should never happen, all hwComponentType default icons are in .jar as a resource
      }
    }

    // create new buffered image to paint on
    bi = new BufferedImage(tmp.getWidth(null), tmp.getHeight(null), BufferedImage.TYPE_INT_ARGB);

    // create graphics and set hints
    Graphics2D graphics2D = bi.createGraphics();
    graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    graphics2D.setRenderingHint(
        RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);

    // draw image
    graphics2D.drawImage(tmp, 0, 0, null);

    // if marked, draw transparent white rectangle over
    if (marked) {
      rescaleOp.filter(bi, bi);
    }

    graphics2D.dispose();

    return bi;
  }
Beispiel #7
0
 public BufferedImage getBrighten() {
   RescaleOp rop = new RescaleOp(1.0F, 0.0F, null);
   return this.image = rop.filter(this.image, null);
 }
 /**
  * @time : 11:08:58 AM Sep 10, 2015 @Description : For static snapshot, we are used to put a dark
  *     image as back image. So the original image should be darken.
  */
 public void darkScreenImage() {
   RescaleOp ro = new RescaleOp(0.9f, 0, null);
   whiteImage = ro.filter(screenImage, null);
 }
Beispiel #9
0
 @Override
 public void paint(Graphics g) {
   RescaleOp ro = new RescaleOp(0.8f, 0, null);
   tempImage = ro.filter(image, null);
   g.drawImage(tempImage, 0, 0, this);
 }
  /**
   * {@collect.stats} Rescales the source BufferedImage. If the color model in the source image is
   * not the same as that in the destination image, the pixels will be converted in the destination.
   * If the destination image is null, a BufferedImage will be created with the source ColorModel.
   * An IllegalArgumentException may be thrown if the number of scaling factors/offsets in this
   * object does not meet the restrictions stated in the class comments above, or if the source
   * image has an IndexColorModel.
   *
   * @param src the <code>BufferedImage</code> to be filtered
   * @param dst the destination for the filtering operation or <code>null</code>
   * @return the filtered <code>BufferedImage</code>.
   * @throws IllegalArgumentException if the <code>ColorModel</code> of <code>src</code> is an
   *     <code>IndexColorModel</code>, or if the number of scaling factors and offsets in this
   *     <code>RescaleOp</code> do not meet the requirements stated in the class comments.
   */
  public final BufferedImage filter(BufferedImage src, BufferedImage dst) {
    ColorModel srcCM = src.getColorModel();
    ColorModel dstCM;
    int numBands = srcCM.getNumColorComponents();

    if (srcCM instanceof IndexColorModel) {
      throw new IllegalArgumentException("Rescaling cannot be " + "performed on an indexed image");
    }
    if (length != 1 && length != numBands && length != srcCM.getNumComponents()) {
      throw new IllegalArgumentException(
          "Number of scaling constants "
              + "does not equal the number of"
              + " of color or color/alpha "
              + " components");
    }

    boolean needToConvert = false;

    // Include alpha
    if (length > numBands && srcCM.hasAlpha()) {
      length = numBands + 1;
    }

    int width = src.getWidth();
    int height = src.getHeight();

    if (dst == null) {
      dst = createCompatibleDestImage(src, null);
      dstCM = srcCM;
    } else {
      if (width != dst.getWidth()) {
        throw new IllegalArgumentException(
            "Src width (" + width + ") not equal to dst width (" + dst.getWidth() + ")");
      }
      if (height != dst.getHeight()) {
        throw new IllegalArgumentException(
            "Src height (" + height + ") not equal to dst height (" + dst.getHeight() + ")");
      }

      dstCM = dst.getColorModel();
      if (srcCM.getColorSpace().getType() != dstCM.getColorSpace().getType()) {
        needToConvert = true;
        dst = createCompatibleDestImage(src, null);
      }
    }

    BufferedImage origDst = dst;

    //
    // Try to use a native BI rescale operation first
    //
    if (ImagingLib.filter(this, src, dst) == null) {
      //
      // Native BI rescale failed - convert to rasters
      //
      WritableRaster srcRaster = src.getRaster();
      WritableRaster dstRaster = dst.getRaster();

      if (srcCM.hasAlpha()) {
        if (numBands - 1 == length || length == 1) {
          int minx = srcRaster.getMinX();
          int miny = srcRaster.getMinY();
          int[] bands = new int[numBands - 1];
          for (int i = 0; i < numBands - 1; i++) {
            bands[i] = i;
          }
          srcRaster =
              srcRaster.createWritableChild(
                  minx, miny, srcRaster.getWidth(), srcRaster.getHeight(), minx, miny, bands);
        }
      }
      if (dstCM.hasAlpha()) {
        int dstNumBands = dstRaster.getNumBands();
        if (dstNumBands - 1 == length || length == 1) {
          int minx = dstRaster.getMinX();
          int miny = dstRaster.getMinY();
          int[] bands = new int[numBands - 1];
          for (int i = 0; i < numBands - 1; i++) {
            bands[i] = i;
          }
          dstRaster =
              dstRaster.createWritableChild(
                  minx, miny, dstRaster.getWidth(), dstRaster.getHeight(), minx, miny, bands);
        }
      }

      //
      // Call the raster filter method
      //
      filter(srcRaster, dstRaster);
    }

    if (needToConvert) {
      // ColorModels are not the same
      ColorConvertOp ccop = new ColorConvertOp(hints);
      ccop.filter(dst, origDst);
    }

    return origDst;
  }