+ View the NASA Portal

Search JPL

Search CLARAty

- Algorithms- Infrastructure - Doxygen (public)- Doxygen (private)- Tutorials

- Repository- Nightly Build- Nightly Regression- Feature/Bug Tracking- Build Targets- Procedure- Conventions- Tools

camera_model.cc

Go to the documentation of this file.

// -*-c++-*- 
//---------------------------< /-/ CLARAty /-/ >------------------------------
/** 
 * @file  camera_model.cc
 *
 * This is the pure abstract base class for building camera models.
 *
 * <br>@b Designer(s):  Clay Kunz, Issa A.D. Nesnas
 * <br>@b Author(s):    Clay Kunz
 * <br>@b Date:         December 13, 2001
 *
 * <b>Software License:</b><br>
 * <code>  http://claraty.jpl.nasa.gov/license/open_src/  or
 *         file: license/open_src.txt  </code>
 *
 * &copy; 2006, Jet Propulsion Laboratory, California Institute of Technology<br>
 * &copy; 2006, NASA Ames Research Center
 *
 * $Revision: 1.5 $
 */ 
//-----------------------------------------------------------------------------

#include "claraty/camera_model.h"

#include <fstream>
#include <iostream>

//#include "claraty/frame.h"
//#include "claraty/parse_tree.h"
#include "claraty/fdm_parse_tree.h"
#include "claraty/point.h"
#include "claraty/matrix.h"
#include "claraty/2d_point.h"

using namespace std;

namespace claraty {

//-----------------------------------------------------------------------------

Camera_Model::
Camera_Model()  
  : _mounting_frame ( NULL )
{
}

//-----------------------------------------------------------------------------

Camera_Model::
Camera_Model(Frame * f)
  : _mounting_frame ( f )
{
}

//-----------------------------------------------------------------------------

Camera_Model::
Camera_Model(const Camera_Model& rhs)
  : _mounting_frame ( rhs._mounting_frame),
    _name ( rhs._name )
{
}

//-----------------------------------------------------------------------------

Camera_Model::
~Camera_Model()
{
}

//-----------------------------------------------------------------------------

bool Camera_Model::
operator==(const Camera_Model & rhs) const 
{
  return _mounting_frame == rhs._mounting_frame && _name == rhs._name;
}

//-----------------------------------------------------------------------------

Camera_Model & Camera_Model::
operator=(const Camera_Model & rhs)
{
  if (this != &rhs) {
    _mounting_frame = rhs._mounting_frame;
    _name = rhs._name;
  }
  return *this;
}

//-----------------------------------------------------------------------------
/**
 * Assign frame to the camera model
 *
 * @param[in] f The frame coordinate transformation that defines the mounting
 *              of the camera relative to other coordinate frames
 */
void Camera_Model::
set_frame(Frame * f)
{ 
  _mounting_frame = f; 
}

//-----------------------------------------------------------------------------
/**
 * Most camera models deal with lens distortion by mapping raw images
 * that contain lens distortion to some form of "ideal" images that
 * filter out this distortion.  This function maps coordinates from
 * the raw image to the processed (linearized) image.  For mapping between
 * raw (unrectified) images and their processed (rectified/linearized)
 * versions, subclasses should override this function. Default
 * implementation models no distortion at all.  
 *
 * @param[in] unmapped_coord The (x,y) coordinates of the pixel in the 
 *                           raw unmapped image
 * @return                   The corresponding (x,y) pixel coordinates
 *                           in the mapped processed image.
 */
Pixel_Coord Camera_Model::
get_mapped_coordinates(Pixel_Coord unmapped_coord) const
{ 
  return unmapped_coord;
}

//-----------------------------------------------------------------------------
/**
 * Most camera models deal with lens distortion by mapping raw images
 * that contain lens distortion to some form of "ideal" images that
 * filter out this distortion.  This function maps coordinates from
 * the processed (linearized) image back to the original raw image.
 * For mapping between processed and raw images, subclasses should
 * override this function. Default implementation models no distortion
 * at all.  This function provides the inverse mapping of the above
 * function. Lens distortion models are often difficult to invert, and
 * must be inverted numerically. So typically one of these two
 * functions is going significantly more expensive to call than the
 * other. Map_Op assumes that the previous function is low-cost;
 * subclasses should document complexity of both.
 * 
 * @param[in] mapped_coord The (x,y) coordinates of the pixel in the 
 *                         mapped image.
 * @return The (x,y) pixel coordinates of the original raw (or unrectified)
 *         image.
 */
Pixel_Coord Camera_Model::
get_unmapped_coordinates(Pixel_Coord mapped_coord) const
{ 
  return mapped_coord;
}
//-----------------------------------------------------------------------------
/**
 * Subsample the internal model so that the ray-to-pixel and
 * pixel-to-ray functions work on images subsampled by the same
 * amount. This way image algorithms can work with subsampled images
 * and still have correct camera models to work with.  The
 * subsample_factor is a factor; images are sampled to 1/factor, so a
 * factor of 3 means 1/3 the image height & width.  Default behavior
 * is to print a warning message and return.
*/
void Camera_Model::subsample(int factor)
{
  cerr << AT_FUNCTION << "subsamping not supported in this camera model type" 
       << endl;
}

//-----------------------------------------------------------------------------
/**
 * This function provides a way for the user to correct models and
 * images for lens distortion. Subclasses should do the right thing to
 * ensure that a reasonable new camera model is built and returned in
 * the mapped_model argument.  This should return true if it's
 * possible to build a processed model and mapping op for this model,
 * and false otherwise. Pretty much all subclasses should have a
 * function here that returns true.
 *
 * @param[in] mapped_model     The linearized model.
 * @param[in] map_op           The rectified map.
 * @return    False under all input conditions.
 */
bool Camera_Model::
map_model(Camera_Model & mapped_model,
          Map_Op       & map_op) const 
{
  return false;
}

//-----------------------------------------------------------------------------
/**
 * Serializes a camera model. 
 *
 * @param[in] m A map that holds the content of a serialized camera model
 */
bool Camera_Model::
io(FDM_Map m)
{
  std::string type = get_typename();
  bool ok = m.field("type", type);
  assert(type == get_typename());
  
  const unsigned int latest_version = 1;
  unsigned int this_version = latest_version;

  if (m.is_read() && m.peekfield("camera_model_version", this_version)) {
    ok &= m.field("camera_model_version", this_version);
    assert(this_version <= latest_version);
    ok &= m.field("name", _name);
  }

  if (m.is_write()) {
    ok &= m.field("camera_model_version", this_version);
    ok &= m.field("name", _name);
  }

  //ok &= map.field("frame", *_mounting_frame);

  return ok;
}
//-----------------------------------------------------------------------------

bool io_object(FDM_Map map, auto_ptr<Camera_Model>& model)
{
  bool ok = true;

  if (map.is_read()) {
    // build the underlying pointer via the factory
    std::string type_name;
    ok &= map.peekfield("type", type_name);
    if (type_name == "none") {
      model.reset(NULL);
      return ok;
    }
    model.reset(Camera_Model::build_from_typename(type_name));
    if(model.get()==NULL) {
      cerr << "Unable to construct camera model of type " 
           << type_name << endl;
      return(false);
    }
  }
  if (map.is_write() && model.get() == NULL) {
    std::string type_name= "none";
    ok &= map.field("type", type_name);
    return ok;
  }
  ok &= model->io(map);
  return ok;
}

//-----------------------------------------------------------------------------

Camera_Model * Camera_Model::
build_from_file(const char *filename)
{
  ifstream stream(filename);
  if (!stream) {
    cerr << AT_FUNCTION << " : unable to open file " << filename 
         << " for reading camera model" << endl;
    return NULL;
  }
  return build_from_stream(stream);
}

//-----------------------------------------------------------------------------

Camera_Model * Camera_Model::
build_from_stream(istream& stream)
{
  auto_ptr<Camera_Model> model;

  bool ok = FDM_Parse_Tree::read_object(model, stream);
  if (!ok || model.get()==NULL) return NULL;

  return model.release();
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
/**
 * Align_models is the function that does epipolar alignment with
 * another camera. Two new camera models are produced as the output,
 * as well as two rectify_op objects which can be used to warp images
 * from this camera model and the other camera model into the new
 * ones. Typically this operation would both remove lens distortion
 * ("linearize" the models) and warp the images to make epipolar lines
 * horizontal and at the same y-coordinate ("align" the models).  This
 * function should return true if the alignment can happen, and false
 * otherwise (if for example the camera model types are incompatible).
 */
bool 
align_models(const Camera_Model & model1,
             const Camera_Model & model2,
             Camera_Model * & new_model1, 
             Camera_Model * & new_model2,
             Map_Op & map1,
             Map_Op & map2)
{ 
  return false; 
}
//-----------------------------------------------------------------------------


} // namespace claraty

Last modified: June 05 2007 10:19:53

JPL PRIVACY STATEMENT GLOSSARY SITEMAP FEEDBACK CONTACT US

Site Manager: Issa A.D. Nesnas
Site Maintainer: Kelly Breed
Document Clearance #: CL 07-0635