mesh_CSG_builder.h

/*
 *  Copyright (c) 2000-2023 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#ifndef H_GEO_MESH_CSG_BUILDER_H
#define H_GEO_MESH_CSG_BUILDER_H
 
#include <geogram/basic/common.h>
#include <geogram/mesh/mesh_CSG_utils.h>
#include <memory>
#include <functional>
#include <stack>
 
namespace GEO {
 
    class GEOGRAM_API AbstractCSGBuilder {
    public:
    typedef GEOCSG::ArgList ArgList;
    typedef GEOCSG::Value Value;
 
    static constexpr double DEFAULT_FA = 12.0;
 
    static constexpr double DEFAULT_FS = 2.0;
 
    static constexpr double DEFAULT_FN = 0.0;
 
    AbstractCSGBuilder();
 
    virtual ~AbstractCSGBuilder();
 
    /****** Parameters ******/
 
    void reset_defaults();
 
    void set_fn(double fn) {
        fn_ = std::max(fn, 0.0);
    }
 
    void set_fs(double fs) {
        fs_ = std::max(fs,0.01);
    }
 
    void set_fa(double fa) {
        fa_ = std::max(fa,0.01);
    }
 
    void set_verbose(bool x) {
        verbose_ = x;
        if(verbose_) {
            warnings_ = true;
        }
    }
 
    void set_detailed_verbose(bool x) {
        detailed_verbose_ = x;
        if(detailed_verbose_ && !verbose_) {
            verbose_ = true;
        }
    }
 
    bool verbose() const {
        return verbose_;
    }
 
 
    void add_file_path(const std::filesystem::path& path) {
        file_path_.push_back(path);
    }
 
    void reset_file_path() {
        file_path_.clear();
        file_path_.push_back(std::filesystem::current_path());
    }
 
    void push_file_path(const std::filesystem::path& path) {
        file_path_.push_back(path);
    }
 
    void pop_file_path() {
        geo_assert(file_path_.size() != 0);
        file_path_.pop_back();
    }
 
    /**** Abstract API - objects ******/
 
    virtual void add_object(
        const std::string& object, const ArgList& args
    );
 
    virtual void begin_instruction();
 
    virtual void end_instruction(
        const std::string& instruction, const ArgList& args
    );
 
 
    bool is_object(const std::string& id) const {
        return (object_funcs_.find(id) != object_funcs_.end());
    }
 
    bool is_instruction(const std::string& id) const {
        return (instruction_funcs_.find(id) != instruction_funcs_.end());
    }
 
    protected:
 
    /****** Objects ******************************************/
 
    virtual void add_square(const ArgList& args);
    virtual void add_circle(const ArgList& args);
    virtual void add_cube(const ArgList& args);
    virtual void add_sphere(const ArgList& args);
    virtual void add_cylinder(const ArgList& args);
    virtual void add_polyhedron(const ArgList& args);
    virtual void add_polygon(const ArgList& args);
    virtual void add_import(const ArgList& args);
    virtual void add_surface(const ArgList& args);
    virtual void add_text(const ArgList& args);
 
    /****** Instructions ************************************/
 
    virtual void eval_multmatrix(const ArgList& args);
    virtual void eval_translate(const ArgList& args);
    virtual void eval_rotate(const ArgList& args);
    virtual void eval_scale(const ArgList& args);
    virtual void eval_resize(const ArgList& args);
    virtual void eval_union(const ArgList& args);
    virtual void eval_intersection(const ArgList& args);
    virtual void eval_difference(const ArgList& args);
    virtual void eval_group(const ArgList& args);
    virtual void eval_color(const ArgList& args);
    virtual void eval_hull(const ArgList& args);
    virtual void eval_linear_extrude(const ArgList& args);
    virtual void eval_rotate_extrude(const ArgList& args);
    virtual void eval_projection(const ArgList& args);
    virtual void eval_minkowski(const ArgList& args);
    virtual void eval_render(const ArgList& args);
 
    /**************************/
 
    [[noreturn]] void error(const char* str) {
        throw(std::logic_error(str));
    }
 
    [[noreturn]] void error(const std::string& str) {
        throw(std::logic_error(str.c_str()));
    }
 
    double fn_;
    double fs_;
    double fa_;
 
    std::vector<std::filesystem::path> file_path_;
    bool warnings_;
    bool verbose_;
    bool detailed_verbose_;
 
    typedef std::function<void(const ArgList& args)> csg_builder_func;
    std::map<std::string, csg_builder_func> object_funcs_;
    std::map<std::string, csg_builder_func> instruction_funcs_;
    };
 
    /***********************************************************************/
 
    class CSGScope {
    public:
        CSGScope() {
        }
 
        CSGScope(std::shared_ptr<Mesh> M) {
            emplace_back(M);
        }
 
        CSGScope(
            const std::initializer_list<std::shared_ptr<Mesh>>& Ms
        ) : meshes_(Ms) {
        }
 
        void push_back(std::shared_ptr<Mesh> M) {
            meshes_.push_back(M);
        }
 
        void emplace_back(std::shared_ptr<Mesh> M) {
            meshes_.emplace_back(M);
        }
 
        void pop_back() {
            meshes_.pop_back();
        }
 
        index_t size() const {
            return index_t(meshes_.size());
        }
 
        const std::shared_ptr<Mesh>& operator[](index_t i) const {
            geo_debug_assert(i < size());
            return meshes_[i];
        }
 
        auto begin() { return meshes_.begin(); }
        auto end() { return meshes_.end(); }
        auto begin() const { return meshes_.begin(); }
        auto end() const { return meshes_.end(); }
        auto rbegin() { return meshes_.rbegin(); }
        auto rend() { return meshes_.rend(); }
        auto rbegin() const { return meshes_.rbegin(); }
        auto rend() const { return meshes_.rend(); }
 
        void append(std::shared_ptr<Mesh> M) {
            emplace_back(M);
        }
 
        template <typename...Types> void append(
            std::shared_ptr<Mesh> head, Types... tail
        ) {
            append(head);
            append(tail...);
        }
 
    private:
        std::vector<std::shared_ptr<Mesh>> meshes_;
    };
 
    class GEOGRAM_API CSGBuilder : public AbstractCSGBuilder {
    public:
    CSGBuilder();
    ~CSGBuilder() override;
 
    /****** Objects **********/
 
    virtual std::shared_ptr<Mesh> square(vec2 size, bool center=false);
 
    std::shared_ptr<Mesh> square(double size=1.0, bool center=false) {
        return square(vec2(size,size), center);
    }
 
    virtual std::shared_ptr<Mesh> circle(double r=1.0, index_t nu=0);
 
    virtual std::shared_ptr<Mesh> cube(vec3 size, bool center=false);
 
    std::shared_ptr<Mesh> cube(double size=1.0, bool center=false) {
        return cube(vec3(size,size,size), center);
    }
 
    virtual std::shared_ptr<Mesh> sphere(double r=1.0);
 
    virtual std::shared_ptr<Mesh> cylinder(
        double h, double r1, double r2, bool center=false
    );
 
    virtual std::shared_ptr<Mesh> import(
        const std::filesystem::path& filename, const std::string& layer="",
        index_t timestamp=0,
        vec2 origin = vec2(0.0, 0.0), vec2 scale = vec2(1.0,1.0)
    );
 
    virtual std::shared_ptr<Mesh> surface(
        const std::filesystem::path& filename, bool center, bool invert
    );
 
    virtual std::shared_ptr<Mesh> text(
        const std::string& text,
        double size = 10.0,
        const std::string& font = "",
        const std::string& halign = "left",
        const std::string& valign = "baseline",
        double spacing = 1.0,
        const std::string& direction = "ltr",
        const std::string& language = "en",
        const std::string& script = "latin"
    );
 
 
    /****** Instructions ****/
 
    virtual std::shared_ptr<Mesh> multmatrix(
        const mat4& M, const CSGScope& scope
    );
 
    virtual std::shared_ptr<Mesh> union_instr(const CSGScope& scope);
 
    template <typename...Types> std::shared_ptr<Mesh> union_instr(Types...args) {
        CSGScope scope;
        scope.append(args...);
        return union_instr(scope);
    }
 
    virtual std::shared_ptr<Mesh> intersection(const CSGScope& scope);
 
    template <typename...Types> std::shared_ptr<Mesh>
    intersection(Types...args) {
        CSGScope scope;
        scope.append(args...);
        return intersection(scope);
    }
 
    virtual std::shared_ptr<Mesh> difference(const CSGScope& scope);
 
    template <typename...Types> std::shared_ptr<Mesh>
    difference(Types...args) {
        CSGScope scope;
        scope.append(args...);
        return difference(scope);
    }
 
    virtual std::shared_ptr<Mesh> group(const CSGScope& scope);
 
    virtual std::shared_ptr<Mesh> color(vec4 color, const CSGScope& scope);
 
    virtual std::shared_ptr<Mesh> hull(const CSGScope& scope);
 
    virtual std::shared_ptr<Mesh> linear_extrude(
        const CSGScope& scope,
        double height = 1.0,
        bool center = false,
        vec2 scale = vec2(1.0,1.0),
        index_t slices = 0,
        double twist = 0.0
    );
 
    virtual std::shared_ptr<Mesh> rotate_extrude(
        const CSGScope& scope, double angle = 360.0
    );
 
    virtual std::shared_ptr<Mesh> projection(const CSGScope& scope, bool cut);
 
    virtual std::shared_ptr<Mesh> minkowski(const CSGScope& scope);
 
    virtual std::shared_ptr<Mesh> append(const CSGScope& scope);
 
    /****** AbstractCSGBuilder API ********************************/
 
    void add_object(const std::string& object, const ArgList& args) override;
    void begin_instruction() override;
    void end_instruction(
        const std::string& instruction, const ArgList& args
    ) override;
 
    /****** Objects (AbstractCSGBuilder API) *********************/
 
    void add_square(const ArgList& args) override;
    void add_circle(const ArgList& args) override;
    void add_cube(const ArgList& args) override;
    void add_sphere(const ArgList& args) override;
    void add_cylinder(const ArgList& args) override;
    void add_polyhedron(const ArgList& args) override;
    void add_polygon(const ArgList& args) override;
    void add_import(const ArgList& args) override;
    void add_surface(const ArgList& args) override;
    void add_text(const ArgList& args) override;
 
    /****** Instructions (AbstractCSGBuilder API) ****************/
 
    void eval_multmatrix(const ArgList& args) override;
    void eval_translate(const ArgList& args) override;
    void eval_rotate(const ArgList& args) override;
    void eval_scale(const ArgList& args) override;
    void eval_resize(const ArgList& args) override;
    void eval_union(const ArgList& args) override;
    void eval_intersection(const ArgList& args) override;
    void eval_difference(const ArgList& args) override;
    void eval_group(const ArgList& args) override;
    void eval_color(const ArgList& args) override;
    void eval_hull(const ArgList& args) override;
    void eval_linear_extrude(const ArgList& args) override;
    void eval_rotate_extrude(const ArgList& args) override;
    void eval_projection(const ArgList& args) override;
    void eval_minkowski(const ArgList& args) override;
    void eval_render(const ArgList& args) override;
 
    /****** Commodity functions **********************************/
 
    static mat4 translation_matrix(const vec3& T) {
        return mat4{{1, 0, 0, T.x},
                    {0, 1, 0, T.y},
                    {0, 0, 1, T.z},
                    {0, 0, 0, 1  }};
    }
 
    static mat4 scaling_matrix(double sx, double sy, double sz) {
        return mat4{{sx, 0,  0,  0},
                    {0,  sy, 0,  0},
                    {0,  0,  sz, 0},
                    {0,  0,  0,  1}};
    }
 
    static mat4 rotation_matrix(double angle, vec3 axis = {0.0, 0.0, 0.0}) {
        if(axis.x == 0.0 && axis.y == 0.0 && axis.z == 0.0) {
            axis.z = 1.0; // special case, OpenSCAD convention
        }
        vec3 N = normalize(axis);
        double x = N.x;
        double y = N.y;
        double z = N.z;
        angle = angle * M_PI / 180;
        double s = sin(angle);
        double c = cos(angle);
        double t = 1.0-c;
        return mat4{{t*x*x + c,   t*x*y - s*z, t*x*z + s*y, 0.0},
                    {t*x*y + s*z, t*y*y + c,   t*y*z - s*x, 0.0},
                    {t*x*z - s*y, t*y*z + s*x, t*z*z + c,   0.0},
                    {0.0,         0.0,         0.0,         1.0}};
    }
 
    static mat4 rotation_matrix(const vec3& angles) {
        double a = angles[0] * M_PI / 180.0;
        double b = angles[1] * M_PI / 180.0;
        double c = angles[2] * M_PI / 180.0;
        double sa = sin(a); double ca = cos(a);
        double sb = sin(b); double cb = cos(b);
        double sc = sin(c); double cc = cos(c);
        return mat4{{cc*cb,  cc*sb*sa - sc*ca,  cc*sb*ca + sc*sa,  0.0},
                    {sc*cb,  sc*sb*sa + cc*ca,  sc*sb*ca - cc*sa,  0.0},
                    {  -sb,             cb*sa,             cb*ca,  0.0},
                    {  0.0,               0.0,               0.0,  1.0}};
    }
 
    std::shared_ptr<Mesh> translate(const vec3& T, const CSGScope& scope) {
        return multmatrix(translation_matrix(T),scope);
    }
 
    std::shared_ptr<Mesh> rotate(double angle, const CSGScope& scope) {
        return multmatrix(rotation_matrix(angle),scope);
    }
 
    std::shared_ptr<Mesh> rotate(
        double angle, const vec3& axis, const CSGScope& scope
    ) {
        return multmatrix(rotation_matrix(angle,axis),scope);
    }
 
    std::shared_ptr<Mesh> rotate(const vec3& angles, const CSGScope& scope) {
        return multmatrix(rotation_matrix(angles),scope);
    }
 
    std::shared_ptr<Mesh> scale(
        double sx, double sy, double sz, const CSGScope& scope
    ) {
        return multmatrix(scaling_matrix(sx,sy,sz),scope);
    }
 
    /**************************/
 
    void set_delaunay(bool x) {
        delaunay_ = x;
    }
 
    void set_detect_intersecting_neighbors(bool x) {
        detect_intersecting_neighbors_ = x;
    }
 
    void set_simplify_coplanar_facets(bool x, double angle_tolerance=0.0) {
        simplify_coplanar_facets_ = x;
        coplanar_angle_tolerance_ = angle_tolerance;
    }
 
    void set_fast_union(bool x) {
        fast_union_ = x;
    }
 
 
    /***** misc ********/
 
    void set_noop(bool x) {
        noop_ = x;
    }
 
 
    static Box3d get_bbox(const std::shared_ptr<Mesh>& mesh);
 
    static std::pair<vec3, vec3> get_bbox_bounds(
        const std::shared_ptr<Mesh>& mesh
    ) {
        Box3d result = get_bbox(mesh);
        return std::make_pair(vec3(result.xyz_min), vec3(result.xyz_max));
    }
 
    protected:
 
    std::shared_ptr<Mesh> surface_with_OpenSCAD(
        const std::filesystem::path& filename, bool center, bool invert
    );
 
    std::shared_ptr<Mesh> text_with_OpenSCAD(
        const std::string& text,
        double size = 10.0,
        const std::string& font = "",
        const std::string& halign = "left",
        const std::string& valign = "baseline",
        double spacing = 1.0,
        const std::string& direction = "ltr",
        const std::string& language = "en",
        const std::string& script = "latin"
    );
 
    /**** Lower-level functions ****/
 
    bool find_file(std::filesystem::path& filename);
 
    const std::filesystem::path& current_path() {
        geo_assert(file_path_.size() != 0);
        return *(file_path_.rbegin());
    }
 
    std::shared_ptr<Mesh> import_with_openSCAD(
        const std::filesystem::path& filename, const std::string& layer="",
        index_t timestamp=0
    );
 
    virtual void do_CSG(
        std::shared_ptr<Mesh>& mesh, const std::string& boolean_expr
    );
 
    virtual void triangulate(
        std::shared_ptr<Mesh>& mesh, const std::string& boolean_expr
    );
 
    virtual void triangulate(std::shared_ptr<Mesh>& mesh);
 
    void keep_z0_only(std::shared_ptr<Mesh>& M);
 
    virtual void finalize_mesh(std::shared_ptr<Mesh>& mesh);
 
    CSGScope& top_scope() {
        geo_debug_assert(!scope_stack_.empty());
        return scope_stack_.top();
    }
 
    void push_scope() {
        scope_stack_.emplace();
    }
 
    void pop_scope() {
        geo_debug_assert(!scope_stack_.empty());
        scope_stack_.pop();
    }
 
    protected:
    double STL_epsilon_;
    index_t max_arity_;
    bool detect_intersecting_neighbors_;
    bool delaunay_;
    bool simplify_coplanar_facets_;
    double coplanar_angle_tolerance_;
    bool fast_union_;
    bool noop_;
    std::shared_ptr<Mesh> empty_mesh_;
    std::shared_ptr<Mesh> result_;
    std::stack<CSGScope> scope_stack_;
 
    friend class CSGCompiler;
    };
 
}
 
#endif