+ 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_io.h

Go to the documentation of this file.

// -*-c++-*- 
//---------------------------< /-/ CLARAty /-/ >------------------------------
/** 
 * @file  camera_image_io.h
 *
 * A few, hopefully simple, functions for reading and writing camera images
 * (including camera_models, and their framestores) into unknown file types,
 * which is figured out using the factory mechanism.
 *
 * <br>@b Designer(s):  Clay Kunz
 * <br>@b Author(s):    Clay Kunz
 * <br>@b Date:         March 20, 2003
 *
 * <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<br>
 * &copy; 2007, NASA Ames Research Center
 *
 * $Revision: 1.3 $
 */ 
//-----------------------------------------------------------------------------

#ifndef _camera_image_io_h_
#define _camera_image_io_h_

#include "claraty/image_io_factory.h"
#include "claraty/camera_image.h"
#include "claraty/rgb_image.h"
#include "claraty/camera_model.h"
#include "claraty/lock_frame.h"
#include "claraty/string_util.h"
#include "claraty/parse_block.h"
#include "claraty/fdm_parse_tree.h"

/**
 * Saves a camera image, with its camera model and associated
 * framestore. Additional header information can be passed in, as well as a
 * color image, which will be saved instead of the pixels in the camera_image
 * if it is given (so far we don't have a color camera_image type).
 *
 * @ingroup vision_file_io
 * 
 */

template <class T>
bool save_camera_image(const std::string& filename,
                       const Camera_Image<T>& img,
                       const Parse_Block *extraHeader = NULL,
                       const RGB_Image<T> *color_img = NULL)
{
  Image_IO_Factory *io =
    (*Image_IO_Factory::factory)(string_suffix(filename));
  if (io == NULL) {
    std::cerr << "Unable to find helper class for saving images of type "
              << string_suffix(filename) << std::endl;
    return false;
  }

  const int image_io_state_version = 2;

  std::auto_ptr<Camera_Model> model(img.get_camera_model_ptr());
  std::string mRep = FDM_Parse_Tree::object_to_string(model);
  assert(model.get() == img.get_camera_model_ptr());

  std::string fs_rep;
  if (model.get() == NULL || model->get_frame().is_empty()) {
    Framestore tmp("");
    fs_rep = FDM_Parse_Tree::object_to_string(tmp);
  } else
    fs_rep = FDM_Parse_Tree::object_to_string(model->get_frame().get_store());

  model.release();

  Parse_Block pb;
  if (extraHeader != NULL)
    pb = *extraHeader;
  
  pb.add_entry("framestore", fs_rep);
  pb.add_entry("model", mRep);
  pb.add_entry("image_io_state_version", image_io_state_version);
  std::string pbString = pb.write_to_string();

  bool raster_allocated = true;
  unsigned char *raster;
  int sig_bits;

  if (color_img != NULL) {
    sig_bits = Image_IO_Factory::compute_sigbits(color_img->get_red_channel());
    raster = Image_IO_Factory::rasterize_image(*color_img);
  } else {
    sig_bits = Image_IO_Factory::compute_sigbits(img);
    raster = Image_IO_Factory::rasterize_image(img, raster_allocated);
  }

  bool ok = io->save_image_bytes(filename, raster, img.nrows(), img.ncols(),
                                 sizeof(T), sig_bits, pbString,
                                 color_img != NULL);
  if (raster_allocated)
    delete [] raster;

  delete io;

  return ok;
}

/* Loads the image+annotations stored in the given file into the camera
   image. A new framestore is built from information in the image header, as
   well as the camera model to be given to the camera image object.
   The header information will be returned in the parse block object, if a
   non-null pointer is given.
   There is not yet any facility for reading color camera images, since no
   such type yet exists.
*/
template <class T>
bool load_camera_image(const std::string& filename,
                       Camera_Image<T> *& img,
                       Framestore *& fs,
                       Parse_Block *header = NULL)
{
  Image_IO_Factory *io =
    (*Image_IO_Factory::factory)(string_suffix(filename));
  if (io == NULL) {
    std::cerr << "Unable to find helper class for reading images of type "
              << string_suffix(filename) << std::endl;
    return false;
  }

  img = NULL;
  fs = NULL;

  unsigned char **rows;
  unsigned int nr, nc;
  std::string comments;
  int maxval;
  int bytes_per_pixel;
  bool color;

  if (!io->load_image_bytes(filename, rows, nr, nc, comments, maxval,
                            bytes_per_pixel, color)) {
    delete io;
    return false;
  }
  delete io;

  Parse_Block parseBlock;
  Parse_Block *pb = header != NULL ? header : &parseBlock;

  img = new Camera_Image<T>(nr, nc, NULL);
  img->set_maximum_value(maxval);
  Image_IO_Factory::move_raster_to_image(rows, bytes_per_pixel, *img, color);

  // get model_and_framestore, if it's there; otherwise just parse the thing
  // and yank out the pieces.
  std::string old_header = "model_and_framestore=";
  std::string::size_type pos = comments.find(old_header);
  if (pos != std::string::npos)
    comments = comments.substr(old_header.size());

  if (!pb->read_from_string(comments)) {
    std::cerr << "unable to parse image header" << std::endl;
    return false;
  }
  std::string value;

  if (!pb->get_entry("framestore", value)) {
    std::cerr << "missed framestore in image header" << std::endl;
    return false;
  }

  if (pb->check_for_entry("image_io_state_version")) {
    fs = new Framestore;
    bool ok = FDM_Parse_Tree::string_to_object(*fs, value);
    if (!ok) {
      std::cerr << "missed framestore (fdm representation expected) "
        "in image header" << std::endl;
      return false;
    }
  } else {
    Parse_Block fsPb(value);
    fs = new Framestore(fsPb);
  }

  if (!pb->get_entry("model", value)) {
    std::cerr << "missed model in image header" << std::endl;
    return false;
  }

  std::istringstream mis(value);
  Camera_Model *model = Camera_Model::build_from_stream(mis, *fs);

  if (model == NULL) {
    std::cerr << "unable to build model from stream" << std::endl;
    return false;
  } else {
    img->set_camera_model(model);
    delete model;
  }
  return true;
}

                       
/* This function is so that two camera images that are a stereo pair can be
   loaded with one function call, which merges the framestores loaded into a
   single framestore, containing the information for both camera models. */
template <class T>
bool load_stereo_camera_images(const std::string& leftFile,
                               const std::string& rightFile,
                               Camera_Image<T>*& leftImg,
                               Camera_Image<T>*& rightImg,
                               Framestore *& fs, Parse_Block *leftHdr = NULL,
                               const std::string& refFrame = "")
{
  Framestore *fs1;
  leftImg = NULL;
  rightImg = NULL;
  bool ok = load_camera_image(leftFile, leftImg, fs, leftHdr);
  ok &= load_camera_image(rightFile, rightImg, fs1);

  if (leftImg == NULL || rightImg == NULL || !ok)
    return false;

  // move the right camera into the left camera's framestore
  const Camera_Model& rightCM = rightImg->get_camera_model();
  Camera_Model *rightCopy = rightCM.clone();
  
  Frame_l rightFrame = rightCM.get_frame();
  Frame_l leftFrame = leftImg->get_camera_model().get_frame();
  if (rightFrame.get_name() == leftFrame.get_name() && refFrame != "") {
    // The two images have the same camera model frame - we have to be
    // careful in case they're in fact the same camera that's moved between
    // the two images, instead of two different cameras taking a pair of
    // pictures simultaneously.
    // In this case, the best we can do is to make a new frame for the
    // second camera, and put it in the correct location relative to the
    // given reference frame, which must be supplied if this is the case.
    Frame_l leftRef = fs->lookup(refFrame);
    Frame_l rightRef = fs1->lookup(refFrame);
    if (leftRef.is_empty() || rightRef.is_empty()) {
      delete rightCopy;
      delete fs1;
      delete leftImg;
      delete rightImg;
      delete fs;
      leftImg = rightImg = NULL;
      fs = NULL;
      return false;
    }
    Location leftCamLoc = leftRef.location_of(leftFrame);
    Location rightCamLoc = rightRef.location_of(rightFrame);
    if (leftCamLoc.get_translation() !=
        rightCamLoc.get_translation() ||
        leftCamLoc.get_rotation() !=
        rightCamLoc.get_rotation()) {
      // The camera models are the same, but in different places in the two
      // images. So we have to move the right one into a new frame.
      // If the two frames are in the same locations in the two images, then
      // there's nothing we can do, except assume that there is additional
      // extrinsic information in the camera model, which distinguishes the
      // two images.
      std::string newRtFrameName = rightFrame.get_name() + ".stereo.right";
      Frame_l newRightFrame =
        fs->add_frame(newRtFrameName.c_str(), &leftRef, rightCamLoc);
      rightCopy->set_frame(newRightFrame);
      rightImg->set_camera_model(rightCopy);
      delete rightCopy;
      delete fs1;
      return false;
    }
  }
  // Make sure that the frame information from the right store (regarding the
  // camera model, at least) is reflected in the model when we move it into
  // the left framestore.
  Frame_l lfsrparent = fs->lookup(rightFrame.get_parent().get_name());
  Location rcmloc = rightFrame.get_location();
  Frame_l lfsrframe = fs->lookup(rightFrame.get_name());
  lfsrframe.change_parent(lfsrparent);
  lfsrframe.set_location(rcmloc);
  rightCopy->set_frame(lfsrframe);
  rightImg->set_camera_model(rightCopy); // clones the model

  delete rightCopy;
  delete fs1;
  return true;
}

#endif

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