source/dng_color_spec.cpp - platform/external/dng_sdk - Git at Google

 /*****************************************************************************/
 // 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;

 	}

 /*****************************************************************************/
	/*****************************************************************************/
	// 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;

	}

	/*****************************************************************************/