+ 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_image.ipp

Go to the documentation of this file.

// -*-c++-*- 
//---------------------------< /-/ CLARAty /-/ >------------------------------
/** 
 * @file  camera_image.ipp
 *
 * Implementation of template functions for Camera_Image class
 *
 * <br>@b Designer(s):  Issa A.D. Nesnas
 * <br>@b Author(s):    Issa A.D. Nesnas
 * <br>@b Date:         February 23, 2007
 *
 * <b>Software License:</b><br>
 * <code>  http://claraty.jpl.nasa.gov/license/open_src.html  or
 *         file: ../share/license.txt  </code>
 *
 * &copy; 2007, Jet Propulsion Laboratory, California Institute of Technology
 *
 * $Revision: 1.3 $
 */ 
//-----------------------------------------------------------------------------

#include <memory>
#include <stdexcept>
#include <sstream>

namespace claraty {

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
/**
 * Creates a Camera_Image using default Image constructor with (0,0) image
 * size.  If no camera model is given, it will be initialized to NULL.  
 * Paramters such as timestamp are similarly set
 *
 * @param[in] model  the Camera_Model to use (if non-NULL).  The model will be
 *                   copied.
 * @param[in] timestamp  the time the image was acquired (zero if not provided)
 * @param[in] properties the frame number used to reconstruct a video stream
 */
template< typename Pixel_Type >
Camera_Image<Pixel_Type >::
Camera_Image(const Camera_Model * model,
             Time timestamp,
             Camera_Image_Properties * properties) :
  _model(model == NULL ? NULL : new Camera_Model(model)),
  _timestamp(timestamp), 
  _properties((properties==NULL) ? NULL : new Camera_Image_Properties(properties))
{
}

//-----------------------------------------------------------------------------
/**
 * Creates a new Camera_Image of the specified width and height.
 * Initializes Camera_Image w/ given values.  If timestamp or frame_num are
 * not provided, they are initialized to zero.
 *
 * @param[in] nrows  the width of the Camera_Image
 * @param[in] ncols  the heigh to the Camera_Image
 * @param[in] model  the Camera_Model to use
 * @param[in] timestamp  the timestamp (zero if not provided)
template< typename Pixel_Type >
Camera_Image<Pixel_Type >::
Camera_Image(int nrows, int ncols,
             const Camera_Model *model,
             Time timestamp)
  : Image<Pixel_Type>(nrows, ncols), _model(model == NULL ? NULL : model->clone()),
    _timestamp(timestamp), _frame_num(frame_num), _feature_map()
{
}
  */

//-----------------------------------------------------------------------------
/**
 * Creates a new Camera_Image from the provided source Image.
 * Deep copies the source Image (all data) to the new Camera_Image.
 * @param[in] src_image  The Image to copy into the new Camera_Image.
 * @param[in] model      The Camera_Model to use.
 * @param[in] timestamp  The timestamp (zero if not provided).
 * @param[in] properties Camera image properties.
 */
template< typename Pixel_Type >
Camera_Image<Pixel_Type>::
Camera_Image(const Image<Pixel_Type> & src_image, 
             const Camera_Model * model,
             Time  timestamp, 
             Camera_Image_Properties * properties)
  : Image<Pixel_Type >(src_image), 
    _model(model == NULL ? NULL : new Camera_Model(model)),
    _timestamp(timestamp), 
    _properties((properties==NULL) ? NULL : 
                  new Camera_Image_Properties(properties))
{
}
  
//-----------------------------------------------------------------------------
/**
 * Copy constructor: creates a new Camera_Image from a source Camera_Image.
 * Does a deep copy of the src_image to the new image.
 *
 * @param[in] src_image Camera_Image to use to construct the new Camera_Image.
 */
template< typename Pixel_Type >
Camera_Image<Pixel_Type >::
Camera_Image(const Camera_Image<Pixel_Type> & src_image)
  : Image<Pixel_Type>(src_image),
    _model(src_image._model == NULL ? NULL : src_image._model->clone()),
    _timestamp(src_image._timestamp), 
    _properties(src_image._properties)
{
}

//-----------------------------------------------------------------------------
/**
 * Destructor.
 */
template< typename Pixel_Type > 
Camera_Image<Pixel_Type>::
~Camera_Image()
{
  delete _model;
  delete _properties;
}

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

template < typename Pixel_Type >
Camera_Image<Pixel_Type> & Camera_Image<Pixel_Type>::
operator=(const Camera_Image & rhs) 
{
  if (this != &rhs) {
    Image<Pixel_Type>::operator=(rhs);
    /*
    resize(rhs.nrows(), rhs.ncols());
    if (rhs.is_subarray()) 
      _copy(rhs.begin());
    else
      _copy(rhs.get_raster());
    set_maximum_value(rhs.get_maximum_value());
    set_interpolation_type(rhs.get_interpolation_type());
    */
    set_camera_model(rhs._model);
    _timestamp = rhs._timestamp;
    _properties = rhs._properties;
  }
  return *this;
}

//-----------------------------------------------------------------------------
/**
 * @return the Frame associated w/ the Camera_Model of the image.
template< typename Pixel_Type>
Frame Camera_Image<Pixel_Type>::get_frame() const
{
  if(_model!=NULL) {
    return _model->get_frame();
  }
  else {
    Frame_l ret;                // return empty frame
    return(ret);
  }
}
 */

//-----------------------------------------------------------------------------
/**
 * Sets the image's Camera_Model.
 *
 * @param[in] model  The Camera_Model to associate w/ the image.
 */
template < typename Pixel_Type >
void Camera_Image<Pixel_Type>::
set_camera_model(const Camera_Model & model)
{
  delete _model;
  _model = model;//->clone();
}

//-----------------------------------------------------------------------------
/**
 * Serializing and unserializing camera images.  
 * @param[out] m  A flexible data marshalling map that contains the 
 *                serializable format
 * @return true if the operation is successful, otherwise false
 */
template < typename Pixel_Type >
bool Camera_Image<Pixel_Type>::io(FDM_Map m)
{
  bool ret = io_image(m, (Image<Pixel_Type>&)(*this));

  if (m.is_read()) {
    delete _model;
    std::string  cmString;
    ret &= m.peekfield("model", cmString);
    if (cmString == "none") {
      ret &= m.field("model", cmString); // swallow it
      _model = NULL;
    } else {
      std::auto_ptr<Camera_Model> cm;
      ret &= m.field("model", cm);
      _model = cm.release();
    }
  } else { // write
    if (_model)
      ret &= m.field("model", *_model);
    else {
      std::string none("none");
      ret &= m.field("model", none);
    }
  }

  ret &= m.field("timestamp", _timestamp);
  //  ret &= m.field("features", _feature_map);
  return ret;
}

//-----------------------------------------------------------------------------
/**
 * Remove lens distortion and update models 
 */
template < typename Pixel_Type >
Camera_Image<Pixel_Type> 
rectify(Camera_Image<Pixel_Type> & image) throw(std::exception)
{
  Camera_Image<Pixel_Type>  ret_image;

  if (image.get_model()) {
    Camera_Model * new_model;
/*    Rectify_Op rectify;
    if (!this->linearize_model(*_model, rectify))
      return false;
    delete _model;
    _model = new_model;
    Image<Pixel_Type> rect;
    rectify.rectify_image(*this, rect);
    resize(rect.nrows(), rect.ncols());
    assert(!rect.is_subarray());
    _copy(rect.get_raster());
*/
  }
  else {
    std::ostringstream os;
    os << AT_FUNCTION << " camera model was not initialized" << std::endl;
    throw std::exception(os);
  }
}
//-----------------------------------------------------------------------------

} // 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