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_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_;
    };
 
    /***********************************************************************/
 
    typedef std::vector<std::shared_ptr<Mesh>> CSGScope;
 
    class GEOGRAM_API CSGBuilder : public AbstractCSGBuilder {
    public:
    CSGBuilder();
    ~CSGBuilder() override;
 
    /****** Objects **********/
 
    virtual std::shared_ptr<Mesh> square(
        vec2 size = vec2(1.0,1.0), bool center=true
    );
 
    virtual std::shared_ptr<Mesh> circle(double r=1.0, index_t nu=0);
 
    virtual std::shared_ptr<Mesh> cube(
        vec3 size = vec3(1.0, 1.0, 1.0), bool center=true
    );
 
    virtual std::shared_ptr<Mesh> sphere(double r=1.0);
 
    virtual std::shared_ptr<Mesh> cylinder(
        double h=1.0, double r1=1.0, double r2=1.0, bool center=true
    );
 
    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);
 
    virtual std::shared_ptr<Mesh> intersection(const CSGScope& scope);
 
    virtual std::shared_ptr<Mesh> difference(const CSGScope& 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_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;
 
    /**************************/
 
    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