Base.h

Go to the documentation of this file.

#ifndef FCAM_BASE_H
#define FCAM_BASE_H

#include <stdlib.h>

namespace FCam {
  
    typedef enum {
    RGB24 = 0, 

    RGB16,     
    
    UYVY,      
    
    YUV24, 

    RAW,
    
    UNKNOWN} ImageFormat;

    int bytesPerPixel(ImageFormat);
    
    struct Size {
        Size() : width(0), height(0) {}

        Size(int w, int h) : width(w), height(h) {}

        bool operator==(const Size &other) const {return width == other.width && height == other.height;}

        bool operator!=(const Size &other) const {return width != other.width || height != other.height;}

        int width; 
    int height; 
    };
    
    struct Rect {
        Rect() : x(0), y(0), width(0), height(0) {}

        Rect(int x_, int y_, int w_, int h_) : x(x_), y(y_), width(w_), height(h_) {}

        bool operator==(const Rect &other) const {
            return (width == other.width &&
                    height == other.height &&
                    x == other.x &&
                    y == other.y);
        }

        bool operator!=(const Rect &other) const {
            return (width != other.width ||
                    height != other.height ||
                    x != other.x ||
                    y != other.y);
        }
    
        int x;      
    int y;      
    int width;  
    int height; 
    };

    class HistogramConfig {         
      public:
        HistogramConfig() : buckets(64), regions(0) {}
      
        Rect region[4];

        unsigned char buckets;

    unsigned char regions;

        bool operator==(const HistogramConfig &other) const {
            if (regions != other.regions) return false;
            if (buckets != other.buckets) return false;
            for (int i = 0; i < regions; i++) {
                if (region[i] != other.region[i]) return false;
            }
            return true;
        }

        bool operator!=(const HistogramConfig &other) const {
            return !((*this) == other);
        }
    };
    
    class SharpnessMapConfig {
      public:
        SharpnessMapConfig() : size(0, 0), enabled(false) {}

        Size size;

        bool enabled;

        bool operator==(const SharpnessMapConfig &other) const {
            if (enabled != other.enabled) return false;
            if (enabled && size != other.size) return false;
            return true;
        }

        bool operator!=(const SharpnessMapConfig &other) const {
            return !((*this) == other);
        }
    };    

    class Histogram : public HistogramConfig {
      public:

    Histogram(): valid(false), channels(0), data(NULL) {
    }

        unsigned operator()(int x, int c) {
            if (!valid) return 0;
            return data[buckets*c + x];
        }

        unsigned operator()(int x) {
            if (!valid) return 0;
            unsigned result = 0;
            for (size_t c = 0; c < channels; c++)
                result += (*this)(x, c);
            return result;
        }

        bool valid;

        unsigned channels;

        unsigned *data; 
    };

    class SharpnessMap : public SharpnessMapConfig {
      public:

    SharpnessMap(): valid(false), channels(0), data(NULL) {
    }

        unsigned operator()(int x, int y, int c) {
            return data[(y*size.width+x)*12 + c*4 + 1];
        }

        unsigned operator()(int x, int y) {
            unsigned total = 0;
            for (size_t c = 0; c < channels; c++) {
                total += (*this)(x, y, c);
            }
            return total;
        }       

        bool valid;

    unsigned channels;

        unsigned *data;
    };

}


#endif

---