+ 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.cc

Go to the documentation of this file.

// -*-c++-*-
//---------------------------< /-/ CLARAty /-/ >------------------------------
/**
 * @file  camera_group.cc
 *
 * Implements non-inline functions of camera group
 *
 * <br>@b Designer(s):  Daniel Clouse, Clay Kunz, Issa Nesnas
 * <br>@b Author(s):    Issa A.D. Nesnas
 * <br>@b Date:         06/09/06
 *
 * <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>
 *
 * $Revision: 1.8 $
 */
//-----------------------------------------------------------------------------

#include "claraty/camera_group.h"
#include "claraty/fdm_parse_tree.h"

using namespace std;
namespace claraty {

//-----------------------------------------------------------------------------
/**
 * Construct a group with two cameras
 *
 * @param[in] cam1 first camera to append to group
 * @param[in] cam2 second camera to append to group
 */
Camera_Group::
Camera_Group(Camera & cam1, Camera & cam2)
  : Device_Group(2)
{
  append(cam1);
  append(cam2);
}

//-----------------------------------------------------------------------------
/**
 * Construct a group with three cameras
 *
 * @param[in] cam1 first camera to append to group
 * @param[in] cam2 second camera to append to group
 * @param[in] cam3 third camera to append to group
 */
Camera_Group::
Camera_Group(Camera & cam1, Camera & cam2, Camera & cam3)
  : Device_Group(3)
{
  append(cam1);
  append(cam2);
  append(cam3);
}
//-----------------------------------------------------------------------------
/**
 * Construct a group with four cameras
 *
 * @param[in] cam1 first camera to append to group
 * @param[in] cam2 second camera to append to group
 * @param[in] cam3 third camera to append to group
 * @param[in] cam4 fourth camera to append to group
 */
Camera_Group::
Camera_Group(Camera & cam1, Camera & cam2, Camera & cam3, Camera & cam4)
  : Device_Group(4)
{
  append(cam1);
  append(cam2);
  append(cam3);
  append(cam4);
}

//-----------------------------------------------------------------------------
/**
 * Construct a group with two cameras
 *
 * @param[in] size 
 * @param[in] name 
 */
Camera_Group::
Camera_Group(int size, 
             const string & group_name)
  : Device_Group(size, group_name)
{ 
};

//-----------------------------------------------------------------------------
/**
 * @param[in] camera_index
 * @return device group
 */
Camera & Camera_Group::
get_camera(unsigned int camera_index) const
  throw(out_of_range)
{ 
  return static_cast<Camera &> (Device_Group::get_device(camera_index));
};

//-----------------------------------------------------------------------------
/**
 * Verify that all camera formats are either set to 8-bit pixels or
 * 16-bit pixels. If the current format (as set by set_format) of any
 * logical camera in this Camera_Group is not one of the 8 or 16 bit
 * known formats (see Camera class), then return throw an exception
 * 
 * @param[in] pixel_size format pixel format which is either set to
 * PIXEL_FORMAT::BIT8 or PIXEL_FORMAT::BIT16
 * @return true if all camera formats match requested format
 */
void Camera_Group::
_verify_pixel_format(size_t pixel_size)
{ 
  for (int i = 0; i < (int)get_size(); ++i) { // compiler warning chage
    Camera & cam = get_camera(i);
    cam._verify_pixel_format(pixel_size);
  }
}

//-----------------------------------------------------------------------------
/**
 * Verify that all image sizes match all camera frame sizes.  If the image
 * sizes do not match the camera frame sizes, this function will resize
 * each image to the proper corresponding camera frame size.
 *
 * @param[in] img_vec Reference to an image object to be resized.
 */
template< class Pixel_Type >
void Camera_Group::
_verify_resize_images(vector< Image<Pixel_Type> * > & img_vec)
{ 
   for (unsigned int i = 0; i < get_size(); ++i) {
     Camera & cam = get_camera(i);
     cam._verify_resize_image(*(img_vec[i]));
   }
}

//-----------------------------------------------------------------------------
/**
 * @brief Acquire synchronized Images (unsigned char version).  
 * 
 * This function is defined to enable children to override this
 * default capability as necessary
 * For each physical camera, set the parameter settings to match
 * those of the corresponding logical camera. Resize each image to
 * match the pixel geometry expected by its corresponding camera. 
 * Acquire the synchronized images (this will need to be overwritten
 * in the specilized hardware group for true synchronization and
 * multi-thread safety.  Fill in each timestamp_vec entry with the
 * time the corresponding image was acquired.  Fill in
 * feature_map_vec entry with the camera parameter settings in
 * effect at the time the image was acquired.
 *    
 * @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()).
 */
int Camera_Group::
acquire(vector< Image<uint8_t> * > & image_vec,
        vector< Time             > * timestamp_vec,
        vector< Feature_Map    * > * feature_map_vec)
  throw (exception)
{
  return _acquire(image_vec, timestamp_vec, feature_map_vec);
}

//-------------------------------------------------------------------------
/*
 * @brief Acquire synchronized Images (unsigned short version).
 *
 * Behavior is the same as that of the unsigned char version except
 * that this version works with MONO16 and RGB16 formats only.
 */
int Camera_Group::
acquire(vector< Image<uint16_t> * > & image_vec,
        vector< Time              > * timestamp_vec,
        vector< Feature_Map     * > * feature_map_vec)
    throw (exception)
{
  return _acquire(image_vec, timestamp_vec, feature_map_vec);
}

//-----------------------------------------------------------------------------
/**
 * [description]
 *
 * @param [in]   map
 * @return       true or false
 */
inline bool 
Camera_Group::io(FDM_Map map)
{
  return Device_Group::io(map);
}

//-----------------------------------------------------------------------------
/**
 * [description]
 *
 * @param [in]   os
 * @param [in]   rhs
 * @return       os
 */
std::ostream & 
operator << (std::ostream & os, const Camera_Group & rhs)
{
  FDM_Parse_Tree::write_object(rhs, os);
  return os;
}

//-----------------------------------------------------------------------------
/**
 * [description]
 *
 * @param [in]   is
 * @param [in]   rhs
 * @return       parse tree
 */
std::istream & 
operator >> (std::istream& is, Camera_Group & rhs)
{
  FDM_Parse_Tree::read_object(rhs, is);
  return is;
}
//-----------------------------------------------------------------------------

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