/*****************************************************************************/
// Copyright 2006-2008 Adobe Systems Incorporated
// All Rights Reserved.
//
// NOTICE: Adobe permits you to use, modify, and distribute this file in
// accordance with the terms of the Adobe license agreement accompanying it.
/*****************************************************************************/
/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_color_spec.cpp#1 $ */
/* $DateTime: 2012/05/30 13:28:51 $ */
/* $Change: 832332 $ */
/* $Author: tknoll $ */
#include "dng_color_spec.h"
#include "dng_assertions.h"
#include "dng_camera_profile.h"
#include "dng_exceptions.h"
#include "dng_matrix.h"
#include "dng_negative.h"
#include "dng_temperature.h"
#include "dng_utils.h"
#include "dng_xy_coord.h"
/*****************************************************************************/
dng_matrix_3by3 MapWhiteMatrix (const dng_xy_coord &white1,
const dng_xy_coord &white2)
{
// Use the linearized Bradford adaptation matrix.
dng_matrix_3by3 Mb ( 0.8951, 0.2664, -0.1614,
-0.7502, 1.7135, 0.0367,
0.0389, -0.0685, 1.0296);
dng_vector_3 w1 = Mb * XYtoXYZ (white1);
dng_vector_3 w2 = Mb * XYtoXYZ (white2);
// Negative white coordinates are kind of meaningless.
w1 [0] = Max_real64 (w1 [0], 0.0);
w1 [1] = Max_real64 (w1 [1], 0.0);
w1 [2] = Max_real64 (w1 [2], 0.0);
w2 [0] = Max_real64 (w2 [0], 0.0);
w2 [1] = Max_real64 (w2 [1], 0.0);
w2 [2] = Max_real64 (w2 [2], 0.0);
// Limit scaling to something reasonable.
dng_matrix_3by3 A;
A [0] [0] = Pin_real64 (0.1, w1 [0] > 0.0 ? w2 [0] / w1 [0] : 10.0, 10.0);
A [1] [1] = Pin_real64 (0.1, w1 [1] > 0.0 ? w2 [1] / w1 [1] : 10.0, 10.0);
A [2] [2] = Pin_real64 (0.1, w1 [2] > 0.0 ? w2 [2] / w1 [2] : 10.0, 10.0);
dng_matrix_3by3 B = Invert (Mb) * A * Mb;
return B;
}
/******************************************************************************/
dng_color_spec::dng_color_spec (const dng_negative &negative,
const dng_camera_profile *profile)
: fChannels (negative.ColorChannels ())
, fTemperature1 (0.0)
, fTemperature2 (0.0)
, fColorMatrix1 ()
, fColorMatrix2 ()
, fForwardMatrix1 ()
, fForwardMatrix2 ()
, fReductionMatrix1 ()
, fReductionMatrix2 ()
, fCameraCalibration1 ()
, fCameraCalibration2 ()
, fAnalogBalance ()
, fWhiteXY ()
, fCameraWhite ()
, fCameraToPCS ()
, fPCStoCamera ()
{
if (fChannels > 1)
{
if (!profile || !profile->IsValid (fChannels))
{
ThrowBadFormat ();
}
if (profile->WasStubbed ())
{
ThrowProgramError ("Using stubbed profile");
}
fTemperature1 = profile->CalibrationTemperature1 ();
fTemperature2 = profile->CalibrationTemperature2 ();
fColorMatrix1 = profile->ColorMatrix1 ();
fColorMatrix2 = profile->ColorMatrix2 ();
fForwardMatrix1 = profile->ForwardMatrix1 ();
fForwardMatrix2 = profile->ForwardMatrix2 ();
fReductionMatrix1 = profile->ReductionMatrix1 ();
fReductionMatrix2 = profile->ReductionMatrix2 ();
fCameraCalibration1.SetIdentity (fChannels);
fCameraCalibration2.SetIdentity (fChannels);
if (negative. CameraCalibrationSignature () ==
profile->ProfileCalibrationSignature ())
{
if (negative.CameraCalibration1 ().Rows () == fChannels &&
negative.CameraCalibration1 ().Cols () == fChannels)
{
fCameraCalibration1 = negative.CameraCalibration1 ();
}
if (negative.CameraCalibration2 ().Rows () == fChannels &&
negative.CameraCalibration2 ().Cols () == fChannels)
{
fCameraCalibration2 = negative.CameraCalibration2 ();
}
}
fAnalogBalance = dng_matrix (fChannels, fChannels);
for (uint32 j = 0; j < fChannels; j++)
{
fAnalogBalance [j] [j] = negative.AnalogBalance (j);
}
dng_camera_profile::NormalizeForwardMatrix (fForwardMatrix1);
fColorMatrix1 = fAnalogBalance * fCameraCalibration1 * fColorMatrix1;
if (!profile->HasColorMatrix2 () ||
fTemperature1 <= 0.0 ||
fTemperature2 <= 0.0 ||
fTemperature1 == fTemperature2)
{
fTemperature1 = 5000.0;
fTemperature2 = 5000.0;
fColorMatrix2 = fColorMatrix1;
fForwardMatrix2 = fForwardMatrix1;
fReductionMatrix2 = fReductionMatrix1;
fCameraCalibration2 = fCameraCalibration1;
}
else
{
dng_camera_profile::NormalizeForwardMatrix (fForwardMatrix2);
fColorMatrix2 = fAnalogBalance * fCameraCalibration2 * fColorMatrix2;
// Swap values if temperatures are out of order.
if (fTemperature1 > fTemperature2)
{
real64 temp = fTemperature1;
fTemperature1 = fTemperature2;
fTemperature2 = temp;
dng_matrix T = fColorMatrix1;
fColorMatrix1 = fColorMatrix2;
fColorMatrix2 = T;
T = fForwardMatrix1;
fForwardMatrix1 = fForwardMatrix2;
fForwardMatrix2 = T;
T = fReductionMatrix1;
fReductionMatrix1 = fReductionMatrix2;
fReductionMatrix2 = T;
T = fCameraCalibration1;
fCameraCalibration1 = fCameraCalibration2;
fCameraCalibration2 = T;
}
}
}
}
/*****************************************************************************/
dng_matrix dng_color_spec::FindXYZtoCamera (const dng_xy_coord &white,
dng_matrix *forwardMatrix,
dng_matrix *reductionMatrix,
dng_matrix *cameraCalibration)
{
// Convert to temperature/offset space.
dng_temperature td (white);
// Find fraction to weight the first calibration.
real64 g;
if (td.Temperature () <= fTemperature1)
g = 1.0;
else if (td.Temperature () >= fTemperature2)
g = 0.0;
else
{
real64 invT = 1.0 / td.Temperature ();
g = (invT - (1.0 / fTemperature2)) /
((1.0 / fTemperature1) - (1.0 / fTemperature2));
}
// Interpolate the color matrix.
dng_matrix colorMatrix;
if (g >= 1.0)
colorMatrix = fColorMatrix1;
else if (g <= 0.0)
colorMatrix = fColorMatrix2;
else
colorMatrix = (g ) * fColorMatrix1 +
(1.0 - g) * fColorMatrix2;
// Interpolate forward matrix, if any.
if (forwardMatrix)
{
bool has1 = fForwardMatrix1.NotEmpty ();
bool has2 = fForwardMatrix2.NotEmpty ();
if (has1 && has2)
{
if (g >= 1.0)
*forwardMatrix = fForwardMatrix1;
else if (g <= 0.0)
*forwardMatrix = fForwardMatrix2;
else
*forwardMatrix = (g ) * fForwardMatrix1 +
(1.0 - g) * fForwardMatrix2;
}
else if (has1)
{
*forwardMatrix = fForwardMatrix1;
}
else if (has2)
{
*forwardMatrix = fForwardMatrix2;
}
else
{
forwardMatrix->Clear ();
}
}
// Interpolate reduction matrix, if any.
if (reductionMatrix)
{
bool has1 = fReductionMatrix1.NotEmpty ();
bool has2 = fReductionMatrix2.NotEmpty ();
if (has1 && has2)
{
if (g >= 1.0)
*reductionMatrix = fReductionMatrix1;
else if (g <= 0.0)
*reductionMatrix = fReductionMatrix2;
else
*reductionMatrix = (g ) * fReductionMatrix1 +
(1.0 - g) * fReductionMatrix2;
}
else if (has1)
{
*reductionMatrix = fReductionMatrix1;
}
else if (has2)
{
*reductionMatrix = fReductionMatrix2;
}
else
{
reductionMatrix->Clear ();
}
}
// Interpolate camera calibration matrix.
if (cameraCalibration)
{
if (g >= 1.0)
*cameraCalibration = fCameraCalibration1;
else if (g <= 0.0)
*cameraCalibration = fCameraCalibration2;
else
*cameraCalibration = (g ) * fCameraCalibration1 +
(1.0 - g) * fCameraCalibration2;
}
// Return the interpolated color matrix.
return colorMatrix;
}
/*****************************************************************************/
void dng_color_spec::SetWhiteXY (const dng_xy_coord &white)
{
fWhiteXY = white;
// Deal with monochrome cameras.
if (fChannels == 1)
{
fCameraWhite.SetIdentity (1);
fCameraToPCS = PCStoXYZ ().AsColumn ();
return;
}
// Interpolate an matric values for this white point.
dng_matrix colorMatrix;
dng_matrix forwardMatrix;
dng_matrix reductionMatrix;
dng_matrix cameraCalibration;
colorMatrix = FindXYZtoCamera (fWhiteXY,
&forwardMatrix,
&reductionMatrix,
&cameraCalibration);
// Find the camera white values.
fCameraWhite = colorMatrix * XYtoXYZ (fWhiteXY);
real64 cameraWhiteMaxEntry = MaxEntry (fCameraWhite);
if (cameraWhiteMaxEntry == 0)
{
ThrowBadFormat ();
}
real64 whiteScale = 1.0 / cameraWhiteMaxEntry;
for (uint32 j = 0; j < fChannels; j++)
{
// We don't support non-positive values for camera neutral values.
fCameraWhite [j] = Pin_real64 (0.001,
whiteScale * fCameraWhite [j],
1.0);
}
// Find PCS to Camera transform. Scale matrix so PCS white can just be
// reached when the first camera channel saturates
fPCStoCamera = colorMatrix * MapWhiteMatrix (PCStoXY (), fWhiteXY);
real64 scale = MaxEntry (fPCStoCamera * PCStoXYZ ());
if (scale == 0)
{
ThrowBadFormat ();
}
fPCStoCamera = (1.0 / scale) * fPCStoCamera;
// If we have a forward matrix, then just use that.
if (forwardMatrix.NotEmpty ())
{
dng_matrix individualToReference = Invert (fAnalogBalance * cameraCalibration);
dng_vector refCameraWhite = individualToReference * fCameraWhite;
fCameraToPCS = forwardMatrix *
Invert (refCameraWhite.AsDiagonal ()) *
individualToReference;
}
// Else we need to use the adapt in XYZ method.
else
{
// Invert this PCS to camera matrix. Note that if there are more than three
// camera channels, this inversion is non-unique.
fCameraToPCS = Invert (fPCStoCamera, reductionMatrix);
}
}
/*****************************************************************************/
const dng_xy_coord & dng_color_spec::WhiteXY () const
{
DNG_ASSERT (fWhiteXY.IsValid (), "Using invalid WhiteXY");
return fWhiteXY;
}
/*****************************************************************************/
const dng_vector & dng_color_spec::CameraWhite () const
{
DNG_ASSERT (fCameraWhite.NotEmpty (), "Using invalid CameraWhite");
return fCameraWhite;
}
/*****************************************************************************/
const dng_matrix & dng_color_spec::CameraToPCS () const
{
DNG_ASSERT (fCameraToPCS.NotEmpty (), "Using invalid CameraToPCS");
return fCameraToPCS;
}
/*****************************************************************************/
const dng_matrix & dng_color_spec::PCStoCamera () const
{
DNG_ASSERT (fPCStoCamera.NotEmpty (), "Using invalid PCStoCamera");
return fPCStoCamera;
}
/*****************************************************************************/
dng_xy_coord dng_color_spec::NeutralToXY (const dng_vector &neutral)
{
const uint32 kMaxPasses = 30;
if (fChannels == 1)
{
return PCStoXY ();
}
dng_xy_coord last = D50_xy_coord ();
for (uint32 pass = 0; pass < kMaxPasses; pass++)
{
dng_matrix xyzToCamera = FindXYZtoCamera (last);
dng_xy_coord next = XYZtoXY (Invert (xyzToCamera) * neutral);
if (Abs_real64 (next.x - last.x) +
Abs_real64 (next.y - last.y) < 0.0000001)
{
return next;
}
// If we reach the limit without converging, we are most likely
// in a two value oscillation. So take the average of the last
// two estimates and give up.
if (pass == kMaxPasses - 1)
{
next.x = (last.x + next.x) * 0.5;
next.y = (last.y + next.y) * 0.5;
}
last = next;
}
return last;
}
/*****************************************************************************/