/*
* $Id: CalRGBColor.java,v 1.2 2007-12-20 18:33:34 rbair Exp $
*
* Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
* Santa Clara, California 95054, U.S.A. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
package com.sun.pdfview.colorspace;
import java.awt.color.ColorSpace;
import java.io.IOException;
import com.sun.pdfview.PDFObject;
import com.sun.pdfview.function.FunctionType0;
/**
* A ColorSpace for calibrated RGB
* @author Mike Wessler
*/
public class CalRGBColor extends ColorSpace {
private static final float[] vonKriesM = { 0.40024f, -0.22630f, 0.00000f,
0.70760f, 1.16532f, 0.00000f,
-0.08081f, 0.04570f, 0.91822f };
private static final float[] vonKriesMinv = { 1.859936f, 0.361191f, 0.000000f,
-1.129382f, 0.638812f, 0.000000f,
0.219897f, -0.000006f, 1.089064f };
private static final float[] xyzToSRGB = { 3.24071f, -0.969258f, 0.0556352f,
-1.53726f, 1.87599f, -0.203996f,
-0.498571f, 0.0415557f, 1.05707f };
private static final float[] xyzToRGB = { 2.04148f, -0.969258f, 0.0134455f,
-0.564977f, 1.87599f, -0.118373f,
-0.344713f, 0.0415557f, 1.01527f };
float[] scale;
float[] max;
float white[]= {1f, 1f, 1f};
float black[]= {0, 0, 0};
float matrix[]= {1f, 0, 0, 0, 1f, 0, 0, 0, 1f};
float gamma[]= {1f, 1f, 1f};
static ColorSpace rgbCS= ColorSpace.getInstance(ColorSpace.CS_sRGB);
static ColorSpace cieCS= ColorSpace.getInstance(ColorSpace.CS_CIEXYZ);
/**
* Create a new Calibrated RGB color space object, given the
* description in a PDF dictionary.
* @param obj a dictionary that contains an array of 3 Numbers
* for "WhitePoint" and "BlackPoint", a Number for "Gamma", and
* an array of 9 Numbers for "Matrix".
*/
public CalRGBColor(PDFObject obj) throws IOException {
// obj is a dictionary that has the following parts:
// WhitePoint [a b c]
// BlackPoint [a b c]
// Gamma a
super(CS_sRGB, 3);
// find out what what is according to the CIE color space
// note that this is not reflexive (i.e. passing this value
// into toRGB does not get you (1.0, 1.0, 1.0) back)
// cieWhite = cieCS.fromRGB(new float[] { 1.0f, 1.0f, 1.0f } );
PDFObject ary= obj.getDictRef("WhitePoint");
if (ary!=null) {
for(int i=0; i<3; i++) {
white[i]= ary.getAt(i).getFloatValue();
}
}
ary= obj.getDictRef("BlackPoint");
if (ary!=null) {
for(int i=0; i<3; i++) {
black[i]= ary.getAt(i).getFloatValue();
}
}
ary= obj.getDictRef("Gamma");
if (ary!=null) {
for (int i=0; i<3; i++) {
gamma[i]= ary.getAt(i).getFloatValue();
}
}
ary= obj.getDictRef("Matrix");
if (ary!=null) {
for (int i=0; i<9; i++) {
matrix[i]= ary.getAt(i).getFloatValue();
}
}
// create a scale matrix relative to the 50 CIE color space.
// see http://www.brucelindbloom.com/Eqn_RGB_XYZ_Matrix.html
// we use the Von Kries cone response domain
float[] cieWhite = rgbCS.toCIEXYZ(new float[] { 1f, 1f, 1f });
float[] sourceWhite = matrixMult(white, vonKriesM, 3);
float[] destWhite = matrixMult(cieWhite, vonKriesM, 3);
scale = new float[] { destWhite[0] / sourceWhite[0], 0, 0,
0, destWhite[1] / sourceWhite[1], 0,
0, 0, destWhite[2] / sourceWhite[2] };
scale = matrixMult(vonKriesM, scale, 3);
scale = matrixMult(scale, vonKriesMinv, 3);
max = matrixMult(white, scale, 3);
max = ciexyzToSRGB(max);
}
/**
* get the number of components (3)
*/
@Override public int getNumComponents() {
return 3;
}
/**
* convert from Calibrated RGB to standard RGB
* @param comp the Calibrated RGB values (0-1)
* @return the RGB values (0-1)
*/
public float[] toRGB(float comp[]) {
if (comp.length==3) {
// compute r', g' and b' by raising the given values to the
// correct gamma
float a = (float)Math.pow(comp[0], gamma[0]);
float b = (float)Math.pow(comp[1], gamma[1]);
float c = (float)Math.pow(comp[2], gamma[2]);
// now multiply by the matrix to get X, Y and Z values
float[] xyz = new float[] {
matrix[0]*a + matrix[3]*b + matrix[6]*c,
matrix[1]*a + matrix[4]*b + matrix[7]*c,
matrix[2]*a + matrix[5]*b + matrix[8]*c};
// now scale the xyz values
xyz = matrixMult(xyz, scale, 3);
// convert to RGB
float[] rgb = ciexyzToSRGB(xyz);
// cheat -- scale based on max
for (int i = 0; i < rgb.length; i++) {
rgb[i] = FunctionType0.interpolate(rgb[i], 0, max[i], 0, 1);
// sometimes we get off a little bit due to precision loss
if (rgb[i] > 1.0) {
rgb[i] = 1.0f;
}
}
return rgb;
} else {
return black;
}
}
/**
* Convert from CIEXYZ, with scale and gamma calculated to sRGB
*/
private float[] ciexyzToSRGB(float[] xyz) {
float[] rgb = matrixMult(xyz, xyzToSRGB, 3);
for (int i = 0; i < rgb.length; i++) {
if (rgb[i] < 0.0) {
rgb[i] = 0f;
} else if (rgb[i] > 1.0) {
rgb[i] = 1f;
}
if (rgb[i] < 0.003928) {
rgb[i] *= 12.92;
} else {
rgb[i] = (float) ((Math.pow(rgb[i], 1.0 / 2.4) * 1.055) - 0.055);
}
}
//float[] rgb = cieCS.toRGB(xyz);
return rgb;
}
/**
* convert from RGB to Calibrated RGB. NOT IMPLEMENTED
*/
public float[] fromRGB(float[] rgbvalue) {
return new float[3];
}
/**
* convert from CIEXYZ to Calibrated RGB. NOT IMPLEMENTED
*/
public float[] fromCIEXYZ(float[] colorvalue) {
return new float[3];
}
/**
* get the type of this color space (TYPE_RGB)
*/
@Override public int getType() {
return TYPE_RGB;
}
/**
* convert from Calibrated RGB to CIEXYZ. NOT IMPLEMENTED
*/
public float[] toCIEXYZ(float[] colorvalue) {
return new float[3];
}
/**
* Slowly multiply two matrices
*
* @param a the first matrix
* @param b the second matrix
* @param len the size of each row. All matrix lengths must be a
* multiple of len.
*/
float[] matrixMult(float[] a, float[] b, int len) {
int rows = a.length / len;
int cols = b.length / len;
float[] out = new float[rows * cols];
for (int i = 0; i < rows; i++) {
for (int k = 0; k < cols; k++) {
for (int j = 0; j < len; j++) {
out[(i * cols) + k] += a[(i * len) + j] * b[(j * cols) + k];
}
}
}
return out;
}
}