+ 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

claraty::Image_IO_Factory Class Reference

#include <image_io_factory.h>

List of all members.

Public Member Functions
	Image_IO_Factory ()
virtual	~Image_IO_Factory ()
virtual bool	save_image_bytes (const std::string &filename, unsigned char *raster, int nr, int nc, int bytes_per_pixel, int sig_bits, const std::string &comments, bool color_image=false)=0
virtual bool	load_image_bytes (const std::string &filename, unsigned char **&rows, unsigned int &nr, unsigned int &nc, std::string &comments, int &maxval, int &bytes_per_pixel, bool &color)=0
Static Public Member Functions
template<typename T>
static unsigned char *	rasterize_image (const Image< T > &img, bool &new_storage_allocated)
template<typename T>
static unsigned char *	rasterize_image (const RGB_Image< T > &img)
template<typename T>
static void	move_raster_to_image (unsigned char **rows, int bytes_per_pixel, Image< T > &img, bool color)
template<typename T>
static void	move_raster_to_image (unsigned char **rows, int bytes_per_pixel, RGB_Image< T > &img, bool color)
template<typename T>
static int	compute_sigbits (const Image< T > &img)
template<typename T>
static bool	save_image (const std::string &filename, const Image< T > &img, bool scale_to_255=false)
template<typename T>
static bool	save_image (const std::string &filename, const RGB_Image< T > &img, bool scale_to_255=false)
template<typename T>
static bool	load_image (const std::string &filename, Image< T > &img)
template<typename T>
static bool	load_image (const std::string &filename, RGB_Image< T > &img)
Static Public Attributes
static Factory< Image_IO_Factory, std::string > *	factory
Static Private Member Functions
template<typename T>
static unsigned char *	host_to_net (const T *hostraster, int numPixels)

---

Detailed Description

Definition at line 59 of file image_io_factory.h.

---

Constructor & Destructor Documentation

claraty::Image_IO_Factory::Image_IO_Factory

(

)

[inline]

Definition at line 66 of file image_io_factory.h.

{ }

virtual claraty::Image_IO_Factory::~Image_IO_Factory

(

)

[inline, virtual]

Definition at line 67 of file image_io_factory.h.

{ }

---

Member Function Documentation

template<typename T>

unsigned char * claraty::Image_IO_Factory::host_to_net	(	const T *	hostraster,
		int	numPixels
	)			[static, private]

Definition at line 165 of file image_io_factory.h.

Referenced by rasterize_image().

{
  unsigned char *netraster = new unsigned char[numPixels * 2];
  for (int i = 0; i < numPixels; i++) {
    unsigned short pix = static_cast<unsigned short>(hostraster[i]);
    netraster[i * 2] = (pix & 0xff00) >> 8;
    netraster[i * 2 + 1] = pix & 0x00ff;
  }
  return netraster;
}

virtual bool claraty::Image_IO_Factory::save_image_bytes	(	const std::string &	filename,
		unsigned char *	raster,
		int	nr,
		int	nc,
		int	bytes_per_pixel,
		int	sig_bits,
		const std::string &	comments,
		bool	color_image = false
	)			[pure virtual]

Referenced by save_image().

virtual bool claraty::Image_IO_Factory::load_image_bytes	(	const std::string &	filename,
		unsigned char **&	rows,
		unsigned int &	nr,
		unsigned int &	nc,
		std::string &	comments,
		int &	maxval,
		int &	bytes_per_pixel,
		bool &	color
	)			[pure virtual]

Referenced by load_image().

template<typename T>

unsigned char * claraty::Image_IO_Factory::rasterize_image	(	const Image< T > &	img,
		bool &	new_storage_allocated
	)			[static]

Definition at line 179 of file image_io_factory.h.

References claraty::Image< T >::get_raster(), host_to_net(), claraty::N_2D_Array< T >::is_subarray(), claraty::N_2D_Array< T >::ncols(), and claraty::N_2D_Array< T >::nrows().

Referenced by save_image().

{
  if (!img.is_subarray() && (sizeof(T) == 1 || htons(0xf00f) == 0xf00f)) {
    new_storage_allocated = false;
    return const_cast<unsigned char*>
      (reinterpret_cast<const unsigned char*>(img.get_raster()));
  }

  new_storage_allocated = true;
  size_t num_image_bytes = img.nrows() * img.ncols() * sizeof(T);

  Image<T> flattened_image(img);

  if (sizeof(T) == 1 || htons(0xf00f) == 0xf00f) {
    unsigned char *raster =
      reinterpret_cast<unsigned char*>(flattened_image.get_raster());
    unsigned char *raster_copy = new unsigned char[num_image_bytes];
    std::copy(raster, raster + num_image_bytes, raster_copy);
    return raster_copy;
  }

  // if we get this far, it means we've got > 1 byte per pixel, and we're
  // not in network byte order.
  return host_to_net(flattened_image.get_raster(),
                     img.nrows() * img.ncols());
}

Here is the call graph for this function:

template<typename T>

unsigned char * claraty::Image_IO_Factory::rasterize_image

(

const RGB_Image< T > &

img

)

[static]

Definition at line 208 of file image_io_factory.h.

References claraty::RGB_Image< T >::get_color(), claraty::RGB_Image< T >::get_num_of_cols(), and claraty::RGB_Image< T >::get_num_of_rows().

{
  T *raster = new T[img.get_num_of_rows() * img.get_num_of_cols() * 3];
  T *ri = raster;
  for (int r = 0; r < img.get_num_of_rows(); r++)
    for (int c = 0; c < img.get_num_of_cols(); c++) {
      RGB_Color<T> color = img.get_color(c, r);
      if (sizeof(T) == 1) {
        *ri++ = color.red;
        *ri++ = color.green;
        *ri++ = color.blue;
      } else {
        *ri++ = htons(color.red);
        *ri++ = htons(color.green);
        *ri++ = htons(color.blue);
      }
    }
  return reinterpret_cast<unsigned char*>(raster);
}

Here is the call graph for this function:

template<typename T>

void claraty::Image_IO_Factory::move_raster_to_image	(	unsigned char **	rows,
		int	bytes_per_pixel,
		Image< T > &	img,
		bool	color
	)			[static]

Definition at line 229 of file image_io_factory.h.

References claraty::Image< T >::get_raster(), claraty::N_2D_Array< T >::ncols(), and claraty::N_2D_Array< T >::nrows().

Referenced by load_image().

{
  T *pixel = img.get_raster();
  for (int r = 0; r < img.nrows(); r++) {
    unsigned char *row = rows[r];
    if (sizeof(T) == 1 && bytes_per_pixel == 1 && !color_img) {
      std::copy(row, row + img.ncols(), pixel);
      pixel += img.ncols();
    } else {
      unsigned char *ri = row;
      if (color_img) {
        for (int c = 0; c < img.ncols(); c++, ri += bytes_per_pixel * 3) {
          if (bytes_per_pixel == 1)
            *pixel++ = (ri[0] + ri[1] + ri[2]) / 3;
          else
            *pixel++ =
              (ntohs(reinterpret_cast<unsigned short*>(ri)[0]) +
               ntohs(reinterpret_cast<unsigned short*>(ri)[1]) +
               ntohs(reinterpret_cast<unsigned short*>(ri)[2])) / 3;
        }
      } else {
        for (int c = 0; c < img.ncols(); c++, ri += bytes_per_pixel) {
          if (bytes_per_pixel == 1)
            *pixel++ = *ri;
          else
            *pixel++ = ntohs(*reinterpret_cast<unsigned short*>(ri));
        }
      }
    }
    delete [] row;
  }
  delete [] rows;
}

Here is the call graph for this function:

template<typename T>

void claraty::Image_IO_Factory::move_raster_to_image	(	unsigned char **	rows,
		int	bytes_per_pixel,
		RGB_Image< T > &	img,
		bool	color
	)			[static]

Definition at line 266 of file image_io_factory.h.

References claraty::RGB_Image< T >::get_num_of_cols(), claraty::RGB_Image< T >::get_num_of_rows(), and claraty::RGB_Image< T >::set_color().

{
  for (int r = 0; r < img.get_num_of_rows(); r++) {
    unsigned char *row = rows[r];
    unsigned char *ri = row;
    if (color_img) {
      for (int c = 0; c < img.get_num_of_cols(); c++) {
        RGB_Color<T> color;
        if (bytes_per_pixel == 1) {
          color.red = *ri++;
          color.green = *ri++;
          color.blue = *ri++;
        } else {
          color.red = ntohs(*reinterpret_cast<unsigned short*>(ri));
          ri += bytes_per_pixel;
          color.green = ntohs(*reinterpret_cast<unsigned short*>(ri));
          ri += bytes_per_pixel;
          color.blue = ntohs(*reinterpret_cast<unsigned short*>(ri));
          ri += bytes_per_pixel;
        }
        img.set_color(c, r, color);
      }
    } else {
      for (int c = 0; c < img.get_num_of_cols(); c++) {
        RGB_Color<T> color;
        if (bytes_per_pixel == 1)
          color.red = *ri;
        else
          color.red = ntohs(*reinterpret_cast<unsigned short*>(ri));
        color.green = color.red;
        color.blue = color.red;
        ri += bytes_per_pixel;
        img.set_color(c, r, color);
      }
    }
    delete [] row;
  }
  delete [] rows;
}

Here is the call graph for this function:

template<typename T>

int claraty::Image_IO_Factory::compute_sigbits

(

const Image< T > &

img

)

[static]

Definition at line 309 of file image_io_factory.h.

References claraty::Image< T >::get_maximum_value(), and claraty::Matrix< T >::max_value().

Referenced by save_image().

{
  T maxval = img.get_maximum_value();
  if (maxval == 0)
    maxval = img.max_value(NULL, NULL);
  int bitsMax = 1;
  int sigbits = 1;
  while (bitsMax < maxval && bitsMax < 65535) {
    bitsMax = (bitsMax << 1) | 1;
    sigbits++;
  }
  /*
  if (sizeof(T) > 1) {
    bitsMax = cl_max(bitsMax, 256);
    sigbits = cl_max(sigbits, 9);
  }
  */
  return sigbits;
}

Here is the call graph for this function:

template<typename T>

bool claraty::Image_IO_Factory::save_image	(	const std::string &	filename,
		const Image< T > &	img,
		bool	scale_to_255 = false
	)			[static]

Definition at line 330 of file image_io_factory.h.

References compute_sigbits(), claraty::Rescale_Op< T >::filter(), claraty::N_2D_Array< T >::ncols(), claraty::N_2D_Array< T >::nrows(), rasterize_image(), save_image_bytes(), and claraty::string_suffix().

Referenced by save_image().

{
  if (scale_to_255) {
    Image<unsigned char> scaled_image;
    Rescale_Op<T> rescale(0, 255);
    rescale.filter(img, scaled_image);
    return save_image(filename, scaled_image, false);
  }

  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;
  }
  bool new_storage;
  unsigned char *raster = rasterize_image(img, new_storage);

  bool ok = io->save_image_bytes(filename, raster,
                                 img.nrows(), img.ncols(), sizeof(T),
                                 compute_sigbits(img), "", false);
  if (new_storage)
    delete [] raster;
  delete io;
  return ok;
}

Here is the call graph for this function:

template<typename T>

bool claraty::Image_IO_Factory::save_image	(	const std::string &	filename,
		const RGB_Image< T > &	img,
		bool	scale_to_255 = false
	)			[static]

Definition at line 360 of file image_io_factory.h.

References compute_sigbits(), claraty::Rescale_Op< T >::filter(), claraty::RGB_Image< T >::get_blue_channel(), claraty::RGB_Image< T >::get_green_channel(), claraty::RGB_Image< T >::get_num_of_cols(), claraty::RGB_Image< T >::get_num_of_rows(), claraty::RGB_Image< T >::get_red_channel(), rasterize_image(), save_image(), save_image_bytes(), and claraty::string_suffix().

{
  if (scale_to_255) {
    RGB_Image<unsigned char> scaled_image;
    Rescale_Op<T> rescale(0, 255);
    rescale.filter(img.get_red_channel(), scaled_image.get_red_channel());
    rescale.filter(img.get_green_channel(), scaled_image.get_green_channel());
    rescale.filter(img.get_blue_channel(), scaled_image.get_blue_channel());
    return save_image(filename, scaled_image, false);
  }

  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;
  }
  unsigned char *raster = rasterize_image(img);

  bool ok = io->save_image_bytes(filename, raster,
                                 img.get_num_of_rows(),
                                 img.get_num_of_cols(), sizeof(T),
                                 compute_sigbits(img.get_red_channel()), "",
                                 true);
    
  delete [] raster;
  delete io;
  return ok;
}

Here is the call graph for this function:

template<typename T>

bool claraty::Image_IO_Factory::load_image	(	const std::string &	filename,
		Image< T > &	img
	)			[static]

Definition at line 393 of file image_io_factory.h.

References load_image_bytes(), move_raster_to_image(), claraty::N_2D_Array< T >::resize(), claraty::Image< T >::set_maximum_value(), and claraty::string_suffix().

{
  Image_IO_Factory *io =
    (*Image_IO_Factory::factory)(string_suffix(filename));
  if (io == NULL) {
    std::cerr << "Unable to find helper class for loading images of type "
              << string_suffix(filename) << std::endl;
    return false;
  }
  unsigned char **rows;
  unsigned int nr, nc;
  std::string comments;
  int maxval;
  int bytes_per_pixel;
  bool color;

  bool ok = io->load_image_bytes(filename, rows, nr, nc, comments, maxval,
                                 bytes_per_pixel, color);

  if (!ok) {
    delete io;
    return false;
  }
  img.resize(nr, nc);
  img.set_maximum_value(maxval);
  move_raster_to_image(rows, bytes_per_pixel, img, color);

  delete io;
  return true;
}

Here is the call graph for this function:

template<typename T>

bool claraty::Image_IO_Factory::load_image	(	const std::string &	filename,
		RGB_Image< T > &	img
	)			[static]

Definition at line 425 of file image_io_factory.h.

References claraty::RGB_Image< T >::get_blue_channel(), claraty::RGB_Image< T >::get_green_channel(), claraty::RGB_Image< T >::get_red_channel(), load_image_bytes(), move_raster_to_image(), claraty::RGB_Image< T >::resize(), and claraty::string_suffix().

{
  Image_IO_Factory *io =
    (*Image_IO_Factory::factory)(string_suffix(filename));
  if (io == NULL) {
    std::cerr << "Unable to find helper class for loading images of type "
              << string_suffix(filename) << std::endl;
    return false;
  }
  unsigned char **rows;
  unsigned int nr, nc;
  std::string comments;
  int maxval;
  int bytes_per_pixel;
  bool color;

  bool ok = io->load_image_bytes(filename, rows, nr, nc, comments, maxval,
                                 bytes_per_pixel, color);

  if (!ok) {
    delete io;
    return false;
  }
  img.resize(nr, nc);
  img.get_red_channel().set_maximum_value(maxval);
  img.get_green_channel().set_maximum_value(maxval);
  img.get_blue_channel().set_maximum_value(maxval);
  move_raster_to_image(rows, bytes_per_pixel, img, color);

  delete io;
  return true;
}

Here is the call graph for this function:

---

Member Data Documentation

Factory< Image_IO_Factory, std::string > * claraty::Image_IO_Factory::factory [static]

Definition at line 64 of file image_io_factory.h.

---

The documentation for this class was generated from the following files:

• image_io_factory.h
• image_io_factory.cc

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