---

ImageGrey.h

Go to the documentation of this file.

/*************************************************************************
 *
 * Source code for Real Time Image Library (libRTImage)
 *
 * Leeds Vision Group give permission for this code to be copied, modified 
 * and distributed within the University of Leeds subject to the following
 * conditions:-
 *
 * - The code is not to be used for commercial gain.
 * - The code and use thereof will be attributed to the authors where
 *   appropriate (including demonstrations which rely on it's use).
 * - All modified, distributions of the source files will retain this header.
 *
 ****************************************************************************/

#ifndef IMAGE_GREY_H
#define IMAGE_GREY_H

#include "ImageBase.h"
#include <CMatrix.h>
#include <Wavelet.h>
 
typedef int      PixelGrey;

struct equivalence {int         eq1;
                    int         eq2;
                    equivalence *next;
                   };

        
class ImageGrey : virtual public ImageBase
{
public:
        PixelGrey               *brightness;    

public:
/* Public Methods */

        
        ImageGrey(unsigned int width, unsigned int height);

        ImageGrey(char *, FileFormat) ;

        ImageGrey(ImageGrey&);  

        ImageGrey(ImageGrey&   img,
                  unsigned int min_x,
                  unsigned int min_y,
                  unsigned int max_x,
                  unsigned int max_y) ;


        ~ImageGrey();

        void            set_pixel(unsigned int x, unsigned int y, 
                                  PixelGrey level);
        
        void            get_pixel(unsigned int x, unsigned int y, 
                                  PixelGrey& p);

        ImageGrey&      clear(int = 0);

        ImageGrey&      copy(ImageGrey& img);

        ImageGrey&      copy(ImageGrey& img,
                             unsigned int min_x,
                             unsigned int min_y,
                             unsigned int max_x,
                             unsigned int max_y,
                             unsigned int start_x,
                             unsigned int start_y);



        void            absolute() ;

        void            threshold(int thresh) ;

        bool            save(char *, FileFormat) ;
        
        /* Operator overloading */
        
        ImageGrey&              operator = (ImageGrey& img)
         { return this->copy(img); }

        ImageGrey&              operator -= (ImageGrey& img) ;

        ImageGrey&              operator += (int fact) ;

        ImageGrey&              operator -= (int fact) ;

        ImageGrey&              operator /= (int fact) ;

        ImageGrey&              operator *= (int fact) ;

        bool            draw_line(int x_start, int y_start,
                                  int x_end, int y_end,
                                  PixelGrey intensity);
        bool            draw_filled_circle(unsigned int centre_x,
                                           unsigned int centre_y,
                                           unsigned int radius,
                                           PixelGrey intensity);
        void            scale_down(unsigned int min_x,
                                   unsigned int min_y,
                                   unsigned int max_x,
                                   unsigned int max_y,
                                   unsigned int new_sx,
                                   unsigned int new_sy,
                                   float        *new_image);
        void            scale_down(unsigned int min_x,
                                   unsigned int min_y,
                                   unsigned int max_x,
                                   unsigned int max_y,
                                   unsigned int new_sx,
                                   unsigned int new_sy,
                                   double       *new_image);    
        void            quick_scale_down(unsigned int min_x,
                                         unsigned int min_y,
                                         unsigned int max_x,
                                         unsigned int max_y,
                                         unsigned int new_sx,
                                         unsigned int new_sy,
                                         double       *new_image);    
        
        // Convolution methods

        float           convolve(unsigned int x,
                                 unsigned int y,
                                 CMatrix      *conv_matrix) ;
        void            plot_conv_kernel(unsigned int x,
                                         unsigned int y,
                                         CMatrix      *conv_matrix,
                                         float        scale_fact,
                                         float        offset) ;
        float           wavelet_convolve(unsigned int x,
                                         unsigned int y,
                                         Wavelet *wavelet,
                                         float        *real,
                                         float        *imag) ;

        void            blur(unsigned int size, ImageGrey &result) ;

        // Edge detection

        bool            sobel_horizontal(ImageGrey &result) ;
        bool            sobel_vertical(ImageGrey &result) ;
        bool            sobel(ImageGrey &result) ;

        // Median Filter
        bool            median(unsigned int n, unsigned int m, 
                               ImageGrey &result) ;

        // Morphology operations

        bool            dilate(ImageGrey &result) ;
        bool            erode(ImageGrey &result) ;
        bool            errode(ImageGrey &result) ; // For back compatibility

        bool            remove_point_noise(ImageGrey &result) ;

        // Extract spatially connected region
        // Call region_identify() then extract_region()
  
        bool            region_identify(unsigned int max_regions,
                                        unsigned int &actual_regions,
                                        ImageGrey    &result) ;
        bool            extract_region(int, ImageGrey &result);

        // Normalisation methods

        void            normalise_intensity(float mean,
                                            float sd) ;
        void            normalise_intensity_range() ;



private:
        // Method required for region_identify() ;
        bool            new_equivalence(int low, int high, 
                                        equivalence **latest) ;
        void            free_equivalence(equivalence **eq) ;

};


#endif  // IMAGE_GREY_H

---