common.h

// Copyright 2026 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 <cmath>
#include <limits>
#include <memory>
#include <vector>
 
#if defined(MANIFOLD_DEBUG) || defined(MANIFOLD_TIMING)
#include <chrono>
#include <iostream>
#endif
 
#include "./math.h"
#include "linalg.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 NAN;
  if (x < 0.0) return -sind(-x);
  int quo;
  x = std::remquo(std::fabs(x), 90.0, &quo);
  const double xr = radians(x);
  switch (quo % 4) {
    case 0:
      return math::sin(xr);
    case 1:
      return math::cos(xr);
    case 2:
      return -math::sin(xr);
    case 3:
      return -math::cos(xr);
  }
  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 RayHit {
  uint64_t faceID = 0;
  double distance = 0;
  vec3 position = vec3(0.0);
  vec3 normal = vec3(0.0);
};

class ExecutionContext {
 public:
  ExecutionContext();
  ~ExecutionContext();
  ExecutionContext(const ExecutionContext&);
  ExecutionContext(ExecutionContext&&) noexcept;
  ExecutionContext& operator=(const ExecutionContext&);
  ExecutionContext& operator=(ExecutionContext&&) noexcept;

  void Cancel();
  bool Cancelled() const;
  double Progress() const;

  struct Impl;
  std::shared_ptr<Impl> impl_;
};

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));
  }

  constexpr bool operator==(const Box& box) const {
    return la::all(la::equal(box.min, min)) && la::all(la::equal(max, box.max));
  }

  constexpr bool operator!=(const Box& box) const { return !(*this == box); }

  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 : char { Add, Subtract, Intersect };
 
constexpr int DEFAULT_SEGMENTS = 0;
constexpr double DEFAULT_ANGLE = 10.0;
constexpr double DEFAULT_LENGTH = 1.0;
class Quality {
 public:
  static void SetMinCircularAngle(double angle);
  static void SetMinCircularEdgeLength(double length);
  static void SetCircularSegments(int number);
  static int GetCircularSegments(double radius);
  static void ResetToDefaults();
};



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

 
#ifdef MANIFOLD_DEBUG
 
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;
}
 
#endif
 
#if defined(MANIFOLD_DEBUG) || defined(MANIFOLD_TIMING)
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