duality.hpp

Go to the documentation of this file.

#pragma once
 
#include "implementation/bounding.hpp"

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

template <class Number, class Label>
template <class ResultNumber>
constexpr Line<Point<ResultNumber, Label>> Point<Number, Label>::dual() const {
    return Line<Point<ResultNumber, Label>>(0, -y(), 1, x() - y());
}

template <class Number, class Label>
template <class ResultNumber>
constexpr Line<Point<ResultNumber, Label>> Point<Number, Label>::polar() const {
    assert(x() != 0 || y() != 0);
    // Build two lines through this point that do not contain the origin.
    Point<ResultNumber, Label> p{x(), y()};
    Point<ResultNumber, Label> q1{x() + 1, y() + 1};
    if (crossSign(p, q1) == 0) {
        q1.y() = y() - 1;
    }
    Point<ResultNumber, Label> q2{x() + 1, y()};
    if (crossSign(p, q2) == 0) {
        q2.y() = y() - 1;
    }
    Line<Point<ResultNumber, Label>> l1{p, q1}, l2{p, q2};
    return Line<Point<ResultNumber, Label>>(l1.template polar<ResultNumber>(),
                                            l2.template polar<ResultNumber>());
}
 
// -----------------------------------------------------------------------------
// Line

template <class PointType, class LabelType>
template <class ResultNumber>
constexpr auto Line<PointType, LabelType>::dualCoordinates() const {
    ResultNumber qx = static_cast<ResultNumber>(min().x());
    ResultNumber qy = static_cast<ResultNumber>(min().y());
    ResultNumber px = static_cast<ResultNumber>(max().x());
    ResultNumber py = static_cast<ResultNumber>(max().y());
 
    ResultNumber den = px - qx;
    ResultNumber anum = py - qy;
    ResultNumber bnum = anum * px - py * den;
    return std::make_tuple(anum, bnum, den);
}

template <class PointType, class LabelType>
template <class ResultNumber>
constexpr auto Line<PointType, LabelType>::polarCoordinates() const {
    ResultNumber qx = static_cast<ResultNumber>(min().x());
    ResultNumber qy = static_cast<ResultNumber>(min().y());
    ResultNumber px = static_cast<ResultNumber>(max().x());
    ResultNumber py = static_cast<ResultNumber>(max().y());
 
    ResultNumber den = px * qy - py * qx;
    ResultNumber anum = qy - py;
    ResultNumber bnum = px - qx;
    return std::make_tuple(anum, bnum, den);
}

template <class PointType, class LabelType>
template <class ResultNumber>
constexpr Point<ResultNumber, typename PointType::LabelType> Line<PointType, LabelType>::dual() const {
    assert(!isVertical());
 
    // Line equation: y = anum/den * x - bnum/den.
    const auto [anum, bnum, den] = dualCoordinates<ResultNumber>();
    return Point<ResultNumber, typename PointType::LabelType>(anum / den, bnum / den);
}

template <class PointType, class LabelType>
template <class ResultNumber>
constexpr Point<ResultNumber, typename PointType::LabelType> Line<PointType, LabelType>::polar() const {
    // Line equation: anum/den * x + bnum/den y = 1.
    const auto [anum, bnum, den] = polarCoordinates<ResultNumber>();
    assert(den != 0);
    return Point<ResultNumber, typename PointType::LabelType>(anum / den, bnum / den);
}
 
}  // namespace pgl