LoHighDistortionMap.cpp

Go to the documentation of this file.

#include "LoHighDistortionMap.h"
#include "IString.h"

using namespace std;

namespace Isis {
  LoHighDistortionMap::LoHighDistortionMap(Camera *parent) :
    CameraDistortionMap(parent, -1) {
  }


  void LoHighDistortionMap::SetDistortion(const int naifIkCode) {
    // Get the perspective correction factors for x and y and the distortion
    // center (point of symmetry of distortion)
    QString perskey = "INS" + toString(naifIkCode) + "_PERSPECTIVE_FACTORS";
    QString centkey = "INS" + toString(naifIkCode) + "_POINT_OF_SYMMETRY";
    p_xPerspective = p_camera->Spice::getDouble(perskey, 0);
    p_yPerspective = p_camera->Spice::getDouble(perskey, 1);
    p_x0 = p_camera->Spice::getDouble(centkey, 0);
    p_y0 = p_camera->Spice::getDouble(centkey, 1);

    // Get the distortion coefficients
    CameraDistortionMap::SetDistortion(naifIkCode);
  }


  bool LoHighDistortionMap::SetFocalPlane(const double dx,
                                          const double dy) {
    p_focalPlaneX = dx;
    p_focalPlaneY = dy;

    // Apply perspective correction factors to get perspective corrected x/y
    double perspectiveFactor = 1. + (p_xPerspective * dx) + (p_yPerspective * dy);
    double pcx = dx * perspectiveFactor;
    double pcy = dy * perspectiveFactor;

    // Translate the perspective-corrected x/y coordinate to be relative to the
    // distortion point of symmetry
    double distx  =  pcx - p_x0;
    double disty  =  pcy - p_y0;

    // Get the distance from the focal plane center and if we are close
    // skip the distortion
    double r2 = distx * distx + disty * disty;
    if(r2 <= 1.0E-6) {
      p_undistortedFocalPlaneX = pcx;
      p_undistortedFocalPlaneY = pcy;
      return true;
    }

    // Otherwise remove distortion
    double drOverR  =  p_odk[0] + p_odk[1] * r2;
    p_undistortedFocalPlaneX = pcx - (drOverR * distx);
    p_undistortedFocalPlaneY = pcy - (drOverR * disty);
    return true;
  }


  bool LoHighDistortionMap::SetUndistortedFocalPlane(const double ux,
      const double uy) {

    p_undistortedFocalPlaneX = ux;
    p_undistortedFocalPlaneY = uy;

    // Translate the distorted x/y coordinate to be relative to the
    // distortion point of symmetry
    double distux  =  p_undistortedFocalPlaneX - p_x0;
    double distuy  =  p_undistortedFocalPlaneY - p_y0;

    // Compute the distance from the focal plane center and if we are
    // close to the center then no distortion is required
    double rp2 = distux * distux + distuy * distuy;

    double pcx, pcy;

    if(rp2 > 1.0E-6) {

      // Add distortion.  First compute fractional distortion at rp (r-prime)
      double drOverR   =   p_odk[0]  +  rp2 * p_odk[1];

      // Compute the perspective corrected x/y
      pcx  =  p_undistortedFocalPlaneX + (distux * drOverR);
      pcy  =  p_undistortedFocalPlaneY + (distuy * drOverR);
    }
    else {
      pcx = p_undistortedFocalPlaneX;
      pcy = p_undistortedFocalPlaneY;
    }

    // Add the perspective error
    double perspectiveCorrection = 1. - (p_xPerspective * pcx) - (p_yPerspective * pcy);
    p_focalPlaneX = pcx * perspectiveCorrection;
    p_focalPlaneY = pcy * perspectiveCorrection;
    return true;
  }
}