TravisLib.hpp

// -*- mode:C++; tab-width:4; c-basic-offset:4; indent-tabs-mode:nil -*-
 
#ifndef __TRAVIS_LIB_HPP__
#define __TRAVIS_LIB_HPP__
 
#include <vector>
 
#include "opencv2/core/mat.hpp"
#include "opencv2/core/types.hpp"
 
namespace roboticslab
{
 
class Travis
{
public:
    Travis(bool quiet=true, bool overwrite=true) : _quiet(quiet), _overwrite(overwrite) {}
 
    bool setCvMat(const cv::Mat& image);
 
    bool setBinCvMat(const cv::Mat& image);
 
    bool binarize(const char* algorithm);
 
    bool binarize(const char* algorithm, const double& threshold);
 
    bool binarize(const char* algorithm, const double& min, const double& max);
 
    void morphClosing(const int& closure);
 
    void morphOpening(const int& opening);
 
    int blobize(const int& maxNumBlobs);
 
    void pushContour(const std::vector<cv::Point>& contour);
 
    bool getBlobsXY(std::vector<cv::Point2d> &locations);
 
    bool getBlobsArea(std::vector<double>& areas);
 
    bool getBlobsSolidity(std::vector<double>& solidities);
 
    bool getBlobsRect(std::vector<cv::Rect>& rects);
 
    bool getBlobsAngle(const int& method, std::vector<double>& angles);
 
    bool getBlobsAspectRatio(std::vector<double>& aspectRatios, std::vector<double>& axisFirsts, std::vector<double>& axisSeconds);
 
    bool getBlobsPerimeter(std::vector<double>& perimeters);
 
    bool getBlobsRectangularity(std::vector<double>& rectangularities);
 
    bool getBlobsHSV(std::vector<double>& hues, std::vector<double>& vals, std::vector<double>& sats,
                     std::vector<double>& hueStdDevs, std::vector<double>& valStdDevs, std::vector<double>& satStdDevs);
 
    cv::Mat& getCvMat(const int& image, const int& vizualization);
 
    void release();
 
protected:
    bool _quiet;
 
    bool _overwrite;
 
    cv::Mat _img;
 
    cv::Mat _imgHsv;
 
    cv::Mat _imgBin;
 
    cv::Mat _imgBin3;
 
    std::vector<std::vector<cv::Point> > _contours;
 
    std::vector<cv::RotatedRect> _minRotatedRects;
 
};
 
bool compareContourAreas (std::vector<cv::Point> contour1, std::vector<cv::Point> contour2 );
 
bool travisCrop(const int x, const int y, const int width, const int height, cv::Mat& img);
 
std::vector<cv::Point> getBiggestContour(const cv::Mat image);
 
void calcLocationXY(float& locX, float& locY, const std::vector<cv::Point> biggestCont);
 
void calcMask(cv::Mat& mask, const std::vector<cv::Point> biggestCont);
 
void calcArea(float& area, const std::vector<cv::Point> biggestCont);
 
void calcRectangularity(float& rectangularity, const std::vector<cv::Point> biggestCont);
 
void calcAngle(float& angle, const std::vector<cv::Point> biggestCont);
 
void calcMassCenter(float& massCenterLocX, float& massCenterLocY , const std::vector<cv::Point> biggestCont);
 
void calcAspectRatio(float& aspectRatio, float& axisFirst, float& axisSecond ,const std::vector<cv::Point> biggestCont);
 
void calcSolidity(float& solidity, const std::vector<cv::Point> biggestCont);
 
void calcHSVMeanStdDev(const cv::Mat image, const cv::Mat mask, float& hue_mean, float& hue_stddev,
                       float& saturation_mean, float& saturation_stddev,
                       float& value_mean, float& value_stddev);
 
void calcHSVPeakColor(const cv::Mat image, const cv::Mat mask, float& hue_mode, float& hue_peak,
                      float& value_mode, float& value_peak);
 
void calcMoments(cv::Mat& theHuMoments, const std::vector<cv::Point> biggestCont );
 
void calcArcLength(float& arc, const std::vector<cv::Point> biggestCont );
 
void calcCircle(float& radius, const std::vector<cv::Point> biggestCont );
 
}  // namespace roboticslab
 
#endif  // __TRAVIS_LIB_HPP__