Examples of java.awt.image.ColorModel

java.awt.image.ColorModel
The ColorModel abstract class encapsulates the methods for translating a pixel value to color components (for example, red, green, and blue) and an alpha component. In order to render an image to the screen, a printer, or another image, pixel values must be converted to color and alpha components. As arguments to or return values from methods of this class, pixels are represented as 32-bit ints or as arrays of primitive types. The number, order, and interpretation of color components for a ColorModel is specified by its ColorSpace. A ColorModel used with pixel data that does not include alpha information treats all pixels as opaque, which is an alpha value of 1.0.
This ColorModel class supports two representations of pixel values. A pixel value can be a single 32-bit int or an array of primitive types. The Java(tm) Platform 1.0 and 1.1 APIs represented pixels as single byte or single int values. For purposes of the ColorModel class, pixel value arguments were passed as ints. The Java(tm) 2 Platform API introduced additional classes for representing images. With {@link BufferedImage} or {@link RenderedImage}objects, based on {@link Raster} and {@link SampleModel} classes, pixelvalues might not be conveniently representable as a single int. Consequently, ColorModel now has methods that accept pixel values represented as arrays of primitive types. The primitive type used by a particular ColorModel object is called its transfer type.
ColorModel objects used with images for which pixel values are not conveniently representable as a single int throw an {@link IllegalArgumentException} when methods taking a single int pixelargument are called. Subclasses of ColorModel must specify the conditions under which this occurs. This does not occur with {@link DirectColorModel} or {@link IndexColorModel} objects.
Currently, the transfer types supported by the Java 2D(tm) API are DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT, DataBuffer.TYPE_INT, DataBuffer.TYPE_SHORT, DataBuffer.TYPE_FLOAT, and DataBuffer.TYPE_DOUBLE. Most rendering operations will perform much faster when using ColorModels and images based on the first three of these types. In addition, some image filtering operations are not supported for ColorModels and images based on the latter three types. The transfer type for a particular ColorModel object is specified when the object is created, either explicitly or by default. All subclasses of ColorModel must specify what the possible transfer types are and how the number of elements in the primitive arrays representing pixels is determined.
For BufferedImages, the transfer type of its Raster and of the Raster object's SampleModel (available from the getTransferType methods of these classes) must match that of the ColorModel. The number of elements in an array representing a pixel for the Raster and SampleModel (available from the getNumDataElements methods of these classes) must match that of the ColorModel.
The algorithm used to convert from pixel values to color and alpha components varies by subclass. For example, there is not necessarily a one-to-one correspondence between samples obtained from the SampleModel of a BufferedImage object's Raster and color/alpha components. Even when there is such a correspondence, the number of bits in a sample is not necessarily the same as the number of bits in the corresponding color/alpha component. Each subclass must specify how the translation from pixel values to color/alpha components is done.
Methods in the ColorModel class use two different representations of color and alpha components - a normalized form and an unnormalized form. In the normalized form, each component is a float value between some minimum and maximum values. For the alpha component, the minimum is 0.0 and the maximum is 1.0. For color components the minimum and maximum values for each component can be obtained from the ColorSpace object. These values will often be 0.0 and 1.0 (e.g. normalized component values for the default sRGB color space range from 0.0 to 1.0), but some color spaces have component values with different upper and lower limits. These limits can be obtained using the getMinValue and getMaxValue methods of the ColorSpace class. Normalized color component values are not premultiplied. All ColorModels must support the normalized form.
In the unnormalized form, each component is an unsigned integral value between 0 and 2ⁿ - 1, where n is the number of significant bits for a particular component. If pixel values for a particular ColorModel represent color samples premultiplied by the alpha sample, unnormalized color component values are also premultiplied. The unnormalized form is used only with instances of ColorModel whose ColorSpace has minimum component values of 0.0 for all components and maximum values of 1.0 for all components. The unnormalized form for color and alpha components can be a convenient representation for ColorModels whose normalized component values all lie between 0.0 and 1.0. In such cases the integral value 0 maps to 0.0 and the value 2ⁿ - 1 maps to 1.0. In other cases, such as when the normalized component values can be either negative or positive, the unnormalized form is not convenient. Such ColorModel objects throw an {@link IllegalArgumentException} when methods involvingan unnormalized argument are called. Subclasses of ColorModel must specify the conditions under which this occurs. @see IndexColorModel @see ComponentColorModel @see PackedColorModel @see DirectColorModel @see java.awt.Image @see BufferedImage @see RenderedImage @see java.awt.color.ColorSpace @see SampleModel @see Raster @see DataBuffer @version 10 Feb 1997

     *
     * @return a compatible <code>ColorModel</code> or <code>null</code>.
     */
    public static ColorModel getCompatibleColorModel(SampleModel sm,
                                                     Map config) {
        ColorModel cm = null;


        if(config == null ||
           !Boolean.FALSE.equals(
               config.get(JAI.KEY_DEFAULT_COLOR_MODEL_ENABLED))) {

View Full Code Here

  IndexColorModel icm = null;
 
  SampleModel sm = im.getSampleModel();
  int numBands = sm.getNumBands();


  ColorModel cm = im.getColorModel();


  if (numBands != 1 && numBands != 3) {
      throw new 
    IllegalArgumentException(JaiI18N.getString("BMPImageEncoder1"));
  }

View Full Code Here

    private int encode(RenderedImage im, TIFFEncodeParam encodeParam,
                       int ifdOffset, boolean isLast) throws IOException {
        // Cannot store a packed byte image directly so reformat it.
        if(CodecUtils.isPackedByteImage(im)) {
            // Get the source ColorModel.
            ColorModel sourceCM = im.getColorModel();


            // Create an equivalent ComponentColorModel.
            ColorModel destCM =
                RasterFactory.createComponentColorModel(
                    DataBuffer.TYPE_BYTE,
                    sourceCM.getColorSpace(),
                    sourceCM.hasAlpha(),
                    sourceCM.isAlphaPremultiplied(),
                    sourceCM.getTransparency());


            // Create a raster which can contain the entire source.
            Point origin = new Point(im.getMinX(), im.getMinY());
            WritableRaster raster =
                Raster.createWritableRaster(
                    destCM.createCompatibleSampleModel(im.getWidth(),
                                                       im.getHeight()),
                    origin);


            // Copy the source data.
            raster.setRect(im.getData());


            // Replace the source reference with the new image.
            im = new SingleTileRenderedImage(raster, destCM);
        }


  // Currently all images are stored uncompressed.
  int compression = encodeParam.getCompression();


  // Get tiled output preference.
  boolean isTiled = encodeParam.getWriteTiled();


        // Set bounds.
        int minX = im.getMinX();
        int minY = im.getMinY();
        int width = im.getWidth();
        int height = im.getHeight();


        // Get SampleModel.
        SampleModel sampleModel = im.getSampleModel();


        // Retrieve and verify sample size.
  int sampleSize[] = sampleModel.getSampleSize();
        for(int i = 1; i < sampleSize.length; i++) {
            if(sampleSize[i] != sampleSize[0]) {
                throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder0"));
            }
        }


        // Check low bit limits.
  int numBands = sampleModel.getNumBands();
        if((sampleSize[0] == 1 || sampleSize[0] == 4) && numBands != 1) {
            throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder1"));
        }


        // Retrieve and verify data type.
  int dataType = sampleModel.getDataType();
        switch(dataType) {
        case DataBuffer.TYPE_BYTE:
            if(sampleSize[0] != 1 && sampleSize[0] != 4 &&
               sampleSize[0] != 8) {
                throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder2"));
            }
            break;
        case DataBuffer.TYPE_SHORT:
        case DataBuffer.TYPE_USHORT:
            if(sampleSize[0] != 16) {
                throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder3"));
            }
            break;
        case DataBuffer.TYPE_INT:
        case DataBuffer.TYPE_FLOAT:
            if(sampleSize[0] != 32) {
                throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder4"));
            }
            break;
        default:
      throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder5"));
  }


        boolean dataTypeIsShort =
            dataType == DataBuffer.TYPE_SHORT ||
            dataType == DataBuffer.TYPE_USHORT;


  ColorModel colorModel = im.getColorModel();
        if (colorModel != null &&
            colorModel instanceof IndexColorModel &&
            dataType != DataBuffer.TYPE_BYTE) {
            // Don't support (unsigned) short palette-color images.
      throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder6"));
        }
  IndexColorModel icm = null;
  int sizeOfColormap = 0;  
  int colormap[] = null;


        // Set image type.
  int imageType = TIFF_UNSUPPORTED;
        int numExtraSamples = 0;
        int extraSampleType = EXTRA_SAMPLE_UNSPECIFIED;
        if(colorModel instanceof IndexColorModel) { // Bilevel or palette
            icm = (IndexColorModel)colorModel;
            int mapSize = icm.getMapSize();


            if(sampleSize[0] == 1 && numBands == 1) { // Bilevel image


    if (mapSize != 2) {
        throw new IllegalArgumentException(
          JaiI18N.getString("TIFFImageEncoder7"));
    }


    byte r[] = new byte[mapSize];
    icm.getReds(r);
    byte g[] = new byte[mapSize];
    icm.getGreens(g);
    byte b[] = new byte[mapSize];
    icm.getBlues(b);


    if ((r[0] & 0xff) == 0 && 
        (r[1] & 0xff) == 255 && 
        (g[0] & 0xff) == 0 && 
        (g[1] & 0xff) == 255 && 
        (b[0] & 0xff) == 0 && 
        (b[1] & 0xff) == 255) {


        imageType = TIFF_BILEVEL_BLACK_IS_ZERO;


    } else if ((r[0] & 0xff) == 255 && 
         (r[1] & 0xff) == 0 && 
         (g[0] & 0xff) == 255 && 
         (g[1] & 0xff) == 0 && 
         (b[0] & 0xff) == 255 && 
         (b[1] & 0xff) == 0) {
        
        imageType = TIFF_BILEVEL_WHITE_IS_ZERO;


    } else {
        imageType = TIFF_PALETTE;
    }


      } else if(numBands == 1) { // Non-bilevel image.
    // Palette color image.
    imageType = TIFF_PALETTE;
      } 
  } else if(colorModel == null) {


            if(sampleSize[0] == 1 && numBands == 1) { // bilevel
                imageType = TIFF_BILEVEL_BLACK_IS_ZERO;
            } else { // generic image
                imageType = TIFF_GENERIC;
                if(numBands > 1) {
                    numExtraSamples = numBands - 1;
                }
            }


        } else { // colorModel is non-null but not an IndexColorModel
            ColorSpace colorSpace = colorModel.getColorSpace();


            switch(colorSpace.getType()) {
            case ColorSpace.TYPE_CMYK:
                imageType = TIFF_CMYK;
                break;
            case ColorSpace.TYPE_GRAY:
                imageType = TIFF_GRAY;
                break;
            case ColorSpace.TYPE_Lab:
                imageType = TIFF_CIELAB;
                break;
            case ColorSpace.TYPE_RGB:
                if(compression == COMP_JPEG_TTN2 &&
                   encodeParam.getJPEGCompressRGBToYCbCr()) {
                    imageType = TIFF_YCBCR;
                } else {
                    imageType = TIFF_RGB;
                }
                break;
            case ColorSpace.TYPE_YCbCr:
                imageType = TIFF_YCBCR;
                break;
            default:
                imageType = TIFF_GENERIC; // generic
                break;
            }


            if(imageType == TIFF_GENERIC) {
                numExtraSamples = numBands - 1;
            } else if(numBands > 1) {
                numExtraSamples = numBands - colorSpace.getNumComponents();
            }


            if(numExtraSamples == 1 && colorModel.hasAlpha()) {
                extraSampleType = colorModel.isAlphaPremultiplied() ?
                    EXTRA_SAMPLE_ASSOCIATED_ALPHA :
                    EXTRA_SAMPLE_UNASSOCIATED_ALPHA;
            }
        }


        if(imageType == TIFF_UNSUPPORTED) {
            throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder8"));
        }


        // Check JPEG compatibility.
        if(compression == COMP_JPEG_TTN2) {
            if(imageType == TIFF_PALETTE) {
                throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder11"));
            } else if(!(sampleSize[0] == 8 &&
                        (imageType == TIFF_GRAY ||
                         imageType == TIFF_RGB ||
                         imageType == TIFF_YCBCR))) {
                throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder9"));
            }
        }


        // Check bilevel encoding compatibility.
        if((imageType != TIFF_BILEVEL_WHITE_IS_ZERO &&
            imageType != TIFF_BILEVEL_BLACK_IS_ZERO) &&
           (compression == COMP_GROUP3_1D ||
            compression == COMP_GROUP3_2D ||
            compression == COMP_GROUP4)) {
            throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder12"));
        }
  
  int photometricInterpretation = -1;
  switch (imageType) {


  case TIFF_BILEVEL_WHITE_IS_ZERO:
      photometricInterpretation = 0;
      break;


  case TIFF_BILEVEL_BLACK_IS_ZERO:
      photometricInterpretation = 1;
      break;


  case TIFF_GRAY:
        case TIFF_GENERIC:
      // Since the CS_GRAY colorspace is always of type black_is_zero
      photometricInterpretation = 1;
      break;


  case TIFF_PALETTE:
      photometricInterpretation = 3;


      icm = (IndexColorModel)colorModel;
      sizeOfColormap = icm.getMapSize();


      byte r[] = new byte[sizeOfColormap];
      icm.getReds(r);
      byte g[] = new byte[sizeOfColormap];
      icm.getGreens(g);
      byte b[] = new byte[sizeOfColormap];
      icm.getBlues(b);


      int redIndex = 0, greenIndex = sizeOfColormap;
      int blueIndex = 2 * sizeOfColormap;
      colormap = new int[sizeOfColormap * 3];
      for (int i=0; i<sizeOfColormap; i++) {
    colormap[redIndex++] = (r[i] << 8) & 0xffff;
    colormap[greenIndex++] = (g[i] << 8) & 0xffff;
    colormap[blueIndex++] = (b[i] << 8) & 0xffff;
      }


      sizeOfColormap *= 3;


      break;


  case TIFF_RGB:
      photometricInterpretation = 2;
      break;


        case TIFF_CMYK:
      photometricInterpretation = 5;
            break;


        case TIFF_YCBCR:
      photometricInterpretation = 6;
            break;


        case TIFF_CIELAB:
      photometricInterpretation = 8;
            break;


        default:
            throw new RuntimeException(JaiI18N.getString("TIFFImageEncoder8"));
  }


        // Initialize tile dimensions.
        int tileWidth;
        int tileHeight;
        if(isTiled) {
            tileWidth = encodeParam.getTileWidth() > 0 ?
                encodeParam.getTileWidth() : im.getTileWidth();
            tileHeight = encodeParam.getTileHeight() > 0 ?
                encodeParam.getTileHeight() : im.getTileHeight();
        } else {
            tileWidth = width;
            // XXX Set rows per strip based on memory value if not specified?
            tileHeight = encodeParam.getTileHeight() > 0 ?
                encodeParam.getTileHeight() : DEFAULT_ROWS_PER_STRIP;
        }


        // Re-tile for JPEG conformance if needed.
        JPEGEncodeParam jep = null;
        if(compression == COMP_JPEG_TTN2) {
            // Get JPEGEncodeParam from encodeParam.
            jep = encodeParam.getJPEGEncodeParam();


            // Determine maximum subsampling.
            int maxSubH = jep.getHorizontalSubsampling(0);
            int maxSubV = jep.getVerticalSubsampling(0);
            for(int i = 1; i < numBands; i++) {
                int subH = jep.getHorizontalSubsampling(i);
                if(subH > maxSubH) {
                    maxSubH = subH;
                }
                int subV = jep.getVerticalSubsampling(i);
                if(subV > maxSubV) {
                    maxSubV = subV;
                }
            }


            int factorV = 8*maxSubV;
            tileHeight =
                (int)((float)tileHeight/(float)factorV + 0.5F)*factorV;
            if(tileHeight < factorV) {
                tileHeight = factorV;
            }


            if(isTiled) {
                int factorH = 8*maxSubH;
                tileWidth =
                    (int)((float)tileWidth/(float)factorH + 0.5F)*factorH;
                if(tileWidth < factorH) {
                    tileWidth = factorH;
                }
            }
        }


        int numTiles;
        if(isTiled) {
            // NB: Parentheses are used in this statement for correct rounding.
            numTiles =
                ((width + tileWidth - 1)/tileWidth) *
                ((height + tileHeight - 1)/tileHeight);
        } else {
            numTiles = (int)Math.ceil((double)height/(double)tileHeight);
        }


  long tileByteCounts[] = new long[numTiles];


  long bytesPerRow =
            (long)Math.ceil((sampleSize[0] / 8.0) * tileWidth * numBands);


  long bytesPerTile = bytesPerRow * tileHeight;


  for (int i=0; i<numTiles; i++) {
      tileByteCounts[i] = bytesPerTile;
  }


        if(!isTiled) {
            // Last strip may have lesser rows
            long lastStripRows = height - (tileHeight * (numTiles-1));
            tileByteCounts[numTiles-1] = lastStripRows * bytesPerRow;
        }


  long totalBytesOfData = bytesPerTile * (numTiles - 1) + 
      tileByteCounts[numTiles-1];


        // The data will be written after the IFD: create the array here
        // but fill it in later.
  long tileOffsets[] = new long[numTiles];


  // Basic fields - have to be in increasing numerical order.
  // ImageWidth                     256
  // ImageLength                    257
  // BitsPerSample                  258
  // Compression                    259
  // PhotoMetricInterpretation      262
  // StripOffsets                   273
  // RowsPerStrip                   278
  // StripByteCounts                279
  // XResolution                    282
  // YResolution                    283
  // ResolutionUnit                 296  


  // Create Directory
  SortedSet fields = new TreeSet();


  // Image Width
  fields.add(new TIFFField(TIFFImageDecoder.TIFF_IMAGE_WIDTH, 
                                 TIFFField.TIFF_LONG, 1, 
                                 (Object)(new long[] {(long)width})));


  // Image Length
  fields.add(new TIFFField(TIFFImageDecoder.TIFF_IMAGE_LENGTH, 
                                 TIFFField.TIFF_LONG, 1, 
                                 new long[] {(long)height}));


  fields.add(new TIFFField(TIFFImageDecoder.TIFF_BITS_PER_SAMPLE,
                                 TIFFField.TIFF_SHORT, numBands,
                                 intsToChars(sampleSize)));


  fields.add(new TIFFField(TIFFImageDecoder.TIFF_COMPRESSION,
                                 TIFFField.TIFF_SHORT, 1, 
                                 new char[] {(char)compression}));


  fields.add(
      new TIFFField(TIFFImageDecoder.TIFF_PHOTOMETRIC_INTERPRETATION,
                          TIFFField.TIFF_SHORT, 1, 
                          new char[] {(char)photometricInterpretation}));


        if(!isTiled) {
            fields.add(new TIFFField(TIFFImageDecoder.TIFF_STRIP_OFFSETS,
                                     TIFFField.TIFF_LONG, numTiles, 
                                     (long[])tileOffsets));
        }
  
  fields.add(new TIFFField(TIFFImageDecoder.TIFF_SAMPLES_PER_PIXEL,
                                 TIFFField.TIFF_SHORT, 1, 
                                 new char[] {(char)numBands}));


        if(!isTiled) {
            fields.add(new TIFFField(TIFFImageDecoder.TIFF_ROWS_PER_STRIP, 
                                     TIFFField.TIFF_LONG, 1, 
                                     new long[] {(long)tileHeight}));


            fields.add(new TIFFField(TIFFImageDecoder.TIFF_STRIP_BYTE_COUNTS,
                                     TIFFField.TIFF_LONG, numTiles, 
                                     (long[])tileByteCounts));
        }


  if (colormap != null) {
      fields.add(new TIFFField(TIFFImageDecoder.TIFF_COLORMAP,
                                     TIFFField.TIFF_SHORT, sizeOfColormap,
                                     intsToChars(colormap)));
  }


        if(isTiled) {
            fields.add(new TIFFField(TIFFImageDecoder.TIFF_TILE_WIDTH, 
                                     TIFFField.TIFF_LONG, 1, 
                                     new long[] {(long)tileWidth}));


            fields.add(new TIFFField(TIFFImageDecoder.TIFF_TILE_LENGTH, 
                                     TIFFField.TIFF_LONG, 1, 
                                     new long[] {(long)tileHeight}));


            fields.add(new TIFFField(TIFFImageDecoder.TIFF_TILE_OFFSETS,
                                     TIFFField.TIFF_LONG, numTiles, 
                                     (long[])tileOffsets));


            fields.add(new TIFFField(TIFFImageDecoder.TIFF_TILE_BYTE_COUNTS,
                                     TIFFField.TIFF_LONG, numTiles, 
                                     (long[])tileByteCounts));
        }


        if(numExtraSamples > 0) {
            int[] extraSamples = new int[numExtraSamples];
            for(int i = 0; i < numExtraSamples; i++) {
                extraSamples[i] = extraSampleType;
            }
            fields.add(new TIFFField(TIFFImageDecoder.TIFF_EXTRA_SAMPLES,
                                     TIFFField.TIFF_SHORT, numExtraSamples, 
                                     intsToChars(extraSamples)));
        }


        // Data Sample Format Extension fields.
        if(dataType != DataBuffer.TYPE_BYTE) {
            // SampleFormat
            int[] sampleFormat = new int[numBands];
            if(dataType == DataBuffer.TYPE_FLOAT) {
                sampleFormat[0] = 3;
            } else if(dataType == DataBuffer.TYPE_USHORT) {
                sampleFormat[0] = 1;
            } else {
                sampleFormat[0] = 2;
            }
            for(int b = 1; b < numBands; b++) {
                sampleFormat[b] = sampleFormat[0];
            }
      fields.add(new TIFFField(TIFFImageDecoder.TIFF_SAMPLE_FORMAT,
                                     TIFFField.TIFF_SHORT, numBands,
                                     intsToChars(sampleFormat)));


            // NOTE: We don't bother setting the SMinSampleValue and
            // SMaxSampleValue fields as these both default to the
            // extrema of the respective data types.  Probably we should
            // check for the presence of the "extrema" property and
            // use it if available.
        }


        // Bilevel compression variables.
        boolean inverseFill = encodeParam.getReverseFillOrder();
        boolean T4encode2D = encodeParam.getT4Encode2D();
        boolean T4PadEOLs = encodeParam.getT4PadEOLs();
        TIFFFaxEncoder faxEncoder = null;


        // Add bilevel compression fields.
        if((imageType == TIFF_BILEVEL_BLACK_IS_ZERO ||
            imageType == TIFF_BILEVEL_WHITE_IS_ZERO) &&
           (compression == COMP_GROUP3_1D ||
            compression == COMP_GROUP3_2D ||
            compression == COMP_GROUP4)) {


            // Create the encoder.
            faxEncoder = new TIFFFaxEncoder(inverseFill);


            // FillOrder field.
            fields.add(new TIFFField(TIFFImageDecoder.TIFF_FILL_ORDER,
                                     TIFFField.TIFF_SHORT, 1, 
                                     new char[] {inverseFill ?
                                                 (char)2 : (char)1}));


            if(compression == COMP_GROUP3_2D) {
                // T4Options field.
                long T4Options = 0x00000000;
                if(T4encode2D) {
                    T4Options |= 0x00000001;
                }
                if(T4PadEOLs) {
                    T4Options |= 0x00000004;
                }
                fields.add(new TIFFField(TIFFImageDecoder.TIFF_T4_OPTIONS,
                                         TIFFField.TIFF_LONG, 1, 
                                         new long[] {T4Options}));
            } else if(compression == COMP_GROUP4) {
                // T6Options field.
                fields.add(new TIFFField(TIFFImageDecoder.TIFF_T6_OPTIONS,
                                         TIFFField.TIFF_LONG, 1, 
                                         new long[] {(long)0x00000000}));
            }
        }


        // Initialize some JPEG variables.
        com.sun.image.codec.jpeg.JPEGEncodeParam jpegEncodeParam = null;
        com.sun.image.codec.jpeg.JPEGImageEncoder jpegEncoder = null;
        int jpegColorID = 0;


        if(compression == COMP_JPEG_TTN2) {


            // Initialize JPEG color ID.
            jpegColorID =
                com.sun.image.codec.jpeg.JPEGDecodeParam.COLOR_ID_UNKNOWN;
            switch(imageType) {
            case TIFF_GRAY:
            case TIFF_PALETTE:
                jpegColorID =
                    com.sun.image.codec.jpeg.JPEGDecodeParam.COLOR_ID_GRAY;
                break;
            case TIFF_RGB:
                jpegColorID =
                    com.sun.image.codec.jpeg.JPEGDecodeParam.COLOR_ID_RGB;
                break;
            case TIFF_YCBCR:
                jpegColorID =
                    com.sun.image.codec.jpeg.JPEGDecodeParam.COLOR_ID_YCbCr;
                break;
            }


            // Get the JDK encoding parameters.
            Raster tile00 = im.getTile(im.getMinTileX(), im.getMinTileY());
            jpegEncodeParam =
                com.sun.image.codec.jpeg.JPEGCodec.getDefaultJPEGEncodeParam(
                    tile00, jpegColorID);


            // Modify per values passed in.
            JPEGImageEncoder.modifyEncodeParam(jep, jpegEncodeParam, numBands);


            // JPEGTables field.
            if(jep.getWriteImageOnly()) {
                // Write an abbreviated tables-only stream to JPEGTables field.
                jpegEncodeParam.setImageInfoValid(false);
                jpegEncodeParam.setTableInfoValid(true);
                ByteArrayOutputStream tableStream =
                    new ByteArrayOutputStream();
                jpegEncoder =
                    com.sun.image.codec.jpeg.JPEGCodec.createJPEGEncoder(
                        tableStream,
                        jpegEncodeParam);
                jpegEncoder.encode(tile00);
                byte[] tableData = tableStream.toByteArray();
                fields.add(new TIFFField(TIFF_JPEG_TABLES,
                                         TIFFField.TIFF_UNDEFINED,
                                         tableData.length,
                                         tableData));


                // Reset encoder so it's recreated below.
                jpegEncoder = null;
            }
        }


        if(imageType == TIFF_YCBCR) {
            // YCbCrSubSampling: 2 is the default so we must write 1 as
            // we do not (yet) do any subsampling.
            int subsampleH = 1;
            int subsampleV = 1;


            // If JPEG, update values.
            if(compression == COMP_JPEG_TTN2) {
                // Determine maximum subsampling.
                subsampleH = jep.getHorizontalSubsampling(0);
                subsampleV = jep.getVerticalSubsampling(0);
                for(int i = 1; i < numBands; i++) {
                    int subH = jep.getHorizontalSubsampling(i);
                    if(subH > subsampleH) {
                        subsampleH = subH;
                    }
                    int subV = jep.getVerticalSubsampling(i);
                    if(subV > subsampleV) {
                        subsampleV = subV;
                    }
                }
            }


            fields.add(new TIFFField(TIFF_YCBCR_SUBSAMPLING,
                                     TIFFField.TIFF_SHORT, 2, 
                                     new char[] {(char)subsampleH,
                                                 (char)subsampleV}));




            // YCbCr positioning.
            fields.add(new TIFFField(TIFF_YCBCR_POSITIONING,
                                     TIFFField.TIFF_SHORT, 1, 
                                     new char[] {compression == COMP_JPEG_TTN2 ?
                                                 (char)1 : (char)2}));


            // Reference black/white.
            long[][] refbw;
            if(compression == COMP_JPEG_TTN2) {
                refbw =
                    new long[][] { // no headroon/footroom
                        {0, 1}, {255, 1}, {128, 1}, {255, 1}, {128, 1}, {255, 1}
                    };
            } else {
                refbw =
                    new long[][] { // CCIR 601.1 headroom/footroom (presumptive)
                        {15, 1}, {235, 1}, {128, 1}, {240, 1}, {128, 1}, {240, 1}
                    };
            }
            fields.add(new TIFFField(TIFF_REF_BLACK_WHITE,
                                     TIFFField.TIFF_RATIONAL, 6, 
                                     refbw));
        }


        // ---- No more automatically generated fields should be added
        //      after this point. ----


        // Add extra fields specified via the encoding parameters.
        TIFFField[] extraFields = encodeParam.getExtraFields();
        if(extraFields != null) {
            ArrayList extantTags = new ArrayList(fields.size());
            Iterator fieldIter = fields.iterator();
            while(fieldIter.hasNext()) {
                TIFFField fld = (TIFFField)fieldIter.next();
                extantTags.add(new Integer(fld.getTag()));
            }


            int numExtraFields = extraFields.length;
            for(int i = 0; i < numExtraFields; i++) {
                TIFFField fld = extraFields[i];
                Integer tagValue = new Integer(fld.getTag());
                if(!extantTags.contains(tagValue)) {
                    fields.add(fld);
                    extantTags.add(tagValue);
                }
            }
        }


        // ---- No more fields of any type should be added after this. ----


        // Determine the size of the IFD which is written after the header
        // of the stream or after the data of the previous image in a
        // multi-page stream.
        int dirSize = getDirectorySize(fields);


        // The first data segment is written after the field overflow
        // following the IFD so initialize the first offset accordingly.
  tileOffsets[0] = ifdOffset + dirSize;


        // Branch here depending on whether data are being comrpressed.
        // If not, then the IFD is written immediately.
        // If so then there are three possibilities:
        // A) the OutputStream is a SeekableOutputStream (outCache null);
        // B) the OutputStream is not a SeekableOutputStream and a file cache
        //    is used (outCache non-null, tempFile non-null);
        // C) the OutputStream is not a SeekableOutputStream and a memory cache
        //    is used (outCache non-null, tempFile null).


        OutputStream outCache = null;
        byte[] compressBuf = null;
        File tempFile = null;


        int nextIFDOffset = 0;
        boolean skipByte = false;


        Deflater deflater = null;
        int deflateLevel = Deflater.DEFAULT_COMPRESSION;


        boolean jpegRGBToYCbCr = false;


        if(compression == COMP_NONE) {
            // Determine the number of bytes of padding necessary between
            // the end of the IFD and the first data segment such that the
            // alignment of the data conforms to the specification (required
            // for uncompressed data only).
            int numBytesPadding = 0;
            if(sampleSize[0] == 16 && tileOffsets[0] % 2 != 0) {
                numBytesPadding = 1;
                tileOffsets[0]++;
            } else if(sampleSize[0] == 32 && tileOffsets[0] % 4 != 0) {
                numBytesPadding = (int)(4 - tileOffsets[0] % 4);
                tileOffsets[0] += numBytesPadding;
            }


            // Update the data offsets (which TIFFField stores by reference).
            for (int i = 1; i < numTiles; i++) {
                tileOffsets[i] = tileOffsets[i-1] + tileByteCounts[i-1];
            }


            if(!isLast) {
                // Determine the offset of the next IFD.
                nextIFDOffset = (int)(tileOffsets[0] + totalBytesOfData);


                // IFD offsets must be on a word boundary.
                if(nextIFDOffset % 2 != 0) {
                    nextIFDOffset++;
                    skipByte = true;
                }
            }


            // Write the IFD and field overflow before the image data.
            writeDirectory(ifdOffset, fields, nextIFDOffset);


            // Write any padding bytes needed between the end of the IFD
            // and the start of the actual image data.
            if(numBytesPadding != 0) {
                for(int padding = 0; padding < numBytesPadding; padding++) {
                    output.write((byte)0);
                }
            }
        } else {
            // If compressing, the cannot be written yet as the size of the
            // data segments is unknown.


            if((output instanceof SeekableOutputStream)) {
                // Simply seek to the first data segment position.
                ((SeekableOutputStream)output).seek(tileOffsets[0]);
            } else {
                // Cache the original OutputStream.
                outCache = output;


                try {
                    // Attempt to create a temporary file.
                    tempFile = File.createTempFile("jai-SOS-", ".tmp");
                    tempFile.deleteOnExit();
                    RandomAccessFile raFile =
                        new RandomAccessFile(tempFile, "rw");
                    output = new SeekableOutputStream(raFile);
                    // XXX Be sure that this file is deleted no matter how
                    // this method is exited!
                } catch(Exception e) {
                    tempFile = null;
                    // Allocate memory for the entire image data (!).
                    output = new ByteArrayOutputStream((int)totalBytesOfData);
                }
            }


            int bufSize = 0;
            switch(compression) {
            case COMP_GROUP3_1D:
                // This initial buffer size is based on an alternating 1-0
                // pattern generating the most bits when converted to code
                // words: 9 bits out for each pair of bits in. So the number
                // of bit pairs is determined, multiplied by 9, converted to
                // bytes, and a ceil() is taken to account for fill bits at the
                // end of each line.  The "2" addend accounts for the case
                // of the pattern beginning with black.  The buffer is intended
                // to hold only a single row.
                bufSize = (int)Math.ceil((((tileWidth + 1)/2)*9 + 2)/8.0);
                break;
            case COMP_GROUP3_2D:
            case COMP_GROUP4:
                // Calculate the maximum row as the G3-1D size plus the EOL,
                // multiply this by the number of rows in the tile, and add
                // 6 EOLs for the RTC (return to control).
                bufSize = (int)Math.ceil((((tileWidth + 1)/2)*9 + 2)/8.0);
                bufSize = tileHeight*(bufSize + 2) + 12;
                break;
            case COMP_PACKBITS:
                bufSize = (int)(bytesPerTile +
                                ((bytesPerRow+127)/128)*tileHeight);
                break;
            case COMP_JPEG_TTN2:
                bufSize = 0;


                // Set color conversion flag.
                if(imageType == TIFF_YCBCR &&
                   colorModel != null &&
                   colorModel.getColorSpace().getType() ==
                   ColorSpace.TYPE_RGB) {
                    jpegRGBToYCbCr = true;
                }
                break;
            case COMP_DEFLATE:

View Full Code Here

        if (numBands < 1 || numBands > 4) {
            return false;
        }


        // Palette images must be 1-banded, depth 8 or less
        ColorModel colorModel = im.getColorModel();
        if (colorModel instanceof IndexColorModel) {
            if (numBands != 1 || bitDepth > 8) {
                return false;
            }
        }

View Full Code Here

        int minY = im.getMinY();
        int width = im.getWidth();
        int height = im.getHeight();
        int numBands = im.getSampleModel().getNumBands();
        int scansize = width*numBands;
        ColorModel colorModel = im.getColorModel();
        int[] pixels = new int[scansize];


        Rectangle rect = new Rectangle(minX, minY, width, 1);


        for (int i = 0; i < numConsumers; i++) {

View Full Code Here

        int[] aHistory = new int[shadowSize];
        int historyIdx;


        int aSum;


        ColorModel srcColorModel = src.getColorModel();
        WritableRaster srcRaster = src.getRaster();
        int[] dstBuffer = ((DataBufferInt) dst.getRaster().getDataBuffer()).getData();


        int lastPixelOffset = right * dstWidth;
        float hSumDivider = 1.0f / size;
        float vSumDivider = opacity / size;


        // horizontal pass : extract the alpha mask from the source picture and
        // blur it into the destination picture
        for (int srcY = 0, dstOffset = left * dstWidth; srcY < srcHeight; srcY++) {


            // first pixels are empty
            for (historyIdx = 0; historyIdx < shadowSize; ) {
                aHistory[historyIdx++] = 0;
            }


            aSum = 0;
            historyIdx = 0;


            // compute the blur average with pixels from the source image
            for (int srcX = 0; srcX < srcWidth; srcX++) {


                int a = (int) (aSum * hSumDivider); // calculate alpha value
                dstBuffer[dstOffset++] = a << 24;   // store the alpha value only
                                                    // the shadow color will be added in the next pass


                aSum -= aHistory[historyIdx]; // substract the oldest pixel from the sum


                // extract the new pixel ...
                a = srcColorModel.getAlpha(srcRaster.getDataElements(srcX, srcY, null));
                aHistory[historyIdx] = a;   // ... and store its value into history
                aSum += a;                  // ... and add its value to the sum


                if (++historyIdx >= shadowSize) {
                    historyIdx -= shadowSize;

View Full Code Here

        }
        return xform;
    }


    private static RenderedImage systemColorSpaceImage(RenderedImage image) {
        ColorModel colors = image.getColorModel();
        ColorSpace space = colors.getColorSpace();
        if (space != null) {
            if (! space.equals(JAIContext.systemColorSpace)) {
                image = Functions.toColorSpace(
                    image, JAIContext.systemColorSpace, null
                );

View Full Code Here

                                                         sm.getHeight(),
                                                         1);
      il.setSampleModel(sm);


            // Clear the ColorModel mask if needed.
            ColorModel cm = il.getColorModel(null);
            if(cm != null &&
               !JDKWorkarounds.areCompatibleDataModels(sm, cm)) {
                // Clear the mask bit if incompatible.
                il.unsetValid(ImageLayout.COLOR_MODEL_MASK);
            }
        }


        // Set an IndexColorModel on the image if:
        // a. none is provided in the layout;
        // b. source, destination, and colormap have byte data type;
        // c. the colormap has 3 bands.
        if((layout == null || !il.isValid(ImageLayout.COLOR_MODEL_MASK)) &&
           source.getSampleModel().getDataType() == DataBuffer.TYPE_BYTE &&
           sm.getDataType() == DataBuffer.TYPE_BYTE &&
           colormap.getDataType() == DataBuffer.TYPE_BYTE &&
           colormap.getNumBands() == 3) {
            ColorModel cm = source.getColorModel();
            if(cm == null ||
               (cm != null && cm.getColorSpace().isCS_sRGB())) {
                int size = colormap.getNumEntries();
                byte[][] cmap = new byte[3][256];
                for(int i = 0; i < 3; i++) {
                    byte[] band = cmap[i];
                    byte[] data = colormap.getByteData(i);

View Full Code Here

 * </ul>
 */
class FastImageFactory {


    static RenderedImage systemColorSpaceImage(RenderedImage image) {
        ColorModel colors = image.getColorModel();
        ColorSpace space = colors.getColorSpace();
        if (space != null) {
            if (! space.equals(JAIContext.systemColorSpace)) {
                image = Functions.toColorSpace(
                    image, JAIContext.systemColorSpace, null
                );

View Full Code Here

     * the given image will be successfully encoded by the PNG
     * encoder, as it only performs a very superficial analysis of
     * the image structure. 
     */
    public static PNGEncodeParam getDefaultEncodeParam(RenderedImage im) {
        ColorModel colorModel = im.getColorModel();
        if (colorModel instanceof IndexColorModel) {
            return new PNGEncodeParam.Palette();
        }


        SampleModel sampleModel = im.getSampleModel();

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of java.awt.image.ColorModel

BMPSubsamplingTest

com.alibaba.simpleimage.util.ImageColorConvertHelper

com.alibaba.simpleimage.util.IndexImageBuilder

com.alkacon.simapi.CmykJpegReader.ResampleOp

com.alkacon.simapi.Simapi

com.lightcrafts.media.jai.mlib.MediaLibAccessor

com.lightcrafts.media.jai.rmi.ColorModelState

com.lightcrafts.mediax.jai.OpImage

com.scriptographer.ai.Raster

com.sun.imageio.plugins.common.ImageUtil

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.