RGBImage.h

Go to the documentation of this file.

// -*- C++ -*-

// PLearn (A C++ Machine Learning Library)
// Copyright (C) 1998 Pascal Vincent
// Copyright (C) 1999-2002 Pascal Vincent, Yoshua Bengio and University of Montreal
//

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 
//  1. Redistributions of source code must retain the above copyright
//     notice, this list of conditions and the following disclaimer.
// 
//  2. Redistributions in binary form must reproduce the above copyright
//     notice, this list of conditions and the following disclaimer in the
//     documentation and/or other materials provided with the distribution.
// 
//  3. The name of the authors may not be used to endorse or promote
//     products derived from this software without specific prior written
//     permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
// NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// This file is part of the PLearn library. For more information on the PLearn
// library, go to the PLearn Web site at www.plearn.org


 

/* *******************************************************      
   * $Id: RGBImage.h,v 1.4 2004/07/21 16:30:51 chrish42 Exp $
   * AUTHORS: Pascal Vincent & Yoshua Bengio
   * This file is part of the PLearn library.
   ******************************************************* */


#ifndef RGBIMAGE_INC
#define RGBIMAGE_INC

#include <plearn/base/Array.h>
//#include "general.h"
#include <plearn/base/Object.h>
#include <plearn/base/Storage.h>
#include <plearn/math/TMat.h>
//#include "VMat.h"

namespace PLearn {
using namespace std;


class HSV;

class RGB
{
public:
  unsigned char r;
  unsigned char g;
  unsigned char b;
  
  RGB() {}
  RGB(unsigned char the_r, unsigned char the_g, unsigned char the_b)
    : r(the_r), g(the_g), b(the_b) {}


public:
  static const RGB BLACK;
  static const RGB WHITE;
  static const RGB RED;
  static const RGB GREEN;
  static const RGB BLUE;
  static const RGB DISCOCOLORS[];
};


class HSV
{
public:
  unsigned char h;
  unsigned char s;
  unsigned char v;

  HSV() {}
  HSV(unsigned char the_h, unsigned char the_s, unsigned char the_v)
    : h(the_h), s(the_s), v(the_v) {}

};


class RGBImage
{
protected:
  int height_;
  int width_;

  PP< Storage<RGB> > storage;
  char tmpfilename[100]; 

public:
  RGBImage(int the_height=0, int the_width=0);
  RGBImage(Mat r, Mat g, Mat b); 
  ~RGBImage();

  int width() const { return width_; }
  int height() const { return height_; }
  void resize(int newheight, int newwidth);

  inline RGB getPixel(int i, int j) const; 
  inline void setPixel(int i, int j, RGB value); 
  void fill(RGB color);
  void clear() { fill(RGB(255,255,255)); }

  void loadPPM(const char* filename);
  void savePPM(const char* filename) const;
  void loadJPEG(const char* filename, int scale=1);
  void display() const;
  void displayAndWait() const;

  void removeBorders(int top_border,int bottom_border,
                     int left_border,int right_border);
  
  void removeBorders(int border) { removeBorders(border,border,border,border); }

  void shrinkToIntersection(int& i, int& j, int& h, int& w) const;

  void blit(int desti, int destj, RGBImage srcim);
  RGB computeAverage() const;

  Vec computeHistogram(int r_bins=16, int g_bins=16, int b_bins=16, bool do_normalize=false);
};

inline RGB
RGBImage::getPixel(int i, int j) const
{
#ifdef BOUNDCHECK
  if(!storage)
    PLERROR("In RGBImage::getPixeel(int i, int j) EMPTY IMAGE!!!");
  if(i<0 || j<0 || i>=height_ || j>=width_)
    PLERROR("In RGBImage::getPixel(int i, int j) OUT OF IMAGE BOUNDS");
#endif
  return storage->data[i*width_+j];
}

inline void
RGBImage::setPixel(int i, int j, RGB value)
{
#ifdef BOUNDCHECK
  if(!storage)
    PLERROR("In RGBImage::getPixeel(int i, int j) EMPTY IMAGE!!!");
  if(i<0 || j<0 || i>=height_ || j>=width_)
    PLERROR("In RGBImage::getPixel(int i, int j) OUT OF IMAGE BOUNDS");
#endif
  storage->data[i*width_+j] = value;
}

class RGBImageDB
{
protected:
  Array<char*> filenames;
  Array<RGBImage*> images;
  int subsample_factor;
  int remove_border;
  int max_n_images_in_memory;
  int n_images_in_memory;
  
  int append(char* filename);
  void load(char* dbfile);

  RGBImageDB(int the_subsample_factor=1,int remove_border=0, int the_max_n_images_in_memory=10); 

public:
  Mat imageIdAndClass;

  RGBImageDB(char* dbfilename, int the_subsample_factor=1,int remove_border=0, int the_max_n_images_in_memory=10);

  RGBImage getImage(int imageid);

  Mat computeHistogramRepresentation(int r_bins=16, int g_bins=16, int b_bins=16, bool do_normalize=false);

  ~RGBImageDB();
};


class RGBImagesVMatrix;

class RGBImageVMatrix: public Object
{
  friend class RGBImagesVMatrix;

protected:
  RGBImage image;
  Vec delta_row; 
  Vec delta_column; 
  real scale; 
  real offset_; 
  int width_; 
  int max_delta_row, max_delta_column;
  int first_row; 
  int first_column; 
  int bottom_border_row; 
  int right_border_col; 
  int n_cols; 
  int current_i, current_j; 

public:
  RGBImageVMatrix(RGBImage image, 
                       const Vec& delta_row, const Vec& delta_col,
                       real scale=1.0, 
                       real offset_=0.0);
  virtual int width();
  virtual int length();
  virtual void reset();
  virtual void sample(Vec& samplevec);
  virtual void seek(int position);
  virtual int position();

  virtual bool first() 
    { return (current_i==first_row) && (current_j==first_column); }

  void setImage(RGBImage new_image);
};


class RGBImagesVMatrix: public Object
{
protected:
  RGBImageVMatrix image_distr;
  RGBImageDB& images_db;
  int current_image;
  bool append_class;
  int length_;
  Vec pixelsAndClass;
  Vec pixels;
  Vec image_start; 
  int width_;

public:
  RGBImagesVMatrix(RGBImageDB& images_db,
                        const Vec& delta_row,
                        const Vec& delta_col, 
                        bool append_class,
                        real scale=1.0,
                        real offset_=0.0);

  virtual int width();
  virtual int length();
  virtual void reset();
  virtual void sample(Vec& samplevec);
  virtual void seek(int position);
  virtual int position();
  virtual bool firstSampleOfObject();
  virtual int nSamplesOfObject();
  virtual int nObjects();
};

} // end of namespace PLearn

#endif

---