def test_tesselate_torus(self): """ 2st test : tesselation of a torus """ a_box = BRepPrimAPI_MakeTorus(10, 4).Shape() tess = Tesselator(a_box, atNormal, 1.0, 1, 0.01, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.) self.assert_(tess.ObjGetTriangleCount() > 100) self.assert_(tess.ObjGetNormalCount() > 100)
def test_x3dom_render_torus(self): '''Test: point from curve''' torus_shp = BRepPrimAPI_MakeTorus(20., 10.).Shape() my_renderer = x3dom_renderer.X3DomRenderer() my_renderer.DisplayShape(torus_shp) assert os.path.isfile('./shape.x3d') assert os.path.isfile('./x3dom_topods_shape.html')
def test_x3dom_render_torus(self): '''Test: point from curve''' torus_shp = BRepPrimAPI_MakeTorus(20., 10.).Shape() my_renderer = x3dom_renderer.X3DomRenderer(path="./test_io") x3d_file, html_file = my_renderer.create_files(torus_shp) assert os.path.isfile(x3d_file) assert os.path.isfile(html_file)
def test_threejs_render_torus(self): '''Test: point from curve''' torus_shp = BRepPrimAPI_MakeTorus(20., 10.).Shape() my_renderer = threejs_renderer.ThreejsRenderer(background_color="#123345") my_renderer.DisplayShape(torus_shp) assert os.path.isfile('./shape.js') assert os.path.isfile('./webgl_topods_shape.html')
def test_tesselate_torus_with_edges(self): """ 2st test : tesselation of a torus """ a_torus = BRepPrimAPI_MakeTorus(10, 4).Shape() tess = Tesselator(a_torus, atNormal, 1.0, 1, 0.01, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.) tess.Compute(compute_edges=True) self.assert_(tess.ObjGetTriangleCount() > 100) self.assert_(tess.ObjGetNormalCount() > 100)
def test_x3dom_random_mesh_quality(self): """ Test: threejs 10 random boxes """ my_x3dom_renderer = x3dom_renderer.X3DomRenderer() torus_shp = BRepPrimAPI_MakeTorus(20., 10.).Shape() my_x3dom_renderer.DisplayShape(torus_shp, mesh_quality=1.0) my_x3dom_renderer.DisplayShape(torus_shp, mesh_quality=0.8) my_x3dom_renderer.DisplayShape(torus_shp, mesh_quality=2.0)
def test_threejs_render_torus(self): '''Test: point from curve''' torus_shp = BRepPrimAPI_MakeTorus(20., 10.).Shape() my_renderer = threejs_renderer.ThreejsRenderer( background_color="#123345") js_file, html_file = my_renderer.create_files(torus_shp) assert os.path.isfile(js_file) assert os.path.isfile(html_file)
def create_shape(self): d = self.declaration args = [d.axis, d.radius, d.radius2] #: Ugly... if d.angle: args.append(d.angle) if d.angle2: args.append(d.angle2) self.shape = BRepPrimAPI_MakeTorus(*args)
def test_tesselate_torus_with_bad_quality(self): """ 2st test : tesselation of a torus """ a_torus = BRepPrimAPI_MakeTorus(10, 4).Shape() tess = Tesselator(a_torus, atNormal, 1.0, 1, 0.01, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.) tess.Compute(mesh_quality=40.) # since mesh quality is much lower, we should count less vertices and # triangles self.assert_(tess.ObjGetTriangleCount() > 10) self.assert_(tess.ObjGetTriangleCount() < 100) self.assert_(tess.ObjGetNormalCount() > 10) self.assert_(tess.ObjGetNormalCount() < 100)
def makeTorus(cls, radius1, radius2, pnt=None, dir=None, angleDegrees1=None, angleDegrees2=None): """ makeTorus(radius1,radius2,[pnt,dir,angle1,angle2,angle]) -- Make a torus with agiven radii and angles By default pnt=Vector(0,0,0),dir=Vector(0,0,1),angle1=0 ,angle1=360 and angle=360' """ return cls( BRepPrimAPI_MakeTorus(gp_Ax2(pnt.toPnt(), dir.toDir()), radius1, radius2, angleDegrees1 * DEG2RAD, angleDegrees2 * DEG2RAD).Shape())
def section(event=None): Torus = BRepPrimAPI_MakeTorus(120, 20).Shape() radius = 120.0 sections = [] for i in range(-3, 4): # Create Sphere Sphere = BRepPrimAPI_MakeSphere(gp_Pnt(26 * 3 * i, 0, 0), radius).Shape() # Computes Torus/Sphere section section = BRepAlgoAPI_Section(Torus, Sphere, False) section.ComputePCurveOn1(True) section.Approximation(True) section.Build() sections.append(section) display.EraseAll() display.DisplayShape(Torus) for section in sections: display.DisplayShape(section.Shape()) display.FitAll()
def boolean_fuse(base): ring_radius = 0.25 torus_radius = 1.0 - ring_radius torus = BRepPrimAPI_MakeTorus(torus_radius, ring_radius).Shape() fuse = BRepAlgoAPI_Fuse(base, torus).Shape() return fuse
def create_single_assembly(self, tire_radius, wheel_radius, struct_length, scale=1): tire_radius = tire_radius wheel_radius = wheel_radius struct_length = struct_length straight_arm_height = tire_radius * 1.5 ring_radius = wheel_radius torus_radius = tire_radius torus = BRepPrimAPI_MakeTorus(torus_radius, ring_radius).Shape() straight_arm_radius = ring_radius / 2 straight_arm = BRepPrimAPI_MakeCylinder(straight_arm_radius, straight_arm_height).Shape() angled_arm_radius = straight_arm_radius angled_arm_height = tire_radius * 1.5 angle = -40 angled_arm = BRepPrimAPI_MakeCylinder(angled_arm_radius, angled_arm_height).Shape() traf = CTiglTransformation() traf.add_rotation_x(angle) angled_arm = traf.transform(angled_arm) traf = CTiglTransformation() traf.add_translation(0, angled_arm_height * sin(angle), 0) angled_arm = traf.transform(angled_arm) traf = CTiglTransformation() traf.add_translation(0, angled_arm_height * cos(angle), angled_arm_height * sin(angle)) straight_arm = traf.transform(straight_arm) arm_assembly = BRepAlgoAPI_Fuse(straight_arm, angled_arm).Shape() traf = CTiglTransformation() traf.add_rotation_x(90) torus = traf.transform(torus) pin_radius = wheel_radius pin_height = tire_radius pin = BRepPrimAPI_MakeCylinder(pin_radius, pin_height).Shape() traf = CTiglTransformation() traf.add_translation(0, 0, -straight_arm_height + torus_radius / 2) torus = traf.transform(torus) traf = CTiglTransformation() traf.add_rotation_x(90) pin = traf.transform(pin) traf = CTiglTransformation() traf.add_translation(0, 0, -straight_arm_height + pin_radius) pin = traf.transform(pin) traf = CTiglTransformation() traf.add_mirroring_at_xzplane() mirrored_arm_assembly = traf.transform(arm_assembly) traf = CTiglTransformation() traf.add_mirroring_at_xzplane() mirrored_pin = traf.transform(pin) arm_assembly = BRepAlgoAPI_Fuse(mirrored_arm_assembly, arm_assembly).Shape() struct_radius = wheel_radius - 0.5 * wheel_radius struct_height = struct_length struct = BRepPrimAPI_MakeCylinder(struct_radius, struct_height).Shape() traf = CTiglTransformation() traf.add_translation(0, 0, torus_radius) struct = traf.transform(struct) pin = BRepAlgoAPI_Fuse(mirrored_pin, pin).Shape() part_1 = BRepAlgoAPI_Fuse(arm_assembly, pin).Shape() part_2 = BRepAlgoAPI_Fuse(part_1, struct).Shape() part_3 = BRepAlgoAPI_Fuse(part_2, pin).Shape() return BRepAlgoAPI_Fuse(part_3, torus).Shape()
from __future__ import print_function import random from OCC.Display.WebGl import threejs_renderer from OCC.BRepPrimAPI import BRepPrimAPI_MakeTorus from OCC.gp import gp_Vec from OCC.Extend.ShapeFactory import translate_shp, rotate_shp_3_axis my_ren = threejs_renderer.ThreejsRenderer() n_toruses = 100 idx = 0 for i in range(n_toruses): torus_shp = BRepPrimAPI_MakeTorus(10 + random.random() * 10, random.random() * 10).Shape() # random position and orientation and color angle_x = random.random() * 360 angle_y = random.random() * 360 angle_z = random.random() * 360 rotated_torus = rotate_shp_3_axis(torus_shp, angle_x, angle_y, angle_z, 'deg') tr_x = random.uniform(-70, 50) tr_y = random.uniform(-70, 50) tr_z = random.uniform(-50, 50) trans_torus = translate_shp(rotated_torus, gp_Vec(tr_x, tr_y, tr_z)) rnd_color = (random.random(), random.random(), random.random()) my_ren.DisplayShape(trans_torus, export_edges=True, color=rnd_color, transparency=random.random())
#!/usr/bin/python # coding: utf-8 r""" """ from OCC.Display.WebGl import threejs_renderer from OCC.BRepPrimAPI import BRepPrimAPI_MakeTorus # create box cube_shp = BRepPrimAPI_MakeTorus(25., 15.).Shape() # load shaders vs = open('shaders/pink.vs', 'r').read() fs = open('shaders/pink.fs', 'r').read() u = open('shaders/pink.uniforms', 'r').read() my_renderer = threejs_renderer.ThreejsRenderer(vertex_shader=vs, fragment_shader=fs, uniforms=u) my_renderer.DisplayShape(cube_shp)
print("Shape selected: ", shape) print(kwargs) def compute_bbox(shp, *kwargs): print("Compute bbox for %s " % shp) for shape in shp: bbox = Bnd_Box() brepbndlib_Add(shape, bbox) xmin, ymin, zmin, xmax, ymax, zmax = bbox.Get() dx = xmax - xmin dy = ymax - ymin dz = zmax - zmin print("Selected shape bounding box : dx=%f, dy=%f, dz=%f." % (dx, dy, dz)) print(" bounding box center: x=%f, y=%f, z=%f" % (xmin + dx / 2., ymin + dy / 2., zmin + dz / 2.)) display, start_display, add_menu, add_function_to_menu = init_display() # register callbacks display.register_select_callback(print_xy_click) display.register_select_callback(compute_bbox) # creating geometry my_torus = BRepPrimAPI_MakeBox(10., 20., 30.).Shape() my_box = BRepPrimAPI_MakeTorus(30., 5.).Shape() # and finally display geometry display.DisplayShape(my_torus) display.DisplayShape(my_box, update=True) start_display()
#!/usr/bin/python # coding: utf-8 r""" """ from OCC.Display.WebGl import threejs_renderer from OCC.BRepPrimAPI import BRepPrimAPI_MakeTorus torus_shp = BRepPrimAPI_MakeTorus(20., 10.).Shape() my_renderer = threejs_renderer.ThreejsRenderer(background_color="#123345") my_renderer.DisplayShape(torus_shp)
##along with pythonOCC. If not, see <http://www.gnu.org/licenses/>. from __future__ import print_function import random from OCC.Display.WebGl import threejs_renderer from OCC.BRepPrimAPI import BRepPrimAPI_MakeTorus from OCC.gp import gp_Vec from OCC.Extend.ShapeFactory import translate_shp my_ren = threejs_renderer.ThreejsRenderer() idx = 0 torus_shp1 = BRepPrimAPI_MakeTorus(20, 5).Shape() torus_shp2 = translate_shp(torus_shp1, gp_Vec(60, 0, 0)) torus_shp3 = translate_shp(torus_shp1, gp_Vec(-60, 0, 0)) # default quality print("Computing RED torus: default quality") my_ren.DisplayShape(torus_shp1, export_edges=True, color=(1,0,0)) # red # better mesh quality, i.e. more triangles print("Computing GREEN torus: better quality, more time to compute") my_ren.DisplayShape(torus_shp2, export_edges=True, color=(0,1,0), # green mesh_quality = 0.2) # worse quality, i.e. less triangles print("Computing BLUE torus: worse quality, faster to compute") my_ren.DisplayShape(torus_shp3, export_edges=True, color=(0,0,1), # blue
##pythonOCC 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 Lesser General Public License for more details. ## ##You should have received a copy of the GNU Lesser General Public License ##along with pythonOCC. If not, see <http://www.gnu.org/licenses/>. from OCC.Display.SimpleGui import init_display from OCC.BRepPrimAPI import BRepPrimAPI_MakeTorus from OCC.Graphic3d import (Graphic3d_EF_PDF, Graphic3d_EF_SVG, Graphic3d_EF_TEX, Graphic3d_EF_PostScript, Graphic3d_EF_EnhPostScript) display, start_display, add_menu, add_function_to_menu = init_display() my_box = BRepPrimAPI_MakeTorus(40., 20.).Shape() display.DisplayShape(my_box, update=True) f = display.View.View().GetObject() #------------------------------------------------------------------------------- # for this example to work, pythonocc / OCE needs to be built with the gl2ps lib #------------------------------------------------------------------------------- def export_to_PDF(event=None): f.Export('torus_export.pdf', Graphic3d_EF_PDF) def export_to_SVG(event=None): f.Export('torus_export.svg', Graphic3d_EF_SVG)
def GenerateHTMLFile(self): """ Generate the HTML file to be rendered wy the web browser """ with open(self._html_filename, "w") as fp: fp.write("<!DOCTYPE HTML>") fp.write('<html lang="en">') # header fp.write(HTMLHeader().get_str()) # body fp.write(HTMLBody(self._x3d_shapes).get_str()) fp.write("</html>\n") if __name__ == "__main__": from OCC.BRepPrimAPI import BRepPrimAPI_MakeBox, BRepPrimAPI_MakeTorus from OCC.BRepBuilderAPI import BRepBuilderAPI_Transform from OCC.gp import gp_Trsf, gp_Vec def translate_shp(shp, vec, copy=False): trns = gp_Trsf() trns.SetTranslation(vec) brep_trns = BRepBuilderAPI_Transform(shp, trns, copy) brep_trns.Build() return brep_trns.Shape() box = BRepPrimAPI_MakeBox(100., 200., 300.).Shape() torus = BRepPrimAPI_MakeTorus(300., 105).Shape() t_torus = translate_shp(torus, gp_Vec(700, 0, 0)) my_ren = X3DomRenderer() my_ren.DisplayShape(box) my_ren.DisplayShape(t_torus) my_ren.render()
def test_threejs_render_torus(self): """ Render a simple torus in threejs """ torus_shp = BRepPrimAPI_MakeTorus(20., 10.).Shape() my_threejs_renderer = threejs_renderer.ThreejsRenderer() my_threejs_renderer.DisplayShape(torus_shp)
##(at your option) any later version. ## ##pythonOCC 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 Lesser General Public License for more details. ## ##You should have received a copy of the GNU Lesser General Public License ##along with pythonOCC. If not, see <http://www.gnu.org/licenses/>. import os from OCC.BRepPrimAPI import BRepPrimAPI_MakeTorus from OCC.Extend.DataExchange import write_stl_file # first, create the shape my_torus = BRepPrimAPI_MakeTorus(20., 10.).Shape() # set the directory where to output the stl_output_dir = os.path.abspath(os.path.join("..", "assets", "models")) # make sure the path exists otherwise OCE get confused assert os.path.isdir(stl_output_dir) stl_low_resolution_file = os.path.join(stl_output_dir, "torus_default_resolution.stl") write_stl_file(my_torus, stl_low_resolution_file) # then we change the mesh resolution, and export as binary stl_high_resolution_file = os.path.join(stl_output_dir, "torus_high_resolution.stl") # we set the format to binary write_stl_file(my_torus, stl_low_resolution_file, mode="binary", linear_deflection=0.5, angular_deflection=0.3)
import sys sys.path.append('../..') import WebServer.TornadoWeb import tornado.ioloop from OCC.BRepPrimAPI import BRepPrimAPI_MakeTorus renderer = WebServer.TornadoWeb.TornadoWebRenderer() torus = BRepPrimAPI_MakeTorus(40, 10).Shape() renderer.DisplayShape(torus) print(renderer) if __name__ == "__main__": io_loop = tornado.ioloop.IOLoop.current() io_loop.start()
def test_x3dom_render_torus(self): """ Render a simple torus using x3dom """ torus_shp = BRepPrimAPI_MakeTorus(20., 10.).Shape() my_x3dom_renderer = x3dom_renderer.X3DomRenderer() my_x3dom_renderer.DisplayShape(torus_shp)