primitives.hpp

Go to the documentation of this file.

/*
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 *
 * This program 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, version 3.
 *
 * This program 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.
 */
#ifndef PLASK__PRIMITIVES_H
#define PLASK__PRIMITIVES_H
 
#include "../exceptions.hpp"
#include "../vec.hpp"
 
namespace plask {
 
constexpr double POINT_TOLLERANCE = 1e-12;
 
struct PLASK_API Box2D {
    Vec<2, double> lower;
 
    Vec<2, double> upper;
 
    constexpr Vec<2, double> size() const { return upper - lower; }
 
    constexpr double height() const { return upper.vert() - lower.vert(); }
 
    constexpr double width() const { return upper.tran() - lower.tran(); }
 
    constexpr Vec<2, double> center() const { return 0.5 * (upper + lower); }
 
    Box2D() {}
 
    constexpr Box2D(const Vec<2, double>& lower, const Vec<2, double>& upper) : lower(lower), upper(upper) {}
 
    constexpr Box2D(double x_lo, double y_lo, double x_up, double y_up) : lower(x_lo, y_lo), upper(x_up, y_up) {}
 
    static Box2D invalidInstance() {
        Box2D r;
        r.makeInvalid();
        return r;
    }
 
    bool operator==(const Box2D& r) const;
 
    bool operator!=(const Box2D& r) const;
 
    void fix();
 
    bool contains(const Vec<2, double>& p) const;
 
    bool intersects(const Box2D& other) const;
 
    void makeInclude(const Vec<2, double>& p);
 
    void makeInclude(const Box2D& other);
 
    void makeIntersection(const Box2D& other);
 
    Box2D intersection(Box2D other) const;
 
    Box2D extension(Box2D other) const;
 
    Box2D translated(const Vec<2, double>& translation_vec) const {
        return Box2D(lower + translation_vec, upper + translation_vec);
    }
 
    Box2D operator+(const Vec<2, double>& translation_vec) const {
        return Box2D(lower + translation_vec, upper + translation_vec);
    }
 
    Box2D operator-(const Vec<2, double>& translation_vec) const {
        return Box2D(lower - translation_vec, upper - translation_vec);
    }
 
    Box2D translatedUp(const double trasnalation_in_up_dir) const {
        return translated(vec(0.0, trasnalation_in_up_dir));
    }
 
    void translate(const Vec<2, double>& translation_vec) {
        lower += translation_vec;
        upper += translation_vec;
    }
 
    Box2D& operator+=(const Vec<2, double>& translation_vec) {
        lower += translation_vec;
        upper -= translation_vec;
        return *this;
    }
 
    Box2D& operator-=(const Vec<2, double>& translation_vec) {
        lower -= translation_vec;
        upper -= translation_vec;
        return *this;
    }
 
    void translateUp(const double trasnalation_in_up_dir) {
        lower.vert() += trasnalation_in_up_dir;
        upper.vert() += trasnalation_in_up_dir;
    }
 
    void translateDir(unsigned dir_index, const double trasnalation_in_dir) {
        lower[dir_index] += trasnalation_in_dir;
        upper[dir_index] += trasnalation_in_dir;
    }
 
    Vec<2, double> moveInside(Vec<2, double> p) const;
 
    friend inline std::ostream& operator<<(std::ostream& out, const Box2D& to_print) {
        return out << '[' << to_print.lower << ", " << to_print.upper << ']';
    }
 
    bool isValid() const { return upper.c0 >= lower.c0 && upper.c1 >= lower.c1; }
 
    void makeInvalid() {
        lower = vec(0.0, 0.0);
        upper = vec(-1.0, -1.0);
    }
 
    double getArea() const {
        Vec<2, double> v = size();
        return v.c0 * v.c1;
    }
 
    inline void flip(size_t flipDir) {
        assert(flipDir < 2);
        double temp = lower[flipDir];
        lower[flipDir] = -upper[flipDir];
        upper[flipDir] = -temp;
    }
 
    inline Box2D flipped(size_t i) const {
        Box2D res = *this;
        res.flip(i);
        return res;
    }
 
    const double& left() const { return lower.c0; }
 
    double& left() { return lower.c0; }
 
    const double& right() const { return upper.c0; }
 
    double& right() { return upper.c0; }
 
    const double& bottom() const { return lower.c1; }
 
    double& bottom() { return lower.c1; }
 
    const double& top() const { return upper.c1; }
 
    double& top() { return upper.c1; }
 
    void setLeft(double v) { lower.c0 = v; }
    void setRight(double v) { upper.c0 = v; }
    void setBottom(double v) { lower.c1 = v; }
    void setTop(double v) { upper.c1 = v; }
 
    double getLeft() const { return lower.c0; }
    double getRight() const { return upper.c0; }
    double getBottom() const { return lower.c1; }
    double getTop() const { return upper.c1; }
};
 
struct PLASK_API Box3D {
    Vec<3, double> lower;
 
    Vec<3, double> upper;
 
    constexpr Vec<3, double> size() const { return upper - lower; }
 
    constexpr double height() const { return upper.vert() - lower.vert(); }
 
    constexpr double width() const { return upper.tran() - lower.tran(); }
 
    constexpr double depth() const { return upper.lon() - lower.lon(); }
 
    constexpr Vec<3, double> center() const { return 0.5 * (upper + lower); }
 
    Box3D() {}
 
    constexpr Box3D(const Vec<3, double>& lower, const Vec<3, double>& upper) : lower(lower), upper(upper) {}
 
    constexpr Box3D(double x_lo, double y_lo, double z_lo, double x_up, double y_up, double z_up)
        : lower(x_lo, y_lo, z_lo), upper(x_up, y_up, z_up) {}
 
    static Box3D invalidInstance() {
        Box3D r;
        r.makeInvalid();
        return r;
    }
 
    bool operator==(const Box3D& r) const;
 
    bool operator!=(const Box3D& r) const;
 
    void fix();
 
    bool contains(const Vec<3, double>& p) const;
 
    bool intersects(const Box3D& other) const;
 
    void makeInclude(const Vec<3, double>& p);
 
    void makeInclude(const Box3D& other);
 
    void makeIntersection(const Box3D& other);
 
    Box3D extension(Box3D other) const;
 
    Box3D intersection(Box3D other) const;
 
    Box3D translated(const Vec<3, double>& translation_vec) const {
        return Box3D(lower + translation_vec, upper + translation_vec);
    }
 
    Box3D operator+(const Vec<3, double>& translation_vec) const {
        return Box3D(lower + translation_vec, upper + translation_vec);
    }
 
    Box3D operator-(const Vec<3, double>& translation_vec) const {
        return Box3D(lower - translation_vec, upper - translation_vec);
    }
 
    Box3D translatedUp(const double trasnalation_in_up_dir) const {
        Box3D r = *this;
        r.translateUp(trasnalation_in_up_dir);
        return r;
    }
 
    void translate(const Vec<3, double>& translation_vec) {
        lower += translation_vec;
        upper += translation_vec;
    }
 
    Box3D& operator+=(const Vec<3, double>& translation_vec) {
        lower += translation_vec;
        upper -= translation_vec;
        return *this;
    }
 
    Box3D& operator-=(const Vec<3, double>& translation_vec) {
        lower -= translation_vec;
        upper -= translation_vec;
        return *this;
    }
 
    void translateUp(const double trasnalation_in_up_dir) {
        lower.vert() += trasnalation_in_up_dir;
        upper.vert() += trasnalation_in_up_dir;
    }
 
    void translateDir(unsigned dir_index, const double trasnalation_in_dir) {
        lower[dir_index] += trasnalation_in_dir;
        upper[dir_index] += trasnalation_in_dir;
    }
 
    void makeInclude(const Box2D& other);
 
    Vec<3, double> moveInside(Vec<3, double> p) const;
 
    friend inline std::ostream& operator<<(std::ostream& out, const Box3D& to_print) {
        return out << '[' << to_print.lower << ", " << to_print.upper << ']';
    }
 
    bool isValid() const { return upper.c0 >= lower.c0 && upper.c1 >= lower.c1 && upper.c2 >= lower.c2; }
 
    void makeInvalid() {
        lower = vec(0.0, 0.0, 0.0);
        upper = vec(-1.0, -1.0, -1.0);
    }
 
    double getArea() const {
        Vec<3, double> v = size();
        return v.c0 * v.c1 * v.c2;
    }
 
    inline void flip(size_t flipDir) {
        assert(flipDir < 3);
        double temp = lower[flipDir];
        lower[flipDir] = -upper[flipDir];
        upper[flipDir] = -temp;
    }
 
    inline Box3D flipped(size_t i) const {
        Box3D res = *this;
        res.flip(i);
        return res;
    }
 
    const double& back() const { return lower.c0; }
 
    double& back() { return lower.c0; }
 
    const double& front() const { return upper.c0; }
 
    double& front() { return upper.c0; }
 
    const double& left() const { return lower.c1; }
 
    double& left() { return lower.c1; }
 
    const double& right() const { return upper.c1; }
 
    double& right() { return upper.c1; }
 
    const double& bottom() const { return lower.c2; }
 
    double& bottom() { return lower.c2; }
 
    const double& top() const { return upper.c2; }
 
    double& top() { return upper.c2; }
 
    void setBack(double v) { lower.c0 = v; }
    void setFront(double v) { upper.c0 = v; }
    void setLeft(double v) { lower.c1 = v; }
    void setRight(double v) { upper.c1 = v; }
    void setBottom(double v) { lower.c2 = v; }
    void setTop(double v) { upper.c2 = v; }
 
    double getBack() const { return lower.c0; }
    double getFront() const { return upper.c0; }
    double getLeft() const { return lower.c1; }
    double getRight() const { return upper.c1; }
    double getBottom() const { return lower.c2; }
    double getTop() const { return upper.c2; }
};
 
template <int dim> struct Primitive {};
 
template <> struct PLASK_API Primitive<1> {
    typedef double DVec;
 
    static const int dim = 1;
 
    static const DVec ZERO_VEC;
 
    enum Direction { DIRECTION = 0 };
 
    inline static bool vecFuzzyCompare(DVec a, DVec b) { return b - a > POINT_TOLLERANCE; }
};
 
template <> struct PLASK_API Primitive<2> {
    typedef Box2D Box;
 
    typedef Vec<2, double> DVec;
 
    static const int dim = 2;
 
    static const DVec ZERO_VEC;
 
    static const DVec NAN_VEC;
 
    static const Box INF_BOX;
 
    enum Direction { DIRECTION_TRAN = 0, DIRECTION_VERT = 1 };
 
    static void ensureIsValidDirection(unsigned direction) {
        if (direction > 1) throw Exception("bad 2D direction index, {0} was given but allowed are: 0, 1.", direction);
    }
 
    inline static bool vecFuzzyCompare(const DVec& a, const DVec& b) {
        return b.c1 - a.c1 > POINT_TOLLERANCE || (a.c1 - b.c1 <= POINT_TOLLERANCE && b.c0 - a.c0 > POINT_TOLLERANCE);
    }
};
 
template <> struct PLASK_API Primitive<3> {
    typedef Box3D Box;
 
    typedef Vec<3, double> DVec;
 
    static const int dim = 3;
 
    static const DVec ZERO_VEC;
 
    static const DVec NAN_VEC;
 
    static const Box INF_BOX;
 
    enum Direction { DIRECTION_LONG = 0, DIRECTION_TRAN = 1, DIRECTION_VERT = 2 };
 
    static void ensureIsValidDirection(unsigned direction) {
        if (direction > 2)
            throw DimensionError("bad 3D direction index, {} was given but allowed are: 0, 1, 2.", direction);
    }
 
    static void ensureIsValid2DDirection(unsigned direction) {
        if (direction != DIRECTION_TRAN && direction != DIRECTION_VERT)
            throw DimensionError(
                "bad 2D direction index, {} was given but allowed are: 1 (DIRECTION_TRAN), 2 (DIRECTION_VERT).",
                direction);
    }
 
    inline static bool vecFuzzyCompare(const DVec& a, const DVec& b) {
        return b.c2 - a.c2 > POINT_TOLLERANCE || (a.c2 - b.c2 <= POINT_TOLLERANCE &&
                                                  (b.c1 - a.c1 > POINT_TOLLERANCE || (a.c1 - b.c1 <= POINT_TOLLERANCE &&
                                                                                      b.c0 - a.c0 > POINT_TOLLERANCE)));
    }
};
 
constexpr inline Primitive<3>::Direction direction3D(Primitive<2>::Direction dir2D) {
    return Primitive<3>::Direction(dir2D + 1);
}
 
constexpr inline Primitive<3>::Direction direction3D(Primitive<3>::Direction dir3D) { return dir3D; }
 
template <int dim, typename Primitive<dim>::Direction dirToSkip> struct DirectionWithout {};
 
template <> struct DirectionWithout<2, Primitive<2>::DIRECTION_TRAN> {
    static const Primitive<2>::Direction value = Primitive<2>::DIRECTION_VERT;
    static const Primitive<3>::Direction value3d = Primitive<3>::DIRECTION_VERT;
};
 
template <> struct DirectionWithout<2, Primitive<2>::DIRECTION_VERT> {
    static const Primitive<2>::Direction value = Primitive<2>::DIRECTION_TRAN;
    static const Primitive<3>::Direction value3d = Primitive<3>::DIRECTION_TRAN;
};
 
template <> struct DirectionWithout<3, Primitive<3>::DIRECTION_LONG> {
    static const unsigned value = Primitive<3>::DIRECTION_TRAN | Primitive<3>::DIRECTION_VERT;
    static const Primitive<3>::Direction valueLower = Primitive<3>::DIRECTION_TRAN;
    static const Primitive<3>::Direction valueHigher = Primitive<3>::DIRECTION_VERT;
 
    // should be not usedm but sometimes it is useful to make compilation possible
    static const Primitive<2>::Direction value2D =
        Primitive<2>::Direction(Primitive<2>::DIRECTION_VERT | Primitive<2>::DIRECTION_VERT);
};
 
template <> struct DirectionWithout<3, Primitive<3>::DIRECTION_TRAN> {
    static const unsigned value = Primitive<3>::DIRECTION_LONG | Primitive<3>::DIRECTION_VERT;
    static const Primitive<3>::Direction valueLower = Primitive<3>::DIRECTION_LONG;
    static const Primitive<3>::Direction valueHigher = Primitive<3>::DIRECTION_VERT;
 
    static const Primitive<2>::Direction value2D = Primitive<2>::DIRECTION_VERT;
};
 
template <> struct DirectionWithout<3, Primitive<3>::DIRECTION_VERT> {
    static const unsigned value = Primitive<3>::DIRECTION_LONG | Primitive<3>::DIRECTION_TRAN;
    static const Primitive<3>::Direction valueLower = Primitive<3>::DIRECTION_LONG;
    static const Primitive<3>::Direction valueHigher = Primitive<3>::DIRECTION_TRAN;
 
    static const Primitive<2>::Direction value2D = Primitive<2>::DIRECTION_TRAN;
};
 
}  // namespace plask
 
#endif