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

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

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