draw.hxx

Go to the documentation of this file.

/*
 * Copyright:: Copyright (c) 2013, 2014, 2015, Frank Fischer
 *
 * This file is part of DynG.
 *
 * DynG is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * DynG is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with DynG.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef __DYNG_DRAW_HXX__
#define __DYNG_DRAW_HXX__

#include <iosfwd>
#include <string>
#include <vector>
#include <memory>

namespace Dyng {

typedef int index_type;

class Net;

void write_basegraph_tikz(const Net& net, bool withdoc, std::ostream& out);

void write_basegraph_grav(const Net& net,
                          const std::string& name,
                          std::ostream& out);

void write_rgraph(const Net& net, std::ostream& out);


class GravWriter
{
public:
    struct Color { uint8_t r, g, b; };

    enum NodeShape { Disc, Circ };

public:
    GravWriter(const Net& net, const std::string& name);

    virtual ~GravWriter();

    virtual bool append() const;

    virtual bool node(index_type nodeid,
                      Color& color,
                      NodeShape& shape,
                      std::string& desc) = 0;

    virtual bool arc(index_type arcid,
                     double& cost,
                     double& flow,
                     Color& color,
                     std::string& desc) = 0;

    virtual void write(std::ostream& out);

protected:
    const Net& _net;         
    const std::string _name; 
};

class CorridorGravWriter : public GravWriter
{
public:
    CorridorGravWriter(const Net& net, const std::string& name, bool addgraph = false);

    ~CorridorGravWriter();

    bool append() const;

    bool node(index_type nodeid,
              Color& color,
              NodeShape& shape,
              std::string& desc);

    bool arc(index_type arcid,
             double& cost,
             double& flow,
             Color& color,
             std::string& desc);

    void write(std::ostream& out);

private:
    enum State { Exist, NotExist, Active, Corr };

    void init();

    void node_state(index_type bnodeid, int time,
                    State& state, State& old_state) const;

private:
    struct Data;
    std::unique_ptr<Data> data;
};


enum Attribute : int {
    COST = 0,      
    BASECOST = 1,  
    AUGCOST = 2,   
    FLOW = 3,      
    NODE = 4,      
    TIME = 5,      
};

class Description;

class PathGravWriter : public GravWriter
{
public:
    PathGravWriter(const Net& net, const std::string& name,
                   const std::vector<index_type>& path);

    PathGravWriter(const Net& net, const std::string& name,
                   const std::vector<double>& basecosts,
                   const std::vector<double>& augcosts,
                   const std::vector<index_type>& path);

    PathGravWriter(const Net& net, const std::string& name,
                   int (*getattr)(Attribute attr, index_type id, void* value),
                   const std::vector<index_type>& path);

    PathGravWriter(const Net& net, const std::string& name,
                   const std::vector<const char*>& nodedesc,
                   const std::vector<const char*>& arcdesc,
                   const std::vector<index_type>& path);

    PathGravWriter(const Net& net, const std::string& name,
                   const std::vector<double>& basecosts,
                   const std::vector<double>& augcosts,
                   const std::vector<const char*>& nodedesc,
                   const std::vector<const char*>& arcdesc,
                   const std::vector<index_type>& path);

    ~PathGravWriter();

    bool node(index_type nodeid,
              Color& color,
              NodeShape& shape,
              std::string& desc);

    bool arc(index_type arcid,
             double& cost,
             double& flow,
             Color& color,
             std::string& desc);

private:
    void init_path();

private:
    std::vector<index_type> _path;
    std::vector<index_type> _pathnodes;
    std::vector<double> _basecosts;
    std::vector<double> _augcosts;
    std::unique_ptr<Description> _desc;
};

class FlowGravWriter: public GravWriter
{
public:
    FlowGravWriter(const Net& net, const std::string& name,
                   const std::vector<double>& basecosts,
                   const std::vector<double>& augcosts,
                   const std::vector<const char*>& nodedesc,
                   const std::vector<const char*>& arcdesc,
                   const std::vector<double>& flows,
                   bool append = false);

    ~FlowGravWriter();

    bool append() const { return _append; }

    bool node(index_type nodeid,
              Color& color,
              NodeShape& shape,
              std::string& desc);

    bool arc(index_type arcid,
             double& cost,
             double& flow,
             Color& color,
             std::string& desc);

private:
    bool _append;
    std::vector<double> _flow;
    std::vector<double> _basecosts;
    std::vector<double> _augcosts;
    std::unique_ptr<Description> _desc;
};

void write_corridor_grav(std::ostream& out, const Net& net, const std::string& name, bool addgraph = false);

void write_grav(const Net& net, const std::string& name,
                const std::vector<index_type>& path,
                std::ostream& out);

void write_grav(const Net& net, const std::string& name,
                const std::vector<double>& basecosts,
                const std::vector<double>& augcosts,
                const std::vector<index_type>& path,
                std::ostream& out);


void write_grav(const Net& net, const std::string& name,
                int (*getattr)(Attribute attr, index_type id, void* value),
                const std::vector<index_type>& path,
                std::ostream& out);

void write_grav(const Net& net, const std::string& name,
                const std::vector<const char*>& nodedesc,
                const std::vector<const char*>& arcdesc,
                const std::vector<index_type>& path,
                std::ostream& out);

void write_grav(const Net& net, const std::string& name,
                const std::vector<double>& basecosts,
                const std::vector<double>& augcosts,
                const std::vector<const char*>& nodedesc,
                const std::vector<const char*>& arcdesc,
                const std::vector<index_type>& path,
                std::ostream& out);

void write_flow_grav(std::ostream& out,
                     const Net& net, const std::string& name,
                     const std::vector<double>& basecosts,
                     const std::vector<double>& augcosts,
                     const std::vector<const char*>& nodedesc,
                     const std::vector<const char*>& arcdesc,
                     const std::vector<double>& flow,
                     bool append = false);

}

#endif