+ 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

a_camera_model.h

Go to the documentation of this file.

// -*-c++-*- 
//---------------------------< /-/ CLARAty /-/ >------------------------------
/** 
 * @file  a_camera_model.h
 *
 * A stub for a camera model that define concrete functions for the pure
 * virtual methods
 *
 * <br>@b Designer(s):  Issa A.D. Nesnas
 * <br>@b Author(s):    Issa A.D. Nesnas
 * <br>@b Date:         February 26, 2007
 *
 * <b>Software License:</b><br>
 * <code>  http://claraty.jpl.nasa.gov/license/open_src/  or
 *         file: license/open_src.txt  </code>
 *
 * &copy; 2007, Jet Propulsion Laboratory, California Institute of Technology<br>
 *
 * $Revision: 1.3 $
 */ 
//-----------------------------------------------------------------------------

#ifndef A_CAMERA_MODEL_H
#define A_CAMERA_MODEL_H

#include "claraty/camera_model.h"
#include "claraty/point.h"
#include "claraty/2d_point.h"
#include <sstream>
#include "claraty/fdm_parse_tree.h"

namespace claraty {

/**
 * @ingroup vision_data_structure
 */

/**
 * Most basic pin-hole camera model with no lens distortion
 *  
 *                     Map_Op (one-to-one)
 *        Camera_Model 1  -------------->  Camera_Model 2 (mapped)
 *       (unmapped coord)                  (mapped_coord)
 *
 */

class A_Camera_Model : public Camera_Model {

private:
  int _image_width;
  int _image_height;

public:
  // @{ @name Frame constructor/destructor 
  A_Camera_Model() {};
  A_Camera_Model(int width, int height, Frame * frame) 
    : Camera_Model (frame),
      _image_width(width),
      _image_height(height) {}; 
  //@}

  // A_Camera_Model& operator=(const A_Camera_Model& rhs) :;
  Camera_Model *   clone() const  {return new A_Camera_Model(*this); }
  static Camera_Model * build()   {return new A_Camera_Model; }

  int get_image_width()  { return _image_width; }
  int get_image_height() { return _image_height; }

  void ray_to_pixel (const Ray & vector, 
                     Pixel_Coord & pixel_coord) const;
  void pixel_to_ray (const Pixel_Coord & pixel_coord,
                     Ray & vector) const;

  std::string   get_typename () const {return "A_Camera_Model";}

  bool map_model (Camera_Model & mapped_model,
                  Map_Op       & map_op) const {return false;}

  bool io(FDM_Map m);

};

//-----------------------------------------------------------------------------
/**
 * Computes the 2D pixel location in the image from a 3D ray described
 * by the pointing 'vector' with respect to the model's coordinate frame
 */
void A_Camera_Model::
ray_to_pixel(const Ray & ray, 
             Pixel_Coord & pixel_coord) const 
{
  pixel_coord(0) = ray(0) / ray(2);
  pixel_coord(1) = ray(1) / ray(2);

  pixel_coord += 0.01; // Adding DC offset for noise
};

//-----------------------------------------------------------------------------
/**
 * Computes the 3D ray 'vector' (not necessarily a unit vector) with
 * respect to the camera model's reference that passes through the
 * given image pixel
 */
void A_Camera_Model::
pixel_to_ray(const Pixel_Coord & pixel_coord,
             Ray & ray) const
{ 
  float x = pixel_coord(0);
  float y = pixel_coord(1);

  float _fx = 1.0, _fy = 1.0;

  ray(0) = (x - _image_width/2)  / _fx;
  ray(1) = (y - _image_height/2) / _fy;
  ray(2) = 1.0;

  ray.normalize();
};
  
//-----------------------------------------------------------------------------

bool io_object(FDM_Map map, std::auto_ptr<A_Camera_Model>& model);

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

std::istream& operator >> (std::istream& str,       A_Camera_Model & m);
std::ostream& operator << (std::ostream& str, const A_Camera_Model & m);

//-----------------------------------------------------------------------------
/**
 */
inline bool A_Camera_Model::
io(FDM_Map m)
{
  bool ok = Camera_Model::io(m);

  double dummy;

  if (m.is_read()) {
    std::string distString;

    ok &= m.field("distortion", distString);

    std::istringstream dist(distString);

    for (int i = 0; i < 4; i++)
      dist >> dummy;
    return ok;
  }
  ok &= m.field("width",  _image_width);
  ok &= m.field("height", _image_height);
  return ok;
}
//-----------------------------------------------------------------------------
/**
 */
inline
std::ostream& operator<<(std::ostream& os, const A_Camera_Model& model)
{
  FDM_Parse_Tree::write_object(model, os);
  return(os);
} 
//-----------------------------------------------------------------------------
/**
 */
inline 
std::istream& operator>>(std::istream& is, A_Camera_Model& model)
{
  FDM_Parse_Tree::read_object(model, is);
  return(is);
}

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

//DECLARE_BUILDER_INIT(Camera_Model, A_Camera_Model, factory, A_Camera_Model::build);

} // namespace claraty

#endif // CAMERA_MODEL_H

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