axes.h

Go to the documentation of this file.

#pragma once
#include <string>
#include "interop/util/lexical_cast.h"

namespace illumina { namespace interop { namespace model { namespace plot {

    class axis
    {
    public:
        axis() : m_min(0), m_max(0){}
    public:
        void set_range(const float vmin, const float vmax)
        {
            m_min = vmin;
            m_max = vmax;
        }
        void set_label(const std::string& label)
        {
            m_label = label;
        }
        void clear()
        {
            m_min = 0.0f;
            m_max = 0.0f;
            m_label = "";
        }

    public:
        const std::string& label()const
        {
            return m_label;
        }
        float min()const
        {
            return m_min;
        }
        float max()const
        {
            return m_max;
        }
    public:
        friend std::ostream& operator<<(std::ostream& out, const axis& data)
        {
            std::ios::fmtflags previous_state( out.flags() );
            out << std::setprecision(10) << data.m_min << "," << data.m_max << ",";
            out << data.m_label << ",";
            out.flags(previous_state);
            return out;
        }
        friend std::istream& operator>>(std::istream& in, axis& data)
        {
            std::string tmp;
            std::getline(in, tmp, ',');
            data.m_min = util::lexical_cast<float>(tmp);
            std::getline(in, tmp, ',');
            data.m_max = util::lexical_cast<float>(tmp);
            std::getline(in, data.m_label, ',');
            return in;
        }

    private:
        float m_min;
        float m_max;
        std::string m_label;
    };
    class axes
    {
    public:
        void set_range(const float xmin, const float xmax, const float ymin, const float ymax)
        {
            set_xrange(xmin, xmax);
            set_yrange(ymin, ymax);
        }
        void set_xrange(const float vmin, const float vmax)
        {
            m_x.set_range(vmin, vmax);
        }
        void set_yrange(const float vmin, const float vmax)
        {
            m_y.set_range(vmin, vmax);
        }
        void set_xlabel(const std::string& label)
        {
            m_x.set_label(label);
        }
        void set_ylabel(const std::string& label)
        {
            m_y.set_label(label);
        }
        void set_xaxis(const axis& xaxes)
        {
            m_x = xaxes;
        }
        void set_yaxis(const axis& yaxes)
        {
            m_y = yaxes;
        }
        void clear()
        {
            m_x.clear();
            m_y.clear();
        }

    public:
        const std::string& xlabel()const
        {
            return m_x.label();
        }
        const std::string& ylabel()const
        {
            return m_y.label();
        }
        const axis& x()const
        {
            return m_x;
        }
        const axis& y()const
        {
            return m_y;
        }
    public:

        friend std::ostream& operator<<(std::ostream& out, const axes& data)
        {
            out << data.m_x;
            out << data.m_y;
            return out;
        }
        friend std::istream& operator>>(std::istream& in, axes& data)
        {
            in >> data.m_x;
            in >> data.m_y;
            return in;
        }

    private:
        axis m_x;
        axis m_y;
    };

}}}}