complexGeomObjects.h

Go to the documentation of this file.

/*
* -------------------------------------------
* Copyright (c) 2021 - 2026 Prashant K. Jha
* -------------------------------------------
* PeriDEM https://github.com/prashjha/PeriDEM
*
* Distributed under the Boost Software License, Version 1.0. (See accompanying
* file LICENSE)
*/
 
#ifndef GEOM_COMPLEXGEOMOBJECTS_H
#define GEOM_COMPLEXGEOMOBJECTS_H
 
#include <iostream>
#include <utility>
#include <memory>
#include <map>
 
#include "geomObjects.h"
#include "geomObjectsUtil.h"
 
namespace geom {
 
  class AnnulusGeomObject : public GeomObject {
  public:
    GeomObject *d_outObj_p;
 
    GeomObject *d_inObj_p;
 
    size_t d_dim;
 
  public:
    AnnulusGeomObject()
      : GeomObject("annulus_object", ""),
        d_outObj_p(nullptr),
        d_inObj_p(nullptr),
        d_dim(0) {
    };
 
    AnnulusGeomObject(GeomObject *in, GeomObject *out, std::string description = "")
      : GeomObject("annulus_object", description),
        d_outObj_p(out),
        d_inObj_p(in),
        d_dim(0) {
      d_dim = getGeomTypeToDim(d_outObj_p->d_name); // assume all types have same dim
    };
 
    AnnulusGeomObject(const AnnulusGeomObject &other)
      : GeomObject(other.d_name, other.d_description),
        d_outObj_p(nullptr),
        d_inObj_p(nullptr),
        d_dim(other.d_dim) {
      // Copy tags from base class
      d_tags = other.d_tags;
 
      // Deep copy inner and outer objects using utility function
      d_inObj_p = createGeomDeepCopy(other.d_inObj_p);
      d_outObj_p = createGeomDeepCopy(other.d_outObj_p);
    }
 
    ~AnnulusGeomObject() {
      delete d_inObj_p;
      delete d_outObj_p;
    }
 
    AnnulusGeomObject& operator=(const AnnulusGeomObject& other) {
      if (this != &other) {
        // Clean up existing objects
        delete d_inObj_p;
        delete d_outObj_p;
        d_inObj_p = nullptr;
        d_outObj_p = nullptr;
 
        // Copy base class members
        d_tags = other.d_tags;
        d_dim = other.d_dim;
 
        // Deep copy inner and outer objects using utility function
        d_inObj_p = createGeomDeepCopy(other.d_inObj_p);
        d_outObj_p = createGeomDeepCopy(other.d_outObj_p);
      }
      return *this;
    }
 
    void transform(const util::Point &translation, const double &scale, 
                  const double &angle, const util::Point &axis,
                  const util::Point *rotationPoint) override {
      const util::Point *pivot = rotationPoint;
      util::Point pivotStore;
      if (pivot == nullptr) {
        if (d_inObj_p && d_outObj_p) {
          pivotStore = center();
          pivot = &pivotStore;
        } else if (d_inObj_p) {
          pivotStore = d_inObj_p->center();
          pivot = &pivotStore;
        } else if (d_outObj_p) {
          pivotStore = d_outObj_p->center();
          pivot = &pivotStore;
        }
      }
      if (d_inObj_p) d_inObj_p->transform(translation, scale, angle, axis, pivot);
      if (d_outObj_p) d_outObj_p->transform(translation, scale, angle, axis, pivot);
    }
 
    double volume() const override;
 
    util::Point center() const override;
 
    std::pair<util::Point, util::Point> box() const override;
 
    std::pair<util::Point, util::Point>
    box(const double &tol) const override;
 
    double inscribedRadius() const override;
 
    double boundingRadius() const override;
 
    bool isInside(const util::Point &x) const override;
 
    bool isOutside(const util::Point &x) const override;
 
    bool isNear(const util::Point &x, const double &tol) const override;
 
    bool isNearBoundary(const util::Point &x, const double &tol,
                        const bool &within) const override;
 
    bool doesIntersect(const util::Point &x) const override;
 
    bool
    isInside(
      const std::pair<util::Point, util::Point> &box) const override;
 
    bool
    isOutside(
      const std::pair<util::Point, util::Point> &box) const override;
 
    bool isNear(const std::pair<util::Point, util::Point> &box,
                const double &tol) const override;
 
    bool doesIntersect(
      const std::pair<util::Point, util::Point> &box) const override;
 
    std::string printStr(int nt, int lvl) const override;
 
    void print(int nt, int lvl) const override {
      std::cout << printStr(nt, lvl);
    };
 
    void print() const override { print(0, 0); };
  };
 
  class ComplexGeomObject : public GeomObject {
  
  public:
    std::vector<std::shared_ptr<GeomObject> > d_obj;
 
    std::vector<std::string> d_objFlag;
 
    std::vector<int> d_objFlagInt;
 
    size_t d_dim;
 
  public:
    ComplexGeomObject() : GeomObject("complex", ""), d_dim(0) {
    };
 
    ComplexGeomObject(
      std::vector<std::shared_ptr<GeomObject> > &obj,
      std::vector<std::string> obj_flag, std::string description = "")
      : GeomObject("complex", description),
        d_obj(obj),
        d_objFlag(obj_flag),
        d_dim(0) {
 
      d_dim = getGeomTypeToDim(d_obj[0]->d_name); // assume all types have same dim
 
      for (const auto &s: d_objFlag)
        if (s == "plus")
          d_objFlagInt.push_back(1);
        else if (s == "minus")
          d_objFlagInt.push_back(-1);
        else {
          std::cerr
              << "Error: Check object flag " + s +
              " passed to create ComplexGeomObject\n";
          exit(1);
        }
    };
 
    ComplexGeomObject(const ComplexGeomObject &other)
      : GeomObject(other.d_name, other.d_description),
        d_objFlag(other.d_objFlag),
        d_objFlagInt(other.d_objFlagInt),
        d_dim(other.d_dim) {
      d_tags = other.d_tags;
 
      // Deep copy each geometric object
      d_obj.reserve(other.d_obj.size());
      for (const auto& obj : other.d_obj) {
        if (obj) {
          // Create a raw pointer copy first
          GeomObject* raw_copy = createGeomDeepCopy(obj.get());
          // Convert to shared_ptr and store
          d_obj.push_back(std::shared_ptr<GeomObject>(raw_copy));
        } else {
          d_obj.push_back(nullptr);
        }
      }
    }
 
    ComplexGeomObject& operator=(const ComplexGeomObject& other) {
      if (this != &other) {
        // Copy base class members
        d_tags = other.d_tags;
        
        // Copy flags and dimension
        d_objFlag = other.d_objFlag;
        d_objFlagInt = other.d_objFlagInt;
        d_dim = other.d_dim;
 
        // Deep copy each geometric object
        d_obj.clear();
        d_obj.reserve(other.d_obj.size());
        for (const auto& obj : other.d_obj) {
          if (obj) {
            // Create a raw pointer copy first
            GeomObject* raw_copy = createGeomDeepCopy(obj.get());
            // Convert to shared_ptr and store
            d_obj.push_back(std::shared_ptr<GeomObject>(raw_copy));
          } else {
            d_obj.push_back(nullptr);
          }
        }
      }
      return *this;
    }
 
    void transform(const util::Point &translation, const double &scale, 
                  const double &angle, const util::Point &axis,
                  const util::Point *rotationPoint) override {
      const util::Point *pivot = rotationPoint;
      util::Point pivotStore;
      if (pivot == nullptr) {
        pivotStore = center();
        pivot = &pivotStore;
      }
      for (auto &obj : d_obj) {
        if (obj) obj->transform(translation, scale, angle, axis, pivot);
      }
    }
 
    double volume() const override;
 
    util::Point center() const override;
 
    std::pair<util::Point, util::Point> box() const override;
 
    std::pair<util::Point, util::Point>
    box(const double &tol) const override;
 
    double inscribedRadius() const override;
 
    double boundingRadius() const override;
 
    bool isInside(const util::Point &x) const override;
 
    bool isOutside(const util::Point &x) const override;
 
    bool isNear(const util::Point &x, const double &tol) const override;
 
    bool isNearBoundary(const util::Point &x, const double &tol,
                        const bool &within) const override;
 
    bool doesIntersect(const util::Point &x) const override;
 
    bool
    isInside(
      const std::pair<util::Point, util::Point> &box) const override;
 
    bool
    isOutside(
      const std::pair<util::Point, util::Point> &box) const override;
 
    bool isNear(const std::pair<util::Point, util::Point> &box,
                const double &tol) const override;
 
    bool doesIntersect(
      const std::pair<util::Point, util::Point> &box) const override;
 
    std::string printStr(int nt, int lvl) const override;
 
    void print(int nt, int lvl) const override {
      std::cout << printStr(nt, lvl);
    };
 
    void print() const override { print(0, 0); };
  };
 
  } // namespace geom
 
#endif // GEOM_COMPLEXGEOMOBJECTS_H