+ 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 File Reference

#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"

Include dependency graph for camera_image_io.h:

Go to the source code of this file.

Functions
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)
template<class T>
bool	load_camera_image (const std::string &filename, Camera_Image< T > *&img, Framestore *&fs, Parse_Block *header=NULL)
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="")

---

Detailed Description

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.

Designer(s): Clay Kunz
Author(s): Clay Kunz
Date: March 20, 2003

Software License:
http://claraty.jpl.nasa.gov/license/open_src.html or file: ../share/license.txt

© 2007, Jet Propulsion Laboratory, California Institute of Technology
© 2007, NASA Ames Research Center

Revision

1.3

Definition in file camera_image_io.h.

---

Function Documentation

template<class T>

bool load_camera_image	(	const std::string &	filename,
		Camera_Image< T > *&	img,
		Framestore *&	fs,
		Parse_Block *	header = NULL
	)

Definition at line 117 of file camera_image_io.h.

References claraty::string_suffix(), and claraty::string_to_object().

Referenced by load_stereo_camera_images().

{
  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;
}

Here is the call graph for this function:

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 = ""
	)

Definition at line 208 of file camera_image_io.h.

References load_camera_image().

{
  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;
}

Here is the call graph for this function:

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