精华内容
下载资源
问答
  • 三维模型布尔运算
    2022-05-15 20:08:23

    转载;深入剖析三维几何内核(5)--布尔运算 (qq.com)

    重点:

    1.布尔运算是三维几何内核的一个基本功能,其功能,稳定性,性能直接反应了内核的质量。

    1.布尔运算的基本原理和算法

    常见的三种布尔运算:并集,交集,减集。其实这三种布尔运算的前面运算逻辑是一样的,最后一步不同。

    1.并集就是把两个物体合并成一个物体

    2.交集是求两个物体公共的部分

    3.减集是从一个物体中减去两个物体公共的部分

    布尔运算基础算法涉及到的计算有:

    1.几何面的相交计算,需要得出交点,交线等几何信息;

    2.基于原始拓扑结构,对Face面进行裁剪;

    3.裁剪区域Edge边和顶点Vertex的拓扑重建。

    更多相关内容
  • 三维模型布尔运算 求并、交、差

    热门讨论 2011-06-18 17:37:14
    三维模型布尔运算 相交 相减 求并 三维模型布尔运算 求并、交、差 三维模型布尔运算 求并、交、差 三维模型布尔运算 求并、交、差
  • and布尔"与" - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值,即如果x 为假(0),则打印假(0),否则打印y的值。a=10 b=20 c=0a and c=10 and 20 =20(10,非0,为真,打印y(20)).c and a=0 and 10 =0 (x...

    0为假,1为真。

    and 布尔"与" - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值,即如果x 为假(0),则打印假(0),否则打印y的值。

    a=10  b=20 c=0

    a and c=10 and 20 =20(10,非0,为真,打印y(20)).

    c and a=0 and 10 =0 (x=0,为假,为0)

    c and b and c =10 and 20 and 0 (x非0,非假,打印最后一个y的值0)

    a and c and b =10 and 0 and 20 (当对比到0 and 20时,x=0,打印假(0),对比结束)

    orx or y布尔"或"- 如果 x 是非 0,它返回 x 的值,否则它返回 y 的计算值。

    10 or 20 如果 10(x)不是0值 ,显示10(x),否则打印 y值20

    0 or 20 x=0, 打印y值 20

    notnot x布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。

    当x为真时,打印假。当x为假时,打印真。

    >> not 5 and 1   x 非0 ,为真,打印非真:false (0)

    >> not 0 and 1   x为0,为假。打印非假:true (1)

    本文转自笔下生辉  51CTO博客,原文链接:http://blog.51cto.com/752030200/1829610,如需转载请自行联系原作者

    展开全文
  • 为了快速正确地对各种复杂程度(开放、封闭)的网格模型进行空间布尔运算,根据复式网格的可定向性建立各元素间的拓扑关系,并根据这些拓扑关系判断网格面片的最终去舍,得到布尔运算结果.算法首先对网格方向一致化,...
  • 研究了三角形表面模型的布尔运算。传统的CSG 算法是基于基本实体的布尔运算进行的,对于由三角形或多边形描述的表面模 型的复杂模型运算则十分...各种布尔运算,组合分割后的结果,实现了不规则三维模型布尔运算
  • // 三维矩阵 typedef CGAL_Exact_Kernel3::Aff_transformation_3 CGAL_Exact_transformation3; typedef CGAL_Inexact_Kernel3::Aff_transformation_3 CGAL_Inexact_transformation3; typedef CGAL_Exact_...

    本示例使用 boost_1_68_0, CGAL-5.1.2

    特别提醒: 目前CGAL5以上版本可以用头文件模式使用, 编译出来的东西运行仅仅依赖libgmp 和libmpfr  ,  以前编译出来的会依赖一堆boost和cgal  的dll,部署容易出错.

    CGAL首先是模板库开发, 要先定义一堆模板对象:

    #pragma once
    
    // Construction kernel
    #include "CGAL/Exact_predicates_exact_constructions_kernel.h"
    #include "CGAL/Exact_predicates_inexact_constructions_kernel.h"
    
    // Polygon
    #include "CGAL/Nef_polyhedron_2.h"
    #include "CGAL/Polygon_2.h"
    #include "CGAL/Polygon_with_holes_2.h"
    
    // Polyhedron
    #include "CGAL/convex_hull_3.h"
    #include "CGAL/Polyhedron_3.h"
    #include "CGAL/Polyhedron_incremental_builder_3.h"
    #include "CGAL/Nef_polyhedron_3.h"
    #include "CGAL/IO/Polyhedron_iostream.h"
    #include "CGAL/IO/Nef_polyhedron_iostream_3.h"
    
    // Utils
    #include "CGAL/exceptions.h"
    #include "CGAL/assertions.h"
    #include "CGAL/assertions_behaviour.h"
    #include "CGAL/utils.h"
    #include "CGAL/Real_timer.h"
    #include "CGAL/bounding_box.h"
    
    // Straight skeleton
    #include "CGAL/Straight_skeleton_builder_2.h"
    #include "CGAL/Polygon_offset_builder_2.h"
    #include "CGAL/compute_outer_frame_margin.h"
    #include "CGAL/create_straight_skeleton_2.h"
    #include "CGAL/create_straight_skeleton_from_polygon_with_holes_2.h"
    
    // Surface mesh
    #include "CGAL/Surface_mesh.h"
    #include "CGAL/Surface_mesh_default_triangulation_3.h"
    #include "CGAL/Complex_2_in_triangulation_3.h"
    #include "CGAL/Side_of_triangle_mesh.h"
    #include "CGAL/boost/graph/graph_traits_Surface_mesh.h"
    #include "CGAL/make_surface_mesh.h"
    #include "CGAL/Surface_mesh_default_criteria_3.h"
    #include "CGAL/Implicit_surface_3.h"
    
    // Polygon mesh processing
    #include "CGAL/Polygon_mesh_processing/bbox.h"
    #include "CGAL/Polygon_mesh_processing/self_intersections.h"
    #include "CGAL/Polygon_mesh_processing/stitch_borders.h"
    #include "CGAL/Polygon_mesh_processing/orientation.h"
    
    // Delaunay triangulation
    #include "CGAL/Constrained_Delaunay_triangulation_2.h"
    #include "CGAL/Triangulation_face_base_with_info_2.h"
    #include "CGAL/Delaunay_mesher_2.h"
    #include "CGAL/Delaunay_mesh_face_base_2.h"
    #include "CGAL/Delaunay_mesh_size_criteria_2.h"
    
    // AABB tree for cutting plane
    //#include "CGAL/AABB_intersections.h"
    #include "CGAL/AABB_tree.h"
    #include "CGAL/AABB_traits.h"
    #include "CGAL/boost/graph/graph_traits_Polyhedron_3.h"
    #include "CGAL/AABB_halfedge_graph_segment_primitive.h"
    #include "CGAL/AABB_face_graph_triangle_primitive.h"
    
    // Poisson for Point Cloud
    //#include "CGAL/trace.h"
    #include "CGAL/Surface_mesh_default_triangulation_3.h"
    #include "CGAL/make_surface_mesh.h"
    #include "CGAL/Implicit_surface_3.h"
    #include "CGAL/Poisson_reconstruction_function.h"
    #include "CGAL/Point_with_normal_3.h"
    #include "CGAL/property_map.h"
    #include "CGAL/compute_average_spacing.h"
    
    // IO
    #include "CGAL/IO/Complex_2_in_triangulation_3_file_writer.h"
    #include "CGAL/IO/facets_in_complex_2_to_triangle_mesh.h"
    #include "CGAL/IO/output_surface_facets_to_polyhedron.h"
    
    //#ifdef CGAL_EIGEN3_ENABLED
    //#include "CGAL/Eigen_solver_traits.h"
    //#endif
    
    //#include "Base3D/UGPolySet.h"
    
    #include "CGAL/GMP/Gmpq_type.h"
    namespace GeoStar
    {
    	namespace Kernel
    	{
    		namespace CGALData
    		{
    
    			// 基本要素
    			typedef CGAL::Color CGAL_Color;
    			typedef CGAL::Bbox_2 CGAL_Bbox2;
    			typedef CGAL::Bbox_3 CGAL_Bbox3;
    
    			// Kernel2结构
    			typedef CGAL::Gmpq NT2;
    			typedef CGAL::Extended_cartesian<NT2> CGAL_Kernel2;
    
    			typedef CGAL::Point_2<CGAL_Kernel2> CGAL_Point2;
    			typedef CGAL::Line_2<CGAL_Kernel2> CGAL_Line2;
    
    			// 二维多边形结构
    			typedef CGAL::Polygon_2<CGAL_Kernel2> CGAL_Polygon;
    			typedef CGAL::Polygon_with_holes_2<CGAL_Kernel2> CGAL_Polygon_with_holes;
    
    			// 二维矩阵
    			typedef CGAL_Kernel2::Aff_transformation_2 CGAL_Aff_transformation2;
    
    			// Kernel3结构
    			typedef CGAL::Exact_predicates_exact_constructions_kernel	CGAL_Exact_Kernel3;
    			typedef CGAL::Exact_predicates_inexact_constructions_kernel CGAL_Inexact_Kernel3;
    			typedef CGAL_Exact_Kernel3 CGAL_Kernel3;
    
    			typedef CGAL::Simple_cartesian<double> CGAL_Simple_Kernel;
    			typedef CGAL::Epick CGAL_Epick_Kernel;
    
    			// 三维矩阵
    			typedef CGAL_Exact_Kernel3::Aff_transformation_3 CGAL_Exact_transformation3;
    			typedef CGAL_Inexact_Kernel3::Aff_transformation_3 CGAL_Inexact_transformation3;
    			typedef CGAL_Exact_transformation3 CGAL_transformation3;
    
    			// 三维多面体
    			typedef CGAL::Polyhedron_3<CGAL_Exact_Kernel3> CGAL_Exact_Polyhedron;
    			typedef CGAL::Polyhedron_3<CGAL_Inexact_Kernel3> CGAL_Inexact_Polyhedron;
    			typedef CGAL_Exact_Polyhedron CGAL_Polyhedron;
    
    			// Boolean operations work only with exact kernel
    			typedef CGAL::Nef_polyhedron_2<CGAL_Kernel2> CGAL_Nef_polyhedron2;
    			typedef CGAL::Nef_polyhedron_3<CGAL_Exact_Kernel3> CGAL_Nef_polyhedron3;
    
    			// 三维基本类型
    			typedef CGAL::Point_3<CGAL_Exact_Kernel3> CGAL_Exact_Point3;
    			typedef CGAL::Point_3<CGAL_Inexact_Kernel3> CGAL_Inexact_Point3;
    			typedef CGAL_Exact_Point3 CGAL_Point3;
    
    			typedef CGAL::Line_3<CGAL_Exact_Kernel3> CGAL_Exact_Line3;
    			typedef CGAL::Line_3<CGAL_Inexact_Kernel3> CGAL_Inexact_Line3;
    			typedef CGAL_Exact_Line3 CGAL_Line3;
    
    			typedef CGAL::Segment_3<CGAL_Exact_Kernel3> CGAL_Exact_Segment3;
    			typedef CGAL::Segment_3<CGAL_Inexact_Kernel3> CGAL_Inexact_Segment3;
    			typedef CGAL_Exact_Segment3 CGAL_Segment3;
    
    			typedef CGAL::Vector_3<CGAL_Exact_Kernel3> CGAL_Exact_Vector3;
    			typedef CGAL::Vector_3<CGAL_Inexact_Kernel3> CGAL_Inexact_Vector3;
    			typedef CGAL_Exact_Vector3 CGAL_Vector3;
    
    			typedef CGAL::Plane_3<CGAL_Exact_Kernel3> CGAL_Exact_Plane3;
    			typedef CGAL::Plane_3<CGAL_Inexact_Kernel3> CGAL_Inexact_Plane3;
    			typedef CGAL_Exact_Plane3 CGAL_Plane3;
    
    			typedef CGAL::Direction_3<CGAL_Exact_Kernel3> CGAL_Exact_Direction_3;
    			typedef CGAL::Direction_3<CGAL_Inexact_Kernel3> CGAL_Inexact_Direction_3;
    			typedef CGAL_Exact_Direction_3 CGAL_Direction_3;
    
    			// AABB Tree
    			typedef CGAL::AABB_face_graph_triangle_primitive<CGAL_Exact_Polyhedron> CGAL_Exact_AABB_Primetive;
    			typedef CGAL::AABB_face_graph_triangle_primitive<CGAL_Inexact_Polyhedron> CGAL_Inexact_AABB_Primetive;
    
    			typedef CGAL::AABB_traits<CGAL_Exact_Kernel3, CGAL_Exact_AABB_Primetive> CGAL_Exact_AABB_Traits;
    			typedef CGAL::AABB_traits<CGAL_Inexact_Kernel3, CGAL_Inexact_AABB_Primetive> CGAL_Inexact_AABB_Traits;
    
    			typedef CGAL::AABB_tree<CGAL_Exact_AABB_Traits> CGAL_Exact_AABB_Tree;
    			typedef CGAL::AABB_tree<CGAL_Inexact_AABB_Traits> CGAL_Inexact_AABB_Tree;
    			typedef CGAL_Exact_AABB_Tree CGAL_AABB_Tree;
    
    			// Surface Mesh
    			typedef CGAL::Surface_mesh<CGAL_Exact_Point3> CGAL_Exact_Surface_Mesh;
    			typedef CGAL::Surface_mesh<CGAL_Inexact_Point3> CGAL_Inexact_Surface_Mesh;
    			typedef CGAL_Exact_Surface_Mesh CGAL_Surface_Mesh;
    			
    
    			typedef CGAL_Point2	* Point2_iterator;
    			typedef std::pair<Point2_iterator, Point2_iterator> Point2_range;
    			typedef std::list<Point2_range> CGAL_Path2;
    			typedef CGAL_Path2* Path2_iterator;
    			typedef std::vector<Path2_iterator> CGAL_Polyline2;
    
    			typedef CGAL_Point3	* Point3_iterator;
    			typedef std::pair<Point3_iterator, Point3_iterator> Point3_range;
    			typedef std::list<Point3_range> CGAL_Path3;
    			typedef CGAL_Path3* Path3_iterator;
    			typedef std::vector<Path3_iterator> CGAL_Polyline3;
    		}
    
    	}
    }

    调用文件如下:

    #include "stdafx.h"
    
    #include <iostream>
    #include "cgaldefine.h"
    
    
    #pragma comment(lib,"libgmp-10.lib")
    #pragma comment(lib,"libmpfr-4.lib")
    //#include <CGAL/Simple_cartesian.h>
    //typedef CGAL::Simple_cartesian<double> Kernel;
    //typedef Kernel::Point_2 Point_2;
    //typedef Kernel::Segment_2 Segment_2;
    //
    //
    //int testpoint()
    //{
    //	//!笛卡尔坐标系双精度浮点类型的点和线段
    //	Point_2 p(1, 1), q(10, 10);
    //	std::cout << "p = " << p << std::endl;
    //	std::cout << "q = " << q.x() << " " << q.y() << std::endl;
    //	std::cout << "sqdist(p,q) = "
    //		<< CGAL::squared_distance(p, q) << std::endl;
    //
    //	Segment_2 s(p, q);
    //	Point_2 m(5, 9);
    //
    //	std::cout << "m = " << m << std::endl;
    //	std::cout << "sqdist(Segment_2(p,q), m) = "
    //		<< CGAL::squared_distance(s, m) << std::endl;
    //	std::cout << "p, q, and m ";
    //	//!方位
    //	switch (CGAL::orientation(p, q, m)) {
    //
    //
    //
    //	case CGAL::COLLINEAR:
    //		std::cout << "are collinear\n";
    //		break;
    //	case CGAL::LEFT_TURN:
    //		std::cout << "make a left turn\n";
    //		break;
    //	case CGAL::RIGHT_TURN:
    //		std::cout << "make a right turn\n";
    //		break;
    //	}
    //	std::cout << " midpoint(p,q) = " << CGAL::midpoint(p, q) << std::endl;
    //	system("pause");
    //	return 0;
    //}
    
    
    //#include <CGAL/Exact_integer.h>
    //#include <CGAL/Homogeneous.h>
    //#include <CGAL/Nef_polyhedron_3.h>
    //typedef CGAL::Homogeneous<CGAL::Exact_integer>  Kernel;
    //typedef CGAL::Nef_polyhedron_3<Kernel> Nef_polyhedron;
    //
    //int main()
    //{
    //	Nef_polyhedron N0(Nef_polyhedron::EMPTY);
    //	Nef_polyhedron N1(Nef_polyhedron::COMPLETE);
    //	CGAL_assertion(N0 == N1.complement());
    //	CGAL_assertion(N0 != N1);
    //
    //}
    
    //
    //#include <CGAL/Exact_integer.h>
    //#include <CGAL/Extended_homogeneous.h>
    //#include <CGAL/Nef_polyhedron_3.h>
    //typedef CGAL::Exact_integer  NT;
    //typedef CGAL::Extended_homogeneous<NT>  Kernel;
    //typedef CGAL::Nef_polyhedron_3<Kernel>  Nef_polyhedron;
    //typedef Nef_polyhedron::Plane_3  Plane_3;
    //typedef Kernel::Plane_3 Plane_3;
    //int main() {
    //	Nef_polyhedron N1(Plane_3(2, 5, 7, 11), Nef_polyhedron::INCLUDED);
    //	Nef_polyhedron N2(Plane_3(2, 5, 7, 11), Nef_polyhedron::EXCLUDED);
    //	CGAL_assertion(N1 >= N2);
    //	CGAL_assertion(N2 <= N1);
    //	CGAL_assertion(N1 != N2);
    //	CGAL_assertion(N1 > N2);
    //	CGAL_assertion(N2 < N1);
    //	N2 = N2.closure();
    //	CGAL_assertion(N1 == N2);
    //	CGAL_assertion(N1 >= N2);
    //	CGAL_assertion(N1 <= N2);
    //	return 0;
    //}
    
    
    //#include <CGAL/Exact_integer.h>
    //#include <CGAL/Homogeneous.h>
    //
    //#include <CGAL/Nef_polyhedron_3.h>
    //#include <CGAL/IO/Nef_polyhedron_iostream_3.h>
    //typedef CGAL::Exact_integer  NT;
    //typedef CGAL::Homogeneous<NT>  Kernel;
    //typedef CGAL::Nef_polyhedron_3<Kernel>  Nef_polyhedron;
    //int main() {
    //	Nef_polyhedron N;
    //	std::cin >> N;
    //	CGAL_assertion((N - N.boundary()) == N.interior());
    //	CGAL_assertion(N.closure() == N.complement().interior().complement());
    //	CGAL_assertion(N.regularization() == N.interior().closure());
    //	N.intersection(N);
    //
    //	return 0;
    //}
    #define		CGAL_TYPE	GeoStar::Kernel::CGALData 
    
    
    
    
    typedef		CGAL_TYPE::CGAL_Point2				Gs_Point2;
    typedef		CGAL_TYPE::CGAL_Point3				Gs_Point3;
    typedef		CGAL_TYPE::CGAL_Bbox2				Gs_Box2;
    typedef		CGAL_TYPE::CGAL_Bbox3				Gs_Box3;
    typedef		CGAL_TYPE::CGAL_Line2				Gs_Line2;
    typedef		CGAL_TYPE::CGAL_Line3				Gs_Line3;
    typedef		CGAL_TYPE::CGAL_Path2				Gs_Path2;
    typedef		CGAL_TYPE::CGAL_Polyline3			Gs_Polyline2;
    typedef		CGAL_TYPE::CGAL_Path3				Gs_Path3;
    typedef		CGAL_TYPE::CGAL_Polyline3			Gs_Polyline3;
    
    typedef		CGAL_TYPE::CGAL_Segment3			Gs_Segment3;
    typedef		CGAL_TYPE::CGAL_Polygon				Gs_Polygon;
    typedef		CGAL_TYPE::CGAL_Polygon_with_holes	Gs_Polygon_With_Holes;
    typedef		CGAL_TYPE::CGAL_Exact_Polyhedron	Gs_Polyhedron2;
    typedef		CGAL_TYPE::CGAL_Nef_polyhedron2		Gs_Nef_Polyhedron2;
    typedef		CGAL_TYPE::CGAL_Polyhedron			Gs_Polyhedron3;
    typedef		CGAL_TYPE::CGAL_Nef_polyhedron3		Gs_Nef_Polyhedron3;
    typedef		CGAL_TYPE::CGAL_Plane3				Gs_Plane3;
    typedef		CGAL_TYPE::CGAL_Direction_3			Gs_Direction_3;
    typedef		CGAL_TYPE::CGAL_AABB_Tree			Gs_AABB_Tree;
    typedef		CGAL_TYPE::CGAL_Surface_Mesh		Gs_Surface_Mesh;
    //CGAL::convert_nef_polyhedron_to_polygon_mesh
    
    
    void fill_cube_1(Gs_Polyhedron3& poly)
    {
    	std::string input =
    		"OFF\n\
    8 12 0\n\
    -1 -1 -1\n\
    -1 1 -1\n\
    1 1 -1\n\
    1 -1 -1\n\
    -1 -1 1\n\
    -1 1 1\n\
    1 1 1\n\
    1 -1 1\n\
    3  0 1 3\n\
    3  3 1 2\n\
    3  0 4 1\n\
    3  1 4 5\n\
    3  3 2 7\n\
    3  7 2 6\n\
    3  4 0 3\n\
    3  7 4 3\n\
    3  6 4 7\n\
    3  6 5 4\n\
    3  1 5 6\n\
    3  2 1 6";
    	std::stringstream ss;
    	ss << input;
    	ss >> poly;
    }
    void fill_cube_2(Gs_Polyhedron3& poly)
    {
    	std::string input =
    		"OFF\n\
    8 12 0\n\
    -0.5 -0.5 -0.5\n\
    -0.5 0.5 -0.5\n\
    0.5 0.5 -0.5\n\
    0.5 -0.5 -0.5\n\
    -0.5 -0.5 0.5\n\
    -0.5 0.5 0.5\n\
    0.5 0.5 0.5\n\
    0.5 -0.5 0.5\n\
    3  0 1 3\n\
    3  3 1 2\n\
    3  0 4 1\n\
    3  1 4 5\n\
    3  3 2 7\n\
    3  7 2 6\n\
    3  4 0 3\n\
    3  7 4 3\n\
    3  6 4 7\n\
    3  6 5 4\n\
    3  1 5 6\n\
    3  2 1 6";
    	std::stringstream ss;
    	ss << input;
    	ss >> poly;
    }
    int main() {
    	//构造两个多面体
    	Gs_Polyhedron3 cube1, cube2;
    	fill_cube_1(cube1);
    	fill_cube_2(cube2);
    	Gs_Nef_Polyhedron3 nef1(cube1);
    	Gs_Nef_Polyhedron3 nef2(cube2);
    	//交
    	auto t =	nef1.intersection(nef2);
    
    	//并
    	nef1.join(nef2);
    	//对称差
    	nef1.symmetric_difference(nef2);
    	//差
    	nef1.difference(nef2);
    	//凸包
    	nef1.boundary();
    	//
    	nef1.simplify();
    	nef1.is_simple();
    
    
    
    	
    	return 0;
    }

    vs工程资源:

    https://download.csdn.net/download/chijingjing/21455609

    展开全文
  • 利用openGL库编写,采用VC++6.0开发环境,实现STL文件读取、显示、操作、控制、分层。
  • 3D网格布尔运算开源库

    千次阅读 2021-03-08 00:41:56
    网格的布尔运算广泛应用于建筑、医学导航软件、游戏和电影动画等应用场景中,3D模型的编辑软件,3D Max、Maya以及Blender就广泛应用网格的布尔运算于构建新的模型。 常用的开源库 开源库的名称 应用范围 实验...

    3D网格布尔运算开源库

    3D网格布尔运算开源库

    网格的布尔运算广泛应用于建筑、医学导航软件、游戏和电影动画等应用场景中,3D模型的编辑软件,3D Max、Maya以及Blender就广泛应用网格的布尔运算于构建新的模型。

    常用的开源库

    开源库的名称应用范围实验结果BooleanOperation API下载地址
    VTK生物医学领域计算速度中等,但是非常不稳定,cpu利用效率低vtkBooleanOperationPolyDataFilterhttps://vtk.org/download/
    VTKbool生物医学领域计算速度很慢,比较稳定,cpu利用效率比较低vtkPolyDataBooleanFilterhttps://github.com/zippy84/vtkbool
    CGAL计算机图形处理库计算速度最快,稳定性比VTK稍强,cpu利用效率中等corefine_and_compute_differencehttps://www.cgal.org/download.html
    Cork(使用的最为广泛)Blender设计;建筑;CloudCompare,开源的几何处理库生物医学领域计算速度很快,比CGAL慢,比libigl封装的CGAL快,稳定性较好,不会崩(遇到not solid的物体)程序不会崩,但是无法结束,使用的内存一直递增,原始版本为单核计算,CPU利用率较低。compute Differencec
    omputeUnionc
    omputeIntersection
    原始版本-https://github.com/gilbo/cork
    多线程版本-https://github.com/stephanfr/Cork
    Blender版本-https://github.com/dfelinto/cork-on-blender
    libigl计算机图形处理库计算速度比较快,稳定性比较强,CPU利用率100%igl::copyleft::cgal::mesh_boolean
    igl::copyleft::cork::mesh_boolean
    https://github.com/libigl/libigl
    MEPP2计算机图形处理库,处理3D网格和点云的数据库类似于Cork,计算速度较快,稳定性较好https://projet.liris.cnrs.fr/mepp/mepp2/index.html
    QuickCSG(免费但是不公开代码)专门处理网格布尔运算的库,只有exe程序,不公开源代码计算速度非常快,稳定性非常好,非封闭的曲面也可以进行计算,但是生成的曲面碎片化比较明显http://morpheo.inrialpes.fr/static/QuickCSG/
    trimesh计算机图形学库,布尔运算使用的是OpenSCAD和Blender作为后端base.intersection(cuts, engine=‘scad’)https://github.com/mikedh/trimesh
    CassiopeeCFD图形处理库,用于网格的布尔运算http://elsa.onera.fr/Cassiopee/Userguide.html

    Cork的评价

    Cork的需要输入的模型为Solid的,也就是网格模型需要是流形的,对非流形网格( non-manifold)非常敏感。流形网格包含两个情况,自相交的和非封闭的。可以使用CGAL将非流形网格转为流形网格,(需要注意CGAL不能加载部分off文件,而meshlab、MEPP等软件可以加载)Cork的多线程版本比原始版本稳定性稍低些,需要线程无法结束导致崩溃的问题。多线程版本的计算时间减少70%左右,运行消耗的内存空间提升为原始版本的3倍左右,并行效率较好。
    多线程版本
    在这里插入图片描述
    原始版本
    在这里插入图片描述

    QuickCSG的效果与评价

    前几次的运算,效果比较好,运算速度非常快,不到1S,生成的网格(绿色区域)也比较好
    在这里插入图片描述
    但是,第四次运算的时候,出现断面的情况,生成的网格面与原始网格面并不相连接
    在这里插入图片描述

    展开全文
  • stl模型布尔运算的代码实现(DIY)

    千次阅读 2016-09-22 13:16:50
    开发三维模型布尔运算的图形软件因其难度较大,具挑战性而激发了诸多有志者为之努力不懈,但也让许多尝试者怯步。本文推荐一款几何运算库,调用由(wsxdll)几何运算库提供的库函数可以使开发三维模型布尔运算的图形软件...
  • 最好是unity的!如果确实好用也可以付费,但必须全部源代码。
  • CGAL多面体布尔运算,利用CGAL计算几何算法库,解决了多面体模型布尔运算问题(多面体的并、交、差的实现)。资源包含完整代码和详细说明文档。
  • 三维体数据之构造与分析

    千次阅读 2019-07-23 15:24:01
    作者:dongyx         ...三维体对象通过交、并、差等布尔运算后,也是拓 扑闭合的,仍然是三维体;支持计算模型的体积、表面积,截取模型的任意剖面...
  • 以图形单元作为建模要素,采用顾及台阶属性Delaunay三角网凸包算法建立界面模型,通过面域拉伸和实体布尔运算等方法生成三维矿模。研究结果表明,该方法不仅能达到逼真的三维动态效果,而且对于边坡稳定性分析更为准确...
  • SuperMap iDesktop.Net里“三维地理设计”选项卡中“运算分析”模块的布尔运算功能,是数字符号化的逻辑推演法,SuperMap引用这种逻辑运算方法实现对三维模型对象间进行合并、求差、求交运算,输出结果数据。...
  • 三维模型

    2021-06-28 04:19:25
    中文名三维模型生成三维建模工具这种专门的软件构成网格 纹理建模范围任何物理自然界存在的东西三维模型介绍编辑语音三维模型经常用三维建模工具这种专门的软件生成,但是也可以用其它方法生成。作为点和其它信息...
  • 布尔运算介绍 布尔运算是英国数学家布尔在1847年发明的处理二值关系的逻辑数学计算法,主要包括联合(Union),相交(Intersection),相减(subtraction)。直接用图说明,及时逻辑运算并交差。对于程序自动生成的数据...
  • ThreeBSP.js 是 three.js 的一个扩展库,可以实现对模型的数学布尔运算,实际上就是个个点的重新组合和拆分,来重新生成 几何体对象和网格模型。 本实示例浏览地址:...
  • 几何图形布尔运算简介 布尔运算在计算机领域是一个多含义的概念,包括逻辑上布尔类型的与并否操作,而在计算机几何上,它代表的是多边形或多面体之间的集合与并或非等操作。我们也可以粗暴地将图形布尔运算理解为...
  • 例如增加一支辅助流道,或减少、改变一支流道 以上的任何一个三维图档的变化,都需要重新在三维CAD里面做布尔运算,然后重新网格划分,最后才能进入模拟分析环节。而在设计的初期阶段,设计变更是非常多的,通常10次...
  • 由于在对大型建筑群进行三维建模的过程中,常常会遇到模型重叠,需要对模型大小或形状进行调整,最常见的方法是布尔运算。 1.这里是两幢大楼,建模完成后需要对其地面周围区域进行绿化,铺上草坪。(以3dmax2014版...
  • C4D快速入门教程——布尔运算

    千次阅读 2022-02-16 09:59:12
    C4D快速入门教程——布尔运算什么是布尔运算多次布尔运算排母制作PS:主要使用的就是布尔运算。不需要的就不用看具体流程了,上面知识点都讲完了。 C4D版本R24 做了一个母排样品,这个东西在...并由二维布尔运算发展
  • 第一张是对方形圆柱进行扭曲操作的效果图,第二张图是对扁平立方体面进行弯曲操作的效果图,第张图是从内到外依次是原物体,裁剪后的物体,裁剪后掏空物体的效果,从左到右依次对圆柱、球体、甜圈圈进行同样变换的...
  • GTS连续布尔运算失败~

    2019-01-08 08:13:28
    一直在关注和解决的问题是关于实体的布尔运算的问题,这是几何造型上面的一个大问题,也是切削加工仿真等等的核心。虽然有一些技巧性的方法能够模拟“布尔运算”,但是其效果都不好,最直接的还是进行真正的布尔运算...
  • matlab在三维建模计算的应用 Matlab在三维建模计算的应用 为了显示三维图形,MATLAB 提供了各种各样的函数。有一些函数可在三维 空间中画线,而另一些可以画曲面与线格框架。另外,颜色可以用来代表第四维。 当颜色...
  • 1、github上下载资源 2、使用CesiumMeshVisualizer进行模型布尔运算 3、输出计算效果并与threeBSP进行对比
  • 多面体布尔运算算法改进及误差处理。布尔运算算法是三维几何造型技术的核心。本文提出了一种布尔运算改进算法,分析了算法误差处理,并且 简单实现了两个多面体的布尔运算
  • 采用合并法构建三维地质实体模型,通过各个地层实体间的布尔运算构建三维地质集成模型;利用边坡构成要素及参数构建露天矿分层开采境界模型;通过三维地质集成模型与分层开采境界模型之间的布尔运算,对露天矿境界内...
  • 但是当我把off文件换成较为复杂的不规则模型,比如说骆驼这种的数据的时候并不能获得布尔运算的结果。输出得到的数据依旧是我输入进去的第一个off文件。 下面这个是我所采用的源码。 ``` #include #include #...
  • 采油螺杆泵立体模型的有限元分析...利用布尔运算分离密封带和定子内腔,并在它们之间建立接触对,实现定子内腔流体压力模拟;通过设置相关参数模拟定、转子之间的过盈配合,建立螺杆泵三维有限元分析模型,并利用螺杆泵水

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,947
精华内容 3,178
关键字:

三维模型布尔运算