Home | History | Annotate | Download | only in source
      1 /*****************************************************************************/
      2 // Copyright 2006-2007 Adobe Systems Incorporated
      3 // All Rights Reserved.
      4 //
      5 // NOTICE:  Adobe permits you to use, modify, and distribute this file in
      6 // accordance with the terms of the Adobe license agreement accompanying it.
      7 /*****************************************************************************/
      8 
      9 /* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_render.h#2 $ */
     10 /* $DateTime: 2012/07/31 22:04:34 $ */
     11 /* $Change: 840853 $ */
     12 /* $Author: tknoll $ */
     13 
     14 /** \file
     15  * Classes for conversion of RAW data to final image.
     16  */
     17 
     18 /*****************************************************************************/
     19 
     20 #ifndef __dng_render__
     21 #define __dng_render__
     22 
     23 /*****************************************************************************/
     24 
     25 #include "dng_1d_function.h"
     26 #include "dng_auto_ptr.h"
     27 #include "dng_classes.h"
     28 #include "dng_spline.h"
     29 #include "dng_xy_coord.h"
     30 
     31 /******************************************************************************/
     32 
     33 /// \brief Curve for pre-exposure-compensation adjustment based on noise floor,
     34 /// shadows, and highlight level.
     35 
     36 class dng_function_exposure_ramp: public dng_1d_function
     37 	{
     38 
     39 	public:
     40 
     41 		real64 fSlope;		// Slope of straight segment.
     42 
     43 		real64 fBlack;		// Intercept of straight segment.
     44 
     45 		real64 fRadius;		// Rounding radius.
     46 
     47 		real64 fQScale;		// Quadradic scale.
     48 
     49 	public:
     50 
     51 		dng_function_exposure_ramp (real64 white,
     52 				   					real64 black,
     53 				   					real64 minBlack);
     54 
     55 		virtual real64 Evaluate (real64 x) const;
     56 
     57 	};
     58 
     59 /******************************************************************************/
     60 
     61 /// \brief Exposure compensation curve for a given compensation amount in stops using
     62 /// quadric for roll-off.
     63 
     64 class dng_function_exposure_tone: public dng_1d_function
     65 	{
     66 
     67 	protected:
     68 
     69 		bool fIsNOP;		// Is this a NOP function?
     70 
     71 		real64 fSlope;		// Slope for lower part of curve.
     72 
     73 		real64 a;			// Quadradic parameters for upper two f-stops.
     74 		real64 b;
     75 		real64 c;
     76 
     77 	public:
     78 
     79 		dng_function_exposure_tone (real64 exposure);
     80 
     81 		/// Returns output value for a given input tone.
     82 
     83 		virtual real64 Evaluate (real64 x) const;
     84 
     85 	};
     86 
     87 /*****************************************************************************/
     88 
     89 /// Default ACR3 tone curve.
     90 
     91 class dng_tone_curve_acr3_default: public dng_1d_function
     92 	{
     93 
     94 	public:
     95 
     96 		/// Returns output value for a given input tone.
     97 
     98 		virtual real64 Evaluate (real64 x) const;
     99 
    100 		/// Returns nearest input value for a given output tone.
    101 
    102 		virtual real64 EvaluateInverse (real64 x) const;
    103 
    104 		static const dng_1d_function & Get ();
    105 
    106 	};
    107 
    108 /*****************************************************************************/
    109 
    110 /// \brief Encoding gamma curve for a given color space.
    111 
    112 class dng_function_gamma_encode: public dng_1d_function
    113 	{
    114 
    115 	protected:
    116 
    117 		const dng_color_space &fSpace;
    118 
    119 	public:
    120 
    121 		dng_function_gamma_encode (const dng_color_space &space);
    122 
    123 		virtual real64 Evaluate (real64 x) const;
    124 
    125 	};
    126 
    127 /*****************************************************************************/
    128 
    129 /// \brief Class used to render digital negative to displayable image.
    130 
    131 class dng_render
    132 	{
    133 
    134 	protected:
    135 
    136 		dng_host &fHost;
    137 
    138 		const dng_negative &fNegative;
    139 
    140 		dng_xy_coord fWhiteXY;
    141 
    142 		real64 fExposure;
    143 
    144 		real64 fShadows;
    145 
    146 		const dng_1d_function *fToneCurve;
    147 
    148 		const dng_color_space *fFinalSpace;
    149 
    150 		uint32 fFinalPixelType;
    151 
    152 		uint32 fMaximumSize;
    153 
    154 	private:
    155 
    156 		AutoPtr<dng_spline_solver> fProfileToneCurve;
    157 
    158 	public:
    159 
    160 		/// Construct a rendering instance that will be used to convert a given digital negative.
    161 		/// \param host The host to use for memory allocation, progress updates, and abort testing.
    162 		/// \param negative The digital negative to convert to a displayable image.
    163 
    164 		dng_render (dng_host &host,
    165 					const dng_negative &negative);
    166 
    167 		virtual ~dng_render ()
    168 			{
    169 			}
    170 
    171 		/// Set the white point to be used for conversion.
    172 		/// \param white White point to use.
    173 
    174 		void SetWhiteXY (const dng_xy_coord &white)
    175 			{
    176 			fWhiteXY = white;
    177 			}
    178 
    179 		/// Get the white point to be used for conversion.
    180 		/// \retval White point to use.
    181 
    182 		const dng_xy_coord WhiteXY () const
    183 			{
    184 			return fWhiteXY;
    185 			}
    186 
    187 		/// Set exposure compensation.
    188 		/// \param exposure Compensation value in stops, positive or negative.
    189 
    190 		void SetExposure (real64 exposure)
    191 			{
    192 			fExposure = exposure;
    193 			}
    194 
    195 		/// Get exposure compensation.
    196 		/// \retval Compensation value in stops, positive or negative.
    197 
    198 		real64 Exposure () const
    199 			{
    200 			return fExposure;
    201 			}
    202 
    203 		/// Set shadow clip amount.
    204 		/// \param shadows Shadow clip amount.
    205 
    206 		void SetShadows (real64 shadows)
    207 			{
    208 			fShadows = shadows;
    209 			}
    210 
    211 		/// Get shadow clip amount.
    212 		/// \retval Shadow clip amount.
    213 
    214 		real64 Shadows () const
    215 			{
    216 			return fShadows;
    217 			}
    218 
    219 		/// Set custom tone curve for conversion.
    220 		/// \param curve 1D function that defines tone mapping to use during conversion.
    221 
    222 		void SetToneCurve (const dng_1d_function &curve)
    223 			{
    224 			fToneCurve = &curve;
    225 			}
    226 
    227 		/// Get custom tone curve for conversion.
    228 		/// \retval 1D function that defines tone mapping to use during conversion.
    229 
    230 		const dng_1d_function & ToneCurve () const
    231 			{
    232 			return *fToneCurve;
    233 			}
    234 
    235 		/// Set final color space in which resulting image data should be represented.
    236 		/// (See dng_color_space.h for possible values.)
    237 		/// \param space Color space to use.
    238 
    239 		void SetFinalSpace (const dng_color_space &space)
    240 			{
    241 			fFinalSpace = &space;
    242 			}
    243 
    244 		/// Get final color space in which resulting image data should be represented.
    245 		/// \retval Color space to use.
    246 
    247 		const dng_color_space & FinalSpace () const
    248 			{
    249 			return *fFinalSpace;
    250 			}
    251 
    252 		/// Set pixel type of final image data.
    253 		/// Can be ttByte (default), ttShort, or ttFloat.
    254 		/// \param type Pixel type to use.
    255 
    256 		void SetFinalPixelType (uint32 type)
    257 			{
    258 			fFinalPixelType = type;
    259 			}
    260 
    261 		/// Get pixel type of final image data.
    262 		/// Can be ttByte (default), ttShort, or ttFloat.
    263 		/// \retval Pixel type to use.
    264 
    265 		uint32 FinalPixelType () const
    266 			{
    267 			return fFinalPixelType;
    268 			}
    269 
    270 		/// Set maximum dimension, in pixels, of resulting image.
    271 		/// If final image would have either dimension larger than maximum, the larger
    272 		/// of the two dimensions is set to this maximum size and the smaller dimension
    273 		/// is adjusted to preserve aspect ratio.
    274 		/// \param size Maximum size to allow.
    275 
    276 		void SetMaximumSize (uint32 size)
    277 			{
    278 			fMaximumSize = size;
    279 			}
    280 
    281 		/// Get maximum dimension, in pixels, of resulting image.
    282 		/// If the final image would have either dimension larger than this maximum, the larger
    283 		/// of the two dimensions is set to this maximum size and the smaller dimension
    284 		/// is adjusted to preserve the image's aspect ratio.
    285 		/// \retval Maximum allowed size.
    286 
    287 		uint32 MaximumSize () const
    288 			{
    289 			return fMaximumSize;
    290 			}
    291 
    292 		/// Actually render a digital negative to a displayable image.
    293 		/// Input digital negative is passed to the constructor of this dng_render class.
    294 		/// \retval The final resulting image.
    295 
    296 		virtual dng_image * Render ();
    297 
    298 	private:
    299 
    300 		// Hidden copy constructor and assignment operator.
    301 
    302 		dng_render (const dng_render &render);
    303 
    304 		dng_render & operator= (const dng_render &render);
    305 
    306 	};
    307 
    308 /*****************************************************************************/
    309 
    310 #endif
    311 
    312 /*****************************************************************************/
    313