improc.hpp

Go to the documentation of this file.

#ifndef _THERMALVIS_IMPROC_H_
#define _THERMALVIS_IMPROC_H_

//#include "general_resources.hpp"
//#include "opencv_resources.hpp"

#include "tools.hpp"

#define CUSTOM                  3
#define MAP_LENGTH              1024

#define GRAYSCALE               0

#define CIECOMP                 100
#define CIECOMP_ALT_1   110
#define CIECOMP_ALT_2   120
#define CIECOMP_ALT_3   130

#define CIELUV                  140

#define BLACKBODY               150

#define HIGHLIGHTED             180

#define RAINBOW                 200
#define RAINBOW_ALT_1   210
#define RAINBOW_ALT_2   220
#define RAINBOW_ALT_3   230
#define RAINBOW_ALT_4   240

#define IRON                    300
#define IRON_ALT_1              310
#define IRON_ALT_2              320
#define IRON_ALT_3              330

#define BLUERED                 400
#define BLUERED_ALT_1   410
#define BLUERED_ALT_2   420

#define JET                             500
#define JET_ALT_1               510

#define ICE                             600
#define ICE_ALT_1               610
#define ICE_ALT_2               620
#define ICE_ALT_3               630

#define ICEIRON                 700
#define ICEIRON_ALT_1   710
#define ICEIRON_ALT_2   720

#define ICEFIRE                 800
#define ICEFIRE_ALT_1   810
#define ICEFIRE_ALT_2   820
#define ICEFIRE_ALT_3   830

#define REPEATED                900
#define REPEATED_ALT_1  910
#define REPEATED_ALT_2  920
#define REPEATED_ALT_3  930
#define REPEATED_ALT_4  940
#define REPEATED_ALT_5  950
#define REPEATED_ALT_6  960

#define NORMALIZATION_STANDARD                  0
#define NORMALIZATION_EQUALIZE                  1
//#define NORMALIZATION_CLAHE                           2
#define NORMALIZATION_ADAPTIVE                  3
#define NORMALIZATION_CENTRALIZED               4
#define NORMALIZATION_EXPANDED                  5

#define NO_FILTERING                                    0
#define GAUSSIAN_FILTERING                              1
#define BILATERAL_FILTERING                     2

#define MIN_PROP_THRESHOLD 0.002

#define DEFAULT_LOWER_VISIBLE_FUSION_LIMIT              0.2
#define DEFAULT_UPPER_VISIBLE_FUSION_LIMIT              0.8

void applyFilter(const cv::Mat& src, cv::Mat& dst, int filter = NO_FILTERING, double param = 2.0);

//void straightCLAHE(const cv::Mat& src, cv::Mat& dst, double factor);

double findBestAlpha(const cv::Mat& K, const cv::Mat& coeff, const cv::Size& camSize);

void weightedMixture(cv::Mat& dst, const cv::vector<cv::Mat>& srcs, const std::vector<double>& weightings);

void addBorder(cv::Mat& inputMat, int borderSize);

void normalize_64_vec(cv::Mat& dst, cv::Mat& src);

void mixImages(cv::Mat& dst, cv::vector<cv::Mat>& images);

bool rectangle_contains_centroid(cv::Rect mainRectangle, cv::Rect innerRectangle);
cv::Rect meanRectangle(vector<cv::Rect>& rectangles);
void clusterRectangles(vector<cv::Rect>& rectangles, double minOverlap);

cv::Point rectangle_center(cv::Rect input);

void combineImages(const cv::Mat& im1, const cv::Mat& im2, cv::Mat& dst);

void unpackTo8bit3Channel(const cv::Mat& src, cv::Mat& dst);

double rectangleOverlap(cv::Rect rectangle1, cv::Rect rectangle2);

void obtainEightBitRepresentation(cv::Mat& src, cv::Mat& dst);
void obtainColorRepresentation(cv::Mat& src, cv::Mat& dst);

void trimToDimensions(cv::Mat& image, int width, int height);

void cropImage(cv::Mat& image, cv::Point tl, cv::Point br);

void drawGrid(const cv::Mat& src, cv::Mat& dst, int mode = 0);

void convertVectorToPoint2f(vector<cv::Point>& input, vector<cv::Point2f>& output);

void convertVectorToPoint(vector<cv::Point2f>& input, vector<cv::Point>& output);

void splitMultimodalImage(const cv::Mat& src, cv::Mat& therm, cv::Mat& vis);

cv::Point findCentroid(vector<cv::Point>& contour);

cv::Point2f findCentroid2f(vector<cv::Point>& contour);

void simpleResize(cv::Mat& src, cv::Mat& dst, cv::Size size);

void thresholdRawImage(cv::Mat& img, double *vals);

void createGaussianMatrix(cv::Mat& gaussianMat, double sigmaFactor = 1.0);

void copyContour(vector<cv::Point>& src, vector<cv::Point>& dst);

void invertMatIntensities(const cv::Mat& src, cv::Mat& dst);

void swapElements(vector<cv::Point2f>& corners, int index1, int index2);

void contourDimensions(vector<cv::Point> contour, double& width, double& height);



void drawLinesBetweenPoints(cv::Mat& image, const vector<cv::Point2f>& src, const vector<cv::Point2f>& dst);





double scoreColorImage(const cv::Mat& src);

double scoreThermalImage(const cv::Mat& src);

void transferElement(vector<cv::Point2f>& dst, vector<cv::Point2f>& src, int index);

void normalize_16(cv::Mat& dst, const cv::Mat& src, double dblmin = -1.0, double dblmax = -1.0);
void histExpand8(const cv::Mat& src, cv::Mat& dst);
void reduceToPureImage(cv::Mat& dst, cv::Mat& src);
void fix_bottom_right(cv::Mat& mat);

void convert16bitTo8bitConfidence(const cv::Mat& src, const cv::Mat& conf, cv::Mat& dst);

void fixedDownsample(const cv::Mat& src, cv::Mat& dst, double center, double range);


void temperatureDownsample(const cv::Mat& src, cv::Mat& dst, double minVal, double maxVal);

void convertToTemperatureMat(const cv::Mat& src, cv::Mat& dst);

void temperatureDownsample16(const cv::Mat& src, cv::Mat& dst);

//void downsampleCLAHE(const cv::Mat& src, cv::Mat& dst, double factor);
void adaptiveDownsample(const cv::Mat& src, cv::Mat& dst, int code = NORMALIZATION_STANDARD, double factor = 0.0);

void process8bitImage(const cv::Mat& src, cv::Mat& dst, int code = NORMALIZATION_STANDARD, double factor = 0.0);

bool checkIfActuallyGray(const cv::Mat& im);

void findIntensityValues(double *vals, cv::Mat& im, cv::Mat& mask);
void shiftIntensities(cv::Mat& im, double scaler, double shifter, double downer);
void findPercentiles(const cv::Mat& img, double *vals, double *percentiles, unsigned int num);

void generateHistogram(cv::Mat& src, cv::Mat& dst, double* im_hist, double* im_summ, double* im_stat);

void down_level(cv::Mat& dst, cv::Mat& src);

void applyIntensityShift(const cv::Mat& src1, cv::Mat& dst1, const cv::Mat& src2, cv::Mat& dst2, double grad, double shift);

cv::Mat normForDisplay(cv::Mat origMat);

class cScheme {
protected:
        
        double* dx;
        
        double* rx;
        double red[MAP_LENGTH];
        double* gx;
        double green[MAP_LENGTH];
        double* bx;
        double blue[MAP_LENGTH];
        int             length;
        int             code;

        unsigned char   lookupTable_1[256][3];
        unsigned short  lookupTable_2[65536][3];

public:
        cScheme();



        cScheme(double *d, double *r, double *g, double *b, int len);

        ~cScheme();

        void load_standard(int mapCode, int mapParam = 0);

        void create_long_map();

        void setupLookupTable(unsigned int depth = 65536);

        void customize(double* d, double* r, double* g, double* b, int len);

        void falsify_image(const cv::Mat& thermIm, cv::Mat& outputIm, int param = 1);

        void fuse_image(cv::Mat& thermIm, cv::Mat& visualIm, cv::Mat& outputIm, double *params = NULL);
        
        void forge_image(cv::Mat& thermIm, cv::Mat& visualIm, cv::Mat& outputIm, double* params = NULL, double thresh = 0.05);

        int current_scheme();

        void image_resize(cv::Mat& inputIm, int dim_i, int dim_j);


};

#endif