common.h

// Copyright 2021 The Manifold Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
#include <limits>
#include <vector>
 
#ifdef MANIFOLD_DEBUG
#include <chrono>
#endif
 
#include "linalg.h"
#include "optional_assert.h"
 
namespace manifold {

namespace la = linalg;
using vec2 = la::vec<double, 2>;
using vec3 = la::vec<double, 3>;
using vec4 = la::vec<double, 4>;
using bvec4 = la::vec<bool, 4>;
using mat2 = la::mat<double, 2, 2>;
using mat3x2 = la::mat<double, 3, 2>;
using mat4x2 = la::mat<double, 4, 2>;
using mat2x3 = la::mat<double, 2, 3>;
using mat3 = la::mat<double, 3, 3>;
using mat4x3 = la::mat<double, 4, 3>;
using mat3x4 = la::mat<double, 3, 4>;
using mat4 = la::mat<double, 4, 4>;
using ivec2 = la::vec<int, 2>;
using ivec3 = la::vec<int, 3>;
using ivec4 = la::vec<int, 4>;
using quat = la::vec<double, 4>;

 
constexpr double kPi = 3.14159265358979323846264338327950288;
constexpr double kTwoPi = 6.28318530717958647692528676655900576;
constexpr double kHalfPi = 1.57079632679489661923132169163975144;

constexpr double radians(double a) { return a * kPi / 180; }

constexpr double degrees(double a) { return a * 180 / kPi; }

constexpr double smoothstep(double edge0, double edge1, double a) {
  const double x = la::clamp((a - edge0) / (edge1 - edge0), 0, 1);
  return x * x * (3 - 2 * x);
}

inline double sind(double x) {
  if (!la::isfinite(x)) return sin(x);
  if (x < 0.0) return -sind(-x);
  int quo;
  x = remquo(fabs(x), 90.0, &quo);
  switch (quo % 4) {
    case 0:
      return sin(radians(x));
    case 1:
      return cos(radians(x));
    case 2:
      return -sin(radians(x));
    case 3:
      return -cos(radians(x));
  }
  return 0.0;
}

inline double cosd(double x) { return sind(x + 90.0); }


using SimplePolygon = std::vector<vec2>;

using Polygons = std::vector<SimplePolygon>;

struct Smoothness {
  size_t halfedge;
  double smoothness;
};

struct Box {
  vec3 min = vec3(std::numeric_limits<double>::infinity());
  vec3 max = vec3(-std::numeric_limits<double>::infinity());

  constexpr Box() {}

  constexpr Box(const vec3 p1, const vec3 p2) {
    min = la::min(p1, p2);
    max = la::max(p1, p2);
  }

  constexpr vec3 Size() const { return max - min; }

  constexpr vec3 Center() const { return 0.5 * (max + min); }

  constexpr double Scale() const {
    vec3 absMax = la::max(la::abs(min), la::abs(max));
    return la::max(absMax.x, la::max(absMax.y, absMax.z));
  }

  constexpr bool Contains(const vec3& p) const {
    return la::all(la::gequal(p, min)) && la::all(la::gequal(max, p));
  }

  constexpr bool Contains(const Box& box) const {
    return la::all(la::gequal(box.min, min)) &&
           la::all(la::gequal(max, box.max));
  }

  void Union(const vec3 p) {
    min = la::min(min, p);
    max = la::max(max, p);
  }

  constexpr Box Union(const Box& box) const {
    Box out;
    out.min = la::min(min, box.min);
    out.max = la::max(max, box.max);
    return out;
  }

  constexpr Box Transform(const mat3x4& transform) const {
    Box out;
    vec3 minT = transform * vec4(min, 1.0);
    vec3 maxT = transform * vec4(max, 1.0);
    out.min = la::min(minT, maxT);
    out.max = la::max(minT, maxT);
    return out;
  }

  constexpr Box operator+(vec3 shift) const {
    Box out;
    out.min = min + shift;
    out.max = max + shift;
    return out;
  }

  Box& operator+=(vec3 shift) {
    min += shift;
    max += shift;
    return *this;
  }

  constexpr Box operator*(vec3 scale) const {
    Box out;
    out.min = min * scale;
    out.max = max * scale;
    return out;
  }

  Box& operator*=(vec3 scale) {
    min *= scale;
    max *= scale;
    return *this;
  }

  constexpr bool DoesOverlap(const Box& box) const {
    return min.x <= box.max.x && min.y <= box.max.y && min.z <= box.max.z &&
           max.x >= box.min.x && max.y >= box.min.y && max.z >= box.min.z;
  }

  constexpr bool DoesOverlap(vec3 p) const {  // projected in z
    return p.x <= max.x && p.x >= min.x && p.y <= max.y && p.y >= min.y;
  }

  constexpr bool IsFinite() const {
    return la::all(la::isfinite(min)) && la::all(la::isfinite(max));
  }
};

struct Rect {
  vec2 min = vec2(std::numeric_limits<double>::infinity());
  vec2 max = vec2(-std::numeric_limits<double>::infinity());

  constexpr Rect() {}

  constexpr Rect(const vec2 a, const vec2 b) {
    min = la::min(a, b);
    max = la::max(a, b);
  }


  constexpr vec2 Size() const { return max - min; }

  constexpr double Area() const {
    auto sz = Size();
    return sz.x * sz.y;
  }

  constexpr double Scale() const {
    vec2 absMax = la::max(la::abs(min), la::abs(max));
    return la::max(absMax.x, absMax.y);
  }

  constexpr vec2 Center() const { return 0.5 * (max + min); }

  constexpr bool Contains(const vec2& p) const {
    return la::all(la::gequal(p, min)) && la::all(la::gequal(max, p));
  }

  constexpr bool Contains(const Rect& rect) const {
    return la::all(la::gequal(rect.min, min)) &&
           la::all(la::gequal(max, rect.max));
  }

  constexpr bool DoesOverlap(const Rect& rect) const {
    return min.x <= rect.max.x && min.y <= rect.max.y && max.x >= rect.min.x &&
           max.y >= rect.min.y;
  }

  constexpr bool IsEmpty() const { return max.y <= min.y || max.x <= min.x; };

  constexpr bool IsFinite() const {
    return la::all(la::isfinite(min)) && la::all(la::isfinite(max));
  }



  void Union(const vec2 p) {
    min = la::min(min, p);
    max = la::max(max, p);
  }

  constexpr Rect Union(const Rect& rect) const {
    Rect out;
    out.min = la::min(min, rect.min);
    out.max = la::max(max, rect.max);
    return out;
  }

  constexpr Rect operator+(const vec2 shift) const {
    Rect out;
    out.min = min + shift;
    out.max = max + shift;
    return out;
  }

  Rect& operator+=(const vec2 shift) {
    min += shift;
    max += shift;
    return *this;
  }

  constexpr Rect operator*(const vec2 scale) const {
    Rect out;
    out.min = min * scale;
    out.max = max * scale;
    return out;
  }

  Rect& operator*=(const vec2 scale) {
    min *= scale;
    max *= scale;
    return *this;
  }

  constexpr Rect Transform(const mat2x3& m) const {
    Rect rect;
    rect.min = m * vec3(min, 1);
    rect.max = m * vec3(max, 1);
    return rect;
  }

};

enum class OpType { Add, Subtract, Intersect };
 
constexpr int DEFAULT_SEGMENTS = 0;
constexpr double DEFAULT_ANGLE = 10.0;
constexpr double DEFAULT_LENGTH = 1.0;
class Quality {
 private:
  inline static int circularSegments_ = DEFAULT_SEGMENTS;
  inline static double circularAngle_ = DEFAULT_ANGLE;
  inline static double circularEdgeLength_ = DEFAULT_LENGTH;
 
 public:
  static void SetMinCircularAngle(double angle) {
    if (angle <= 0) return;
    circularAngle_ = angle;
  }

  static void SetMinCircularEdgeLength(double length) {
    if (length <= 0) return;
    circularEdgeLength_ = length;
  }

  static void SetCircularSegments(int number) {
    if (number < 3 && number != 0) return;
    circularSegments_ = number;
  }

  static int GetCircularSegments(double radius) {
    if (circularSegments_ > 0) return circularSegments_;
    int nSegA = 360.0 / circularAngle_;
    int nSegL = 2.0 * radius * kPi / circularEdgeLength_;
    int nSeg = fmin(nSegA, nSegL) + 3;
    nSeg -= nSeg % 4;
    return std::max(nSeg, 4);
  }

  static void ResetToDefaults() {
    circularSegments_ = DEFAULT_SEGMENTS;
    circularAngle_ = DEFAULT_ANGLE;
    circularEdgeLength_ = DEFAULT_LENGTH;
  }
};



struct ExecutionParams {
  bool intermediateChecks = false;
  bool selfIntersectionChecks = false;
  bool processOverlaps = true;
  bool suppressErrors = false;
  bool cleanupTriangles = true;
  int verbose = 0;
};

 
#ifdef MANIFOLD_DEBUG
template <class T>
std::ostream& operator<<(std::ostream& out, const la::vec<T, 1>& v) {
  return out << '{' << v[0] << '}';
}
template <class T>
std::ostream& operator<<(std::ostream& out, const la::vec<T, 2>& v) {
  return out << '{' << v[0] << ',' << v[1] << '}';
}
template <class T>
std::ostream& operator<<(std::ostream& out, const la::vec<T, 3>& v) {
  return out << '{' << v[0] << ',' << v[1] << ',' << v[2] << '}';
}
template <class T>
std::ostream& operator<<(std::ostream& out, const la::vec<T, 4>& v) {
  return out << '{' << v[0] << ',' << v[1] << ',' << v[2] << ',' << v[3] << '}';
}
 
template <class T, int M>
std::ostream& operator<<(std::ostream& out, const la::mat<T, M, 1>& m) {
  return out << '{' << m[0] << '}';
}
template <class T, int M>
std::ostream& operator<<(std::ostream& out, const la::mat<T, M, 2>& m) {
  return out << '{' << m[0] << ',' << m[1] << '}';
}
template <class T, int M>
std::ostream& operator<<(std::ostream& out, const la::mat<T, M, 3>& m) {
  return out << '{' << m[0] << ',' << m[1] << ',' << m[2] << '}';
}
template <class T, int M>
std::ostream& operator<<(std::ostream& out, const la::mat<T, M, 4>& m) {
  return out << '{' << m[0] << ',' << m[1] << ',' << m[2] << ',' << m[3] << '}';
}
 
inline std::ostream& operator<<(std::ostream& stream, const Box& box) {
  return stream << "min: " << box.min << ", "
                << "max: " << box.max;
}
 
inline std::ostream& operator<<(std::ostream& stream, const Rect& box) {
  return stream << "min: " << box.min << ", "
                << "max: " << box.max;
}
 
inline std::ostream& operator<<(std::ostream& stream, const Smoothness& s) {
  return stream << "halfedge: " << s.halfedge << ", "
                << "smoothness: " << s.smoothness;
}

template <typename T>
void Dump(const std::vector<T>& vec) {
  std::cout << "Vec = " << std::endl;
  for (size_t i = 0; i < vec.size(); ++i) {
    std::cout << i << ", " << vec[i] << ", " << std::endl;
  }
  std::cout << std::endl;
}
 
template <typename T>
void Diff(const std::vector<T>& a, const std::vector<T>& b) {
  std::cout << "Diff = " << std::endl;
  if (a.size() != b.size()) {
    std::cout << "a and b must have the same length, aborting Diff"
              << std::endl;
    return;
  }
  for (size_t i = 0; i < a.size(); ++i) {
    if (a[i] != b[i])
      std::cout << i << ": " << a[i] << ", " << b[i] << std::endl;
  }
  std::cout << std::endl;
}
 
struct Timer {
  std::chrono::high_resolution_clock::time_point start, end;
 
  void Start() { start = std::chrono::high_resolution_clock::now(); }
 
  void Stop() { end = std::chrono::high_resolution_clock::now(); }
 
  float Elapsed() {
    return std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
        .count();
  }
  void Print(std::string message) {
    std::cout << "----------- " << std::round(Elapsed()) << " ms for "
              << message << std::endl;
  }
};
#endif
}  // namespace manifold