1 /*****************************************************************************/ 2 // Copyright 2008 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_lens_correction.h#2 $ */ 10 /* $DateTime: 2012/08/02 06:09:06 $ */ 11 /* $Change: 841096 $ */ 12 /* $Author: erichan $ */ 13 14 /** \file 15 * Opcodes to fix lens aberrations such as geometric distortion, lateral chromatic 16 * aberration, and vignetting (peripheral illumination falloff). 17 */ 18 19 /*****************************************************************************/ 20 21 #ifndef __dng_lens_correction__ 22 #define __dng_lens_correction__ 23 24 /*****************************************************************************/ 25 26 #include "dng_1d_function.h" 27 #include "dng_matrix.h" 28 #include "dng_memory.h" 29 #include "dng_opcodes.h" 30 #include "dng_pixel_buffer.h" 31 #include "dng_point.h" 32 #include "dng_resample.h" 33 #include "dng_sdk_limits.h" 34 35 #include <vector> 36 37 /*****************************************************************************/ 38 39 /// \brief Abstract base class holding common warp opcode parameters (e.g., 40 /// number of planes, optical center) and common warp routines. 41 42 class dng_warp_params 43 { 44 45 public: 46 47 // Number of planes to be warped. Must be either 1 or equal to the 48 // number of planes of the image to be processed. If set to 1, then a 49 // single set of warp parameters applies to all planes of the image. 50 // fPlanes must be at least 1 and no greater than kMaxColorPlanes (see 51 // dng_sdk_limits.h). 52 53 uint32 fPlanes; 54 55 // The optical center of the lens in normalized [0,1] coordinates with 56 // respect to the image's active area. For example, a value of (0.5, 57 // 0.5) indicates that the optical center of the lens is at the center 58 // of the image's active area. A normalized radius of 1.0 corresponds to 59 // the distance from fCenter to the farthest corner of the image's 60 // active area. Each component of fCenter must lie in the range [0,1]. 61 62 dng_point_real64 fCenter; 63 64 public: 65 66 /// Create empty (invalid) warp parameters. 67 68 dng_warp_params (); 69 70 /// Create warp parameters with specified number of planes and image 71 /// center. 72 /// 73 /// \param planes The number of planes of parameters specified: It must 74 /// be either 1 or equal to the number of planes of the image to be 75 /// processed. 76 /// 77 /// \param fCenter The image center in relative coordinates. 78 79 dng_warp_params (uint32 planes, 80 const dng_point_real64 &fCenter); 81 82 virtual ~dng_warp_params (); 83 84 /// Is the entire correction a NOP for all planes? 85 86 virtual bool IsNOPAll () const; 87 88 /// Is the entire correction a NOP for the specified plane? 89 90 virtual bool IsNOP (uint32 plane) const; 91 92 /// Is the radial correction a NOP for all planes? 93 94 virtual bool IsRadNOPAll () const; 95 96 /// Is the radial correction a NOP for the specified plane? 97 98 virtual bool IsRadNOP (uint32 plane) const; 99 100 /// Is the tangential correction a NOP for all planes? 101 102 virtual bool IsTanNOPAll () const; 103 104 /// Is the tangential correction a NOP for the specified plane? 105 106 virtual bool IsTanNOP (uint32 plane) const; 107 108 /// Do these warp params appear valid? 109 110 virtual bool IsValid () const; 111 112 /// Are these warp params valid for the specified negative? 113 114 virtual bool IsValidForNegative (const dng_negative &negative) const; 115 116 /// Propagate warp parameters from first plane to all other planes. 117 118 virtual void PropagateToAllPlanes (uint32 totalPlanes) = 0; 119 120 /// Evaluate the 1D radial warp function for the specified plane. 121 /// Parameter r is the destination (i.e., corrected) normalized radius, 122 /// i.e., the normalized Euclidean distance between a corrected pixel 123 /// position and the optical center in the image. r lies in the range 124 /// [0,1]. The returned result is non-negative. 125 126 virtual real64 Evaluate (uint32 plane, 127 real64 r) const = 0; 128 129 /// Compute and return the inverse of Evaluate () above. The base 130 /// implementation uses Newton's method to perform the inversion. 131 /// Parameter r is the source (i.e., uncorrected) normalized radius, 132 /// i.e., normalized Euclidean distance between a corrected pixel 133 /// position and the optical center in the image. Both r and the 134 /// computed result are non-negative. 135 136 virtual real64 EvaluateInverse (uint32 plane, 137 real64 r) const; 138 139 /// Evaluate the 1D radial warp ratio function for the specified plane. 140 /// Parameter r2 is the square of the destination (i.e., corrected) 141 /// normalized radius, i.e., the square of the normalized Euclidean 142 /// distance between a corrected pixel position and the optical center 143 /// in the image. r2 must lie in the range [0,1]. Note that this is 144 /// different than the Evaluate () function, above, in that the argument 145 /// to EvaluateRatio () is the square of the radius, not the radius 146 /// itself. The returned result is non-negative. Mathematically, 147 /// EvaluateRatio (r * r) is the same as Evaluate (r) / r. 148 149 virtual real64 EvaluateRatio (uint32 plane, 150 real64 r2) const = 0; 151 152 /// Evaluate the 2D tangential warp for the specified plane. Parameter 153 /// r2 is the square of the destination (i.e., corrected) normalized 154 /// radius, i.e., the square of the normalized Euclidean distance 155 /// between a corrected pixel position P and the optical center in the 156 /// image. r2 must lie in the range [0,1]. diff contains the vertical 157 /// and horizontal Euclidean distances (in pixels) between P and the 158 /// optical center. diff2 contains the squares of the vertical and 159 /// horizontal Euclidean distances (in pixels) between P and the optical 160 /// center. The returned result is the tangential warp offset, measured 161 /// in pixels. 162 163 virtual dng_point_real64 EvaluateTangential (uint32 plane, 164 real64 r2, 165 const dng_point_real64 &diff, 166 const dng_point_real64 &diff2) const = 0; 167 168 /// Evaluate the 2D tangential warp for the specified plane. diff 169 /// contains the vertical and horizontal Euclidean distances (in pixels) 170 /// between the destination (i.e., corrected) pixel position and the 171 /// optical center in the image. The returned result is the tangential 172 /// warp offset, measured in pixels. 173 174 dng_point_real64 EvaluateTangential2 (uint32 plane, 175 const dng_point_real64 &diff) const; 176 177 /// Evaluate the 2D tangential warp for the specified plane. Parameter 178 /// r2 is the square of the destination (i.e., corrected) normalized 179 /// radius, i.e., the square of the normalized Euclidean distance 180 /// between a corrected pixel position P and the optical center in the 181 /// image. r2 must lie in the range [0,1]. diff contains the vertical 182 /// and horizontal Euclidean distances (in pixels) between P and the 183 /// optical center. The returned result is the tangential warp offset, 184 /// measured in pixels. 185 186 dng_point_real64 EvaluateTangential3 (uint32 plane, 187 real64 r2, 188 const dng_point_real64 &diff) const; 189 190 /// Compute and return the maximum warped radius gap. Let D be a 191 /// rectangle in a destination (corrected) image. Let rDstFar and 192 /// rDstNear be the farthest and nearest points to the image center, 193 /// respectively. Then the specified parameter maxDstGap is the 194 /// Euclidean distance between rDstFar and rDstNear. Warp D through this 195 /// warp function to a closed and bounded (generally not rectangular) 196 /// region S. Let rSrcfar and rSrcNear be the farthest and nearest 197 /// points to the image center, respectively. This routine returns a 198 /// value that is at least (rSrcFar - rSrcNear). 199 200 virtual real64 MaxSrcRadiusGap (real64 maxDstGap) const = 0; 201 202 /// Compute and return the maximum warped tangential gap. minDst is the 203 /// top-left pixel of the image in normalized pixel coordinates. maxDst 204 /// is the bottom-right pixel of the image in normalized pixel 205 /// coordinates. MaxSrcTanGap () computes the maximum absolute shift in 206 /// normalized pixels in the horizontal and vertical directions that can 207 /// occur as a result of the tangential warp. 208 209 virtual dng_point_real64 MaxSrcTanGap (dng_point_real64 minDst, 210 dng_point_real64 maxDst) const = 0; 211 212 /// Debug parameters. 213 214 virtual void Dump () const; 215 216 }; 217 218 /*****************************************************************************/ 219 220 /// \brief Warp parameters for pinhole perspective rectilinear (not fisheye) 221 /// camera model. Supports radial and tangential (decentering) distortion 222 /// correction parameters. 223 /// 224 /// Note the restrictions described below. 225 226 class dng_warp_params_rectilinear: public dng_warp_params 227 { 228 229 public: 230 231 // Radial and tangential polynomial coefficients. These define a warp 232 // from corrected pixel coordinates (xDst, yDst) to uncorrected pixel 233 // coordinates (xSrc, ySrc) for each plane P as follows: 234 // 235 // Let kr0 = fRadParams [P][0] 236 // kr1 = fRadParams [P][1] 237 // kr2 = fRadParams [P][2] 238 // kr3 = fRadParams [P][3] 239 // 240 // kt0 = fTanParams [P][0] 241 // kt1 = fTanParams [P][1] 242 // 243 // Let (xCenter, yCenter) be the optical image center (see fCenter, 244 // below) expressed in pixel coordinates. Let maxDist be the Euclidean 245 // distance (in pixels) from (xCenter, yCenter) to the farthest image 246 // corner. 247 // 248 // First, compute the normalized distance of the corrected pixel 249 // position (xDst, yDst) from the image center: 250 // 251 // dx = (xDst - xCenter) / maxDist 252 // dy = (yDst - yCenter) / maxDist 253 // 254 // r^2 = dx^2 + dy^2 255 // 256 // Compute the radial correction term: 257 // 258 // ratio = kr0 + (kr1 * r^2) + (kr2 * r^4) + (kr3 * r^6) 259 // 260 // dxRad = dx * ratio 261 // dyRad = dy * ratio 262 // 263 // Compute the tangential correction term: 264 // 265 // dxTan = (2 * kt0 * dx * dy) + kt1 * (r^2 + 2 * dx^2) 266 // dyTan = (2 * kt1 * dx * dy) + kt0 * (r^2 + 2 * dy^2) 267 // 268 // Compute the uncorrected pixel position (xSrc, ySrc): 269 // 270 // xSrc = xCenter + (dxRad + dxTan) * maxDist 271 // ySrc = yCenter + (dyRad + dyTan) * maxDist 272 // 273 // Mathematical definitions and restrictions: 274 // 275 // Let { xSrc, ySrc } = f (xDst, yDst) be the warp function defined 276 // above. 277 // 278 // Let xSrc = fx (xDst, yDst) be the x-component of the warp function. 279 // Let ySrc = fy (xDst, yDst) be the y-component of the warp function. 280 // 281 // f (x, y) must be an invertible function. 282 // 283 // fx (x, y) must be an increasing function of x. 284 // fy (x, y) must be an increasing function of x. 285 // 286 // The parameters kr0, kr1, kr2, and kr3 must define an increasing 287 // radial warp function. Specifically, let w (r) be the radial warp 288 // function: 289 // 290 // w (r) = (kr0 * r) + (kr1 * r^3) + (kr2 * r^5) + (kr3 * r^7). 291 // 292 // w (r) must be an increasing function. 293 294 dng_vector fRadParams [kMaxColorPlanes]; 295 dng_vector fTanParams [kMaxColorPlanes]; 296 297 public: 298 299 /// Create empty (invalid) rectilinear warp parameters. 300 301 dng_warp_params_rectilinear (); 302 303 /// Create rectilinear warp parameters with the specified number of 304 /// planes, radial component terms, tangential component terms, and 305 /// image center in relative coordinates. 306 307 dng_warp_params_rectilinear (uint32 planes, 308 const dng_vector radParams [], 309 const dng_vector tanParams [], 310 const dng_point_real64 &fCenter); 311 312 virtual ~dng_warp_params_rectilinear (); 313 314 // Overridden methods. 315 316 virtual bool IsRadNOP (uint32 plane) const; 317 318 virtual bool IsTanNOP (uint32 plane) const; 319 320 virtual bool IsValid () const; 321 322 virtual void PropagateToAllPlanes (uint32 totalPlanes); 323 324 virtual real64 Evaluate (uint32 plane, 325 real64 r) const; 326 327 virtual real64 EvaluateRatio (uint32 plane, 328 real64 r2) const; 329 330 virtual dng_point_real64 EvaluateTangential (uint32 plane, 331 real64 r2, 332 const dng_point_real64 &diff, 333 const dng_point_real64 &diff2) const; 334 335 virtual real64 MaxSrcRadiusGap (real64 maxDstGap) const; 336 337 virtual dng_point_real64 MaxSrcTanGap (dng_point_real64 minDst, 338 dng_point_real64 maxDst) const; 339 340 virtual void Dump () const; 341 342 }; 343 344 /*****************************************************************************/ 345 346 /// \brief Warp parameters for fisheye camera model (radial component only). 347 /// Note the restrictions described below. 348 349 class dng_warp_params_fisheye: public dng_warp_params 350 { 351 352 public: 353 354 // Radial warp coefficients. These define a warp from corrected pixel 355 // coordinates (xDst, yDst) to uncorrected pixel coordinates (xSrc, 356 // ySrc) for each plane P as follows: 357 // 358 // Let kr0 = fRadParams [P][0] 359 // kr1 = fRadParams [P][1] 360 // kr2 = fRadParams [P][2] 361 // kr3 = fRadParams [P][3] 362 // 363 // Let (xCenter, yCenter) be the optical image center (see fCenter, 364 // below) expressed in pixel coordinates. Let maxDist be the Euclidean 365 // distance (in pixels) from (xCenter, yCenter) to the farthest image 366 // corner. 367 // 368 // First, compute the normalized distance of the corrected pixel 369 // position (xDst, yDst) from the image center: 370 // 371 // dx = (xDst - xCenter) / maxDist 372 // dy = (yDst - yCenter) / maxDist 373 // 374 // r = sqrt (dx^2 + dy^2) 375 // 376 // Compute the radial correction term: 377 // 378 // t = atan (r) 379 // 380 // rWarp = (kr0 * t) + (kr1 * t^3) + (kr2 * t^5) + (kr3 * t^7) 381 // 382 // ratio = rWarp / r 383 // 384 // dxRad = dx * ratio 385 // dyRad = dy * ratio 386 // 387 // Compute the uncorrected pixel position (xSrc, ySrc): 388 // 389 // xSrc = xCenter + (dxRad * maxDist) 390 // ySrc = yCenter + (dyRad * maxDist) 391 // 392 // The parameters kr0, kr1, kr2, and kr3 must define an increasing 393 // radial warp function. Specifically, let w (r) be the radial warp 394 // function: 395 // 396 // t = atan (r) 397 // 398 // w (r) = (kr0 * t) + (kr1 * t^3) + (kr2 * t^5) + (kr3 * t^7). 399 // 400 // w (r) must be an increasing function. 401 402 dng_vector fRadParams [kMaxColorPlanes]; 403 404 public: 405 406 /// Create empty (invalid) fisheye warp parameters. 407 408 dng_warp_params_fisheye (); 409 410 /// Create rectilinear warp parameters with the specified number of 411 /// planes, radial component terms, and image center in relative 412 /// coordinates. 413 414 dng_warp_params_fisheye (uint32 planes, 415 const dng_vector radParams [], 416 const dng_point_real64 &fCenter); 417 418 virtual ~dng_warp_params_fisheye (); 419 420 // Overridden methods. 421 422 virtual bool IsRadNOP (uint32 plane) const; 423 424 virtual bool IsTanNOP (uint32 plane) const; 425 426 virtual bool IsValid () const; 427 428 virtual void PropagateToAllPlanes (uint32 totalPlanes); 429 430 virtual real64 Evaluate (uint32 plane, 431 real64 r) const; 432 433 virtual real64 EvaluateRatio (uint32 plane, 434 real64 r2) const; 435 436 virtual dng_point_real64 EvaluateTangential (uint32 plane, 437 real64 r2, 438 const dng_point_real64 &diff, 439 const dng_point_real64 &diff2) const; 440 441 virtual real64 MaxSrcRadiusGap (real64 maxDstGap) const; 442 443 virtual dng_point_real64 MaxSrcTanGap (dng_point_real64 minDst, 444 dng_point_real64 maxDst) const; 445 446 virtual void Dump () const; 447 448 }; 449 450 /*****************************************************************************/ 451 452 /// \brief Warp opcode for pinhole perspective (rectilinear) camera model. 453 454 class dng_opcode_WarpRectilinear: public dng_opcode 455 { 456 457 protected: 458 459 dng_warp_params_rectilinear fWarpParams; 460 461 public: 462 463 dng_opcode_WarpRectilinear (const dng_warp_params_rectilinear ¶ms, 464 uint32 flags); 465 466 explicit dng_opcode_WarpRectilinear (dng_stream &stream); 467 468 // Overridden methods. 469 470 virtual bool IsNOP () const; 471 472 virtual bool IsValidForNegative (const dng_negative &negative) const; 473 474 virtual void PutData (dng_stream &stream) const; 475 476 virtual void Apply (dng_host &host, 477 dng_negative &negative, 478 AutoPtr<dng_image> &image); 479 480 protected: 481 482 static uint32 ParamBytes (uint32 planes); 483 484 }; 485 486 /*****************************************************************************/ 487 488 /// \brief Warp opcode for fisheye camera model. 489 490 class dng_opcode_WarpFisheye: public dng_opcode 491 { 492 493 protected: 494 495 dng_warp_params_fisheye fWarpParams; 496 497 public: 498 499 dng_opcode_WarpFisheye (const dng_warp_params_fisheye ¶ms, 500 uint32 flags); 501 502 explicit dng_opcode_WarpFisheye (dng_stream &stream); 503 504 // Overridden methods. 505 506 virtual bool IsNOP () const; 507 508 virtual bool IsValidForNegative (const dng_negative &negative) const; 509 510 virtual void PutData (dng_stream &stream) const; 511 512 virtual void Apply (dng_host &host, 513 dng_negative &negative, 514 AutoPtr<dng_image> &image); 515 516 protected: 517 518 static uint32 ParamBytes (uint32 planes); 519 520 }; 521 522 /*****************************************************************************/ 523 524 /// \brief Radially-symmetric vignette (peripheral illuminational falloff) 525 /// correction parameters. 526 527 class dng_vignette_radial_params 528 { 529 530 public: 531 532 static const uint32 kNumTerms = 5; 533 534 public: 535 536 // Let v be an uncorrected pixel value of a pixel p in linear space. 537 // 538 // Let r be the Euclidean distance between p and the optical center. 539 // 540 // Compute corrected pixel value v' = v * g, where g is the gain. 541 // 542 // Let k0 = fParams [0] 543 // Let k1 = fParams [1] 544 // Let k2 = fParams [2] 545 // Let k3 = fParams [3] 546 // Let k4 = fParams [4] 547 // 548 // Gain g = 1 + (k0 * r^2) + (k1 * r^4) + (k2 * r^6) + (k3 * r^8) + (k4 * r^10) 549 550 dng_std_vector<real64> fParams; 551 552 dng_point_real64 fCenter; 553 554 public: 555 556 dng_vignette_radial_params (); 557 558 dng_vignette_radial_params (const dng_std_vector<real64> ¶ms, 559 const dng_point_real64 ¢er); 560 561 bool IsNOP () const; 562 563 bool IsValid () const; 564 565 // For debugging. 566 567 void Dump () const; 568 569 }; 570 571 /*****************************************************************************/ 572 573 /// \brief Radially-symmetric lens vignette correction opcode. 574 575 class dng_opcode_FixVignetteRadial: public dng_inplace_opcode 576 { 577 578 protected: 579 580 dng_vignette_radial_params fParams; 581 582 uint32 fImagePlanes; 583 584 int64 fSrcOriginH; 585 int64 fSrcOriginV; 586 587 int64 fSrcStepH; 588 int64 fSrcStepV; 589 590 uint32 fTableInputBits; 591 uint32 fTableOutputBits; 592 593 AutoPtr<dng_memory_block> fGainTable; 594 595 AutoPtr<dng_memory_block> fMaskBuffers [kMaxMPThreads]; 596 597 public: 598 599 dng_opcode_FixVignetteRadial (const dng_vignette_radial_params ¶ms, 600 uint32 flags); 601 602 explicit dng_opcode_FixVignetteRadial (dng_stream &stream); 603 604 virtual bool IsNOP () const; 605 606 virtual bool IsValidForNegative (const dng_negative &) const; 607 608 virtual void PutData (dng_stream &stream) const; 609 610 virtual uint32 BufferPixelType (uint32 /* imagePixelType */) 611 { 612 return ttFloat; 613 } 614 615 virtual void Prepare (dng_negative &negative, 616 uint32 threadCount, 617 const dng_point &tileSize, 618 const dng_rect &imageBounds, 619 uint32 imagePlanes, 620 uint32 bufferPixelType, 621 dng_memory_allocator &allocator); 622 623 virtual void ProcessArea (dng_negative &negative, 624 uint32 threadIndex, 625 dng_pixel_buffer &buffer, 626 const dng_rect &dstArea, 627 const dng_rect &imageBounds); 628 629 protected: 630 631 static uint32 ParamBytes (); 632 633 }; 634 635 /*****************************************************************************/ 636 637 #endif 638 639 /*****************************************************************************/ 640
