553 lines
24 KiB
Python
553 lines
24 KiB
Python
#***************************************************************************
|
|
#* Copyright (c) 2021 Chris Hennes <chennes@pioneerlibrarysystem.org> *
|
|
#* *
|
|
#* This program is free software; you can redistribute it and/or modify *
|
|
#* it under the terms of the GNU Lesser General Public License (LGPL) *
|
|
#* as published by the Free Software Foundation; either version 2 of *
|
|
#* the License, or (at your option) any later version. *
|
|
#* for detail see the LICENSE text file. *
|
|
#* *
|
|
#* 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 Library General Public License for more details. *
|
|
#* *
|
|
#* You should have received a copy of the GNU Library General Public *
|
|
#* License along with this program; if not, write to the Free Software *
|
|
#* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
|
|
#* USA *
|
|
#* *
|
|
#***************************************************************************
|
|
|
|
import unittest
|
|
import FreeCAD
|
|
import OpenSCAD
|
|
import importCSG
|
|
import tempfile
|
|
import os
|
|
import math
|
|
|
|
from os.path import join
|
|
|
|
__title__ = "ImportCSG OpenSCAD App unit tests"
|
|
__author__ = "Chris Hennes"
|
|
__url__ = "https://www.freecad.org"
|
|
|
|
|
|
class TestImportCSG(unittest.TestCase):
|
|
|
|
MODULE = 'test_importCSG' # file name without extension
|
|
temp_dir = tempfile.TemporaryDirectory()
|
|
|
|
|
|
def setUp(self):
|
|
self.test_dir = join(FreeCAD.getHomePath(), "Mod", "OpenSCAD", "OpenSCADTest", "data")
|
|
|
|
def test_open_scad(self):
|
|
testfile = join(self.test_dir, "CSG.scad")
|
|
doc = importCSG.open(testfile)
|
|
|
|
# Doc should now contain three solids: a union, an intersection, and a difference
|
|
union = doc.getObject("union")
|
|
intersection = doc.getObject("intersection")
|
|
difference = doc.getObject("difference")
|
|
|
|
self.assertTrue (union is not None)
|
|
self.assertTrue (intersection is not None)
|
|
self.assertTrue (difference is not None)
|
|
|
|
FreeCAD.closeDocument("CSG")
|
|
|
|
def test_open_csg(self):
|
|
testfile = join(self.test_dir, "CSG.csg")
|
|
doc = importCSG.open(testfile)
|
|
|
|
# Doc should now contain three solids: a union, an intersection, and a difference
|
|
union = doc.getObject("union")
|
|
intersection = doc.getObject("intersection")
|
|
difference = doc.getObject("difference")
|
|
|
|
self.assertTrue (union is not None)
|
|
self.assertTrue (intersection is not None)
|
|
self.assertTrue (difference is not None)
|
|
|
|
FreeCAD.closeDocument("CSG")
|
|
|
|
def utility_create_scad(self, scadCode, name):
|
|
filename = self.temp_dir.name + os.path.sep + name + ".scad"
|
|
print (f"Creating {filename}")
|
|
f = open(filename,"w+")
|
|
f.write(scadCode)
|
|
f.close()
|
|
return importCSG.open(filename)
|
|
|
|
def test_import_sphere(self):
|
|
doc = self.utility_create_scad("sphere(10.0);","sphere")
|
|
sphere = doc.getObject("sphere")
|
|
self.assertTrue (sphere is not None)
|
|
self.assertTrue (sphere.Radius == 10.0)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_import_cylinder(self):
|
|
doc = self.utility_create_scad("cylinder(50.0,d=10.0);","cylinder")
|
|
cylinder = doc.getObject("cylinder")
|
|
self.assertTrue (cylinder is not None)
|
|
self.assertTrue (cylinder.Radius == 5.0)
|
|
self.assertTrue (cylinder.Height == 50.0)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_import_cube(self):
|
|
doc = self.utility_create_scad("cube([1.0,2.0,3.0]);","cube")
|
|
cube = doc.getObject("cube")
|
|
self.assertTrue (cube is not None)
|
|
self.assertTrue (cube.Length == 1.0)
|
|
self.assertTrue (cube.Width == 2.0)
|
|
self.assertTrue (cube.Height == 3.0)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_import_circle(self):
|
|
doc = self.utility_create_scad("circle(10.0);","circle")
|
|
circle = doc.getObject("circle")
|
|
self.assertTrue (circle is not None)
|
|
self.assertTrue (circle.Radius == 10.0)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_import_square(self):
|
|
doc = self.utility_create_scad("square([1.0,2.0]);","square")
|
|
square = doc.getObject("square")
|
|
self.assertTrue (square is not None)
|
|
self.assertTrue (square.Length == 1.0)
|
|
self.assertTrue (square.Width == 2.0)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_import_text(self):
|
|
# This uses the DXF importer that may pop-up modal dialogs
|
|
# if not all 3rd party libraries are installed
|
|
if FreeCAD.GuiUp:
|
|
return
|
|
try:
|
|
doc = self.utility_create_scad("text(\"X\");","text") # Keep it short to keep the test fast-ish
|
|
text = doc.getObject("text")
|
|
self.assertTrue (text is not None)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
except Exception:
|
|
return # We may not have the DXF importer available
|
|
|
|
# Try a number with a set script:
|
|
doc = self.utility_create_scad("text(\"2\",script=\"latin\");","two_text")
|
|
text = doc.getObject("text")
|
|
self.assertTrue (text is not None)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
# Leave off the script (which is supposed to default to "latin")
|
|
doc = self.utility_create_scad("text(\"1\");","one_text")
|
|
text = doc.getObject("text")
|
|
self.assertTrue (text is not None)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_import_polygon_nopath(self):
|
|
doc = self.utility_create_scad("polygon(points=[[0,0],[100,0],[130,50],[30,50]]);","polygon_nopath")
|
|
polygon = doc.getObject("polygon")
|
|
self.assertTrue (polygon is not None)
|
|
self.assertAlmostEqual (polygon.Shape.Area, 5000.0)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_import_polygon_path(self):
|
|
doc = self.utility_create_scad("polygon([[0,0],[100,0],[130,50],[30,50]], paths=[[0,1,2,3]]);","polygon_path")
|
|
wire = doc.ActiveObject # With paths, the polygon gets created as a wire...
|
|
self.assertTrue (wire is not None)
|
|
self.assertAlmostEqual (wire.Shape.Area, 5000.0)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_import_polyhedron(self):
|
|
doc = self.utility_create_scad(
|
|
"""
|
|
polyhedron(
|
|
points=[ [10,10,0],[10,-10,0],[-10,-10,0],[-10,10,0], // the four points at base
|
|
[0,0,10] ], // the apex point
|
|
faces=[ [0,1,4],[1,2,4],[2,3,4],[3,0,4], // each triangle side
|
|
[1,0,3],[2,1,3] ] // two triangles for square base
|
|
);
|
|
""","polyhedron"
|
|
)
|
|
polyhedron = doc.ActiveObject # With paths, the polygon gets created as a wire...
|
|
self.assertTrue (polyhedron is not None)
|
|
self.assertAlmostEqual (polyhedron.Shape.Volume, 1333.3333, 4)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_import_difference(self):
|
|
doc = self.utility_create_scad("difference() { cube(15, center=true); sphere(10); }", "difference")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 266.1323, 3)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_import_intersection(self):
|
|
doc = self.utility_create_scad("intersection() { cube(15, center=true); sphere(10); }", "intersection")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 3108.8677, 3)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_import_union(self):
|
|
doc = self.utility_create_scad("union() { cube(15, center=true); sphere(10); }", "union")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 4454.9224, 3)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_import_rotate_extrude(self):
|
|
doc = self.utility_create_scad("rotate_extrude() translate([10, 0]) square(5);", "rotate_extrude_simple")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 1963.4954, 3)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
doc = self.utility_create_scad("translate([0, 30, 0]) rotate_extrude() polygon( points=[[0,0],[8,4],[4,8],[4,12],[12,16],[0,20]] );", "rotate_extrude_no_hole")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 2412.7431, 3)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
# Bug #4353 - https://tracker.freecad.org/view.php?id=4353
|
|
doc = self.utility_create_scad("rotate_extrude($fn=4, angle=180) polygon([[0,0],[3,3],[0,3]]);", "rotate_extrude_low_fn")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 9.0, 5)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
doc = self.utility_create_scad("rotate_extrude($fn=4, angle=-180) polygon([[0,0],[3,3],[0,3]]);", "rotate_extrude_low_fn_negative_angle")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 9.0, 5)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
doc = self.utility_create_scad("rotate_extrude(angle=180) polygon([[0,0],[3,3],[0,3]]);", "rotate_extrude_angle")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 4.5*math.pi, 5)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
doc = self.utility_create_scad("rotate_extrude(angle=-180) polygon([[0,0],[3,3],[0,3]]);", "rotate_extrude_negative_angle")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 4.5*math.pi, 5)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_import_linear_extrude(self):
|
|
doc = self.utility_create_scad("linear_extrude(height = 20) square([20, 10], center = true);", "linear_extrude_simple")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 4000.000, 3)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
doc = self.utility_create_scad("linear_extrude(height = 20, twist = 90) square([20, 10], center = true);", "linear_extrude_twist")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 4000.000, 2)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
doc = self.utility_create_scad("linear_extrude(height = 20, scale = 0.2) square([20, 10], center = true);", "linear_extrude_scale")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
h = 20
|
|
a1 = 20*10
|
|
a2 = 20*0.2 * 10*0.2
|
|
expected_volume = (h/3) * (a1+a2+math.sqrt(a1*a2))
|
|
self.assertAlmostEqual (object.Shape.Volume, expected_volume, 3)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
doc = self.utility_create_scad("linear_extrude(height = 20, twist = 180, scale=0.2) square([20, 10], center = true);", "linear_extrude_twist_scale")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, expected_volume, 2)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_import_rotate_extrude_file(self):
|
|
# OpenSCAD doesn't seem to have this feature at this time (March 2021)
|
|
pass
|
|
|
|
# There is a problem with the DXF code right now, it doesn't like this square.
|
|
# def test_import_import_dxf(self):
|
|
# testfile = join(self.test_dir, "Square.dxf").replace('\\','/')
|
|
# doc = self.utility_create_scad("import(\"{}\");".format(testfile), "import_dxf");
|
|
# object = doc.ActiveObject
|
|
# self.assertTrue (object is not None)
|
|
# FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_import_import_stl(self):
|
|
preferences = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/OpenSCAD")
|
|
transfer_mechanism = preferences.GetInt('transfermechanism',0)
|
|
if transfer_mechanism == 2:
|
|
print ("Cannot test STL import, communication with OpenSCAD is via pipes")
|
|
print ("If either OpenSCAD or FreeCAD are installed as sandboxed packages,")
|
|
print ("use of import is not possible.")
|
|
return
|
|
testfile = join(self.test_dir, "Cube.stl").replace('\\','/')
|
|
doc = self.utility_create_scad("import(\"{}\");".format(testfile), "import_stl");
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_import_resize(self):
|
|
doc = self.utility_create_scad("resize([2,2,2]) cube();", "resize_simple")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 8.000000, 6)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
doc = self.utility_create_scad("resize([2,2,0]) cube();", "resize_with_zero")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 4.000000, 6)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
doc = self.utility_create_scad("resize([2,0,0], auto=true) cube();", "resize_with_auto")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 8.000000, 6)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
doc = self.utility_create_scad("resize([2,2,2]) cube([2,2,2]);", "resize_no_change")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 8.000000, 6)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
doc = self.utility_create_scad("resize([2,2,2]) cube([4,8,12]);", "resize_non_uniform")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 8.000000, 6)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
# Make sure to test something that isn't just a box (where the bounding box is trivial)
|
|
doc = self.utility_create_scad("""
|
|
resize(newsize = [0,0,10], auto = [0,0,0]) {
|
|
sphere($fn = 96, $fa = 12, $fs = 2, r = 8.5);
|
|
}""", "resize_non_uniform_sphere")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
object.Shape.tessellate(0.025) # To ensure the bounding box calculation is correct
|
|
self.assertAlmostEqual (object.Shape.BoundBox.XLength, 2*8.5, 1)
|
|
self.assertAlmostEqual (object.Shape.BoundBox.YLength, 2*8.5, 1)
|
|
self.assertAlmostEqual (object.Shape.BoundBox.ZLength, 10.0, 1)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_import_surface(self):
|
|
preferences = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/OpenSCAD")
|
|
transfer_mechanism = preferences.GetInt('transfermechanism',0)
|
|
if transfer_mechanism == 2:
|
|
print ("Cannot test .dat surface import, communication with OpenSCAD is via pipes")
|
|
print ("If either OpenSCAD or FreeCAD are installed as sandboxed packages, use of")
|
|
print ("import is not possible.")
|
|
return
|
|
# Workaround for absolute vs. relative path issue
|
|
# Inside the OpenSCAD file an absolute path name to Surface.dat is used
|
|
# but by using the OpenSCAD executable to create a CSG file it's converted
|
|
# into a path name relative to the output filename.
|
|
# In order to open the CAG file correctly the cwd must be temporarily changed
|
|
with tempfile.TemporaryDirectory() as temp_dir:
|
|
cwd = os.getcwd()
|
|
os.chdir(temp_dir)
|
|
try:
|
|
testfile = join(self.test_dir, "Surface.dat").replace('\\','/')
|
|
doc = self.utility_create_scad(f"surface(file = \"{testfile}\", center = true, convexity = 5);", "surface_simple_dat")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 275.000000, 6)
|
|
self.assertAlmostEqual (object.Shape.BoundBox.XMin, -4.5, 6)
|
|
self.assertAlmostEqual (object.Shape.BoundBox.XMax, 4.5, 6)
|
|
self.assertAlmostEqual (object.Shape.BoundBox.YMin, -4.5, 6)
|
|
self.assertAlmostEqual (object.Shape.BoundBox.YMax, 4.5, 6)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
testfile = join(self.test_dir, "Surface.dat").replace('\\','/')
|
|
doc = self.utility_create_scad(f"surface(file = \"{testfile}\", convexity = 5);", "surface_uncentered_dat")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 275.000000, 6)
|
|
self.assertAlmostEqual (object.Shape.BoundBox.XMin, 0, 6)
|
|
self.assertAlmostEqual (object.Shape.BoundBox.XMax, 9, 6)
|
|
self.assertAlmostEqual (object.Shape.BoundBox.YMin, 0, 6)
|
|
self.assertAlmostEqual (object.Shape.BoundBox.YMax, 9, 6)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
testfile = join(self.test_dir, "Surface2.dat").replace('\\','/')
|
|
doc = self.utility_create_scad(f"surface(file = \"{testfile}\", center = true, convexity = 5);", "surface_rectangular_dat")
|
|
object = doc.ActiveObject
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Volume, 24.5500000, 6)
|
|
self.assertAlmostEqual (object.Shape.BoundBox.XMin, -2, 6)
|
|
self.assertAlmostEqual (object.Shape.BoundBox.XMax, 2, 6)
|
|
self.assertAlmostEqual (object.Shape.BoundBox.YMin, -1.5, 6)
|
|
self.assertAlmostEqual (object.Shape.BoundBox.YMax, 1.5, 6)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
except:
|
|
os.chdir(cwd)
|
|
raise Exception
|
|
else:
|
|
os.chdir(cwd)
|
|
|
|
def test_import_projection(self):
|
|
base_shape = "linear_extrude(height=5,center=true,twist=90,scale=0.5){square([1,1],center=true);}"
|
|
hole = "cube([0.25,0.25,6],center=true);"
|
|
cut_shape = f"difference() {{ {base_shape} {hole} }}"
|
|
|
|
doc = self.utility_create_scad(f"projection(cut=true) {base_shape}", "projection_slice_square")
|
|
object = doc.getObject("projection_cut")
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Area, 0.75*0.75, 3)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
doc = self.utility_create_scad(f"projection(cut=true) {cut_shape}", "projection_slice_square_with_hole")
|
|
object = doc.getObject("projection_cut")
|
|
self.assertTrue (object is not None)
|
|
self.assertAlmostEqual (object.Shape.Area, 0.75*0.75 - 0.25*0.25, 3)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
# Unimplemented functionality:
|
|
|
|
# With cut=false, the twisted unit square projects to a circle of radius sqrt(0.5)
|
|
#doc = self.utility_create_scad(f"projection(cut=false) {base_shape}", "projection_circle")
|
|
#object = doc.getObject("projection")
|
|
#self.assertTrue (object is not None)
|
|
#self.assertAlmostEqual (object.Shape.Area, 2*math.pi*math.sqrt(2), 3)
|
|
#FreeCAD.closeDocument(doc.Name)
|
|
|
|
#doc = self.utility_create_scad(f"projection(cut=false) {cut_shape}", "projection_circle_with_hole")
|
|
#object = doc.getObject("projection")
|
|
#self.assertTrue (object is not None)
|
|
#self.assertAlmostEqual (object.Shape.Area, 2*math.pi*math.sqrt(0.5) - 0.125, 3)
|
|
#FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_import_hull(self):
|
|
pass
|
|
|
|
def test_import_minkowski(self):
|
|
pass
|
|
|
|
def test_import_offset(self):
|
|
pass
|
|
|
|
def test_empty_union(self):
|
|
content = """union() {
|
|
color(c = [0.30, 0.50, 0.80, 0.50]) {
|
|
union() {
|
|
union() {
|
|
union() {
|
|
translate(v = [23.0, -9.50, 13.60]) {
|
|
union() {
|
|
difference() {
|
|
difference() {
|
|
difference() {
|
|
difference() {
|
|
difference() {
|
|
difference() {
|
|
difference() {
|
|
union() {
|
|
union() {
|
|
union() {
|
|
union() {
|
|
union() {
|
|
union() {
|
|
union() {
|
|
union();
|
|
translate(v = [2.50, 2.50, 9.50]) {
|
|
cylinder(h = 19.0, r = 2.50, center = true, $fn = 100);
|
|
}
|
|
}
|
|
translate(v = [11.50, 2.50, 9.50]) {
|
|
cylinder(h = 19.0, r = 2.50, center = true, $fn = 100);
|
|
}
|
|
}
|
|
translate(v = [11.50, 6.30, 9.50]) {
|
|
cylinder(h = 19.0, r = 2.50, center = true, $fn = 100);
|
|
}
|
|
}
|
|
translate(v = [2.50, 6.30, 9.50]) {
|
|
cylinder(h = 19.0, r = 2.50, center = true, $fn = 100);
|
|
}
|
|
}
|
|
translate(v = [2.50, 0.0, 0.0]) {
|
|
cube(size = [9.0, 8.80, 19.0]);
|
|
}
|
|
}
|
|
translate(v = [0.0, 2.50, 0.0]) {
|
|
cube(size = [14.0, 3.80, 19.0]);
|
|
}
|
|
}
|
|
}
|
|
translate(v = [-1.0, 8.40, 3.50]) {
|
|
cube(size = [30.0, 10.0, 12.0]);
|
|
}
|
|
}
|
|
translate(v = [4.0, 4.0, -0.10]) {
|
|
cylinder($fn = 30, h = 20.0, r = 1.750, r1 = 1.80);
|
|
}
|
|
}
|
|
translate(v = [9.0, 4.40, -0.10]) {
|
|
cylinder($fn = 30, h = 20.0, r = 2.150, r1 = 2.20);
|
|
}
|
|
}
|
|
translate(v = [12.30, 2.10, -0.10]) {
|
|
cube(size = [5.0, 2.20, 20.0]);
|
|
}
|
|
}
|
|
translate(v = [1.90, 7.60, -0.10]) {
|
|
cube(size = [2.20, 5.0, 20.0]);
|
|
}
|
|
}
|
|
translate(v = [3.60, 7.20, 1.80]) {
|
|
cube(size = [30.0, 10.0, 2.0]);
|
|
}
|
|
}
|
|
translate(v = [0, 0, 13.40]) {
|
|
translate(v = [3.60, 7.20, 1.80]) {
|
|
cube(size = [30.0, 10.0, 2.0]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}"""
|
|
doc = self.utility_create_scad(content, "empty_union")
|
|
self.assertEqual (len(doc.RootObjects), 1)
|
|
FreeCAD.closeDocument(doc.Name)
|
|
|
|
def test_complex_fuse_no_placement(self):
|
|
# Issue #7878 - https://github.com/FreeCAD/FreeCAD/issues/7878
|
|
|
|
csg_data = """
|
|
group() {
|
|
multmatrix([[1, 0, 0, 0], [0, 1, 0, -127], [0, 0, 1, -6], [0, 0, 0, 1]]) {
|
|
union() {
|
|
group() {
|
|
difference() {
|
|
cube(size = [4, 106.538, 12], center = false);
|
|
group() {
|
|
polyhedron(points = [[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1], [1, 0, 1], [0, 1, 1]], faces = [[0, 1, 2], [5, 4, 3], [3, 1, 0], [1, 3, 4], [0, 2, 3], [5, 3, 2], [4, 2, 1], [2, 4, 5]], convexity = 1);
|
|
}
|
|
}
|
|
}
|
|
polyhedron(points = [[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1], [1, 0, 1], [0, 1, 1]], faces = [[0, 1, 2], [5, 4, 3], [3, 1, 0], [1, 3, 4], [0, 2, 3], [5, 3, 2], [4, 2, 1], [2, 4, 5]], convexity = 1);
|
|
polyhedron(points = [[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1], [1, 0, 1], [0, 1, 1]], faces = [[0, 1, 2], [5, 4, 3], [3, 1, 0], [1, 3, 4], [0, 2, 3], [5, 3, 2], [4, 2, 1], [2, 4, 5]], convexity = 1);
|
|
}
|
|
}
|
|
multmatrix([[1, 0, 0, 6.4], [0, 1, 0, -125], [0, 0, 1, -40], [0, 0, 0, 1]]) {
|
|
difference() {
|
|
cylinder($fn = 0, $fa = 12, $fs = 2, h = 80, r1 = 8, r2 = 8, center = false);
|
|
multmatrix([[1, 0, 0, -14.4], [0, 1, 0, -8], [0, 0, 1, -5], [0, 0, 0, 1]]) {
|
|
cube(size = [8, 16, 90], center = false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
"""
|
|
doc = self.utility_create_scad(csg_data, "complex-fuse")
|
|
self.assertEqual (doc.RootObjects[0].Placement, FreeCAD.Placement())
|
|
FreeCAD.closeDocument(doc.Name)
|