public void testCreateInterleaved() {
    ColorSpace colorSpace = ColorSpace.getInstance(ColorSpace.CS_sRGB);
    int[] bandOffsets = new int[] {1, 2, 3};
    int dataType = DataBuffer.TYPE_BYTE;

    ImageTypeSpecifier type =
        ImageTypeSpecifier.createInterleaved(colorSpace, bandOffsets, dataType, false, false);
    ColorModel colorModel = type.getColorModel();
    PixelInterleavedSampleModel sampleModel = (PixelInterleavedSampleModel) type.getSampleModel();

    // validate the colorModel
    assertEquals(
        "Failed to create with the correct colorspace type",
        ColorSpace.TYPE_RGB,
        colorModel.getColorSpace().getType());
    assertEquals(
        "Failed to create with the correct transparency",
        Transparency.OPAQUE,
        colorModel.getTransparency());
    assertEquals(
        "Failed to create with the correct transfer type",
        DataBuffer.TYPE_BYTE,
        colorModel.getTransferType());

    // validate the sampleModel
    assertTrue(
        "The sampleModel and colorModel are not compatible",
        colorModel.isCompatibleSampleModel(sampleModel));
    assertArrayEquals(
        "Failed to create with the correct bandOffsets", bandOffsets, sampleModel.getBandOffsets());
    assertEquals("Failed to create with the correct pixel stride", 3, sampleModel.getPixelStride());
  }
Exemplo n.º 2
0
 /**
  * Returns a width- and height-aligned image representation sharing data w/ {@link #image}.
  *
  * @param width
  * @param height
  * @return
  * @throws IllegalArgumentException if requested size exceeds image size
  */
 public BufferedImage getAlignedImage(int width, int height) throws IllegalArgumentException {
   if (width * height > image.getWidth() * image.getHeight()) {
     throw new IllegalArgumentException(
         "Requested size exceeds image size: "
             + width
             + "x"
             + height
             + " > "
             + image.getWidth()
             + "x"
             + image.getHeight());
   }
   if (width == image.getWidth() && height == image.getHeight()) {
     return image;
   } else {
     final ColorModel cm = image.getColorModel();
     final WritableRaster raster0 = image.getRaster();
     final DataBuffer dataBuffer = raster0.getDataBuffer();
     final SinglePixelPackedSampleModel sppsm0 =
         (SinglePixelPackedSampleModel) raster0.getSampleModel();
     final SinglePixelPackedSampleModel sppsm1 =
         new SinglePixelPackedSampleModel(
             dataBuffer.getDataType(),
             width,
             height,
             width /* scanLineStride */,
             sppsm0.getBitMasks());
     final WritableRaster raster1 = WritableRaster.createWritableRaster(sppsm1, dataBuffer, null);
     return new BufferedImage(cm, raster1, cm.isAlphaPremultiplied(), null);
   }
 }
Exemplo n.º 3
0
 /**
  * Returns a copy of this EditableImage.
  *
  * @return A copy of this EditableImage.
  */
 public EditableImage copy() {
   ColorModel colorModel = image.getColorModel();
   boolean isAlphaPremultiplied = colorModel.isAlphaPremultiplied();
   WritableRaster writeableRaster = image.copyData(null);
   return new EditableImage(
       new BufferedImage(colorModel, writeableRaster, isAlphaPremultiplied, null));
 }
Exemplo n.º 4
0
 private GDIWindowSurfaceData(WComponentPeer peer, SurfaceType sType) {
   super(sType, peer.getDeviceColorModel());
   ColorModel cm = peer.getDeviceColorModel();
   this.peer = peer;
   int rMask = 0, gMask = 0, bMask = 0;
   int depth;
   switch (cm.getPixelSize()) {
     case 32:
     case 24:
       if (cm instanceof DirectColorModel) {
         depth = 32;
       } else {
         depth = 24;
       }
       break;
     default:
       depth = cm.getPixelSize();
   }
   if (cm instanceof DirectColorModel) {
     DirectColorModel dcm = (DirectColorModel) cm;
     rMask = dcm.getRedMask();
     gMask = dcm.getGreenMask();
     bMask = dcm.getBlueMask();
   }
   this.graphicsConfig = (Win32GraphicsConfig) peer.getGraphicsConfiguration();
   this.solidloops = graphicsConfig.getSolidLoops(sType);
   Win32GraphicsDevice gd = graphicsConfig.getDevice();
   scaleX = gd.getDefaultScaleX();
   scaleY = gd.getDefaultScaleY();
   initOps(peer, depth, rMask, gMask, bMask, gd.getScreen());
   setBlitProxyKey(graphicsConfig.getProxyKey());
 }
Exemplo n.º 5
0
 public static SurfaceType getSurfaceType(ColorModel cm) {
   switch (cm.getPixelSize()) {
     case 32:
     case 24:
       if (cm instanceof DirectColorModel) {
         if (((DirectColorModel) cm).getRedMask() == 0xff0000) {
           return IntRgbGdi;
         } else {
           return SurfaceType.IntRgbx;
         }
       } else {
         return ThreeByteBgrGdi;
       }
     case 15:
       return Ushort555RgbGdi;
     case 16:
       if ((cm instanceof DirectColorModel) && (((DirectColorModel) cm).getBlueMask() == 0x3e)) {
         return SurfaceType.Ushort555Rgbx;
       } else {
         return Ushort565RgbGdi;
       }
     case 8:
       if (cm.getColorSpace().getType() == ColorSpace.TYPE_GRAY
           && cm instanceof ComponentColorModel) {
         return SurfaceType.ByteGray;
       } else if (cm instanceof IndexColorModel && isOpaqueGray((IndexColorModel) cm)) {
         return SurfaceType.Index8Gray;
       } else {
         return SurfaceType.ByteIndexedOpaque;
       }
     default:
       throw new sun.java2d.InvalidPipeException(
           "Unsupported bit " + "depth: " + cm.getPixelSize());
   }
 }
 /*     */ public void Blit(
     SurfaceData paramSurfaceData1,
     SurfaceData paramSurfaceData2,
     Composite paramComposite,
     Region paramRegion,
     int paramInt1,
     int paramInt2,
     int paramInt3,
     int paramInt4,
     int paramInt5,
     int paramInt6)
       /*     */ {
   /* 120 */ Raster localRaster1 =
       paramSurfaceData1.getRaster(paramInt1, paramInt2, paramInt5, paramInt6);
   /* 121 */ ColorModel localColorModel = paramSurfaceData1.getColorModel();
   /*     */
   /* 123 */ Raster localRaster2 =
       paramSurfaceData2.getRaster(paramInt3, paramInt4, paramInt5, paramInt6);
   /* 124 */ IntegerComponentRaster localIntegerComponentRaster =
       (IntegerComponentRaster) localRaster2;
   /* 125 */ int[] arrayOfInt1 = localIntegerComponentRaster.getDataStorage();
   /*     */
   /* 127 */ Region localRegion =
       CustomComponent.getRegionOfInterest(
           paramSurfaceData1,
           paramSurfaceData2,
           paramRegion,
           paramInt1,
           paramInt2,
           paramInt3,
           paramInt4,
           paramInt5,
           paramInt6);
   /*     */
   /* 130 */ SpanIterator localSpanIterator = localRegion.getSpanIterator();
   /*     */
   /* 132 */ Object localObject = null;
   /*     */
   /* 134 */ int i = localIntegerComponentRaster.getScanlineStride();
   /*     */
   /* 136 */ paramInt1 -= paramInt3;
   /* 137 */ paramInt2 -= paramInt4;
   /* 138 */ int[] arrayOfInt2 = new int[4];
   /* 139 */ while (localSpanIterator.nextSpan(arrayOfInt2)) {
     /* 140 */ int j =
         localIntegerComponentRaster.getDataOffset(0) + arrayOfInt2[1] * i + arrayOfInt2[0];
     /* 141 */ for (int k = arrayOfInt2[1]; k < arrayOfInt2[3]; k++) {
       /* 142 */ int m = j;
       /* 143 */ for (int n = arrayOfInt2[0]; n < arrayOfInt2[2]; n++) {
         /* 144 */ localObject =
             localRaster1.getDataElements(n + paramInt1, k + paramInt2, localObject);
         /* 145 */ arrayOfInt1[(m++)] = localColorModel.getRGB(localObject);
         /*     */ }
       /* 147 */ j += i;
       /*     */ }
     /*     */
     /*     */ }
   /*     */
   /* 152 */ localIntegerComponentRaster.markDirty();
   /*     */ }
Exemplo n.º 7
0
  /**
   * This function 'fixes' the source's color model. Right now it just selects if it should have one
   * or two bands based on if the source had an alpha channel.
   */
  protected static ColorModel fixColorModel(CachableRed src) {
    ColorModel cm = src.getColorModel();
    if (cm != null) {
      if (cm.hasAlpha()) return GraphicsUtil.Linear_sRGB_Unpre;

      return GraphicsUtil.Linear_sRGB;
    } else {
      // No ColorModel so try to make some intelligent
      // decisions based just on the number of bands...
      // 1 bands -> replicated into RGB
      // 2 bands -> Band 0 replicated into RGB & Band 1 -> alpha premult
      // 3 bands -> sRGB (not-linear?)
      // 4 bands -> sRGB premult (not-linear?)
      SampleModel sm = src.getSampleModel();

      switch (sm.getNumBands()) {
        case 1:
          return GraphicsUtil.Linear_sRGB;
        case 2:
          return GraphicsUtil.Linear_sRGB_Unpre;
        case 3:
          return GraphicsUtil.Linear_sRGB;
      }
      return GraphicsUtil.Linear_sRGB_Unpre;
    }
  }
Exemplo n.º 8
0
  public BufferedImage filter(BufferedImage src, BufferedImage dst) {
    int width = src.getWidth();
    int height = src.getHeight();
    int type = src.getType();
    WritableRaster srcRaster = src.getRaster();

    originalSpace = new Rectangle(0, 0, width, height);
    transformedSpace = new Rectangle(0, 0, width, height);
    transformSpace(transformedSpace);

    if (dst == null) {
      ColorModel dstCM = src.getColorModel();
      dst =
          new BufferedImage(
              dstCM,
              dstCM.createCompatibleWritableRaster(transformedSpace.width, transformedSpace.height),
              dstCM.isAlphaPremultiplied(),
              null);
    }
    WritableRaster dstRaster = dst.getRaster();

    int[] inPixels = getRGB(src, 0, 0, width, height, null);
    inPixels = filterPixels(width, height, inPixels, transformedSpace);
    setRGB(dst, 0, 0, transformedSpace.width, transformedSpace.height, inPixels);

    return dst;
  }
Exemplo n.º 9
0
  /**
   * Construct a fully transparent image <tt>bounds</tt> size, will paint one tile with paint. Thus
   * paint should not be a pattered paint or gradient but should be a solid color.
   *
   * @param bounds the bounds of the image (in fact will respond with any request).
   */
  public FloodRed(Rectangle bounds, Paint paint) {
    super(); // We _must_ call init...

    ColorModel cm = GraphicsUtil.sRGB_Unpre;

    int defSz = AbstractTiledRed.getDefaultTileSize();

    int tw = bounds.width;
    if (tw > defSz) tw = defSz;
    int th = bounds.height;
    if (th > defSz) th = defSz;

    // fix my sample model so it makes sense given my size.
    SampleModel sm = cm.createCompatibleSampleModel(tw, th);

    // Finish initializing our base class...
    init((CachableRed) null, bounds, cm, sm, 0, 0, null);

    raster = Raster.createWritableRaster(sm, new Point(0, 0));
    BufferedImage offScreen = new BufferedImage(cm, raster, cm.isAlphaPremultiplied(), null);

    Graphics2D g = GraphicsUtil.createGraphics(offScreen);
    g.setPaint(paint);
    g.fillRect(0, 0, bounds.width, bounds.height);
    g.dispose();
  }
Exemplo n.º 10
0
  protected static ColorModel fixColorModel(CachableRed src) {
    ColorModel cm = src.getColorModel();

    int b = src.getSampleModel().getNumBands();
    int[] masks = new int[4];
    switch (b) {
      case 1:
        masks[0] = 0xFF;
        break;
      case 2:
        masks[0] = 0x00FF;
        masks[3] = 0xFF00;
        break;
      case 3:
        masks[0] = 0xFF0000;
        masks[1] = 0x00FF00;
        masks[2] = 0x0000FF;
        break;
      case 4:
        masks[0] = 0x00FF0000;
        masks[1] = 0x0000FF00;
        masks[2] = 0x000000FF;
        masks[3] = 0xFF000000;
        break;
      default:
        throw new IllegalArgumentException(
            "GaussianBlurRed8Bit only supports one to four band images");
    }
    ColorSpace cs = cm.getColorSpace();
    return new DirectColorModel(
        cs, 8 * b, masks[0], masks[1], masks[2], masks[3], true, DataBuffer.TYPE_INT);
  }
  private static byte[] getIndexedRGBPixels(BufferedImage img) {
    byte[] indices = ((java.awt.image.DataBufferByte) img.getRaster().getDataBuffer()).getData();
    int numOfPixels = indices.length;
    ColorModel model = img.getColorModel();
    byte[] rgbs = null;

    if (model.hasAlpha()) {
      rgbs = new byte[numOfPixels * 4];
      int i = 0;
      for (int j = 0; j < numOfPixels; j++) {
        int argb = model.getRGB(indices[j]);
        rgbs[i++] = (byte) ((argb >> 24) & 0xff);
        rgbs[i++] = (byte) ((argb) & 0xff);
        rgbs[i++] = (byte) ((argb >> 8) & 0xff);
        rgbs[i++] = (byte) ((argb >> 16) & 0xff);
      }
    } else {
      rgbs = new byte[numOfPixels * 3];
      int i = 0;
      for (int j = 0; j < numOfPixels; j++) {
        int argb = model.getRGB(indices[j]);
        rgbs[i++] = (byte) ((argb) & 0xff);
        rgbs[i++] = (byte) ((argb >> 8) & 0xff);
        rgbs[i++] = (byte) ((argb >> 16) & 0xff);
      }
    }

    return rgbs;
  }
  void createBufferedImage() {
    // REMIND:  Be careful!  Is this called everytime there is a
    // startProduction?  We only want to call it if it is new or
    // there is an error
    isDefaultBI = false;
    try {
      biRaster = cmodel.createCompatibleWritableRaster(width, height);
      bimage = createImage(cmodel, biRaster, cmodel.isAlphaPremultiplied(), null);
    } catch (Exception e) {
      // Create a default image
      cmodel = ColorModel.getRGBdefault();
      biRaster = cmodel.createCompatibleWritableRaster(width, height);
      bimage = createImage(cmodel, biRaster, false, null);
    }
    int type = bimage.getType();

    if ((cmodel == ColorModel.getRGBdefault())
        || (type == BufferedImage.TYPE_INT_RGB)
        || (type == BufferedImage.TYPE_INT_ARGB_PRE)) {
      isDefaultBI = true;
    } else if (cmodel instanceof DirectColorModel) {
      DirectColorModel dcm = (DirectColorModel) cmodel;
      if (dcm.getRedMask() == 0xff0000
          && dcm.getGreenMask() == 0xff00
          && dcm.getBlueMask() == 0xff) {
        isDefaultBI = true;
      }
    }
  }
  public void testCreateBanded() {
    int[] bankIndices = new int[] {0, 1, 2};
    int[] bandOffsets = new int[] {1, 1, 1};
    ColorSpace colorSpace = ColorSpace.getInstance(ColorSpace.CS_sRGB);
    int dataType = DataBuffer.TYPE_BYTE;
    boolean hasAlpha = false;

    ImageTypeSpecifier typeSpecifier =
        ImageTypeSpecifier.createBanded(
            colorSpace, bankIndices, bandOffsets, dataType, hasAlpha, false);

    ColorModel colorModel = typeSpecifier.getColorModel();
    assertEquals(
        "Failed to create with the correct colorspace type",
        ColorSpace.TYPE_RGB,
        colorModel.getColorSpace().getType());
    assertEquals(
        "Failed to create with the correct transparency",
        Transparency.OPAQUE,
        colorModel.getTransparency());
    assertEquals(
        "Failed to create with the correcttransfer type",
        DataBuffer.TYPE_BYTE,
        colorModel.getTransferType());

    BandedSampleModel sampleModel = (BandedSampleModel) typeSpecifier.getSampleModel();
    assertArrayEquals(
        "Failed to create with the correct bankIndices", bankIndices, sampleModel.getBankIndices());
    assertArrayEquals(
        "Failed to create with the correct bankIndices", bandOffsets, sampleModel.getBandOffsets());
  }
Exemplo n.º 14
0
  /**
   * This function 'fixes' the source's sample model. Right now it just selects if it should have 3
   * or 4 bands based on if the source had an alpha channel.
   */
  protected static SampleModel fixSampleModel(CachableRed src) {
    SampleModel sm = src.getSampleModel();
    ColorModel cm = src.getColorModel();

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

    boolean alpha = false;

    if (cm != null) alpha = cm.hasAlpha();
    else {
      switch (sm.getNumBands()) {
        case 1:
        case 3:
          alpha = false;
          break;
        default:
          alpha = true;
          break;
      }
    }
    if (alpha)
      return new SinglePixelPackedSampleModel(
          DataBuffer.TYPE_INT,
          sm.getWidth(),
          sm.getHeight(),
          new int[] {0xFF0000, 0xFF00, 0xFF, 0xFF000000});
    else
      return new SinglePixelPackedSampleModel(
          DataBuffer.TYPE_INT, sm.getWidth(), sm.getHeight(), new int[] {0xFF0000, 0xFF00, 0xFF});
  }
Exemplo n.º 15
0
  protected static ColorModel fixColorModel(CachableRed src) {
    ColorModel cm = src.getColorModel();

    if (cm.hasAlpha()) {
      if (!cm.isAlphaPremultiplied()) cm = GraphicsUtil.coerceColorModel(cm, true);
      return cm;
    }

    ColorSpace cs = cm.getColorSpace();

    int b = src.getSampleModel().getNumBands() + 1;
    if (b == 4) {
      int[] masks = new int[4];
      for (int i = 0; i < b - 1; i++) masks[i] = 0xFF0000 >> (8 * i);
      masks[3] = 0xFF << (8 * (b - 1));

      return new DirectColorModel(
          cs, 8 * b, masks[0], masks[1], masks[2], masks[3], true, DataBuffer.TYPE_INT);
    }

    int[] bits = new int[b];
    for (int i = 0; i < b; i++) bits[i] = 8;
    return new ComponentColorModel(
        cs, bits, true, true, Transparency.TRANSLUCENT, DataBuffer.TYPE_INT);
  }
 @Override
 public String getName(GridCoverage2DReader reader, Map<String, String> map) {
   ImageLayout layout;
   String coverageName = null;
   try {
     layout = reader.getImageLayout();
     ColorModel cm = layout.getColorModel(null);
     ColorSpace cs = cm.getColorSpace();
     int type = cs.getType();
     switch (type) {
       case ColorSpace.TYPE_GRAY:
         coverageName = GRAY;
         break;
       case ColorSpace.TYPE_RGB:
         coverageName = RGB;
         break;
       default:
         throw new IllegalArgumentException(
             "The specified ColorSpace's type is not supported: " + type);
     }
   } catch (IOException e) {
     throw new IllegalArgumentException(e);
   }
   return coverageName;
 }
Exemplo n.º 17
0
 public BufferedImage createCompatibleDestImage(BufferedImage src, ColorModel dstCM) {
   if (dstCM == null) dstCM = src.getColorModel();
   return new BufferedImage(
       dstCM,
       dstCM.createCompatibleWritableRaster(src.getWidth(), src.getHeight()),
       dstCM.isAlphaPremultiplied(),
       null);
 }
Exemplo n.º 18
0
 /**
  * Returns a new <code>BufferedImage</code> using the same color model as the image passed as a
  * parameter. The returned image is only compatible with the image passed as a parameter. This
  * does not mean the returned image is compatible with the hardware.
  *
  * @param image the reference image from which the color model of the new image is obtained
  * @return a new <code>BufferedImage</code>, compatible with the color model of <code>image</code>
  */
 public static BufferedImage createColorModelCompatibleImage(BufferedImage image) {
   ColorModel cm = image.getColorModel();
   return new BufferedImage(
       cm,
       cm.createCompatibleWritableRaster(image.getWidth(), image.getHeight()),
       cm.isAlphaPremultiplied(),
       null);
 }
 public static ColorModel getInternedColorModel(ColorModel cm) {
   if (xrgbmodel == cm || xrgbmodel.equals(cm)) {
     return xrgbmodel;
   }
   if (argbmodel == cm || argbmodel.equals(cm)) {
     return argbmodel;
   }
   return cm;
 }
Exemplo n.º 20
0
  /**
   * Create a new ColorModel with it's alpha premultiplied state matching newAlphaPreMult.
   *
   * @param cm The ColorModel to change the alpha premult state of.
   * @param newAlphaPreMult The new state of alpha premult.
   * @return A new colorModel that has isAlphaPremultiplied() equal to newAlphaPreMult.
   */
  public static ColorModel coerceColorModel(ColorModel cm, boolean newAlphaPreMult) {
    if (cm.isAlphaPremultiplied() == newAlphaPreMult) return cm;

    // Easiest way to build proper colormodel for new Alpha state...
    // Eventually this should switch on known ColorModel types and
    // only fall back on this hack when the CM type is unknown.
    WritableRaster wr = cm.createCompatibleWritableRaster(1, 1);
    return cm.coerceData(wr, newAlphaPreMult);
  }
Exemplo n.º 21
0
  private boolean needToCreateIndex(RenderedImage image) {

    SampleModel sampleModel = image.getSampleModel();
    ColorModel colorModel = image.getColorModel();

    return sampleModel.getNumBands() != 1
        || sampleModel.getSampleSize()[0] > 8
        || colorModel.getComponentSize()[0] > 8;
  }
Exemplo n.º 22
0
  /* (non-Javadoc)
   * @see java.awt.image.BufferedImageOp#filter(java.awt.image.BufferedImage, java.awt.image.BufferedImage)
   */
  public BufferedImage filter(BufferedImage src, BufferedImage dst) {
    if (src == null) {
      throw new NullPointerException("src image is null");
    }
    if (src == dst) {
      throw new IllegalArgumentException("src image cannot be the " + "same as the dst image");
    }

    boolean needToConvert = false;
    ColorModel srcCM = src.getColorModel();
    ColorModel dstCM;
    BufferedImage origDst = dst;

    if (srcCM instanceof IndexColorModel) {
      IndexColorModel icm = (IndexColorModel) srcCM;
      src = icm.convertToIntDiscrete(src.getRaster(), false);
      srcCM = src.getColorModel();
    }
    if (dst == null) {
      dst = createCompatibleDestImage(src, null);
      dstCM = srcCM;
      origDst = dst;
    } else {
      dstCM = dst.getColorModel();
      if (srcCM.getColorSpace().getType() != dstCM.getColorSpace().getType()) {
        needToConvert = true;
        dst = createCompatibleDestImage(src, null);
        dstCM = dst.getColorModel();
      } else if (dstCM instanceof IndexColorModel) {
        dst = createCompatibleDestImage(src, null);
        dstCM = dst.getColorModel();
      }
    }

    java.awt.image.CropImageFilter cropfilter =
        new java.awt.image.CropImageFilter(region.x, region.y, region.width, region.height);
    Image returnImage =
        Toolkit.getDefaultToolkit()
            .createImage(new java.awt.image.FilteredImageSource(src.getSource(), cropfilter));
    dst = ImageConverter.convertImage(returnImage);
    origDst = dst;

    if (needToConvert) {
      ColorConvertOp ccop = new ColorConvertOp(hints);
      ccop.filter(dst, origDst);
    } else if (origDst != dst) {
      java.awt.Graphics2D g2 = origDst.createGraphics();
      try {
        g2.drawImage(dst, 0, 0, null);
      } finally {
        g2.dispose();
      }
    }

    return origDst;
  }
Exemplo n.º 23
0
 /**
  * Converts an SWT ImageData to an AWT BufferedImage.
  *
  * @param bufferedImage
  * @return
  */
 @Override
 public BufferedImage getBufferedImage(ImageData data) {
   ColorModel colorModel = null;
   PaletteData palette = data.palette;
   if (palette.isDirect) {
     colorModel =
         new DirectColorModel(data.depth, palette.redMask, palette.greenMask, palette.blueMask);
     BufferedImage bufferedImage =
         new BufferedImage(
             colorModel,
             colorModel.createCompatibleWritableRaster(data.width, data.height),
             false,
             null);
     for (int y = 0; y < data.height; y++) {
       for (int x = 0; x < data.width; x++) {
         int pixel = data.getPixel(x, y);
         RGB rgb = palette.getRGB(pixel);
         bufferedImage.setRGB(x, y, rgb.red << 16 | rgb.green << 8 | rgb.blue);
       }
     }
     return bufferedImage;
   } else {
     RGB[] rgbs = palette.getRGBs();
     byte[] red = new byte[rgbs.length];
     byte[] green = new byte[rgbs.length];
     byte[] blue = new byte[rgbs.length];
     for (int i = 0; i < rgbs.length; i++) {
       RGB rgb = rgbs[i];
       red[i] = (byte) rgb.red;
       green[i] = (byte) rgb.green;
       blue[i] = (byte) rgb.blue;
     }
     if (data.transparentPixel != -1) {
       colorModel =
           new IndexColorModel(data.depth, rgbs.length, red, green, blue, data.transparentPixel);
     } else {
       colorModel = new IndexColorModel(data.depth, rgbs.length, red, green, blue);
     }
     BufferedImage bufferedImage =
         new BufferedImage(
             colorModel,
             colorModel.createCompatibleWritableRaster(data.width, data.height),
             false,
             null);
     WritableRaster raster = bufferedImage.getRaster();
     int[] pixelArray = new int[1];
     for (int y = 0; y < data.height; y++) {
       for (int x = 0; x < data.width; x++) {
         int pixel = data.getPixel(x, y);
         pixelArray[0] = pixel;
         raster.setPixel(x, y, pixelArray);
       }
     }
     return bufferedImage;
   }
 }
  public void testCreateGrayscale() {
    // create a 8-bit grayscale ImageTypeSpecifier
    ImageTypeSpecifier type = ImageTypeSpecifier.createGrayscale(8, DataBuffer.TYPE_BYTE, true);

    ColorModel model = type.getColorModel();
    assertEquals(
        "Failed to return the colorspace type",
        ColorSpace.TYPE_GRAY,
        model.getColorSpace().getType());
    assertEquals("Failed to return the transparency", Transparency.OPAQUE, model.getTransparency());
    assertEquals(
        "Failed to return the transfer type", DataBuffer.TYPE_BYTE, model.getTransferType());
    assertEquals("Failed to return the pixel size", 8, model.getPixelSize());

    // create a 16-bit grayscale AlphaPremultiplied ImageTypeSpecifier
    type = ImageTypeSpecifier.createGrayscale(16, DataBuffer.TYPE_USHORT, true, false);

    model = type.getColorModel();
    assertEquals(
        "Failed to return the colorspace type",
        ColorSpace.TYPE_GRAY,
        model.getColorSpace().getType());
    assertEquals(
        "Failed to return the transparency", Transparency.TRANSLUCENT, model.getTransparency());
    assertEquals(
        "Failed to return the transfer type", DataBuffer.TYPE_USHORT, model.getTransferType());
    assertEquals("Failed to return the pixel size", 32, model.getPixelSize());
  }
Exemplo n.º 25
0
 public int filterRGB(int x, int y, int rgb) {
   int R, G, B, color;
   ColorModel cm = ColorModel.getRGBdefault();
   if (x == -1) ;
   R = cm.getRed(rgb) & 0xff;
   G = cm.getGreen(rgb) & 0xff;
   B = cm.getBlue(rgb) & 0xff;
   if (R >= 100 && G >= 100 && B >= 100) color = 0xffffffff;
   else color = 0xff000000;
   return color;
 }
 public vc_CompositeContextMisc(
     int rule, float alpha, ColorModel srcColorModel, ColorModel dstColorModel) {
   this.rule = rule;
   this.alpha = alpha;
   this.srcColorModel = srcColorModel;
   this.dstColorModel = dstColorModel;
   this.srcColorSpace = srcColorModel.getColorSpace();
   this.dstColorSpace = dstColorModel.getColorSpace();
   ColorModel srgbCM = ColorModel.getRGBdefault();
   //		srcNeedsConverting = !srcColorModel.equals(srgbCM);
   //		dstNeedsConverting = !dstColorModel.equals(srgbCM);
 }
  /**
   * Returns a <code>BufferedImage</code> that supports the specified transparency and has a data
   * layout and color model compatible with this <code>GraphicsConfiguration</code>. This method has
   * nothing to do with memory-mapping a device. The returned <code>BufferedImage</code> has a
   * layout and color model that can be optimally blitted to a device with this <code>
   * GraphicsConfiguration</code>.
   *
   * @param width the width of the returned <code>BufferedImage</code>
   * @param height the height of the returned <code>BufferedImage</code>
   * @param transparency the specified transparency mode
   * @return a <code>BufferedImage</code> whose data layout and color model is compatible with this
   *     <code>GraphicsConfiguration</code> and also supports the specified transparency.
   * @throws IllegalArgumentException if the transparency is not a valid value
   * @see Transparency#OPAQUE
   * @see Transparency#BITMASK
   * @see Transparency#TRANSLUCENT
   */
  public BufferedImage createCompatibleImage(int width, int height, int transparency) {
    if (getColorModel().getTransparency() == transparency) {
      return createCompatibleImage(width, height);
    }

    ColorModel cm = getColorModel(transparency);
    if (cm == null) {
      throw new IllegalArgumentException("Unknown transparency: " + transparency);
    }
    WritableRaster wr = cm.createCompatibleWritableRaster(width, height);
    return new BufferedImage(cm, wr, cm.isAlphaPremultiplied(), null);
  }
Exemplo n.º 28
0
  /**
   * Creates a buffered image from a raster in the color space specified by the given ICC_Profile.
   *
   * @param raster A raster.
   * @param profile An ICC_Profile specifying the color space of the raster.
   * @return a BufferedImage in the color space specified by the profile.
   */
  public static BufferedImage createImageFromICCProfile(Raster raster, ICC_Profile profile) {
    ICC_ColorSpace cs = new ICC_ColorSpace(profile);
    WritableRaster r = (WritableRaster) raster;

    ColorModel cm;
    if (raster.getSampleModel() instanceof PixelInterleavedSampleModel) {
      cm = new ComponentColorModel(cs, false, false, ColorModel.OPAQUE, raster.getTransferType());
    } else {
      cm = new ICCPackedColorModel(cs, raster);
    }
    return new BufferedImage(cm, (WritableRaster) raster, cm.isAlphaPremultiplied(), null);
  }
Exemplo n.º 29
0
  /**
   * Constructs a <code>ChannelDefinitionBox</code> based on the provided <code>ColorModel</code>.
   */
  public ChannelDefinitionBox(ColorModel colorModel) {
    super(computeLength(colorModel), BOX_TYPE, null);

    // creates the buffers for the channel definitions.
    short length = (short) (colorModel.getComponentSize().length - 1);
    num = (short) (length * (colorModel.isAlphaPremultiplied() ? 3 : 2));
    channels = new short[num];
    types = new int[num];
    associations = new short[num];

    // fills the arrays.
    fillBasedOnBands(length, colorModel.isAlphaPremultiplied(), channels, types, associations);
  }
Exemplo n.º 30
0
  public static BufferedImage createImageFromRGB(Raster rgbRaster, ICC_Profile rgbProfile) {
    if (rgbProfile != null) {
      return createImageFromICCProfile(rgbRaster, rgbProfile);
    } else {
      BufferedImage image;
      int w = rgbRaster.getWidth();
      int h = rgbRaster.getHeight();

      try {
        CompletableFuture<int[]> cfR =
            CompletableFuture.supplyAsync(() -> rgbRaster.getSamples(0, 0, w, h, 0, (int[]) null));
        CompletableFuture<int[]> cfG =
            CompletableFuture.supplyAsync(() -> rgbRaster.getSamples(0, 0, w, h, 1, (int[]) null));
        CompletableFuture<int[]> cfB =
            CompletableFuture.supplyAsync(() -> rgbRaster.getSamples(0, 0, w, h, 2, (int[]) null));
        int[] rgb = new int[w * h];
        int[] R = cfR.get();
        int[] G = cfG.get();
        int[] B = cfB.get();

        // Split the rgb array into bands and process each band in parallel.
        // for (int i=0;i<rgb.length;i++) {
        RangeStream.range(0, rgb.length)
            .parallel()
            .forEach(
                (lo, hi) -> {
                  for (int i = lo; i < hi; i++) {
                    rgb[i] = 0xff << 24 | R[i] << 16 | G[i] << 8 | B[i];
                  }
                });

        WritableRaster packedRaster =
            Raster.createPackedRaster(
                new DataBufferInt(rgb, rgb.length),
                w,
                h,
                w,
                new int[] {0xff0000, 0xff00, 0xff, 0xff000000},
                null);
        ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_sRGB);
        ColorModel cm =
            ColorModel
                .getRGBdefault(); // new DirectColorModel(cs, 32, 0xff0000, 0xff00, 0xff,
                                  // 0x0ff000000, false, DataBuffer.TYPE_INT);
        Hashtable<Object, Object> properties = new Hashtable<Object, Object>();
        return new BufferedImage(cm, packedRaster, cm.isAlphaPremultiplied(), properties);
      } catch (ExecutionException | InterruptedException e) {
        throw new InternalError(e);
      }
    }
  }