svg.hpp

Go to the documentation of this file.

/*
   ____ __     ______
  / ___|\ \   / / ___|
  \___ \ \ \ / / |  _
   ___) | \ V /| |_| |
  |____/   \_/  \____|
 
  SVG for C++ v0.2.0
 
  Copyright (c) 2018-2026 Vincent La
  SPDX-License-Identifier: MIT
 
  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
#define PI 3.14159265
#define RAD_TO_DEG (180/PI)
#define SVG_TYPE_CHECK static_assert(std::is_base_of<Element, T>::value, "Child must be an SVG element.")
#define APPROX_EQUALS(x, y, tol) bool(abs(x - y) < tol)
#include <iostream>
#include <algorithm> // min, max
#include <cctype>
#include <fstream>   // ofstream
#include <math.h>    // NAN
#include <map>
#include <deque>
#include <vector>
#include <string>
#include <sstream> // stringstream
#include <iomanip> // setprecision
#include <memory>
#include <stdexcept>
#include <type_traits> // is_base_of
#include <typeinfo>
#include <utility>
 
namespace SVG {
    class AttributeMap;
    class SVG;
    class Shape;
 
    struct QuadCoord {
        double x1;
        double x2;
        double y1;
        double y2;
    };
 
    using SelectorProperties = std::map<std::string, AttributeMap>;
    using SVGAttrib = std::map<std::string, std::string>;
    using Point = std::pair<double, double>;
    using Margins = QuadCoord;
    const static Margins DEFAULT_MARGINS = { 10, 10, 10, 10 };
    const static Margins NO_MARGINS = { 0, 0, 0, 0 };
 
#if __cplusplus < 201402L
    namespace detail {
        template<typename T, typename... Args>
        std::unique_ptr<T> make_unique(Args&&... args) {
            return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
        }
    }
#else
    namespace detail {
        using std::make_unique;
    }
#endif
 
    inline std::string to_string(const double& value);
    inline std::string to_string(const Point& point);
    inline std::string to_string(const std::map<std::string, AttributeMap>& css, const size_t indent_level=0);
 
    std::vector<Point> bounding_polygon(const std::vector<Shape*>& shapes);
    SVG frame_animate(std::vector<SVG>& frames, const double fps);
    SVG merge(SVG& left, SVG& right, const Margins& margins = DEFAULT_MARGINS);
    SVG merge(std::vector<SVG>& frames, const double width, const int max_frame_width);
 
    class ClassList {
    public:
        ClassList() = default;
        explicit ClassList(std::string& value) : mutable_value_(&value), value_(&value) {}
        explicit ClassList(const std::string& value) : value_(&value) {}
 
        bool contains(const std::string& token) const {
            validate_token(token);
            const auto values = tokens();
            return std::find(values.begin(), values.end(), token) != values.end();
        }
 
        ClassList& add(const std::string& token) {
            validate_token(token);
            auto values = tokens();
            if (std::find(values.begin(), values.end(), token) == values.end()) {
                values.push_back(token);
                write(values);
            }
            return *this;
        }
 
        ClassList& remove(const std::string& token) {
            validate_token(token);
            auto values = tokens();
            const auto original_size = values.size();
            values.erase(std::remove(values.begin(), values.end(), token), values.end());
            if (values.size() != original_size) {
                write(values);
            }
            return *this;
        }
 
        bool toggle(const std::string& token) {
            if (contains(token)) {
                remove(token);
                return false;
            }
 
            add(token);
            return true;
        }
 
        ClassList& set(const std::string& class_names) {
            write(parse(class_names));
            return *this;
        }
 
        ClassList& clear() {
            write({});
            return *this;
        }
 
        std::string str() const {
            return join(tokens());
        }
 
        std::vector<std::string> tokens() const {
            return parse(value());
        }
 
    private:
        static bool is_space(char ch) {
            return std::isspace(static_cast<unsigned char>(ch)) != 0;
        }
 
        static void validate_token(const std::string& token) {
            if (token.empty()) {
                throw std::invalid_argument("class token cannot be empty");
            }
            if (std::find_if(token.begin(), token.end(), is_space) != token.end()) {
                throw std::invalid_argument("class token cannot contain whitespace");
            }
        }
 
        static std::vector<std::string> parse(const std::string& class_names) {
            std::vector<std::string> result;
            std::string token;
            for (const auto ch : class_names) {
                if (is_space(ch)) {
                    if (!token.empty()) {
                        if (std::find(result.begin(), result.end(), token) == result.end()) {
                            result.push_back(token);
                        }
                        token.clear();
                    }
                    continue;
                }
                token.push_back(ch);
            }
            if (!token.empty() && std::find(result.begin(), result.end(), token) == result.end()) {
                result.push_back(token);
            }
            return result;
        }
 
        static std::string join(const std::vector<std::string>& values) {
            std::string result;
            for (std::size_t i = 0; i < values.size(); ++i) {
                if (i > 0) {
                    result += ' ';
                }
                result += values[i];
            }
            return result;
        }
 
        const std::string& value() const {
            static const std::string empty;
            return value_ ? *value_ : empty;
        }
 
        void write(const std::vector<std::string>& values) {
            if (!mutable_value_) {
                throw std::logic_error("cannot mutate a const class list");
            }
            *mutable_value_ = join(values);
            value_ = mutable_value_;
        }
 
        std::string* mutable_value_ = nullptr;
        const std::string* value_ = nullptr;
    };
 
    namespace util {
        enum Orientation {
            COLINEAR, CLOCKWISE, COUNTERCLOCKWISE
        };
 
        inline std::vector<Point> polar_points(int n, int a, int b, double radius);
        
        template<typename T>
        inline T min_or_not_nan(T first, T second) {
            if (isnan(first) && isnan(second))
                return NAN;
            else if (isnan(first) || isnan(second))
                return isnan(first) ? second : first;
            else
                return std::min(first, second);
        }
 
        template<typename T>
        inline T max_or_not_nan(T first, T second) {
            if (isnan(first) && isnan(second))
                return NAN;
            else if (isnan(first) || isnan(second))
                return isnan(first) ? second : first;
            else
                return std::max(first, second);
        }
 
        inline Orientation orientation(Point& p1, Point& p2, Point& p3) {
            double value = ((p2.second - p1.second) * (p3.first - p2.first) -
                (p2.first - p1.first) * (p3.second - p2.second));
            
            if (value == 0) return COLINEAR;
            else if (value > 0) return CLOCKWISE;
            else return COUNTERCLOCKWISE;
        }
 
        inline std::vector<Point> convex_hull(std::vector<Point>& points) {
            if (points.size() < 3) return {}; // Need at least three points
            std::vector<Point> hull;
 
            // Find leftmost point (ties don't matter)
            int left = 0;
            for (size_t i = 0; i < points.size(); i++)
                if (points[i].first < points[left].first) left = (int)i;
            
            // While we don't reach leftmost point
            int current = left, next;
            do {
                // Add to convex hull
                hull.push_back(points[current]);
 
                // Keep moving counterclockwise
                next = (current + 1) % points.size();
                for (size_t i = 0; i < points.size(); i++) {
                    // We've found a more counterclockwise point --> update next
                    if (orientation(points[current], points[next], points[i]) == COUNTERCLOCKWISE)
                        next = (int)i;
                }
 
                current = next;
            } while (current != left);
 
            return hull;
        }
 
        inline std::vector<Point> polar_points(int n, int a, int b, double radius) {
            std::vector<Point> ret;
            for (double degree = 0; degree < 360; degree += 360/n) {
                ret.push_back(Point(
                    a + radius * cos(degree * (PI/180)), // 1 degree = pi/180 radians
                    b + radius * sin(degree * (PI/180))
                ));
            }
 
            return ret;
        }
    }
 
    inline std::string to_string(const double& value) {
        std::stringstream ss;
        ss << std::fixed << std::setprecision(1);
        ss << value;
        return ss.str();
    }
 
    inline std::string to_string(const Point& point) {
        return to_string(point.first) + "," + to_string(point.second);
    }
 
    class AttributeMap {
    public:
        struct AttrSetter {
            AttrSetter(SVGAttrib::mapped_type& _attr, bool _normalize_class = false) :
                    attr(_attr), normalize_class(_normalize_class) {};
            SVGAttrib::mapped_type& attr;
            bool normalize_class = false;
 
            template<typename T>
            AttrSetter& operator<<(T value) {
                attr += std::to_string(value);
                normalize();
                return *this;
            }
 
            void normalize() {
                if (normalize_class) {
                    ClassList(attr).set(attr);
                }
            }
        };
 
        AttributeMap() = default;
        AttributeMap(SVGAttrib _attr) : attr(_attr) {};
        SVGAttrib attr;
 
        template<typename T>
        AttributeMap& set_attr(const std::string key, T value) {
            this->set_attr_value(key, std::to_string(value));
            return *this;
        }
 
        AttributeMap& set_attrs(std::initializer_list<std::pair<std::string, std::string>> values) {
            for (const auto& pair : values) {
                this->set_attr_value(pair.first, pair.second);
            }
 
            return *this;
        }
 
        AttrSetter set_attr(const std::string key) {
            if (this->attr.find(key) == this->attr.end()) this->attr[key] = "";
            return AttrSetter(this->attr.at(key), key == "class");
        };
 
        ClassList class_list() {
            return ClassList(this->attr["class"]);
        }
 
        ClassList class_list() const {
            const auto found = this->attr.find("class");
            return found == this->attr.end() ? ClassList() : ClassList(found->second);
        }
 
    private:
        void set_attr_value(const std::string& key, const std::string& value) {
            if (key == "class") {
                ClassList(this->attr[key]).set(value);
                return;
            }
            this->attr[key] = value;
        }
    };
 
    template<>
    inline AttributeMap::AttrSetter& AttributeMap::AttrSetter::operator<<(const char * value) {
        attr += value;
        normalize();
        return *this;
    }
 
    template<>
    inline AttributeMap& AttributeMap::set_attr(const std::string key, const double value) {
        this->set_attr_value(key, to_string(value));
        return *this;
    }
 
    template<>
    inline AttributeMap& AttributeMap::set_attr(const std::string key, const char * value) {
        this->set_attr_value(key, value);
        return *this;
    }
 
    template<>
    inline AttributeMap& AttributeMap::set_attr(const std::string key, const std::string value) {
        this->set_attr_value(key, value);
        return *this;
    }
 
    class Element: public AttributeMap {
    public:
        class BoundingBox : public QuadCoord {
        public:
            using QuadCoord::QuadCoord;
            BoundingBox() = default;
            BoundingBox(double a, double b, double c, double d) : QuadCoord({ a, b, c, d }) {};
 
            BoundingBox operator+ (const BoundingBox& other) {
                using namespace util;
                BoundingBox new_box;
                new_box.x1 = min_or_not_nan(this->x1, other.x1);
                new_box.x2 = max_or_not_nan(this->x2, other.x2);
                new_box.y1 = min_or_not_nan(this->y1, other.y1);
                new_box.y2 = max_or_not_nan(this->y2, other.y2);
                return new_box;
            }
        };
        using ChildList = std::vector<Element*>;
        using ChildMap = std::map<std::string, ChildList>;
 
        Element() = default;
        virtual ~Element() = default;
        Element(const Element& other) = delete; // No copy constructor
        Element(Element&& other) = default; // Move constructor
        Element& operator=(const Element&) = delete; // No copy assignment
        Element& operator=(Element&& other) = default;
 
        Element(const char* id) : AttributeMap(
            SVGAttrib({ { "id", id } })) {};
        using AttributeMap::AttributeMap;
 
        // Implicit string conversion
        operator std::string() { return this->svg_to_string(0); };
 
        template<typename T, typename... Args>
        T* add_child(Args&&... args) {
            SVG_TYPE_CHECK;
            this->children.push_back(detail::make_unique<T>(std::forward<Args>(args)...));
            return (T*)this->children.back().get();
        }
 
        template<typename T>
        Element& operator<<(T&& node) {
            SVG_TYPE_CHECK;
            this->children.push_back(detail::make_unique<T>(std::move(node)));
            return *this;
        }
 
        template<typename T>
        std::vector<T*> get_children() {
            SVG_TYPE_CHECK;
            std::vector<T*> ret;
            auto child_elems = this->get_children_helper();
            
            for (auto& child: child_elems)
                if (typeid(*child) == typeid(T)) ret.push_back((T*)child);
 
            return ret;
        }
 
        template<typename T>
        std::vector<T*> get_immediate_children() {
            SVG_TYPE_CHECK;
            std::vector<T*> ret;
            for (auto& child : this->children) {
                auto& t = *child;
                if (typeid(t) == typeid(T)) ret.push_back((T*)child.get());
            }
 
            return ret;
        }
 
        Element* get_element_by_id(const std::string& id);
        std::vector<Element*> get_elements_by_class(const std::string& clsname);
        void autoscale(const Margins& margins=DEFAULT_MARGINS);
        void autoscale(const double margin);
        virtual BoundingBox get_bbox();
        ChildMap get_children();
 
    protected:
        std::vector<std::unique_ptr<Element>> children; 
        std::vector<Element*> get_children_helper();
        void get_bbox(Element::BoundingBox&);
        virtual std::string svg_to_string(const size_t indent_level); 
        virtual std::string tag() = 0; 
        double find_numeric(const std::string& key) {
            if (attr.find(key) != attr.end())
                return std::stof(attr[key]);
            return NAN;
        }
    };
 
    template<>
    inline Element::ChildList Element::get_immediate_children() {
        Element::ChildList ret;
        for (auto& child : this->children) ret.push_back(child.get());
        return ret;
    }
 
    inline Element* Element::get_element_by_id(const std::string &id) {
        auto child_elems = this->get_children_helper();
        for (auto& current: child_elems)
            if (current->attr.find("id") != current->attr.end() && 
                current->attr.find("id")->second == id) return current;
        
        return nullptr;
    }
 
    inline std::vector<Element*> Element::get_elements_by_class(const std::string &clsname) {
        std::vector<Element*> ret;
        auto child_elems = this->get_children_helper();
    
        for (auto& current: child_elems) {
            if ((current->attr.find("class") != current->attr.end())
                && current->class_list().contains(clsname))
                ret.push_back(current);
        }
    
        return ret;
    }
 
    inline Element::BoundingBox Element::get_bbox() {
        return { NAN, NAN, NAN, NAN };
    }
 
    class Shape: public Element {
    public:
        using Element::Element;
 
        operator Point() {
            return std::make_pair(this->x(), this->y());
        }
 
        virtual std::vector<Point> points() {
            auto bbox = this->get_bbox();
            return {
                Point(bbox.x1, bbox.y1), // Top left
                Point(bbox.x2, bbox.y1), // Top right
                Point(bbox.x1, bbox.y2), // Bottom left
                Point(bbox.x2, bbox.y2)  // Bottom right
            };
        }
 
        virtual double x() { return this->find_numeric("x"); }
        virtual double y() { return this->find_numeric("y"); }
        virtual double width() {
            return this->find_numeric("width");
        }
        virtual double height() {
            return this->find_numeric("height");
        }
    };
 
    class SVG : public Shape {
    public:
        class Style : public Element {
        public:
            Style() = default;
            using Element::Element;
            SelectorProperties css; 
            std::map<std::string, SelectorProperties> media_queries; 
            std::map<std::string, SelectorProperties> keyframes; 
        protected:
            std::string svg_to_string(const size_t) override;
            std::string tag() override { return "style"; };
        };
 
        SVG(SVGAttrib _attr =
                { { "xmlns", "http://www.w3.org/2000/svg" } }
        ) : Shape(_attr) {};
 
        AttributeMap& style(const std::string& key) { return this->css->css[key]; }
 
        AttributeMap& media_style(const std::string& query, const std::string& key) {
            return this->css->media_queries[query][key];
        }
 
        std::map<std::string, AttributeMap>& keyframes(const std::string& key) {
            if (!this->css) this->css = this->add_child<Style>();
            return this->css->keyframes[key];
        }
 
        Style* css = this->add_child<Style>(); 
    protected:
        std::string tag() override { return "svg"; }
    };
 
    class Path : public Shape {
    public:
        using Shape::Shape;
 
        template<typename T>
        inline void start(T x, T y) {
            this->attr["d"] = "M " + std::to_string(x) + " " + std::to_string(y);
            this->x_start = x;
            this->y_start = y;
        }
 
        template<typename T>
        inline void line_to(T x, T y) {
            if (this->attr.find("d") == this->attr.end())
                start(x, y);
            else
                this->attr["d"] += " L " + std::to_string(x) +
                                   " " + std::to_string(y);
        }
 
        inline void line_to(std::pair<double, double> coord) {
            this->line_to(coord.first, coord.second);
        }
 
        inline void to_origin() {
            this->line_to(x_start, y_start);
        }
 
    protected:
        std::string tag() override { return "path"; }
 
    private:
        double x_start;
        double y_start;
    };
 
    class Text : public Element {
    public:
        Text() = default;
        using Element::Element;
 
        Text(double x, double y, std::string _content) {
            set_attr("x", to_string(x));
            set_attr("y", to_string(y));
            content = _content;
        }
 
        Text(std::pair<double, double> xy, std::string _content) :
                Text(xy.first, xy.second, _content) {};
 
    protected:
        std::string content;
        std::string svg_to_string(const size_t) override;
        std::string tag() override { return "text"; }
    };
 
    class Group : public Element {
    public:
        using Element::Element;
    protected:
        std::string tag() override { return "g"; }
    };
 
    class Line : public Shape {
    public:
        Line() = default;
        using Shape::Shape;
 
        Line(double x1, double x2, double y1, double y2) : Shape({
                { "x1", to_string(x1) },
                { "x2", to_string(x2) },
                { "y1", to_string(y1) },
                { "y2", to_string(y2) }
        }) {};
 
        Line(Point x, Point y) : Line(x.first, y.first, x.second, y.second) {};
 
        virtual double x() override { return x1() + (x2() - x1()) / 2; }
        virtual double y() override { return y1() + (y2() - y1()) / 2; }
        double x1() { return this->find_numeric("x1"); }
        double x2() { return this->find_numeric("x2"); }
        double y1() { return this->find_numeric("y1"); }
        double y2() { return this->find_numeric("y2"); }
 
        double width() override { return std::abs(x2() - x1()); }
        double height() override { return std::abs(y2() - y1()); }
        double length() { return std::sqrt(pow(width(), 2) + pow(height(), 2)); }
        double slope() { return (y2() - y1()) / (x2() - x1()); }
        double angle() { return atan(this->slope()) * RAD_TO_DEG; }
 
        std::pair<double, double> along(double percent);
 
    protected:
        Element::BoundingBox get_bbox() override;   
        std::string tag() override { return "line"; }
    };
 
    class Rect : public Shape {
    public:
        Rect() = default;
        using Shape::Shape;
 
        Rect(
            double x, double y, double width, double height) :
            Shape({
                    { "x", to_string(x) },
                    { "y", to_string(y) },
                    { "width", to_string(width) },
                    { "height", to_string(height) }
            }) {};
 
        Element::BoundingBox get_bbox() override;
    protected:
        std::string tag() override { return "rect"; }
    };
 
    class Circle : public Shape {
    public:
        Circle() = default;
        using Shape::Shape;
 
        Circle(double cx, double cy, double radius) :
                Shape({
                        { "cx", to_string(cx) },
                        { "cy", to_string(cy) },
                        { "r", to_string(radius) }
                }) {
        };
 
        Circle(std::pair<double, double> xy, double radius) : Circle(xy.first, xy.second, radius) {};
        double radius() { return this->find_numeric("r"); }
        virtual double x() override { return this->find_numeric("cx"); }
        virtual double y() override { return this->find_numeric("cy"); }
        virtual double width() override { return this->radius() * 2; }
        virtual double height() override { return this->width(); }
        Element::BoundingBox get_bbox() override;
 
    protected:
        std::string tag() override { return "circle"; }
    };
 
    class Polygon : public Element {
    public:
        Polygon() = default;
        using Element::Element;
 
        Polygon(const std::vector<Point>& points) {
            // Quick and dirty
            std::string& point_str = this->attr["points"];
            for (auto& pt : points)
                point_str += to_string(pt) + " ";
        };
 
    protected:
        std::string tag() override { return "polygon"; }
    };
 
    inline Element::BoundingBox Line::get_bbox() {
        return { x1(), x2(), y1(), y2() };
    }
 
    inline Element::BoundingBox Rect::get_bbox() {
        double x = this->x(), y = this->y(),
            width = this->width(), height = this->height();
        return { x, x + width, y, y + height };
    }
 
    inline Element::BoundingBox Circle::get_bbox() {
        double x = this->x(), y = this->y(), radius = this->radius();
 
        return {
            x - radius,
            x + radius,
            y - radius,
            y + radius
        };
    }
 
    inline std::pair<double, double> Line::along(double percent) {
        double x_pos, y_pos;
 
        if (x1() != x2()) {
            double length = percent * this->length();
            double discrim = std::sqrt(4 * pow(length, 2) * (1 / (1 + pow(slope(), 2))));
 
            double x_a = (2 * x1() + discrim) / 2;
            double x_b = (2 * x1() - discrim) / 2;
            x_pos = x_a;
 
            if ((x_a > x1() && x_a > x2()) || (x_a < x1() && x_a < x2()))
                x_pos = x_b;
 
            y_pos = slope() * (x_pos - x1()) + y1();
        }
        else { // Edge case:: Completely vertical lines
            x_pos = x1();
 
            if (y1() > y2()) // Downward pointing
                y_pos = y1() - percent * this->length();
            else
                y_pos = y1() + percent * this->length();
        }
 
        return std::make_pair(x_pos, y_pos);
    }
 
    inline std::string Element::svg_to_string(const size_t indent_level) {
        auto indent = std::string(indent_level, '\t');
        std::string ret = indent + "<" + tag();
 
        // Set attributes
        for (auto& pair: attr)
            ret += " " + pair.first + "=" + "\"" + pair.second + "\"";
 
        if (!this->children.empty()) {
            ret += ">\n";
 
            // Recursively get strings for child elements
            for (auto& child : children) {
                // Avoid adding empty strings
                auto str = child->svg_to_string(indent_level + 1);
                if (str.size()) ret += str +"\n";
            }
 
            return ret += indent + "</" + tag() + ">";
        }
 
        return ret += " />";
    }
 
    inline std::string to_string(const std::map<std::string, AttributeMap>& css, const size_t indent_level) {
        auto indent = std::string(indent_level, '\t'), ret = std::string();
        for (auto& selector : css) {
            // Loop over each selector's attribute/value pairs
            ret += indent + "\t\t" + selector.first + " {\n";
            for (auto& attr : selector.second.attr)
                ret += indent + "\t\t\t" + attr.first + ": " + attr.second + ";\n";
            ret += indent + "\t\t" + "}\n";
        }
        return ret;
    }
 
    inline std::string SVG::Style::svg_to_string(const size_t indent_level) {
        auto indent = std::string(indent_level, '\t');
 
        if (!this->css.empty() || !this->media_queries.empty() || !this->keyframes.empty()) {
            std::string ret = indent + "<style type=\"text/css\">\n" +
                indent + "\t<![CDATA[\n";
 
            // Begin CSS stylesheet
            ret += to_string(this->css, indent_level);
 
            // Media queries
            for (auto& media : this->media_queries) {
                ret += indent + "\t\t@media " + media.first + " {\n" +
                    to_string(media.second, indent_level + 1) +
                    indent + "\t\t" + "}\n";
            }
 
            // Animation frames
            for (auto& anim : this->keyframes) {
                ret += indent + "\t\t@keyframes " + anim.first + " {\n" +
                    to_string(anim.second, indent_level + 1) +
                    indent + "\t\t" + "}\n";
            }
 
            ret += indent + "\t]]>\n";
            return ret + indent + "</style>";
        }
 
        return "";
    }
 
    inline std::string Text::svg_to_string(const size_t indent_level) {
        auto indent = std::string(indent_level, '\t');
        std::string ret = indent + "<text";
        for (auto& pair: attr)
            ret += " " + pair.first + "=" + "\"" + pair.second + "\"";
        return ret += ">" + this->content + "</text>";
    }
 
    inline void Element::autoscale(const double margin) {
        Element::BoundingBox bbox = this->get_bbox();
        this->get_bbox(bbox);
        double width = abs(bbox.x1) + abs(bbox.x2),
            height = abs(bbox.y1) + abs(bbox.y2);
 
        this->autoscale({
            width * margin, width * margin,
            height * margin, height * margin 
        });
    }
 
    inline void Element::autoscale(const Margins& margins) {
        using std::stof;
 
        Element::BoundingBox bbox = this->get_bbox();
        this->get_bbox(bbox); // Compute the bounding box (recursive)
        double width = abs(bbox.x1) + abs(bbox.x2) + margins.x1 + margins.x2,
            height = abs(bbox.y1) + abs(bbox.y2) + margins.y1 + margins.y2,
            x1 = bbox.x1 - margins.x1, y1 = bbox.y1 - margins.y1;
 
        this->set_attr("width", width)
             .set_attr("height", height);
 
        if (x1 < 0 || y1 < 0) {
            std::stringstream viewbox;
            viewbox << std::fixed << std::setprecision(1)
                << x1 << " " // min-x
                << y1 << " " // min-y
                << width << " "
                << height;
            this->set_attr("viewBox", viewbox.str());
        }
    }
 
    inline void Element::get_bbox(Element::BoundingBox& box) {
        auto this_bbox = this->get_bbox();
        box = this_bbox + box; // Take union of both
        for (auto& child: this->children) child->get_bbox(box); // Recursion
    }
 
    inline Element::ChildMap Element::get_children() {
        Element::ChildMap child_map;
        for (auto& child : this->get_children_helper())
            child_map[child->tag()].push_back(child);
        return child_map;
    }
 
    inline std::vector<Element*> Element::get_children_helper() {
        std::deque<Element*> temp;
        std::vector<Element*> ret;
 
        for (auto& child : this->children) { temp.push_back(child.get()); }
        while (!temp.empty()) {
            ret.push_back(temp.front());
            for (auto& child : temp.front()->children) { temp.push_back(child.get()); }
            temp.pop_front();
        }
 
        return ret;
    };
 
    inline SVG merge(SVG& left, SVG& right, const Margins& margins) {
        SVG ret;
 
        // Move items
        ret << std::move(left) << std::move(right);
 
        // Set bounding box of individual pieces
        for (auto& svg_child: ret.get_immediate_children<SVG>())
            svg_child->autoscale(margins);
 
        // Set x position for child SVG elements, and compute width/height for this
        double x = 0, height = 0;
        for (auto& svg_child: ret.get_immediate_children<SVG>()) {
            svg_child->set_attr("x", x).set_attr("y", 0);
            x += svg_child->width();
            height = std::max(height, svg_child->height());
        }
 
        ret.set_attr("width", x).set_attr("height", height);
        return ret;
    }
 
    inline std::vector<Point> bounding_polygon(std::vector<Shape*>& shapes) {
        /* Convert shapes into sets of points, aggregate them, and then calculate
         * convex hull for aggregate set
         */
        std::vector<Point> points;
        for (auto& shp : shapes) {
            auto temp_points = shp->points();
            std::move(temp_points.begin(), temp_points.end(), std::back_inserter(points));
        }
 
        return util::convex_hull(points);
    }
 
    inline SVG merge(std::vector<SVG>& frames, const double width, const int max_frame_width) {
        SVG root;
        double x = 0, y = 0, total_width = 0, total_height = 0;
        for (auto& frame : frames) {
            // Scale
            frame.autoscale();
            if (frame.width() > max_frame_width) {
                const double scale_factor = max_frame_width/frame.width();
                frame.set_attr("width", max_frame_width);
                frame.set_attr("height", frame.height() * scale_factor); // Scale height proportionally
            }
        }
 
        // Move
        double current_height = 0;
        for (auto& frame : frames) {
            // Push to next row
            if ((x + frame.width()) > width) {
                total_width = std::max(total_width, x);
                x = 0;
                y += current_height;
                current_height = 0;
            }
 
            frame.set_attr("x", x).set_attr("y", y);
            x += frame.width();
            current_height = std::max(current_height, frame.height());
            root << std::move(frame);
        }
 
        total_height = y + current_height;
 
        // Set viewbox
        root.set_attr("viewBox") << 0 << " " << 0 << " " << total_width << " " << total_height;
        root.set_attr("width", total_width).set_attr("height", total_height);
        return root;
    }
 
    inline SVG frame_animate(std::vector<SVG>& frames, const double fps) {
        SVG root;
        const double duration = (double)frames.size() / fps; // [seconds]
        const double frame_step = 1.0 / fps; // duration of each frame [seconds]
        int current_frame = 0;
 
        root.style("svg.animated").set_attr("animation-iteration-count", "infinite")
            .set_attr("animation-timing-function", "step-end")
            .set_attr("animation-duration", std::to_string(duration) + "s")
            .set_attr("opacity", 0);
 
        // Move frames into new SVG
        for (auto& frame : frames) {
            std::string frame_id = "frame_" + std::to_string(current_frame);
            frame.set_attr("id", frame_id).set_attr("class", "animated");
            root.style("#" + frame_id).set_attr("animation-name",
                "anim_" + std::to_string(current_frame));
            current_frame++;
            root << std::move(frame);
        }
 
        // Set animation frames
        for (size_t i = 0, ilen = frames.size(); i < ilen; i++) {
            auto& anim = root.keyframes("anim_" + std::to_string(i));
            double begin_pct = (double)i / frames.size(),
                end_pct = (double)(i + 1) / frames.size();
            anim["0%"].set_attr("opacity", 0);
            anim[std::to_string(begin_pct * 100) + "%"].set_attr("opacity", 1);
            anim[std::to_string(end_pct * 100) + "%"].set_attr("opacity", 0);
        }
 
        // Scale and center child SVGs
        double width = 0, height = 0;
 
        for (auto& child : root.get_immediate_children<SVG>()) {
            child->autoscale();
            width = std::max(width, child->width());
            height = std::max(height, child->height());
        }
 
        root.set_attr("viewBox", "0 0 " + std::to_string(width) + " " + std::to_string(height));
 
        // Center child SVGs
        for (auto& child : root.get_immediate_children<SVG>())
            child->set_attr("x", (width - child->width())/2).set_attr("y", (height - child->height())/2);
 
        return root;
    }
}