PlotCanvas.h

/* Copyright 2017 Kristofer Björnson
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
 
#ifndef COM_DAFER45_TBTK_PLOT_CANVAS
#define COM_DAFER45_TBTK_PLOT_CANVAS
 
#include "TBTK/TBTKMacros.h"
 
#include <string>
 
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
 
namespace TBTK{
namespace Plot{
 
class PlotCanvas{
public:
    PlotCanvas();
 
    ~PlotCanvas();
 
    void setWidth(unsigned int width);
 
    void setHeight(unsigned int height);
 
    void setPadding(
        double paddingLeft,
        double paddingRight,
        double paddingBottom,
        double paddingTop
    );
 
    void setBoundsX(double minX, double maxX);
 
    void setBoundsY(double minY, double maxY);
 
    void setBounds(double minX, double maxX, double minY, double maxY);
 
    double getMinX() const;
 
    double getMaxX() const;
 
    double getMinY() const;
 
    double getMaxY() const;
 
    void setLabelX(const std::string &labelX);
 
    void setLabelY(const std::string &labelY);
 
    void setShowColorBox(bool showColorBox);
 
    bool getShowColorBox() const;
 
    void setBoundsColor(double minColor, double maxColor);
 
    void setCanvas(cv::Mat &canvas);
 
    const cv::Mat& getCanvas() const;
 
    void clear();
 
    void setPixel(
        unsigned int x,
        unsigned int y,
        unsigned char red,
        unsigned char green,
        unsigned char blue
    );
 
    void drawLine(
        double x0,
        double y0,
        double x1,
        double y1,
        const std::vector<unsigned char> &color,
        unsigned int width
    );
 
    void drawCircle(
        double x,
        double y,
        unsigned int size,
        const std::vector<unsigned char> &color
    );
 
    void save(std::string filename) const;
private:
    cv::Mat canvas;
 
    double width, height;
 
    unsigned int paddingLeft, paddingRight, paddingBottom, paddingTop;
 
    double minX, maxX, minY, maxY;
 
    std::string labelX, labelY;
 
    bool showColorBox;
 
    double minColor, maxColor;
 
    static constexpr unsigned int COLOR_BOX_WINDOW_WIDTH = 100;
 
    void drawColorBox();
public:
    cv::Point getCVPoint(double x, double y) const;
 
    void drawAxes();
};
 
inline void PlotCanvas::setWidth(unsigned int width){
    this->width = width;
}
 
inline void PlotCanvas::setHeight(unsigned int height){
    this->height = height;
}
 
inline void PlotCanvas::setPadding(
    double paddingLeft,
    double paddingRight,
    double paddingBottom,
    double paddingTop
){
    this->paddingLeft = paddingLeft;
    this->paddingRight = paddingRight;
    this->paddingBottom = paddingBottom;
    this->paddingTop = paddingTop;
}
 
inline void PlotCanvas::setBoundsX(
    double minX,
    double maxX
){
    TBTKAssert(
        minX <= maxX,
        "Canvas::setBoundsX()",
        "minX has to be smaller than maxX.",
        ""
    );
 
    if(minX == maxX){
        this->minX = minX - 1e-10;
        this->maxX = maxX + 1e-10;
    }
    else{
        this->minX = minX;
        this->maxX = maxX;
    }
}
 
inline void PlotCanvas::setBoundsY(
    double minY,
    double maxY
){
    TBTKAssert(
        minY <= maxY,
        "Canvas::setBoundsY()",
        "minY has to be smaller than maxY.",
        ""
    );
 
    if(minY == maxY){
        this->minY = minY - 1e-10;
        this->maxY = maxY + 1e-10;
    }
    else{
        this->minY = minY;
        this->maxY = maxY;
    }
}
 
inline void PlotCanvas::setBounds(
    double minX,
    double maxX,
    double minY,
    double maxY
){
    setBoundsX(minX, maxX);
    setBoundsY(minY, maxY);
}
 
inline double PlotCanvas::getMinX() const{
    return minX;
}
 
inline double PlotCanvas::getMaxX() const{
    return maxX;
}
 
inline double PlotCanvas::getMinY() const{
    return minY;
}
 
inline double PlotCanvas::getMaxY() const{
    return maxY;
}
 
inline void PlotCanvas::setLabelX(const std::string &labelX){
    this->labelX = labelX;
}
 
inline void PlotCanvas::setLabelY(const std::string &labelY){
    this->labelY = labelY;
}
 
inline void PlotCanvas::setShowColorBox(bool showColorBox){
    this->showColorBox = showColorBox;
}
 
inline bool PlotCanvas::getShowColorBox() const{
    return showColorBox;
}
 
inline void PlotCanvas::setBoundsColor(double minColor, double maxColor){
    this->minColor = minColor;
    this->maxColor = maxColor;
}
 
inline void PlotCanvas::setCanvas(cv::Mat &canvas){
    this->canvas = canvas;
}
 
inline const cv::Mat& PlotCanvas::getCanvas() const{
    return canvas;
}
 
inline cv::Point PlotCanvas::getCVPoint(double x, double y) const{
    double width = maxX - minX;
    double height = maxY - minY;
    return cv::Point(
        paddingLeft + (1 - (paddingLeft + paddingRight + showColorBox*COLOR_BOX_WINDOW_WIDTH)/(double)canvas.cols)*canvas.cols*(x - minX)/(double)width,
        canvas.rows - 1 - (paddingBottom + (1 - (paddingBottom + paddingTop)/(double)canvas.rows)*canvas.rows*(y - minY)/(double)height)
    );
}
 
inline void PlotCanvas::clear(){
    canvas = cv::Mat::zeros(height, width, CV_8UC3);
    cv::rectangle(
        canvas,
        cv::Point(0, 0),
        cv::Point(width-1, height-1),
        cv::Scalar(255, 255, 255),
#if CV_MAJOR_VERSION > 3
        cv::FILLED,
#else
        CV_FILLED,
#endif
        8,
        0
    );
}
 
inline void PlotCanvas::setPixel(
    unsigned int x,
    unsigned int y,
    unsigned char red,
    unsigned char green,
    unsigned char blue
){
    canvas.at<cv::Vec3b>(y, x)[0] = blue;
    canvas.at<cv::Vec3b>(y, x)[1] = green;
    canvas.at<cv::Vec3b>(y, x)[2] = red;
}
 
inline void PlotCanvas::drawLine(
    double x0,
    double y0,
    double x1,
    double y1,
    const std::vector<unsigned char> &color,
    unsigned int width
){
    //Clip lines
    if(x1 < x0){
        double temp = x0;
        x0 = x1;
        x1 = temp;
        temp = y0;
        y0 = y1;
        y1 = temp;
    }
    if(x0 < minX && x1 < minX)
        return;
    if(x0 > maxX && x1 > maxX)
        return;
    if(x0 < minX){
        if(x1 - x0 != 0)
            y0 += (minX - x0)*(y1 - y0)/(x1 - x0);
        x0 = minX;
    }
    if(x1 > maxX){
        if(x1 - x0 != 0)
            y1 -= (x1 - maxX)*(y1 - y0)/(x1 - x0);
        x1 = maxX;
    }
    if(y0 < minY && y1 < minY)
        return;
    if(y0 > maxY && y1 > maxY)
        return;
    if(y0 < minY){
        if(y1 - y0 != 0)
            x0 += (minY - y0)*(x1 - x0)/(y1 - y0);
        y0 = minY;
    }
    if(y1 > maxY){
        if(y1 - y0 != 0)
            x1 -= (y1 - maxY)*(x1 - x0)/(y1 - y0);
        y1 = maxY;
    }
 
    //Draw line
    cv::line(
        canvas,
        getCVPoint(x0, y0),
        getCVPoint(x1, y1),
        cv::Scalar(color[2], color[1], color[0]),
        width,
#if CV_MAJOR_VERSION > 3
        cv::LINE_AA
#else
        CV_AA
#endif
    );
}
 
inline void PlotCanvas::drawCircle(
    double x,
    double y,
    unsigned int size,
    const std::vector<unsigned char> &color
){
    //Clip point
    if(x < minX)
        return;
    if(x > maxX)
        return;
    if(y < minY)
        return;
    if(y > maxY)
        return;
 
    //Draw cirlce
    cv::circle(
        canvas,
        getCVPoint(x, y),
        size,
        cv::Scalar(color[2], color[1], color[0]),
        -1,
#if CV_MAJOR_VERSION > 3
        cv::LINE_AA
#else
        CV_AA
#endif
    );
}
 
inline void PlotCanvas::save(std::string filename) const{
    imwrite(filename, canvas);
}
 
};  //End namespace Plot
};  //End namespace TBTK
 
#endif