Canvas.hpp

// sciplot - a modern C++ scientific plotting library powered by gnuplot
// https://github.com/sciplot/sciplot
//
// Licensed under the MIT License <http://opensource.org/licenses/MIT>.
//
// Copyright (c) 2018-2022 Allan Leal, Bim Overbohm
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
 
#pragma once
 
// C++ includes
#include <variant>
#include <vector>
 
// sciplot includes
#include <sciplot/Figure.hpp>
 
namespace sciplot
{
 
class Canvas
{
  public:
    Canvas(const std::initializer_list<std::initializer_list<Figure>>& figures);
 
    Canvas(const std::vector<std::vector<Figure>>& figures);
 
    Figure& get(int i, int j);
 
    auto autoclean(bool enable = true) -> void;
 
    auto defaultPalette(const std::string& name) -> Canvas&;
 
    auto size(std::size_t width, std::size_t height) -> Canvas&;
 
    auto fontName(std::string name) -> Canvas&;
 
    auto fontSize(std::size_t size) -> Canvas&;
 
    auto title(const std::string& title) -> Canvas&;
 
    auto saveplotdata() const -> void;
 
    auto show() const -> void;
 
    auto save(const std::string& filename) const -> void;
 
    auto cleanup() const -> void;
 
  private:
    static std::size_t m_counter;
 
    std::size_t m_id = 0;
 
    bool m_autoclean = true;
 
    std::string m_defaultPalette;
 
    FontSpecs m_font;
 
    std::size_t m_width = 0;
 
    std::size_t m_height = 0;
 
    std::size_t m_layoutrows = 0;
 
    std::size_t m_layoutcols = 0;
 
    std::string m_title;
 
    std::string m_scriptfilename;
 
    std::vector<std::vector<Figure>> m_figures;
};
 
// Initialize the counter of plot objects
inline std::size_t Canvas::m_counter = 0;
 
inline Canvas::Canvas(const std::initializer_list<std::initializer_list<Figure>>& figures)
    : m_id(m_counter++), m_scriptfilename("multishow" + internal::str(m_id) + ".plt")
{
    m_layoutrows = figures.size();
    m_layoutcols = 1;
    for (const auto& row : figures)
        m_layoutcols = std::max<decltype(m_layoutcols)>(m_layoutcols, row.size()); // m_layoutcols = max number of columns among all rows
 
    for (const auto& row : figures)
        m_figures.emplace_back(row.begin(), row.end());
}
 
inline Canvas::Canvas(const std::vector<std::vector<Figure>>& figures)
    : m_id(m_counter++), m_scriptfilename("multishow" + internal::str(m_id) + ".plt"), m_figures(figures)
{
    m_layoutrows = figures.size();
    m_layoutcols = 1;
    for (const auto& row : figures)
        m_layoutcols = std::max<decltype(m_layoutcols)>(m_layoutcols, row.size()); // m_layoutcols = max number of columns among all rows
}
 
inline Figure& Canvas::get(int i, int j)
{
    return m_figures.at(j).at(i);
}
 
inline auto Canvas::autoclean(bool enable) -> void
{
    m_autoclean = enable;
}
 
inline auto Canvas::defaultPalette(const std::string& name) -> Canvas&
{
    m_defaultPalette = name;
    return *this;
}
 
inline auto Canvas::size(std::size_t width, std::size_t height) -> Canvas&
{
    m_width = width;
    m_height = height;
    return *this;
}
 
inline auto Canvas::fontName(std::string name) -> Canvas&
{
    m_font.fontName(name);
    return *this;
}
 
inline auto Canvas::fontSize(std::size_t size) -> Canvas&
{
    m_font.fontSize(size);
    return *this;
}
 
inline auto Canvas::title(const std::string& title) -> Canvas&
{
    m_title = title;
    return *this;
}
 
inline auto Canvas::saveplotdata() const -> void
{
    for (const auto& row : m_figures)
    {
        for (const auto& figure : row)
        {
            figure.saveplotdata();
        }
    }
}
 
inline auto Canvas::show() const -> void
{
    // Open script file and truncate it
    std::ofstream script(m_scriptfilename);
    // Add palette info. Use default palette if the user hasn't set one
    gnuplot::palettecmd(script, m_defaultPalette.empty() ? internal::SCIPLOT_DEFAULT_PALETTE : m_defaultPalette);
    // Add terminal info
    auto width = m_width == 0 ? internal::DEFAULT_FIGURE_WIDTH : m_width;
    auto height = m_height == 0 ? internal::DEFAULT_FIGURE_HEIGHT : m_height;
    std::string size = gnuplot::canvasSizeStr(width, height, false);
    gnuplot::showterminalcmd(script, size, m_font, m_title);
    // Add the plot commands
    for (const auto& row : m_figures)
    {
        for (const auto& figure : row)
        {
            // Add the plot commands
            script << figure.repr();
        }
    }
    // Add an empty line at the end and close the script to avoid crashes with gnuplot
    script << std::endl;
    script.close();
    // save plot data to file(s)
    saveplotdata();
    // Show the figure
    gnuplot::runscript(m_scriptfilename, true);
    // remove the temporary files if user wants to
    if (m_autoclean)
    {
        cleanup();
    }
}
 
inline auto Canvas::save(const std::string& filename) const -> void
{
    // Clean the file name to prevent errors
    auto cleanedfilename = gnuplot::cleanpath(filename);
    // Get extension from file name
    auto extension = cleanedfilename.substr(cleanedfilename.rfind(".") + 1);
    // Open script file
    std::ofstream script(m_scriptfilename);
    // Add palette info. Use default palette if the user hasn't set one
    gnuplot::palettecmd(script, m_defaultPalette.empty() ? internal::SCIPLOT_DEFAULT_PALETTE : m_defaultPalette);
    // Add terminal info including output size
    auto width = m_width == 0 ? internal::DEFAULT_FIGURE_WIDTH : m_width;
    auto height = m_height == 0 ? internal::DEFAULT_FIGURE_HEIGHT : m_height;
    std::string size = gnuplot::canvasSizeStr(width, height, extension == "pdf");
    gnuplot::saveterminalcmd(script, extension, size, m_font);
    // Add output command
    gnuplot::outputcmd(script, cleanedfilename);
    // Add the plot commands
    for (const auto& row : m_figures)
    {
        for (const auto& figure : row)
        {
            // Add the plot commands
            script << figure.repr();
        }
    }
    // Unset the output
    script << std::endl;
    script << "set output";
    // Add an empty line at the end and close the script to avoid crashes with gnuplot
    script << std::endl;
    script.close();
    // save plot data to file(s)
    saveplotdata();
    // Save the figure as a file
    gnuplot::runscript(m_scriptfilename, false);
    // remove the temporary files if user wants to
    if (m_autoclean)
    {
        cleanup();
    }
}
 
inline auto Canvas::cleanup() const -> void
{
    std::remove(m_scriptfilename.c_str());
    for (const auto& row : m_figures)
    {
        for (const auto& figure : row)
        {
            figure.cleanup();
        }
    }
}
 
} // namespace sciplot