awt/org/apache/harmony/awt/gl/color/ColorScaler.java - platform/frameworks/base - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
 /**
  * @author Oleg V. Khaschansky
  * @version $Revision$
  */
 package org.apache.harmony.awt.gl.color;

 import java.awt.color.ColorSpace;
 import java.awt.color.ICC_Profile;
 import java.awt.image.DataBuffer;
 import java.awt.image.Raster;
 import java.awt.image.SampleModel;
 import java.awt.image.WritableRaster;

 /**
  * This class provides functionality for scaling color data when
  * ranges of the source and destination color values differs.
  */
 public class ColorScaler {
     private static final float MAX_SHORT = 0xFFFF;
     private static final float MAX_SIGNED_SHORT = 0x7FFF;

     private static final float MAX_XYZ = 1f + (32767f/32768f);

     // Cached values for scaling color data
     private float[] channelMinValues = null;
     private float[] channelMulipliers = null; // for scale
     private float[] invChannelMulipliers = null; // for unscale

     int nColorChannels = 0;

     // For scaling rasters, false if transfer type is double or float
     boolean isTTypeIntegral = false;

     /**
      * Loads scaling data for raster. Note, if profile pf is null,
      * for non-integral data types multipliers are not initialized.
      * @param r - raster
      * @param pf - profile which helps to determine the ranges of the color data
      */
     public void loadScalingData(Raster r, ICC_Profile pf) {
         boolean isSrcTTypeIntegral =
             r.getTransferType() != DataBuffer.TYPE_FLOAT &&
             r.getTransferType() != DataBuffer.TYPE_DOUBLE;
         if (isSrcTTypeIntegral)
             loadScalingData(r.getSampleModel());
         else if (pf != null)
             loadScalingData(pf);
     }

     /**
      * Use this method only for integral transfer types.
      * Extracts min/max values from the sample model
      * @param sm - sample model
      */
     public void loadScalingData(SampleModel sm) {
         // Supposing integral transfer type
         isTTypeIntegral = true;

         nColorChannels = sm.getNumBands();

         channelMinValues = new float[nColorChannels];
         channelMulipliers = new float[nColorChannels];
         invChannelMulipliers = new float[nColorChannels];

         boolean isSignedShort =
             (sm.getTransferType() == DataBuffer.TYPE_SHORT);

         float maxVal;
         for (int i=0; i<nColorChannels; i++) {
             channelMinValues[i] = 0;
             if (isSignedShort) {
                 channelMulipliers[i] = MAX_SHORT / MAX_SIGNED_SHORT;
                 invChannelMulipliers[i] = MAX_SIGNED_SHORT / MAX_SHORT;
             } else {
                 maxVal = ((1 << sm.getSampleSize(i)) - 1);
                 channelMulipliers[i] = MAX_SHORT / maxVal;
                 invChannelMulipliers[i] = maxVal / MAX_SHORT;
             }
         }
     }

     /**
      * Use this method only for double of float transfer types.
      * Extracts scaling data from the color space signature
      * and other tags, stored in the profile
      * @param pf - ICC profile
      */
     public void loadScalingData(ICC_Profile pf) {
         // Supposing double or float transfer type
         isTTypeIntegral = false;

         nColorChannels = pf.getNumComponents();

         // Get min/max values directly from the profile
         // Very much like fillMinMaxValues in ICC_ColorSpace
         float maxValues[] = new float[nColorChannels];
         float minValues[] = new float[nColorChannels];

         switch (pf.getColorSpaceType()) {
             case ColorSpace.TYPE_XYZ:
                 minValues[0] = 0;
                 minValues[1] = 0;
                 minValues[2] = 0;
                 maxValues[0] = MAX_XYZ;
                 maxValues[1] = MAX_XYZ;
                 maxValues[2] = MAX_XYZ;
                 break;
             case ColorSpace.TYPE_Lab:
                 minValues[0] = 0;
                 minValues[1] = -128;
                 minValues[2] = -128;
                 maxValues[0] = 100;
                 maxValues[1] = 127;
                 maxValues[2] = 127;
                 break;
             default:
                 for (int i=0; i<nColorChannels; i++) {
                     minValues[i] = 0;
                     maxValues[i] = 1;
                 }
         }

         channelMinValues = minValues;
         channelMulipliers = new float[nColorChannels];
         invChannelMulipliers = new float[nColorChannels];

         for (int i = 0; i < nColorChannels; i++) {
             channelMulipliers[i] =
                 MAX_SHORT / (maxValues[i] - channelMinValues[i]);

             invChannelMulipliers[i] =
                 (maxValues[i] - channelMinValues[i]) / MAX_SHORT;
         }
     }

     /**
      * Extracts scaling data from the color space
      * @param cs - color space
      */
     public void loadScalingData(ColorSpace cs) {
         nColorChannels = cs.getNumComponents();

         channelMinValues = new float[nColorChannels];
         channelMulipliers = new float[nColorChannels];
         invChannelMulipliers = new float[nColorChannels];

         for (int i = 0; i < nColorChannels; i++) {
             channelMinValues[i] = cs.getMinValue(i);

             channelMulipliers[i] =
                 MAX_SHORT / (cs.getMaxValue(i) - channelMinValues[i]);

             invChannelMulipliers[i] =
                 (cs.getMaxValue(i) - channelMinValues[i]) / MAX_SHORT;
         }
     }

     /**
      * Scales and normalizes the whole raster and returns the result
      * in the float array
      * @param r - source raster
      * @return scaled and normalized raster data
      */
     public float[][] scaleNormalize(Raster r) {
         int width = r.getWidth();
         int height = r.getHeight();
         float result[][] = new float[width*height][nColorChannels];
         float normMultipliers[] = new float[nColorChannels];

         int pos = 0;
         if (isTTypeIntegral) {
             // Change max value from MAX_SHORT to 1f
             for (int i=0; i<nColorChannels; i++) {
                 normMultipliers[i] = channelMulipliers[i] / MAX_SHORT;
             }

             int sample;
             for (int row=r.getMinX(); row<width; row++) {
                 for (int col=r.getMinY(); col<height; col++) {
                     for (int chan = 0; chan < nColorChannels; chan++) {
                         sample = r.getSample(row, col, chan);
                         result[pos][chan] = (sample * normMultipliers[chan]);
                     }
                     pos++;
                 }
             }
         } else { // Just get the samples...
             for (int row=r.getMinX(); row<width; row++) {
                 for (int col=r.getMinY(); col<height; col++) {
                     for (int chan = 0; chan < nColorChannels; chan++) {
                         result[pos][chan] = r.getSampleFloat(row, col, chan);
                     }
                     pos++;
                 }
             }
         }
         return result;
     }

     /**
      * Unscale the whole float array and put the result
      * in the raster
      * @param r - destination raster
      * @param data - input pixels
      */
     public void unscaleNormalized(WritableRaster r, float data[][]) {
         int width = r.getWidth();
         int height = r.getHeight();
         float normMultipliers[] = new float[nColorChannels];

         int pos = 0;
         if (isTTypeIntegral) {
             // Change max value from MAX_SHORT to 1f
             for (int i=0; i<nColorChannels; i++) {
                 normMultipliers[i] = invChannelMulipliers[i] * MAX_SHORT;
             }

             int sample;
             for (int row=r.getMinX(); row<width; row++) {
                 for (int col=r.getMinY(); col<height; col++) {
                     for (int chan = 0; chan < nColorChannels; chan++) {
                         sample = (int) (data[pos][chan] * normMultipliers[chan] + 0.5f);
                         r.setSample(row, col, chan, sample);
                     }
                     pos++;
                 }
             }
         } else { // Just set the samples...
             for (int row=r.getMinX(); row<width; row++) {
                 for (int col=r.getMinY(); col<height; col++) {
                     for (int chan = 0; chan < nColorChannels; chan++) {
                         r.setSample(row, col, chan, data[pos][chan]);
                     }
                     pos++;
                 }
             }
         }
     }

     /**
      * Scales the whole raster to short and returns the result
      * in the array
      * @param r - source raster
      * @return scaled and normalized raster data
      */
     public short[] scale(Raster r) {
         int width = r.getWidth();
         int height = r.getHeight();
         short result[] = new short[width*height*nColorChannels];

         int pos = 0;
         if (isTTypeIntegral) {
             int sample;
             for (int row=r.getMinX(); row<width; row++) {
                 for (int col=r.getMinY(); col<height; col++) {
                     for (int chan = 0; chan < nColorChannels; chan++) {
                         sample = r.getSample(row, col, chan);
                         result[pos++] =
                             (short) (sample * channelMulipliers[chan] + 0.5f);
                     }
                 }
             }
         } else {
             float sample;
             for (int row=r.getMinX(); row<width; row++) {
                 for (int col=r.getMinY(); col<height; col++) {
                     for (int chan = 0; chan < nColorChannels; chan++) {
                         sample = r.getSampleFloat(row, col, chan);
                         result[pos++] = (short) ((sample - channelMinValues[chan])
                             * channelMulipliers[chan] + 0.5f);
                     }
                 }
             }
         }
         return result;
     }

     /**
      * Unscales the whole data array and puts obtained values to the raster
      * @param data - input data
      * @param wr - destination raster
      */
     public void unscale(short[] data, WritableRaster wr) {
         int width = wr.getWidth();
         int height = wr.getHeight();

         int pos = 0;
         if (isTTypeIntegral) {
             int sample;
             for (int row=wr.getMinX(); row<width; row++) {
                 for (int col=wr.getMinY(); col<height; col++) {
                     for (int chan = 0; chan < nColorChannels; chan++) {
                          sample = (int) ((data[pos++] & 0xFFFF) *
                                 invChannelMulipliers[chan] + 0.5f);
                          wr.setSample(row, col, chan, sample);
                     }
                 }
             }
         } else {
             float sample;
             for (int row=wr.getMinX(); row<width; row++) {
                 for (int col=wr.getMinY(); col<height; col++) {
                     for (int chan = 0; chan < nColorChannels; chan++) {
                          sample = (data[pos++] & 0xFFFF) *
                             invChannelMulipliers[chan] + channelMinValues[chan];
                          wr.setSample(row, col, chan, sample);
                     }
                 }
             }
         }
     }

     /**
      * Scales one pixel and puts obtained values to the chanData
      * @param pixelData - input pixel
      * @param chanData - output buffer
      * @param chanDataOffset - output buffer offset
      */
     public void scale(float[] pixelData, short[] chanData, int chanDataOffset) {
         for (int chan = 0; chan < nColorChannels; chan++) {
             chanData[chanDataOffset + chan] =
                     (short) ((pixelData[chan] - channelMinValues[chan]) *
                         channelMulipliers[chan] + 0.5f);
         }
     }

     /**
      * Unscales one pixel and puts obtained values to the pixelData
      * @param pixelData - output pixel
      * @param chanData - input buffer
      * @param chanDataOffset - input buffer offset
      */
     public void unscale(float[] pixelData, short[] chanData, int chanDataOffset) {
         for (int chan = 0; chan < nColorChannels; chan++) {
             pixelData[chan] = (chanData[chanDataOffset + chan] & 0xFFFF)
                 * invChannelMulipliers[chan] + channelMinValues[chan];
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	/**
	* @author Oleg V. Khaschansky
	* @version $Revision$
	*/
	package org.apache.harmony.awt.gl.color;

	import java.awt.color.ColorSpace;
	import java.awt.color.ICC_Profile;
	import java.awt.image.DataBuffer;
	import java.awt.image.Raster;
	import java.awt.image.SampleModel;
	import java.awt.image.WritableRaster;

	/**
	* This class provides functionality for scaling color data when
	* ranges of the source and destination color values differs.
	*/
	public class ColorScaler {
	private static final float MAX_SHORT = 0xFFFF;
	private static final float MAX_SIGNED_SHORT = 0x7FFF;

	private static final float MAX_XYZ = 1f + (32767f/32768f);

	// Cached values for scaling color data
	private float[] channelMinValues = null;
	private float[] channelMulipliers = null; // for scale
	private float[] invChannelMulipliers = null; // for unscale

	int nColorChannels = 0;

	// For scaling rasters, false if transfer type is double or float
	boolean isTTypeIntegral = false;

	/**
	* Loads scaling data for raster. Note, if profile pf is null,
	* for non-integral data types multipliers are not initialized.
	* @param r - raster
	* @param pf - profile which helps to determine the ranges of the color data
	*/
	public void loadScalingData(Raster r, ICC_Profile pf) {
	boolean isSrcTTypeIntegral =
	r.getTransferType() != DataBuffer.TYPE_FLOAT &&
	r.getTransferType() != DataBuffer.TYPE_DOUBLE;
	if (isSrcTTypeIntegral)
	loadScalingData(r.getSampleModel());
	else if (pf != null)
	loadScalingData(pf);
	}

	/**
	* Use this method only for integral transfer types.
	* Extracts min/max values from the sample model
	* @param sm - sample model
	*/
	public void loadScalingData(SampleModel sm) {
	// Supposing integral transfer type
	isTTypeIntegral = true;

	nColorChannels = sm.getNumBands();

	channelMinValues = new float[nColorChannels];
	channelMulipliers = new float[nColorChannels];
	invChannelMulipliers = new float[nColorChannels];

	boolean isSignedShort =
	(sm.getTransferType() == DataBuffer.TYPE_SHORT);

	float maxVal;
	for (int i=0; i<nColorChannels; i++) {
	channelMinValues[i] = 0;
	if (isSignedShort) {
	channelMulipliers[i] = MAX_SHORT / MAX_SIGNED_SHORT;
	invChannelMulipliers[i] = MAX_SIGNED_SHORT / MAX_SHORT;
	} else {
	maxVal = ((1 << sm.getSampleSize(i)) - 1);
	channelMulipliers[i] = MAX_SHORT / maxVal;
	invChannelMulipliers[i] = maxVal / MAX_SHORT;
	}
	}
	}

	/**
	* Use this method only for double of float transfer types.
	* Extracts scaling data from the color space signature
	* and other tags, stored in the profile
	* @param pf - ICC profile
	*/
	public void loadScalingData(ICC_Profile pf) {
	// Supposing double or float transfer type
	isTTypeIntegral = false;

	nColorChannels = pf.getNumComponents();

	// Get min/max values directly from the profile
	// Very much like fillMinMaxValues in ICC_ColorSpace
	float maxValues[] = new float[nColorChannels];
	float minValues[] = new float[nColorChannels];

	switch (pf.getColorSpaceType()) {
	case ColorSpace.TYPE_XYZ:
	minValues[0] = 0;
	minValues[1] = 0;
	minValues[2] = 0;
	maxValues[0] = MAX_XYZ;
	maxValues[1] = MAX_XYZ;
	maxValues[2] = MAX_XYZ;
	break;
	case ColorSpace.TYPE_Lab:
	minValues[0] = 0;
	minValues[1] = -128;
	minValues[2] = -128;
	maxValues[0] = 100;
	maxValues[1] = 127;
	maxValues[2] = 127;
	break;
	default:
	for (int i=0; i<nColorChannels; i++) {
	minValues[i] = 0;
	maxValues[i] = 1;
	}
	}

	channelMinValues = minValues;
	channelMulipliers = new float[nColorChannels];
	invChannelMulipliers = new float[nColorChannels];

	for (int i = 0; i < nColorChannels; i++) {
	channelMulipliers[i] =
	MAX_SHORT / (maxValues[i] - channelMinValues[i]);

	invChannelMulipliers[i] =
	(maxValues[i] - channelMinValues[i]) / MAX_SHORT;
	}
	}

	/**
	* Extracts scaling data from the color space
	* @param cs - color space
	*/
	public void loadScalingData(ColorSpace cs) {
	nColorChannels = cs.getNumComponents();

	channelMinValues = new float[nColorChannels];
	channelMulipliers = new float[nColorChannels];
	invChannelMulipliers = new float[nColorChannels];

	for (int i = 0; i < nColorChannels; i++) {
	channelMinValues[i] = cs.getMinValue(i);

	channelMulipliers[i] =
	MAX_SHORT / (cs.getMaxValue(i) - channelMinValues[i]);

	invChannelMulipliers[i] =
	(cs.getMaxValue(i) - channelMinValues[i]) / MAX_SHORT;
	}
	}

	/**
	* Scales and normalizes the whole raster and returns the result
	* in the float array
	* @param r - source raster
	* @return scaled and normalized raster data
	*/
	public float[][] scaleNormalize(Raster r) {
	int width = r.getWidth();
	int height = r.getHeight();
	float result[][] = new float[width*height][nColorChannels];
	float normMultipliers[] = new float[nColorChannels];

	int pos = 0;
	if (isTTypeIntegral) {
	// Change max value from MAX_SHORT to 1f
	for (int i=0; i<nColorChannels; i++) {
	normMultipliers[i] = channelMulipliers[i] / MAX_SHORT;
	}

	int sample;
	for (int row=r.getMinX(); row<width; row++) {
	for (int col=r.getMinY(); col<height; col++) {
	for (int chan = 0; chan < nColorChannels; chan++) {
	sample = r.getSample(row, col, chan);
	result[pos][chan] = (sample * normMultipliers[chan]);
	}
	pos++;
	}
	}
	} else { // Just get the samples...
	for (int row=r.getMinX(); row<width; row++) {
	for (int col=r.getMinY(); col<height; col++) {
	for (int chan = 0; chan < nColorChannels; chan++) {
	result[pos][chan] = r.getSampleFloat(row, col, chan);
	}
	pos++;
	}
	}
	}
	return result;
	}

	/**
	* Unscale the whole float array and put the result
	* in the raster
	* @param r - destination raster
	* @param data - input pixels
	*/
	public void unscaleNormalized(WritableRaster r, float data[][]) {
	int width = r.getWidth();
	int height = r.getHeight();
	float normMultipliers[] = new float[nColorChannels];

	int pos = 0;
	if (isTTypeIntegral) {
	// Change max value from MAX_SHORT to 1f
	for (int i=0; i<nColorChannels; i++) {
	normMultipliers[i] = invChannelMulipliers[i] * MAX_SHORT;
	}

	int sample;
	for (int row=r.getMinX(); row<width; row++) {
	for (int col=r.getMinY(); col<height; col++) {
	for (int chan = 0; chan < nColorChannels; chan++) {
	sample = (int) (data[pos][chan] * normMultipliers[chan] + 0.5f);
	r.setSample(row, col, chan, sample);
	}
	pos++;
	}
	}
	} else { // Just set the samples...
	for (int row=r.getMinX(); row<width; row++) {
	for (int col=r.getMinY(); col<height; col++) {
	for (int chan = 0; chan < nColorChannels; chan++) {
	r.setSample(row, col, chan, data[pos][chan]);
	}
	pos++;
	}
	}
	}
	}

	/**
	* Scales the whole raster to short and returns the result
	* in the array
	* @param r - source raster
	* @return scaled and normalized raster data
	*/
	public short[] scale(Raster r) {
	int width = r.getWidth();
	int height = r.getHeight();
	short result[] = new short[widthheightnColorChannels];

	int pos = 0;
	if (isTTypeIntegral) {
	int sample;
	for (int row=r.getMinX(); row<width; row++) {
	for (int col=r.getMinY(); col<height; col++) {
	for (int chan = 0; chan < nColorChannels; chan++) {
	sample = r.getSample(row, col, chan);
	result[pos++] =
	(short) (sample * channelMulipliers[chan] + 0.5f);
	}
	}
	}
	} else {
	float sample;
	for (int row=r.getMinX(); row<width; row++) {
	for (int col=r.getMinY(); col<height; col++) {
	for (int chan = 0; chan < nColorChannels; chan++) {
	sample = r.getSampleFloat(row, col, chan);
	result[pos++] = (short) ((sample - channelMinValues[chan])
	* channelMulipliers[chan] + 0.5f);
	}
	}
	}
	}
	return result;
	}

	/**
	* Unscales the whole data array and puts obtained values to the raster
	* @param data - input data
	* @param wr - destination raster
	*/
	public void unscale(short[] data, WritableRaster wr) {
	int width = wr.getWidth();
	int height = wr.getHeight();

	int pos = 0;
	if (isTTypeIntegral) {
	int sample;
	for (int row=wr.getMinX(); row<width; row++) {
	for (int col=wr.getMinY(); col<height; col++) {
	for (int chan = 0; chan < nColorChannels; chan++) {
	sample = (int) ((data[pos++] & 0xFFFF) *
	invChannelMulipliers[chan] + 0.5f);
	wr.setSample(row, col, chan, sample);
	}
	}
	}
	} else {
	float sample;
	for (int row=wr.getMinX(); row<width; row++) {
	for (int col=wr.getMinY(); col<height; col++) {
	for (int chan = 0; chan < nColorChannels; chan++) {
	sample = (data[pos++] & 0xFFFF) *
	invChannelMulipliers[chan] + channelMinValues[chan];
	wr.setSample(row, col, chan, sample);
	}
	}
	}
	}
	}

	/**
	* Scales one pixel and puts obtained values to the chanData
	* @param pixelData - input pixel
	* @param chanData - output buffer
	* @param chanDataOffset - output buffer offset
	*/
	public void scale(float[] pixelData, short[] chanData, int chanDataOffset) {
	for (int chan = 0; chan < nColorChannels; chan++) {
	chanData[chanDataOffset + chan] =
	(short) ((pixelData[chan] - channelMinValues[chan]) *
	channelMulipliers[chan] + 0.5f);
	}
	}

	/**
	* Unscales one pixel and puts obtained values to the pixelData
	* @param pixelData - output pixel
	* @param chanData - input buffer
	* @param chanDataOffset - input buffer offset
	*/
	public void unscale(float[] pixelData, short[] chanData, int chanDataOffset) {
	for (int chan = 0; chan < nColorChannels; chan++) {
	pixelData[chan] = (chanData[chanDataOffset + chan] & 0xFFFF)
	* invChannelMulipliers[chan] + channelMinValues[chan];
	}
	}
	}