jade::basic_svg_tree< TValue > Class Template Reference

A template for a class that renders newick trees as SVG. More...

#include <jade.svg_tree.hpp>

Collaboration diagram for jade::basic_svg_tree< TValue >:

Public Types
typedef TValue	value_type
	The value type. More...
typedef basic_newick_node< value_type >	node_type
	The Newick node type. More...
typedef basic_vec2< value_type >	vec2_type
	The vector type. More...

Public Member Functions
	basic_svg_tree (const node_type &node)
	Initializes a new instance of the class based on the specified node. More...
void	optimize_positions ()
	Optimizes the positions of the vertices using the Nelder-Mead Simplex method. More...
std::string	str () const
	Returns the SVG scene as a string. More...
void	write (std::ostream &out) const
	Writes the SVG scene to the specified output stream. More...
void	write (char const *const path) const
	Writes the SVG scene to the specified output file. More...
void	write (const std::string &path) const
	Writes the SVG scene to the specified output file. More...

Detailed Description

template<typename TValue>
class jade::basic_svg_tree< TValue >

A template for a class that renders newick trees as SVG.

Definition at line 20 of file jade.svg_tree.hpp.

Member Typedef Documentation

node_type

template<typename TValue >

typedef basic_newick_node<value_type> jade::basic_svg_tree< TValue >::node_type

The Newick node type.

Definition at line 27 of file jade.svg_tree.hpp.

value_type

template<typename TValue >

typedef TValue jade::basic_svg_tree< TValue >::value_type

The value type.

Definition at line 24 of file jade.svg_tree.hpp.

vec2_type

template<typename TValue >

typedef basic_vec2<value_type> jade::basic_svg_tree< TValue >::vec2_type

The vector type.

Definition at line 30 of file jade.svg_tree.hpp.

Constructor & Destructor Documentation

basic_svg_tree()

template<typename TValue >

jade::basic_svg_tree< TValue >::basic_svg_tree ( const node_type &  node )

inlineexplicit

Initializes a new instance of the class based on the specified node.

Parameters

node	The newick node.

Definition at line 36 of file jade.svg_tree.hpp.

            : _root  (node.get_id())
            , _table ()
        {
            _init_table(node);
            _update_table(node);
        }

Member Function Documentation

optimize_positions()

template<typename TValue >

void jade::basic_svg_tree< TValue >::optimize_positions ( )

inline

Optimizes the positions of the vertices using the Nelder-Mead Simplex method.

Definition at line 49 of file jade.svg_tree.hpp.

        {
            typedef basic_simplex<value_type>             simplex_type;
            typedef typename simplex_type::container_type container_type;
            typedef typename simplex_type::execute_args   execute_args_type;
            typedef typename simplex_type::options        options_type;
 
            //
            // Updates the radians and positions of each node based on a
            // specified Nelder-Mead parameter set.
            //
            const auto import_params = [this](
                    const container_type & params) -> void
            {
                auto dst = _table.begin();
                for (auto src = params.begin(); src != params.end(); ++src)
                    (dst++)->second.radians = *src;
                _update_table(*_table.find(_root)->second.node);
            };
 
            //
            // Computes the objective function for the Nelder-Mead method. The
            // value returned is the sum of the inverses of the distances
            // between all pairs of distinct nodes.
            //
            const auto objfunc = [this, import_params](
                    const container_type & params) -> value_type
            {
                import_params(params);
                auto sum = value_type(0);
                for (const auto & a0 : _table)
                for (const auto & b0 : _table)
                if (a0.first != b0.first)
                {
                    const auto a = a0.second.position;
                    const auto b = b0.second.position;
                    const auto d = vec2_type::distance_squared(a, b);
                    if (d < 1e-6) // epsilon
                        return std::numeric_limits<value_type>::max();
                    sum += value_type(1) / d;
                }
                return sum;
            };
 
            //
            // Converts a specified number of degrees to radians.
            //
            const auto to_radians = [](const value_type deg) -> value_type
            {
                static const auto tau = value_type(2.0 * std::acos(-1.0));
                return deg * tau / value_type(360.0);
            };
 
            const auto n = _table.size();
 
            //
            // Construct the simplex using a unit size of one degree and the
            // current positions of the nodes.
            //
            options_type opts (n);
            opts.unit = to_radians(1);
            opts.vertex.clear();
            for (const auto & p : _table)
                opts.vertex.push_back(p.second.radians);
            simplex_type simplex (objfunc, opts);
 
            //
            // Execute the Nelder-Mead method until the simplex has collapsed
            // or a maximum timeout occurs; execute at least a minimum number
            // of iterations.
            //
            execute_args_type exe_args_1;
            exe_args_1.max_iterations = 100;
            exe_args_1.max_seconds    = 0.5;
            simplex.execute(objfunc, exe_args_1);
 
            execute_args_type exe_args_2;
            exe_args_2.min_length  = to_radians(0.01) * value_type(n);
            exe_args_2.max_seconds = 0.5;
            simplex.execute(objfunc, exe_args_2);
 
            //
            // Import the final parameters from the simplex.
            //
            import_params(simplex.get_vertex());
        }

Here is the call graph for this function:

Here is the caller graph for this function:

str()

template<typename TValue >

std::string jade::basic_svg_tree< TValue >::str ( ) const

inline

Returns the SVG scene as a string.

Returns

The SVG scene as a string.

Definition at line 141 of file jade.svg_tree.hpp.

        {
            std::ostringstream out;
            write(out);
            return out.str();
        }

Here is the call graph for this function:

write() [1/3]

template<typename TValue >

void jade::basic_svg_tree< TValue >::write ( char const *const  path ) const

inline

Writes the SVG scene to the specified output file.

Parameters

path	The path to the output file.

Definition at line 168 of file jade.svg_tree.hpp.

        {
            assert(path != nullptr);
            std::ofstream out (path);
            if (!out.good())
                throw error() << "error opening '" << path << "' for writing";
            write(out);
        }

Here is the call graph for this function:

write() [2/3]

template<typename TValue >

void jade::basic_svg_tree< TValue >::write ( const std::string &  path ) const

inline

Writes the SVG scene to the specified output file.

Parameters

path	The path to the output file.

Definition at line 182 of file jade.svg_tree.hpp.

        {
            write(path.c_str());
        }

Here is the call graph for this function:

write() [3/3]

template<typename TValue >

void jade::basic_svg_tree< TValue >::write ( std::ostream &  out ) const

inline

Writes the SVG scene to the specified output stream.

Parameters

out	The output stream.

Definition at line 151 of file jade.svg_tree.hpp.

        {
            const auto & root  = *_table.find(_root)->second.node;
            metrics_data metrics;
            _create_metrics(metrics);
 
            _write_svg_header(out, metrics);
            _write_edges(out, metrics, root);
            _write_nodes(out, metrics, root);
            _write_svg_footer(out);
        }

Here is the caller graph for this function:

---

The documentation for this class was generated from the following file:

• jade.svg_tree.hpp