mesh_CSG.h

Go to the documentation of this file.

/*
 *  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_ALGO_MESH_CSG_H
#define H_GEO_MESH_ALGO_MESH_CSG_H
 
#include <geogram/basic/common.h>
#include <geogram/mesh/mesh.h>
#include <geogram/basic/smart_pointer.h>
#include <geogram/basic/memory.h>
 
namespace GEO {
 
    class ProgressTask;
    class Image;
 
    class GEOGRAM_API CSGMesh : public Mesh, public Counted {
    public:
        CSGMesh();
        ~CSGMesh() override;
        const Box3d& bbox() const {
            geo_debug_assert(vertices.nb() == 0 || bbox_initialized());
            return bbox_;
        }
 
        bool bbox_initialized() const;
 
        void update_bbox();
 
        void append_mesh(const CSGMesh* other, index_t operand = NO_INDEX);
 
        bool may_have_intersections_with(const CSGMesh* other) const {
            return bboxes_overlap(bbox(), other->bbox());
        }
 
    private:
        Box3d bbox_;
    };
 
    typedef SmartPointer<CSGMesh> CSGMesh_var;
 
    typedef std::vector< CSGMesh_var > CSGScope;
 
    class GEOGRAM_API CSGBuilder {
    public:
    static constexpr double DEFAULT_FA = 12.0;
 
    static constexpr double DEFAULT_FS = 2.0;
 
    static constexpr double DEFAULT_FN = 0.0;
 
    CSGBuilder();
 
    /****** Objects **********/
 
    CSGMesh_var square(vec2 size = vec2(1.0,1.0), bool center=true);
    CSGMesh_var circle(double r=1.0);
    CSGMesh_var cube(vec3 size = vec3(1.0, 1.0, 1.0), bool center=true);
    CSGMesh_var sphere(double r=1.0);
    CSGMesh_var cylinder(
        double h=1.0, double r1=1.0, double r2=1.0, bool center=true
    );
    CSGMesh_var import(
        const std::string& filename, const std::string& layer="",
        index_t timestamp=0,
        vec2 origin = vec2(0.0, 0.0), vec2 scale = vec2(1.0,1.0)
    );
    CSGMesh_var surface(
        const std::string& filename, bool center, bool invert
    );
    CSGMesh_var 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"
    );
 
 
    /****** Instructions ****/
 
    CSGMesh_var multmatrix(const mat4& M, const CSGScope& scope);
 
    CSGMesh_var union_instr(const CSGScope& scope);
 
    CSGMesh_var intersection(const CSGScope& scope);
 
    CSGMesh_var difference(const CSGScope& scope);
 
    CSGMesh_var group(const CSGScope& scope) {
        return union_instr(scope);
    }
 
    CSGMesh_var color(vec4 color, const CSGScope& scope);
 
    CSGMesh_var hull(const CSGScope& scope);
 
    CSGMesh_var linear_extrude(
        const CSGScope& scope,
        double height = 1.0,
        bool center = true,
        vec2 scale = vec2(1.0,1.0),
        index_t slices = 0,
        double twist = 0.0
    );
 
 
    CSGMesh_var rotate_extrude(const CSGScope& scope, double angle = 360.0);
 
    CSGMesh_var projection(const CSGScope& scope, bool cut);
 
    CSGMesh_var append(const CSGScope& scope);
 
    /****** 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_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;
    }
 
    void set_verbose(bool x) {
        verbose_ = x;
        if(!verbose_ && fine_verbose_) {
            fine_verbose_ = false;
        }
    }
 
    void set_fine_verbose(bool x) {
        fine_verbose_ = x;
        if(fine_verbose_ && !verbose_) {
            verbose_ = true;
        }
    }
 
    bool verbose() const {
        return verbose_;
    }
 
    void add_file_path(const std::string& path) {
        file_path_.push_back(path);
    }
 
    void push_file_path(const std::string& path) {
        file_path_.push_back(path);
    }
 
    void pop_file_path() {
        geo_assert(file_path_.size() != 0);
        file_path_.pop_back();
    }
 
    void reset_file_path() {
        file_path_.clear();
        file_path_.push_back(".");
    }
 
    /**** misc ****/
 
    void triangulate_2D_contours(CSGMesh_var mesh) {
        geo_assert(mesh->vertices.dimension() == 2);
        geo_assert(mesh->facets.nb() == 0);
        triangulate(mesh, "union");
    }
 
    void set_noop(bool x) {
        noop_ = x;
    }
 
    protected:
 
    bool find_file(std::string& filename);
 
    void do_CSG(CSGMesh_var mesh, const std::string& boolean_expr);
 
    void triangulate(
        CSGMesh_var mesh, const std::string& boolean_expr,
        bool keep_border_only=false
    );
 
    CSGMesh_var import_with_openSCAD(
        const std::string& filename, const std::string& layer="",
        index_t timestamp=0
    );
 
    Image* load_dat_image(const std::string& file_name);
 
    void post_process(CSGMesh_var mesh);
 
    index_t get_fragments_from_r(double r, double twist = 360.0);
 
    private:
    double fn_;
    double fs_;
    double fa_;
    double STL_epsilon_;
    bool verbose_;
    bool fine_verbose_;
    index_t max_arity_;
    std::vector<std::string> file_path_;
    bool detect_intersecting_neighbors_;
    bool delaunay_;
    bool simplify_coplanar_facets_;
    double coplanar_angle_tolerance_;
    bool fast_union_;
    bool warnings_;
    bool noop_;
    };
 
    /**************************************************************/
 
    class GEOGRAM_API CSGCompiler {
    public:
 
    CSGCompiler();
    CSGMesh_var compile_file(const std::string& input_filename);
    CSGMesh_var compile_string(const std::string& source);
 
    void set_verbose(bool x) {
        builder_.set_verbose(x);
    }
 
    void set_fine_verbose(bool x) {
        builder_.set_fine_verbose(x);
    }
 
    CSGBuilder& builder() {
        return builder_;
    }
 
    protected:
 
    /****** Value, Arglist **********************************/
 
    struct Value {
        enum Type {NONE, NUMBER, BOOLEAN, ARRAY1D, ARRAY2D, STRING};
 
        Value();
        Value(double x);
        Value(int x);
        Value(bool x);
        Value(const std::string& x);
        std::string to_string() const;
 
        Type type;
        bool boolean_val;
        double number_val;
        vector<vector<double> > array_val;
        std::string string_val;
    };
 
    class ArgList {
    public:
        typedef std::pair<std::string, Value> Arg;
 
        index_t size() const {
            return args_.size();
        }
 
        const std::string& ith_arg_name(index_t i) const {
            geo_assert(i < size());
            return args_[i].first;
        }
 
        const Value& ith_arg_val(index_t i) const {
            geo_assert(i < size());
            return args_[i].second;
        }
 
        void add_arg(const std::string& name, const Value& value);
        bool has_arg(const std::string& name) const;
        const Value& get_arg(const std::string& name) const;
        double get_arg(const std::string& name,double default_value) const;
        int get_arg(const std::string& name, int default_value) const;
        bool get_arg(const std::string& name, bool default_value) const;
        vec2 get_arg(const std::string& name, vec2 default_value) const;
        vec3 get_arg(const std::string& name, vec3 default_value) const;
        vec4 get_arg(const std::string& name, vec4 default_value) const;
        mat4 get_arg(
            const std::string& name, const mat4& default_value
        ) const;
        std::string get_arg(
            const std::string& name, const std::string& default_value
        ) const;
        std::string get_arg(
            const std::string& name, const char* default_value
        ) const {
            return get_arg(name, std::string(default_value));
        }
 
    private:
        vector<Arg> args_;
    };
 
 
    /****** Objects *****************************************/
 
    CSGMesh_var square(const ArgList& args);
    CSGMesh_var circle(const ArgList& args);
    CSGMesh_var cube(const ArgList& args);
    CSGMesh_var sphere(const ArgList& args);
    CSGMesh_var cylinder(const ArgList& args);
    CSGMesh_var polyhedron(const ArgList& args);
    CSGMesh_var polygon(const ArgList& args);
    CSGMesh_var import(const ArgList& args);
    CSGMesh_var surface(const ArgList& args);
    CSGMesh_var text(const ArgList& args);
 
    /****** Instructions ************************************/
 
    CSGMesh_var multmatrix(const ArgList& args, const CSGScope& scope);
    CSGMesh_var resize(const ArgList& args, const CSGScope& scope);
    CSGMesh_var union_instr(const ArgList& args, const CSGScope& scope);
    CSGMesh_var intersection(const ArgList& args, const CSGScope& scope);
    CSGMesh_var difference(const ArgList& args, const CSGScope& scope);
    CSGMesh_var group(const ArgList& args, const CSGScope& scope);
    CSGMesh_var color(const ArgList& args, const CSGScope& scope);
    CSGMesh_var hull(const ArgList& args, const CSGScope& scope);
    CSGMesh_var linear_extrude(const ArgList& args, const CSGScope& scope);
    CSGMesh_var rotate_extrude(const ArgList& args, const CSGScope& scope);
    CSGMesh_var projection(const ArgList& args, const CSGScope& scope);
 
    /***** Parser *******************************************/
 
    CSGMesh_var parse_instruction_or_object();
    CSGMesh_var parse_object();
    CSGMesh_var parse_instruction();
    ArgList     parse_arg_list();
    Value       parse_value();
    Value       parse_array();
    bool        is_object(const std::string& id) const;
    bool        is_instruction(const std::string& id) const;
 
    bool is_modifier(int toktype) const;
 
    /***** Parser internals ********************************/
 
    struct Token {
        Token();
        std::string to_string() const;
        int type;
        std::string str_val;
        int int_val;
        double double_val;
        bool boolean_val;
    };
 
    void next_token_check(char c);
 
    Token next_token();
 
    Token lookahead_token();
 
    Token next_token_internal();
 
    int lines() const;
 
    int line() const;
 
 
    [[noreturn]] void syntax_error(const char* msg);
 
    [[noreturn]] void syntax_error(const char* msg, const Token& tok);
 
    private:
    std::string filename_;
    void* lex_;
    Token lookahead_token_;
    CSGBuilder builder_;
 
    typedef CSGMesh_var (CSGCompiler::*object_funptr)(const ArgList& args);
    typedef CSGMesh_var (CSGCompiler::*instruction_funptr)(
        const ArgList& args, const CSGScope& scope
    );
    std::map<std::string, object_funptr> object_funcs_;
    std::map<std::string, instruction_funptr> instruction_funcs_;
    ProgressTask* progress_;
    index_t lines_;
    };
}
 
#endif