/*****************************************************************************/
// Copyright 2006-2007 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_render.h#2 $ */
/* $DateTime: 2012/07/31 22:04:34 $ */
/* $Change: 840853 $ */
/* $Author: tknoll $ */
/** \file
* Classes for conversion of RAW data to final image.
*/
/*****************************************************************************/
#ifndef __dng_render__
#define __dng_render__
/*****************************************************************************/
#include "dng_1d_function.h"
#include "dng_auto_ptr.h"
#include "dng_classes.h"
#include "dng_spline.h"
#include "dng_xy_coord.h"
/******************************************************************************/
/// \brief Curve for pre-exposure-compensation adjustment based on noise floor,
/// shadows, and highlight level.
class dng_function_exposure_ramp: public dng_1d_function
{
public:
real64 fSlope; // Slope of straight segment.
real64 fBlack; // Intercept of straight segment.
real64 fRadius; // Rounding radius.
real64 fQScale; // Quadradic scale.
public:
dng_function_exposure_ramp (real64 white,
real64 black,
real64 minBlack);
virtual real64 Evaluate (real64 x) const;
};
/******************************************************************************/
/// \brief Exposure compensation curve for a given compensation amount in stops using
/// quadric for roll-off.
class dng_function_exposure_tone: public dng_1d_function
{
protected:
bool fIsNOP; // Is this a NOP function?
real64 fSlope; // Slope for lower part of curve.
real64 a; // Quadradic parameters for upper two f-stops.
real64 b;
real64 c;
public:
dng_function_exposure_tone (real64 exposure);
/// Returns output value for a given input tone.
virtual real64 Evaluate (real64 x) const;
};
/*****************************************************************************/
/// Default ACR3 tone curve.
class dng_tone_curve_acr3_default: public dng_1d_function
{
public:
/// Returns output value for a given input tone.
virtual real64 Evaluate (real64 x) const;
/// Returns nearest input value for a given output tone.
virtual real64 EvaluateInverse (real64 x) const;
static const dng_1d_function & Get ();
};
/*****************************************************************************/
/// \brief Encoding gamma curve for a given color space.
class dng_function_gamma_encode: public dng_1d_function
{
protected:
const dng_color_space &fSpace;
public:
dng_function_gamma_encode (const dng_color_space &space);
virtual real64 Evaluate (real64 x) const;
};
/*****************************************************************************/
/// \brief Class used to render digital negative to displayable image.
class dng_render
{
protected:
dng_host &fHost;
const dng_negative &fNegative;
dng_xy_coord fWhiteXY;
real64 fExposure;
real64 fShadows;
const dng_1d_function *fToneCurve;
const dng_color_space *fFinalSpace;
uint32 fFinalPixelType;
uint32 fMaximumSize;
private:
AutoPtr<dng_spline_solver> fProfileToneCurve;
public:
/// Construct a rendering instance that will be used to convert a given digital negative.
/// \param host The host to use for memory allocation, progress updates, and abort testing.
/// \param negative The digital negative to convert to a displayable image.
dng_render (dng_host &host,
const dng_negative &negative);
virtual ~dng_render ()
{
}
/// Set the white point to be used for conversion.
/// \param white White point to use.
void SetWhiteXY (const dng_xy_coord &white)
{
fWhiteXY = white;
}
/// Get the white point to be used for conversion.
/// \retval White point to use.
const dng_xy_coord WhiteXY () const
{
return fWhiteXY;
}
/// Set exposure compensation.
/// \param exposure Compensation value in stops, positive or negative.
void SetExposure (real64 exposure)
{
fExposure = exposure;
}
/// Get exposure compensation.
/// \retval Compensation value in stops, positive or negative.
real64 Exposure () const
{
return fExposure;
}
/// Set shadow clip amount.
/// \param shadows Shadow clip amount.
void SetShadows (real64 shadows)
{
fShadows = shadows;
}
/// Get shadow clip amount.
/// \retval Shadow clip amount.
real64 Shadows () const
{
return fShadows;
}
/// Set custom tone curve for conversion.
/// \param curve 1D function that defines tone mapping to use during conversion.
void SetToneCurve (const dng_1d_function &curve)
{
fToneCurve = &curve;
}
/// Get custom tone curve for conversion.
/// \retval 1D function that defines tone mapping to use during conversion.
const dng_1d_function & ToneCurve () const
{
return *fToneCurve;
}
/// Set final color space in which resulting image data should be represented.
/// (See dng_color_space.h for possible values.)
/// \param space Color space to use.
void SetFinalSpace (const dng_color_space &space)
{
fFinalSpace = &space;
}
/// Get final color space in which resulting image data should be represented.
/// \retval Color space to use.
const dng_color_space & FinalSpace () const
{
return *fFinalSpace;
}
/// Set pixel type of final image data.
/// Can be ttByte (default), ttShort, or ttFloat.
/// \param type Pixel type to use.
void SetFinalPixelType (uint32 type)
{
fFinalPixelType = type;
}
/// Get pixel type of final image data.
/// Can be ttByte (default), ttShort, or ttFloat.
/// \retval Pixel type to use.
uint32 FinalPixelType () const
{
return fFinalPixelType;
}
/// Set maximum dimension, in pixels, of resulting image.
/// If final image would have either dimension larger than maximum, the larger
/// of the two dimensions is set to this maximum size and the smaller dimension
/// is adjusted to preserve aspect ratio.
/// \param size Maximum size to allow.
void SetMaximumSize (uint32 size)
{
fMaximumSize = size;
}
/// Get maximum dimension, in pixels, of resulting image.
/// If the final image would have either dimension larger than this maximum, the larger
/// of the two dimensions is set to this maximum size and the smaller dimension
/// is adjusted to preserve the image's aspect ratio.
/// \retval Maximum allowed size.
uint32 MaximumSize () const
{
return fMaximumSize;
}
/// Actually render a digital negative to a displayable image.
/// Input digital negative is passed to the constructor of this dng_render class.
/// \retval The final resulting image.
virtual dng_image * Render ();
private:
// Hidden copy constructor and assignment operator.
dng_render (const dng_render &render);
dng_render & operator= (const dng_render &render);
};
/*****************************************************************************/
#endif
/*****************************************************************************/