plane.h

/*
 * Copyright (c) 2017 FilipeCN
 *
 * The MIT License (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.
 *
 */
 
#ifndef HERMES_GEOMETRY_PLANE_H
#define HERMES_GEOMETRY_PLANE_H
 
#include <hermes/geometry/point.h>
#include <hermes/geometry/normal.h>
#include <hermes/geometry/surface.h>
#include <hermes/geometry/vector.h>
 
#include <iostream>
 
namespace hermes {
 
class Plane {
public:
  Plane() { offset = 0; }
  Plane(normal3 n, real_t o) {
    normal = n;
    offset = o;
  }
  Plane(normal3 n, point3 p) {
    normal = n;
    offset = dot(n, (vec3) p);
  }
  static Plane XY(bool invert_normal = false) {
    return {normal3(0, 0, invert_normal ? -1 : 1), 0};
  }
  static Plane XZ(bool invert_normal = false) {
    return {normal3(0, invert_normal ? -1 : 1, 0), 0};
  }
  static Plane YZ(bool invert_normal = false) {
    return {
        normal3(invert_normal ? -1 : 1, 0, 0), 0};
  }
 
  [[nodiscard]] point3 closestPoint(const point3 &p) const {
    float t = (dot(vec3(normal), vec3(p)) - offset) / vec3(normal).length2();
    return p - t * vec3(normal);
  }
  [[nodiscard]] vec3 project(const vec3 &v) const { return hermes::project(v, normal); }
  [[nodiscard]] vec3 reflect(const vec3 &v) const { return hermes::reflect(v, normal); }
  [[nodiscard]] bool onNormalSide(const point3 &p) const {
    return dot(vec3(normal), p - closestPoint(p)) >= 0;
  }
 
  friend std::ostream &operator<<(std::ostream &os, const Plane &p) {
    os << "[Plane] offset " << p.offset << " " << p.normal;
    return os;
  }
 
  normal3 normal;
  real_t offset;
};
 
class ImplicitPlane2D : public ImplicitCurveInterface {
public:
  ImplicitPlane2D() { offset = 0.f; }
  ImplicitPlane2D(normal2 n, real_t o) {
    normal = n;
    offset = o;
  }
  ImplicitPlane2D(point2 p, normal2 n) {
    normal = n;
    offset = dot(vec2(normal), vec2(p));
  }
  [[nodiscard]] vec2 project(const vec2 &v) const { return hermes::project(v, normal); }
  [[nodiscard]] vec2 reflect(const vec2 &v) const { return hermes::reflect(v, normal); }
  [[nodiscard]] point2 closestPoint(const point2 &p) const override {
    real_t t = (dot(vec2(normal), vec2(p)) - offset) / vec2(normal).length2();
    return p - t * vec2(normal);
  }
  [[nodiscard]] normal2 closestNormal(const point2 &p) const override {
    if (dot(vec2(normal), vec2(p)) < 0.f)
      return -normal;
    return normal;
  }
  [[nodiscard]] bbox2 boundingBox() const override { return bbox2(); }
  void closestIntersection(const Ray2 &r,
                           CurveRayIntersection *i) const override {
    HERMES_UNUSED_VARIABLE(r);
    HERMES_UNUSED_VARIABLE(i);
  }
  [[nodiscard]] double signedDistance(const point2 &p) const override {
    return (dot(vec2(p), vec2(normal)) - offset) / vec2(normal).length();
  }
 
  friend std::ostream &operator<<(std::ostream &os, const ImplicitPlane2D &p) {
    os << "[Plane] offset " << p.offset << " " << p.normal;
    return os;
  }
 
  normal2 normal;
  real_t offset;
};
 
} // namespace hermes
 
#endif