mesh_grob_surface_commands.h

Go to the documentation of this file.

/*
 *  OGF/Graphite: Geometry and Graphics Programming Library + Utilities
 *  Copyright (C) 2000-2009 INRIA - Project ALICE
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *  If you modify this software, you should include a notice giving the
 *  name of the person performing the modification, the date of modification,
 *  and the reason for such modification.
 *
 *  Contact: Bruno Levy - levy@loria.fr
 *
 *     Project ALICE
 *     LORIA, INRIA Lorraine,
 *     Campus Scientifique, BP 239
 *     54506 VANDOEUVRE LES NANCY CEDEX
 *     FRANCE
 *
 *  Note that the GNU General Public License does not permit incorporating
 *  the Software into proprietary programs.
 *
 * As an exception to the GPL, Graphite can be linked with the following
 *  (non-GPL) libraries:
 *     Qt, SuperLU, WildMagic and CGAL
 */
 
 
#ifndef H_OGF_MESH_COMMANDS_MESH_GROB_SURFACE_COMMANDS_H
#define H_OGF_MESH_COMMANDS_MESH_GROB_SURFACE_COMMANDS_H
 
#include <OGF/mesh/common/common.h>
#include <OGF/mesh/commands/mesh_grob_commands.h>
#include <geogram/parameterization/mesh_atlas_maker.h>
#include <geogram/parameterization/mesh_segmentation.h>
 
namespace OGF {
 
    gom_class MESH_API MeshGrobSurfaceCommands :
        public MeshGrobCommands {
 
    public:
 
        MeshGrobSurfaceCommands();
 
        ~MeshGrobSurfaceCommands() override;
 
    gom_slots:
 
        void repair_surface(
            double epsilon = 1e-6,
            double min_comp_area = 0.03,
            double max_hole_area = 1e-3,
            double max_hole_edges = 2000,
            double max_degree3_dist = 0.0,
            bool remove_intersections = false
        );
 
       /**********************************************************/
 
        void merge_vertices(double epsilon = 0.0);
 
       /**********************************************************/
 
        void expand_border(double margin=0.05);
 
       /**********************************************************/
 
        void fill_holes(index_t max_nb_vertices=0);
 
 
       /**********************************************************/
 
        void fix_facets_orientation();
 
       /**********************************************************/
 
        void remove_invisible_facets(double min_visibility = 0.005);
 
 
       /**********************************************************/
 
        MeshGrob* remesh_smooth(
            const NewMeshGrobName& remesh = "remesh",
            unsigned int nb_points = 30000,
            double tri_shape_adapt = 1.0,
            double tri_size_adapt = 0.0,
            bool adjust = true,
            double adjust_max_edge_distance = 0.5,
            unsigned int normal_iter = 3,
            unsigned int Lloyd_iter = 5,
            unsigned int Newton_iter = 30,
            unsigned int Newton_m = 7,
            unsigned int LFS_samples = 10000
        );
 
       /**********************************************************/
 
        MeshGrob* remesh_feature_sensitive(
            const NewMeshGrobName& remesh = "remesh",
            unsigned int nb_points = 30000,
            bool refine = false,
            double max_dist = 0.5,
            double normal_anisotropy = 5.0,
            unsigned int nb_Lloyd_iter = 5,
            unsigned int nb_Newton_iter = 30,
            unsigned int nb_LpCVT_iter = 10,
            unsigned int Newton_m = 7,
            bool RVC_centroids = false
        );
 
       /**********************************************************/
 
        MeshGrob* remesh_quad_dominant(
            const NewMeshGrobName& remesh = "remesh",
            double rel_edge_len = 1.0,
            bool sharp_features = true,
            bool optimize_parity = false,
            double max_scaling_corr = 1.0
        );
 
       /**********************************************************/
 
        MeshGrob* compute_union(
            const MeshGrobName& other,
            const NewMeshGrobName& result = "result",
            bool pre_process=false,
            bool post_process=false
        );
 
 
        MeshGrob* compute_intersection(
            const MeshGrobName& other,
            const NewMeshGrobName& result = "result",
            bool pre_process=false,
            bool post_process=false
        );
 
        MeshGrob* compute_difference(
            const MeshGrobName& other,
            const NewMeshGrobName& result = "result",
            bool pre_process=false,
            bool post_process=false
        );
 
        gom_arg_attribute(operation, handler, "combo_box")
        gom_arg_attribute(operation, values, "A+B;A*B;A-B;B-A")
        MeshGrob* compute_boolean_operation(
            const MeshGrobName& other,
            const NewMeshGrobName& result = "result",
            const std::string& operation = "A+B",
            bool pre_process=false,
            bool post_process=false
        );
 
        void intersect(
            bool remove_internal_shells = true,
            bool simplify_coplanar_facets = true,
            double coplanar_angle_tolerance = 0.001,
            bool interpolate_attributes = false,
            bool verbose = false,
            const NewMeshGrobName& skeleton = ""
        );
 
       /**********************************************************/
 
       void decimate(
           index_t nb_bins = 100,
           bool remove_deg3_vrtx = true,
           bool keep_borders = true,
           bool repair = true
       );
 
       /**********************************************************/
 
        void split_triangles(index_t nb_times=1);
 
        void split_quads(index_t nb_times=1);
 
 
        void split_catmull_clark(index_t nb_times=1);
 
        void tessellate_facets(index_t max_vertices_per_facet=4);
 
 
        void triangulate() {
            tessellate_facets(3);
        }
 
 
        void triangulate_center_vertex();
 
 
        void smooth();
 
       /**********************************************************/
 
        enum Parameterizer {
            LSCM, SpectralLSCM, ABFplusplus
        };
 
        void segment(
            MeshSegmenter segmenter=SEGMENT_GEOMETRIC_VSA_L2,
            index_t nb_segments=10
        );
 
        void get_charts();
 
        void remove_charts();
 
        void unglue_sharp_edges(double angle_threshold=90);
 
        void unglue_charts();
 
        void make_texture_atlas(
            bool detect_sharp_edges = false,
            double sharp_edges_threshold = 45.0,
            ChartParameterizer param=PARAM_ABF,
            ChartPacker pack=PACK_XATLAS,
            bool verbose=false
        );
 
 
        void pack_texture_space(
            ChartPacker pack=PACK_XATLAS
        );
 
        void parameterize_chart(
            const std::string& attribute="tex_coord",
            ChartParameterizer param=PARAM_LSCM,
            bool verbose=false
        );
 
        void bake_normals(
            const MeshGrobName& surface,
            index_t size=1024,
            const NewImageFileName& image="normals.png",
            index_t nb_dilate=2,
            const std::string& tex_coord="tex_coord"
        );
 
 
        void bake_colors(
            const MeshGrobName& surface,
            const std::string& color="color",
            index_t size=1024,
            const NewImageFileName& image="colors.png",
            index_t nb_dilate=2,
            const std::string& attribute="tex_coord"
        );
 
 
        void bake_texture(
            const MeshGrobName& src_surface,
            const ImageFileName& src_texture,
            const std::string& src_tex_coord="tex_coord",
            index_t size=1024,
            const NewImageFileName& image="texture.png",
            index_t nb_dilate=2,
            const std::string& tex_coord="tex_coord"
        );
 
 
    };
}
#endif