io.hpp

Go to the documentation of this file.

#pragma once
 
#include "shape/shape.hpp"

 
 
namespace pgl {
 
// -----------------------------------------------------------------------------
// Point

template <class Number, class Label>
std::ostream& operator<<(std::ostream& stream, const Point<Number, Label>& point) {
    if constexpr (detail::has_label_v<Label>) {
        stream << point.label() << ":(" << point.x() << ',' << point.y() << ')';
    } else {
        stream << '(' << point.x() << ',' << point.y() << ')';
    }
    return stream;
}
 
// -----------------------------------------------------------------------------
// Segment

template <class PointType, class LabelType>
std::ostream& operator<<(std::ostream& stream, const Segment<PointType, LabelType>& segment) {
    if constexpr (detail::has_label_v<LabelType>) {
        stream << segment.label() << ":{" << segment.min() << "--" << segment.max() << "}";
    } else {
        stream << segment.min() << "--" << segment.max();
    }
    return stream;
}
 
// -----------------------------------------------------------------------------
// OrientedSegment

template <class PointType, class LabelType>
std::ostream& operator<<(std::ostream& stream, const OrientedSegment<PointType, LabelType>& segment) {
    if constexpr (detail::has_label_v<LabelType>) {
        stream << segment.label() << ":{" << segment.source() << "->" << segment.target() << "}";
    } else {
        stream << segment.source() << "->" << segment.target();
    }
    return stream;
}
 
// -----------------------------------------------------------------------------
// Line

template <class PointType, class LabelType>
std::ostream& operator<<(std::ostream& stream, const Line<PointType, LabelType>& line) {
    if constexpr (detail::has_label_v<LabelType>) {
        stream << line.label() << ":{-" << line.min() << "--" << line.max() << "-}";
    } else {
        stream << '-' << line.min() << "--" << line.max() << '-';
    }
    return stream;
}
 
// -----------------------------------------------------------------------------
// OrientedLine

template <class PointType, class LabelType>
std::ostream& operator<<(std::ostream& stream, const OrientedLine<PointType, LabelType>& line) {
    if constexpr (detail::has_label_v<LabelType>) {
        stream << line.label() << ":{-" << line.source() << "--" << line.target() << "->}";
    } else {
        stream << '-' << line.source() << "--" << line.target() << "->";
    }
    return stream;
}
 
// -----------------------------------------------------------------------------
// Ray

template <class PointType, class LabelType>
std::ostream& operator<<(std::ostream& stream, const Ray<PointType, LabelType>& ray) {
    if constexpr (detail::has_label_v<LabelType>) {
        stream << ray.label() << ":{" << ray.source() << "--" << ray.target() << "->}";
    } else {
        stream << ray.source() << "--" << ray.target() << "->";
    }
    return stream;
}
 
// -----------------------------------------------------------------------------
// Rectangle

template <class PointType, class LabelType>
std::ostream& operator<<(std::ostream& stream, const Rectangle<PointType, LabelType>& rectangle) {
    if constexpr (detail::has_label_v<LabelType>) {
        stream << rectangle.label() << ':';
    }
    // The corners of an empty rectangle are inverted placeholders, so printing
    // them would read as a rectangle it is not.
    if (rectangle.empty()) {
        return stream << "[]";
    }
    return stream << '[' << rectangle.min() << ',' << rectangle.max() << ']';
}
 
// -----------------------------------------------------------------------------
// Triangle

template <class PointType, class LabelType>
std::ostream& operator<<(std::ostream& stream, const Triangle<PointType, LabelType>& triangle) {
    if constexpr (detail::has_label_v<LabelType>) {
        stream << triangle.label() << ":<" << triangle.a() << triangle.b() << triangle.c() << ">";
    } else {
        stream << '<' << triangle.a() << triangle.b() << triangle.c() << '>';
    }
    return stream;
}
 
// -----------------------------------------------------------------------------
// Halfplane

template <class PointType, class LabelType>
std::ostream& operator<<(std::ostream& stream, const Halfplane<PointType, LabelType>& halfplane) {
    if constexpr (detail::has_label_v<LabelType>) {
        stream << halfplane.label() << ":^-" << halfplane.source() << "--" << halfplane.target() << "-^";
    } else {
        stream << "^-" << halfplane.source() << "--" << halfplane.target() << "-^";
    }
    return stream;
}
 
// -----------------------------------------------------------------------------
// Disk

template <class PointType, class LabelType>
std::ostream& operator<<(std::ostream& stream, const Disk<PointType, LabelType>& disk) {
    if constexpr (detail::has_label_v<LabelType>) {
        stream << disk.label() << ":Disk(" << disk.a() << disk.b() << disk.c() << ")";
    } else {
        stream << "Disk(" << disk.a() << disk.b() << disk.c() << ')';
    }
    return stream;
}
 
 
// -----------------------------------------------------------------------------
// Convex
template <class PointType, class LabelType>
std::ostream& operator<<(std::ostream& stream, const Convex<PointType, LabelType>& convex) {
    if constexpr (detail::has_label_v<LabelType>) {
        stream << convex.label() << ':';
    }
    stream << "Convex[";
    for (size_t i = 0; i < convex.size(); ++i) {
        if (i > 0) {
            stream << ",";
        }
        stream << convex[i];
    }
    stream << "]";
    return stream;
}
 
// -----------------------------------------------------------------------------
// Polygon
template <class PointType, class LabelType>
std::ostream& operator<<(std::ostream& stream, const Polygon<PointType, LabelType>& polygon) {
    stream << "Polygon[";
    for (std::size_t i = 0; i < polygon.size(); ++i) {
        if (i > 0) {
            stream << ",";
        }
        stream << polygon[i];
    }
    stream << "]";
    return stream;
}
 
// -----------------------------------------------------------------------------
// PolygonWithHoles
template <class PointType, class LabelType>
std::ostream& operator<<(std::ostream& stream, const PolygonWithHoles<PointType, LabelType>& region) {
    stream << "PolygonWithHoles[" << region.outer();
    for (const auto& hole : region.holes()) {
        stream << "," << hole;
    }
    stream << "]";
    return stream;
}
 
// -----------------------------------------------------------------------------
// PolygonSet
template <class PointType, class LabelType>
std::ostream& operator<<(std::ostream& stream, const PolygonSet<PointType, LabelType>& set) {
    stream << "PolygonSet[";
    bool first = true;
    for (const auto& component : set) {
        if (!first) {
            stream << ",";
        }
        first = false;
        stream << component;
    }
    stream << "]";
    return stream;
}
 
// -----------------------------------------------------------------------------
// MonotoneChain
template <class PointType, class LabelType, class Storage>
std::ostream& operator<<(std::ostream& stream, const MonotoneChain<PointType, LabelType, Storage>& chain) {
    stream << "MonotoneChain[";
    for (std::size_t i = 0; i < chain.size(); ++i) {
        if (i > 0) {
            stream << ",";
        }
        stream << chain[i];
    }
    stream << "]";
    return stream;
}
 
// -----------------------------------------------------------------------------
// Polyline
template <class PointType, class LabelType>
std::ostream& operator<<(std::ostream& stream, const Polyline<PointType, LabelType>& polyline) {
    stream << "Polyline[";
    for (std::size_t i = 0; i < polyline.size(); ++i) {
        if (i > 0) {
            stream << ",";
        }
        stream << polyline[i];
    }
    stream << "]";
    return stream;
}
 
// ---------------------------------------------------------------------------
// HalfplaneIntersection

template <class PointType, class LabelType>
std::ostream& operator<<(std::ostream& stream, const HalfplaneIntersection<PointType, LabelType>& region) {
    if constexpr (detail::has_label_v<LabelType>) {
        stream << region.label() << ":";
    }
    stream << "HalfplaneIntersection[";
    if (region.empty()) {
        stream << "empty";
    } else if (region.isPlane()) {
        stream << "plane";
    } else {
        for (std::size_t i = 0; i < region.size(); ++i) {
            if (i > 0) {
                stream << ",";
            }
            stream << region[i];
        }
    }
    stream << "]";
    return stream;
}
}  // namespace pgl