drwnOpenCVUtils.h

Go to the documentation of this file.

/*****************************************************************************
** DARWIN: A FRAMEWORK FOR MACHINE LEARNING RESEARCH AND DEVELOPMENT
** Distributed under the terms of the BSD license (see the LICENSE file)
** Copyright (c) 2007-2015, Stephen Gould
** All rights reserved.
**
******************************************************************************
** FILENAME:    drwnOpenCVUtils.h
** AUTHOR(S):   Stephen Gould <stephen.gould@anu.edu.au>
**
*****************************************************************************/

#pragma once

#include <cstdlib>
#include <vector>

#include "cv.h"
#include "highgui.h"

#include "drwnBase.h"

using namespace std;
using namespace Eigen;

// Global parameters that can be set from the command line
namespace drwnOpenCVUtils {
    extern unsigned SHOW_IMAGE_MAX_HEIGHT;
    extern unsigned SHOW_IMAGE_MAX_WIDTH;
};

// Convert opencv data structures to a string
string toString(const cv::Mat& m);
string toString(const vector<cv::Mat>& vm);
string toString(const cv::Rect& r);
string toString(const cv::Point& pt);
string toString(const cv::Size& sz);
string toString(const cv::Scalar& slr);

// Operators
bool operator==(const CvRect& r, const CvRect& s);
bool operator<(const CvSize& r, const CvSize& s);
bool operator<(const CvPoint& p, const CvPoint& q);

int drwnCmpCount(const cv::Mat& s, const cv::Mat& t, int cmpOp = CV_CMP_EQ);

int drwnShowDebuggingImage(const cv::Mat& img, const std::string& name, bool bWait);
int drwnShowDebuggingImage(const vector<cv::Mat>& views, const std::string& name, bool bWait, int rows = -1);

cv::Rect drwnFitBoundingBox(const vector<cv::Rect> &rects);
cv::Rect drwnFitBoundingBox(const vector<cv::Point> &points);
cv::Rect drwnFitBoundingBox(cv::Rect r, double aspectRatio);

inline double area(const cv::Rect& r) { return (double)r.area(); }
inline double aspect(const cv::Rect& r) { return (double)r.width / (double)r.height; }
double areaOverlap(const cv::Rect& r, const cv::Rect& s);
inline double areaUnion(const cv::Rect& r, const cv::Rect& s) {
    return area(r) + area(s) - areaOverlap(r, s);
}

cv::Mat drwnGreyImage(const cv::Mat& src);
cv::Mat drwnColorImage(const cv::Mat& src);
cv::Mat drwnSoftEdgeMap(const cv::Mat& src, bool bNormalize = false);
void drwnGreyImageInplace(cv::Mat& img);
void drwnColorImageInplace(cv::Mat& img);

cv::Mat drwnPixelwiseMean(const vector<cv::Mat>& imgStack);
cv::Mat drwnPixelwiseMedian(const vector<cv::Mat>& imgStack);

cv::Mat drwnPadImage(const cv::Mat& src, int margin);
cv::Mat drwnPadImage(const cv::Mat& src, const cv::Rect& page);

cv::Mat drwnTranslateMatrix(const cv::Mat& matrix, const cv::Point& origin,
    double fillValue = 0.0);

cv::Mat drwnRotateImage(const cv::Mat& img, float theta);

void drwnScaleToRange(cv::Mat& m, double minValue = 0.0, double maxValue = 1.0);
void drwnResizeInPlace(cv::Mat& m, const cv::Size& size, int interpolation = CV_INTER_LINEAR);
void drwnResizeInPlace(cv::Mat& m, int rows, int cols, int interpolation = CV_INTER_LINEAR);
void drwnCropInPlace(cv::Mat& image, cv::Rect roi);

bool drwnValidRect(const cv::Rect& r, int width, int height);
inline bool drwnValidRect(const cv::Rect& r, const cv::Mat& img) { return drwnValidRect(r, img.cols, img.rows); }
void drwnTruncateRect(cv::Rect& r, int width, int height);
inline void drwnTruncateRect(cv::Rect& r, const cv::Mat& img) { return drwnTruncateRect(r, img.cols, img.rows); }

cv::Mat drwnCombineImages(const vector<cv::Mat>& images, int rows = -1, int cols = -1,
    unsigned margin = 0, const cv::Scalar& colour = cv::Scalar(0));

typedef enum {
    DRWN_COLORMAP_RAINBOW,  
    DRWN_COLORMAP_HOT,      
    DRWN_COLORMAP_COOL,     
    DRWN_COLORMAP_REDGREEN, 
    DRWN_COLORMAP_ANU       
} drwnColorMap;

cv::Mat drwnCreateHeatMap(const cv::Mat& m, drwnColorMap cm = DRWN_COLORMAP_RAINBOW);

cv::Mat drwnCreateHeatMap(const cv::Mat& m, cv::Scalar colourA, cv::Scalar colourB);

cv::Mat drwnCreateHeatMap(const cv::Mat& m, const vector<cv::Scalar>& colours);

vector<cv::Scalar> drwnCreateColorTable(unsigned n, drwnColorMap cm = DRWN_COLORMAP_RAINBOW);

void drwnDrawBoundingBox(cv::Mat& canvas, const cv::Rect& roi, cv::Scalar fgcolor,
    cv::Scalar bgcolor = CV_RGB(255, 255, 255), int lineWidth = 2);

void drwnDrawPolygon(cv::Mat& canvas, const vector<cv::Point> &poly, cv::Scalar fgcolor,
    cv::Scalar bgcolor = CV_RGB(255, 255, 255), int lineWidth = 2, bool bClose = true);

void drwnDrawFullLinePlot(cv::Mat& canvas, const vector<double>& points,
    const cv::Scalar& lineColour, unsigned lineWidth = 2,
    const cv::Scalar& baseShading = CV_RGB(0, 0, 0), double baseAlpha = 0.0);

void drwnDrawTarget(cv::Mat& canvas, const cv::Point& center,
    cv::Scalar color = CV_RGB(255, 0, 0), int size = 5, int lineWidth = 1);

class drwnMouseState {
 public:
    int event, x, y, flags;

 public:
    drwnMouseState() : event(-1), x(0), y(0), flags(0) { /* do nothing */ }
    ~drwnMouseState() { /* do nothing */ }
};

void drwnOnMouse(int event, int x, int y, int flags, void *ptr);

vector<cv::Point> drwnWaitMouse(const string& windowName, const cv::Mat& img,
    int numPoints = DRWN_INT_MAX);

cv::Rect drwnInputBoundingBox(const string& windowName, const cv::Mat& img);

cv::Mat drwnInputScribble(const string& windowName, const cv::Mat& img,
    const cv::Scalar& colour = CV_RGB(255, 0, 0), int width = 5);

double drwnComparePatches(const cv::Mat& patchA, const cv::Mat& patchB, int method = CV_TM_SQDIFF);

// Drawing functions
typedef enum {
    DRWN_FILL_SOLID,      
    DRWN_FILL_DIAG,       
    DRWN_FILL_CROSSHATCH  
} drwnFillType;

void drwnOverlayImages(cv::Mat& canvas, const cv::Mat& overlay, double alpha = 0.5);
void drwnOverlayMask(cv::Mat& canvas, const cv::Mat& mask, const cv::Scalar& color, double alpha = 0.5);
void drwnShadeRectangle(cv::Mat& canvas, cv::Rect roi, const cv::Scalar& color,
    double alpha = 0.5, drwnFillType fill = DRWN_FILL_SOLID, int thickness = 1);
void drwnShadeRegion(cv::Mat& canvas, const cv::Mat& mask, const cv::Scalar& color,
    double alpha = 0.5, drwnFillType fill = DRWN_FILL_SOLID, int thickness = 1);
void drwnMaskRegion(cv::Mat& canvas, const cv::Mat& mask);
void drwnDrawRegionBoundaries(cv::Mat& canvas, const cv::Mat& mask,
    const cv::Scalar& color, int thickness = 1);
void drwnDrawRegionBoundary(cv::Mat& canvas, const cv::Mat& mask,
    int idRegionA, int idRegionB, const cv::Scalar& color, int thickness = 1);
void drwnAverageRegions(cv::Mat& img, const cv::Mat& seg);