Subversion Repositories openrisc

/* ColorLookUpTable.java -- ICC v2 CLUT
   Copyright (C) 2004 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */
 
package gnu.java.awt.color;
 
import java.awt.color.ColorSpace;
import java.awt.color.ICC_Profile;
import java.nio.ByteBuffer;
 
 
/**
 * ColorLookUpTable handles color lookups through a color lookup table,
 * as defined in the ICC specification.
 * Both 'mft2' and 'mft1' (8 and 16-bit) type CLUTs are handled.
 *
 * This will have to be updated later for ICC 4.0.0
 *
 * @author Sven de Marothy
 */
public class ColorLookUpTable
{
  /**
   * CIE 1931 D50 white point (in Lab coordinates)
   */
  private static float[] D50 = { 0.96422f, 1.00f, 0.82521f };
 
  /**
   * Number of input/output channels
   */
  int nIn;
 
  /**
   * Number of input/output channels
   */
  int nOut;
  int nInTableEntries; // Number of input table entries
  int nOutTableEntries; // Number of output table entries
  int gridpoints; // Number of gridpoints
  int nClut; // This is nOut*(gridpoints**nIn)
  double[][] inTable; // 1D input table ([channel][table])
  short[][] outTable; // 1D input table ([channel][table])
  double[] clut; // The color lookup table
  float[][] inMatrix; // input matrix (XYZ only)
  boolean useMatrix; // Whether to use the matrix or not.
  int[] multiplier;
  int[] offsets; // Hypercube offsets
  boolean inputLab; // Set if the CLUT input CS is Lab
  boolean outputLab; // Set if the CLUT output CS is Lab
 
  /**
   * Constructor
   * Requires a profile file to get the CLUT from and the tag of the
   * CLUT to create. (icSigXToYZTag where X,Y = [A | B], Z = [0,1,2])
   */
  public ColorLookUpTable(ICC_Profile profile, int tag)
  {
    useMatrix = false;
 
    switch (tag)
      {
      case ICC_Profile.icSigAToB0Tag:
      case ICC_Profile.icSigAToB1Tag:
      case ICC_Profile.icSigAToB2Tag:
        if (profile.getColorSpaceType() == ColorSpace.TYPE_XYZ)
          useMatrix = true;
        inputLab = false;
        outputLab = (profile.getPCSType() == ColorSpace.TYPE_Lab);
        break;
      case ICC_Profile.icSigBToA0Tag:
      case ICC_Profile.icSigBToA1Tag:
      case ICC_Profile.icSigBToA2Tag:
        if (profile.getPCSType() == ColorSpace.TYPE_XYZ)
          useMatrix = true;
        inputLab = (profile.getPCSType() == ColorSpace.TYPE_Lab);
        outputLab = false;
        break;
      default:
        throw new IllegalArgumentException("Not a clut-type tag.");
      }
 
    byte[] data = profile.getData(tag);
    if (data == null)
      throw new IllegalArgumentException("Unsuitable profile, does not contain a CLUT.");
 
    // check 'mft'
    if (data[0] != 0x6d || data[1] != 0x66 || data[2] != 0x74)
      throw new IllegalArgumentException("Unsuitable profile, invalid CLUT data.");
 
    if (data[3] == 0x32)
      readClut16(data);
    else if (data[3] == 0x31)
      readClut8(data);
    else
      throw new IllegalArgumentException("Unknown/invalid CLUT type.");
  }
 
  /**
   * Loads a 16-bit CLUT into our data structures
   */
  private void readClut16(byte[] data)
  {
    ByteBuffer buf = ByteBuffer.wrap(data);
 
    nIn = data[8] & (0xFF);
    nOut = data[9] & (0xFF);
    nInTableEntries = buf.getShort(48);
    nOutTableEntries = buf.getShort(50);
    gridpoints = data[10] & (0xFF);
 
    inMatrix = new float[3][3];
    for (int i = 0; i < 3; i++)
      for (int j = 0; j < 3; j++)
        inMatrix[i][j] = ((float) (buf.getInt(12 + (i * 3 + j) * 4))) / 65536.0f;
 
    inTable = new double[nIn][nInTableEntries];
    for (int channel = 0; channel < nIn; channel++)
      for (int i = 0; i < nInTableEntries; i++)
        inTable[channel][i] = (double) ((int) buf.getShort(52
                                                           + (channel * nInTableEntries
                                                           + i) * 2)
                              & (0xFFFF)) / 65536.0;
 
    nClut = nOut;
    multiplier = new int[nIn];
    multiplier[nIn - 1] = nOut;
    for (int i = 0; i < nIn; i++)
      {
        nClut *= gridpoints;
        if (i > 0)
          multiplier[nIn - i - 1] = multiplier[nIn - i] * gridpoints;
      }
 
    int clutOffset = 52 + nIn * nInTableEntries * 2;
    clut = new double[nClut];
    for (int i = 0; i < nClut; i++)
      clut[i] = (double) ((int) buf.getShort(clutOffset + i * 2) & (0xFFFF)) / 65536.0;
 
    outTable = new short[nOut][nOutTableEntries];
    for (int channel = 0; channel < nOut; channel++)
      for (int i = 0; i < nOutTableEntries; i++)
        outTable[channel][i] = buf.getShort(clutOffset
                                            + (nClut
                                            + channel * nOutTableEntries + i) * 2);
 
    // calculate the hypercube corner offsets
    offsets = new int[(1 << nIn)];
    offsets[0] = 0;
    for (int j = 0; j < nIn; j++)
      {
        int factor = 1 << j;
        for (int i = 0; i < factor; i++)
          offsets[factor + i] = offsets[i] + multiplier[j];
      }
  }
 
  /**
   * Loads a 8-bit CLUT into our data structures.
   */
  private void readClut8(byte[] data)
  {
    ByteBuffer buf = ByteBuffer.wrap(data);
 
    nIn = (data[8] & (0xFF));
    nOut = (data[9] & (0xFF));
    nInTableEntries = 256; // always 256
    nOutTableEntries = 256; // always 256
    gridpoints = (data[10] & (0xFF));
 
    inMatrix = new float[3][3];
    for (int i = 0; i < 3; i++)
      for (int j = 0; j < 3; j++)
        inMatrix[i][j] = ((float) (buf.getInt(12 + (i * 3 + j) * 4))) / 65536.0f;
 
    inTable = new double[nIn][nInTableEntries];
    for (int channel = 0; channel < nIn; channel++)
      for (int i = 0; i < nInTableEntries; i++)
        inTable[channel][i] = (double) ((int) buf.get(48
                                                      + (channel * nInTableEntries
                                                      + i)) & (0xFF)) / 255.0;
 
    nClut = nOut;
    multiplier = new int[nIn];
    multiplier[nIn - 1] = nOut;
    for (int i = 0; i < nIn; i++)
      {
        nClut *= gridpoints;
        if (i > 0)
          multiplier[nIn - i - 1] = multiplier[nIn - i] * gridpoints;
      }
 
    int clutOffset = 48 + nIn * nInTableEntries;
    clut = new double[nClut];
    for (int i = 0; i < nClut; i++)
      clut[i] = (double) ((int) buf.get(clutOffset + i) & (0xFF)) / 255.0;
 
    outTable = new short[nOut][nOutTableEntries];
    for (int channel = 0; channel < nOut; channel++)
      for (int i = 0; i < nOutTableEntries; i++)
        outTable[channel][i] = (short) (buf.get(clutOffset + nClut
                                                + channel * nOutTableEntries
                                                + i) * 257);
 
    // calculate the hypercube corner offsets
    offsets = new int[(1 << nIn)];
    offsets[0] = 0;
    for (int j = 0; j < nIn; j++)
      {
        int factor = 1 << j;
        for (int i = 0; i < factor; i++)
          offsets[factor + i] = offsets[i] + multiplier[j];
      }
  }
 
  /**
   * Performs a lookup through the Color LookUp Table.
   * If the CLUT tag type is AtoB the conversion will be from the device
   * color space to the PCS, BtoA type goes in the opposite direction.
   *
   * For convenience, the PCS values for input or output will always be
   * CIE XYZ (D50), if the actual PCS is Lab, the values will be converted.
   *
   * N-dimensional linear interpolation is used.
   */
  float[] lookup(float[] in)
  {
    float[] in2 = new float[in.length];
    if (useMatrix)
      {
        for (int i = 0; i < 3; i++)
          in2[i] = in[0] * inMatrix[i][0] + in[1] * inMatrix[i][1]
                   + in[2] * inMatrix[i][2];
      }
    else if (inputLab)
      in2 = XYZtoLab(in);
    else
      System.arraycopy(in, 0, in2, 0, in.length);
 
    // input table
    for (int i = 0; i < nIn; i++)
      {
        int index = (int) Math.floor(in2[i] * (double) (nInTableEntries - 1)); // floor in
 
        // clip values.
        if (index >= nInTableEntries - 1)
          in2[i] = (float) inTable[i][nInTableEntries - 1];
        else if (index < 0)
          in2[i] = (float) inTable[i][0];
        else
          {
            // linear interpolation
            double alpha = in2[i] * ((double) nInTableEntries - 1.0) - index;
            in2[i] = (float) (inTable[i][index] * (1 - alpha)
                     + inTable[i][index + 1] * alpha);
          }
      }
 
    // CLUT lookup
    double[] output2 = new double[nOut];
    double[] weights = new double[(1 << nIn)];
    double[] clutalpha = new double[nIn]; // interpolation values
    int offset = 0; // = gp
    for (int i = 0; i < nIn; i++)
      {
        int index = (int) Math.floor(in2[i] * ((double) gridpoints - 1.0));
        double alpha = in2[i] * ((double) gridpoints - 1.0) - (double) index;
 
        // clip values.
        if (index >= gridpoints - 1)
          {
            index = gridpoints - 1;
            alpha = 1.0;
          }
        else if (index < 0)
          index = 0;
        clutalpha[i] = alpha;
        offset += index * multiplier[i];
      }
 
    // Calculate interpolation weights
    weights[0] = 1.0;
    for (int j = 0; j < nIn; j++)
      {
        int factor = 1 << j;
        for (int i = 0; i < factor; i++)
          {
            weights[factor + i] = weights[i] * clutalpha[j];
            weights[i] *= (1.0 - clutalpha[j]);
          }
      }
 
    for (int i = 0; i < nOut; i++)
      output2[i] = weights[0] * clut[offset + i];
 
    for (int i = 1; i < (1 << nIn); i++)
      {
        int offset2 = offset + offsets[i];
        for (int f = 0; f < nOut; f++)
          output2[f] += weights[i] * clut[offset2 + f];
      }
 
    // output table
    float[] output = new float[nOut];
    for (int i = 0; i < nOut; i++)
      {
        int index = (int) Math.floor(output2[i] * ((double) nOutTableEntries
                                     - 1.0));
 
        // clip values.
        if (index >= nOutTableEntries - 1)
          output[i] = outTable[i][nOutTableEntries - 1];
        else if (index < 0)
          output[i] = outTable[i][0];
        else
          {
            // linear interpolation
            double a = output2[i] * ((double) nOutTableEntries - 1.0)
                       - (double) index;
            output[i] = (float) ((double) ((int) outTable[i][index] & (0xFFFF)) * (1
                        - a)
                        + (double) ((int) outTable[i][index + 1] & (0xFFFF)) * a) / 65536f;
          }
      }
 
    if (outputLab)
      return LabtoXYZ(output);
    return output;
  }
 
  /**
   * Converts CIE Lab coordinates to (D50) XYZ ones.
   */
  private float[] LabtoXYZ(float[] in)
  {
    // Convert from byte-packed format to a
    // more convenient one (actual Lab values)
    // (See ICC spec for details)
    // factor is 100 * 65536 / 65280
    in[0] = (float) (100.392156862745 * in[0]);
    in[1] = (in[1] * 256.0f) - 128.0f;
    in[2] = (in[2] * 256.0f) - 128.0f;
 
    float[] out = new float[3];
 
    out[1] = (in[0] + 16.0f) / 116.0f;
    out[0] = in[1] / 500.0f + out[1];
    out[2] = out[1] - in[2] / 200.0f;
 
    for (int i = 0; i < 3; i++)
      {
        double exp = out[i] * out[i] * out[i];
        if (exp <= 0.008856)
          out[i] = (out[i] - 16.0f / 116.0f) / 7.787f;
        else
          out[i] = (float) exp;
        out[i] = D50[i] * out[i];
      }
    return out;
  }
 
  /**
   * Converts CIE XYZ coordinates to Lab ones.
   */
  private float[] XYZtoLab(float[] in)
  {
    float[] temp = new float[3];
 
    for (int i = 0; i < 3; i++)
      {
        temp[i] = in[i] / D50[i];
 
        if (temp[i] <= 0.008856f)
          temp[i] = (7.7870689f * temp[i]) + (16f / 116.0f);
        else
          temp[i] = (float) Math.exp((1.0 / 3.0) * Math.log(temp[i]));
      }
 
    float[] out = new float[3];
    out[0] = (116.0f * temp[1]) - 16f;
    out[1] = 500.0f * (temp[0] - temp[1]);
    out[2] = 200.0f * (temp[1] - temp[2]);
 
    // Normalize to packed format
    out[0] = (float) (out[0] / 100.392156862745);
    out[1] = (out[1] + 128f) / 256f;
    out[2] = (out[2] + 128f) / 256f;
    for (int i = 0; i < 3; i++)
      {
        if (out[i] < 0f)
          out[i] = 0f;
        if (out[i] > 1f)
          out[i] = 1f;
      }
    return out;
  }
}