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

Go to the documentation of this file.

//-*-c++-*- 
//---------------------------< /-/ CLARAty /-/ >------------------------------
/** 
 * @file  camera_group.ipp
 *
 * Implementation of camera group template functions
 *
 * <br>@b Designer(s):  Issa A.D. Nesnas, Daniel Clouse
 * <br>@b Author(s):    Issa A.D. Nesnas, Daniel Clouse
 * <br>@b Date:         November 28, 2006
 *
 * <b>Software License:</b><br>
 * 
 * <code>  http://claraty.jpl.nasa.gov/license/open_src.html  or
 *         file: ../share/license.txt  </code>
 *
 * &copy; 2006, Jet Propulsion Laboratory, California Institute of Technology
 * [your institution copyright if applicable]
 *
 * $Revision: 1.3 $
**/ 
//-----------------------------------------------------------------------------

namespace claraty {
/**
 * @brief Acquire synchronized Images (unsigned char version).
 * All vectors (even empty vectors) grow or shrink to match the number
 * of cameras in the camera group, except for the default argument values
 * which are left empty by this routine.
 *
 * This version of acquire treats the default values differently from
 * the NULL (or empty) vector.  If an empty vector is passed in, it is
 * grown to match the number of cameras in the group.  The default
 * values are checked for explicitly, and are used to signify that the
 * user does not want this result returned.
 *    
 * @param[out] image_vec
 *             Returns newly acquired Images.  Each Image is resized
 *             to match the image size returned by the corresponding
 *             camera.  The size of the image_vec vector is not
 *             changed by this routine.  The number of images
 *             actually returned equals min(image_vec.size(), this.size()).
 *             Any images beyond this number are left unchanged.
 * @param[out] timestamp_vec
 *             Returns timestamps for each image.
 * @param[out] feature_map_vec
 *             Returns camera feature settings for each image.
 * @return     The number of valid images returned in image_vec.
 *             This value may be less than image_vec.size().  It is
 *             equal to min(image_vec.size(), this.size()).
 */
template <class Pixel_Type>
int Camera_Group::
_acquire(std::vector< Image<Pixel_Type> * > & image_vec,
         std::vector< Time                > * timestamp_vec,
         std::vector< Feature_Map       * > * feature_map_vec)
  throw (std::exception)
{
  if (image_vec.size()        != get_size() ||
      timestamp_vec->size()   != get_size() ||
      feature_map_vec->size() != get_size()) {
    std::ostringstream os;
    os << AT_FUNCTION << "camera group acquire failed: invalid argument"
       << "image vector size does not match group size" << std::endl;
    throw std::invalid_argument(os.str());    
  }

  // Verify that all cameras have proper pixel format
  _verify_pixel_format(sizeof(Pixel_Type));

  // Verify and resize images if necessary
  _verify_resize_images(image_vec);

  // Default implementation - loop through each camera and acquire image
  for (unsigned int i = 0; i < image_vec.size(); ++i) {
     Camera & cam = get_camera(i);
     if (timestamp_vec && feature_map_vec) 
       cam.acquire(*image_vec[i], &(*timestamp_vec)[i], (*feature_map_vec)[i]);
     else if (timestamp_vec)
       cam.acquire(*image_vec[i], &(*timestamp_vec)[i]);
     else
       cam.acquire(*image_vec[i]);
   }
  return image_vec.size();
}


//-------------------------------------------------------------------------
/** 
 * The vector arguments are not resized (to match the number of cameras
 * in the group).  However, each image is resized to match the image
 * size implied by the current Camera state.  The return value is the
 * number of valid images returned in cam_img_ptr_vec.  This value may be
 * less than cam_img_ptr_vec.size().  It is equal to
 * min(image_vec.size(), this.get_size()).
 */
template <class Pixel_Type> 
int Camera_Group::
acquire(std::vector< Camera_Image<Pixel_Type> * > & cam_img_ptr_vec)
{
  std::vector< Image< Pixel_Type > * > img_ptr_vec(cam_img_ptr_vec.size());
  std::vector< Time >                 time_ptr_vec(cam_img_ptr_vec.size());
  std::vector< Feature_Map * > feature_map_ptr_vec(cam_img_ptr_vec.size());
  for (unsigned int i = 0; i < cam_img_ptr_vec.size(); ++i) {
    img_ptr_vec[i]         = cam_img_ptr_vec[i];
    time_ptr_vec[i]        = &cam_img_ptr_vec[i]->_timestamp;
    feature_map_ptr_vec[i] = &cam_img_ptr_vec[i]->_feature_map;
  }
  return _acquire(img_ptr_vec, time_ptr_vec, feature_map_ptr_vec);
}

//-------------------------------------------------------------------------
/** The vector (even if empty) grows or shrinks to match the number of
 * cameras in the camera group.
 */
template <class Pixel_Type> 
int Camera_Group::
acquire(std::vector< Camera_Image<Pixel_Type> > & cam_img_vec)
{
  if (cam_img_vec.size() != get_size()) cam_img_vec.resize(get_size());
  std::vector< Image< Pixel_Type > * > img_ptr_vec(get_size());
  std::vector< Time * > time_ptr_vec(get_size());
  std::vector< Feature_Map * > feature_map_ptr_vec(get_size());
  for (unsigned int i = 0; i < get_size(); ++i) {
    img_ptr_vec[i] = &cam_img_vec[i];
    time_ptr_vec[i] = &cam_img_vec[i]._timestamp;
    feature_map_ptr_vec[i] = &cam_img_vec[i]._feature_map;
  }
  return _acquire(img_ptr_vec, time_ptr_vec, feature_map_ptr_vec);
}

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

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