FANDOM


OpenSCAD test run report


Note: This is running a special pre-release of OpenCSG 1.3.2pre

Sysid: linux_i686_software-rasterizer_idwd

Result summary: 88 / 88 tests passed ( 100 % )

System info:

OpenSCAD Version: test
Compiled by: GCC 4.4.3
Compile date: Nov 30 2011
Boost version: 1_40
Eigen version: 2.0.15
CGAL version: 3.7
OpenCSG version:OpenCSG 1.3.2
GLEW version: 1.7.0
GL Renderer: Software Rasterizer
GL Vendor: Mesa Project
OpenGL Version: 2.1 Mesa 7.7.1
GL Extensions: 
GL_ARB_framebuffer_object: yes
GL_EXT_framebuffer_object: yes
GL_EXT_packed_depth_stencil: yes
FBO: RGBA(8888), depth(24), stencil(8)
GL context creator: GLX
PNG generator: lodepng
GLX version: 1.2
OS info: Linux 2.6.32-34-generic #77-Ubuntu SMP Tue Sep 13 19:40:53 UTC 2011
Machine: i686
Git branch: cakebaby from origin git@github.com:donbright/openscad.git
Git upstream: git://github.com/openscad/openscad.git
Image comparison: ImageMagick

start time: Nov 30 22:03 CST
end time : Nov 30 22:12 CST

image tests

opencsgtest_for-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest for-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output for-tests-actual
268/442 Testing: opencsgtest_for-tests
268/442 Test: opencsgtest_for-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/for-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_for-tests" start time: Nov 30 22:03 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 30 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/for-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/for-tests-actual.png
<end of output>
Test time =   2.74 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_for-tests" end time: Nov 30 22:03 CST
"opencsgtest_for-tests" time elapsed: 00:00:02


opencsgtest_rotate_extrude_dxf-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest rotate extrude dxf-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output rotate extrude dxf-tests-actual
269/442 Testing: opencsgtest_rotate_extrude_dxf-tests
269/442 Test: opencsgtest_rotate_extrude_dxf-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/rotate_extrude_dxf-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_rotate_extrude_dxf-tests" start time: Nov 30 22:03 CST
Output:
----------------------------------------------------------
Error output: DEPRECATED: Support for reading files in rotate_extrude will be removed in future releases. Use a child import() instead.
Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/rotate_extrude_dxf-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/rotate_extrude_dxf-tests-actual.png
<end of output>
Test time =   2.50 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_rotate_extrude_dxf-tests" end time: Nov 30 22:03 CST
"opencsgtest_rotate_extrude_dxf-tests" time elapsed: 00:00:02


opencsgtest_import_stl-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest import stl-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output import stl-tests-actual
270/442 Testing: opencsgtest_import_stl-tests
270/442 Test: opencsgtest_import_stl-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/import_stl-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_import_stl-tests" start time: Nov 30 22:03 CST
Output:
----------------------------------------------------------
Error output: DEPRECATED: The import_stl() module will be removed in future releases. Use import() instead.
Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/import_stl-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/import_stl-tests-actual.png
<end of output>
Test time =   2.28 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_import_stl-tests" end time: Nov 30 22:03 CST
"opencsgtest_import_stl-tests" time elapsed: 00:00:02


opencsgtest_cylinder-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest cylinder-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output cylinder-tests-actual
271/442 Testing: opencsgtest_cylinder-tests
271/442 Test: opencsgtest_cylinder-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/cylinder-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_cylinder-tests" start time: Nov 30 22:03 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 11 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/cylinder-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/cylinder-tests-actual.png
<end of output>
Test time =   2.27 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_cylinder-tests" end time: Nov 30 22:03 CST
"opencsgtest_cylinder-tests" time elapsed: 00:00:02


opencsgtest_cube-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest cube-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output cube-tests-actual
272/442 Testing: opencsgtest_cube-tests
272/442 Test: opencsgtest_cube-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/cube-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_cube-tests" start time: Nov 30 22:03 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 7 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/cube-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/cube-tests-actual.png
<end of output>
Test time =   2.14 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_cube-tests" end time: Nov 30 22:03 CST
"opencsgtest_cube-tests" time elapsed: 00:00:02


opencsgtest_intersection-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest intersection-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output intersection-tests-actual
273/442 Testing: opencsgtest_intersection-tests
273/442 Test: opencsgtest_intersection-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/intersection-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_intersection-tests" start time: Nov 30 22:03 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 15 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/intersection-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/intersection-tests-actual.png
<end of output>
Test time =   3.20 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_intersection-tests" end time: Nov 30 22:03 CST
"opencsgtest_intersection-tests" time elapsed: 00:00:03


opencsgtest_union-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest union-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output union-tests-actual
274/442 Testing: opencsgtest_union-tests
274/442 Test: opencsgtest_union-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/union-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_union-tests" start time: Nov 30 22:03 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 12 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/union-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/union-tests-actual.png
<end of output>
Test time =   2.25 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_union-tests" end time: Nov 30 22:03 CST
"opencsgtest_union-tests" time elapsed: 00:00:02


opencsgtest_for-nested-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest for-nested-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output for-nested-tests-actual
275/442 Testing: opencsgtest_for-nested-tests
275/442 Test: opencsgtest_for-nested-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/for-nested-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_for-nested-tests" start time: Nov 30 22:03 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 36 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/for-nested-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/for-nested-tests-actual.png
<end of output>
Test time =   2.58 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_for-nested-tests" end time: Nov 30 22:03 CST
"opencsgtest_for-nested-tests" time elapsed: 00:00:02


opencsgtest_child-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest child-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output child-tests-actual
276/442 Testing: opencsgtest_child-tests
276/442 Test: opencsgtest_child-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/child-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_child-tests" start time: Nov 30 22:03 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 5 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/child-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/child-tests-actual.png
<end of output>
Test time =   3.44 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_child-tests" end time: Nov 30 22:03 CST
"opencsgtest_child-tests" time elapsed: 00:00:03


opencsgtest_highlight-modifier
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest highlight-modifier-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output highlight-modifier-actual
277/442 Testing: opencsgtest_highlight-modifier
277/442 Test: opencsgtest_highlight-modifier
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/highlight-modifier.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_highlight-modifier" start time: Nov 30 22:03 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 2 elements
Compiling highlights (1 CSG Trees)...

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/highlight-modifier-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/highlight-modifier-actual.png
<end of output>
Test time =   4.17 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_highlight-modifier" end time: Nov 30 22:03 CST
"opencsgtest_highlight-modifier" time elapsed: 00:00:04


opencsgtest_linear_extrude-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest linear extrude-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output linear extrude-tests-actual
278/442 Testing: opencsgtest_linear_extrude-tests
278/442 Test: opencsgtest_linear_extrude-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/linear_extrude-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_linear_extrude-tests" start time: Nov 30 22:03 CST
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: cube(size=[1,1,1],center=false); (8 verts)
ERROR: rotate_extrude() is not defined for 3D child objects!
CGAL Cache insert: square(size=[10,10],center=false); (8 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=5); (20 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=3); (14 verts)
CGAL Cache insert: difference(){circle($fn=0,$fa=12,$fs=1,r (30 verts)
CGAL Cache insert: polygon(points=[[-5,-2.5],[5,-2.5],[0,2. (7 verts)
Normalized CSG tree has 5 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/linear_extrude-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/linear_extrude-tests-actual.png
<end of output>
Test time =   3.17 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_linear_extrude-tests" end time: Nov 30 22:03 CST
"opencsgtest_linear_extrude-tests" time elapsed: 00:00:03


opencsgtest_testcolornames
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest testcolornames-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output testcolornames-actual
279/442 Testing: opencsgtest_testcolornames
279/442 Test: opencsgtest_testcolornames
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/testcolornames.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_testcolornames" start time: Nov 30 22:03 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 141 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/testcolornames-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/testcolornames-actual.png
<end of output>
Test time =   3.19 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_testcolornames" end time: Nov 30 22:03 CST
"opencsgtest_testcolornames" time elapsed: 00:00:03


opencsgtest_polyhedron-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest polyhedron-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output polyhedron-tests-actual
280/442 Testing: opencsgtest_polyhedron-tests
280/442 Test: opencsgtest_polyhedron-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/polyhedron-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_polyhedron-tests" start time: Nov 30 22:03 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 9 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/polyhedron-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/polyhedron-tests-actual.png
<end of output>
Test time =   2.74 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polyhedron-tests" end time: Nov 30 22:03 CST
"opencsgtest_polyhedron-tests" time elapsed: 00:00:02


opencsgtest_projection-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest projection-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output projection-tests-actual
281/442 Testing: opencsgtest_projection-tests
281/442 Test: opencsgtest_projection-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/projection-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_projection-tests" start time: Nov 30 22:03 CST
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: square(size=[1,1],center=false); (8 verts)
CGAL Cache insert: sphere($fn=0,$fa=12,$fs=1,r=10); (450 verts)
reduce polygons: 28 -> 1
CGAL Cache insert: projection(cut=false,convexity=0){sphere (34 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,9 (450 verts)
reduce polygons: 56 -> 1
CGAL Cache insert: projection(cut=true,convexity=0){multmat (62 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,7 (450 verts)
reduce polygons: 56 -> 1
CGAL Cache insert: projection(cut=true,convexity=0){multmat (62 verts)
Normalized CSG tree has 3 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/projection-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/projection-tests-actual.png
<end of output>
Test time = 207.01 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_projection-tests" end time: Nov 30 22:07 CST
"opencsgtest_projection-tests" time elapsed: 00:03:27


opencsgtest_sphere-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest sphere-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output sphere-tests-actual
282/442 Testing: opencsgtest_sphere-tests
282/442 Test: opencsgtest_sphere-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/sphere-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_sphere-tests" start time: Nov 30 22:07 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 10 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/sphere-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/sphere-tests-actual.png
<end of output>
Test time =   2.46 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_sphere-tests" end time: Nov 30 22:07 CST
"opencsgtest_sphere-tests" time elapsed: 00:00:02


opencsgtest_hull3-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest hull3-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output hull3-tests-actual
283/442 Testing: opencsgtest_hull3-tests
283/442 Test: opencsgtest_hull3-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/hull3-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_hull3-tests" start time: Nov 30 22:07 CST
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: hull(); (0 verts)
CGAL Cache insert: cube(size=[5,5,5],center=true); (8 verts)
CGAL Cache insert: hull(){cylinder($fn=0,$fa=12,$fs=1,h=1,r (64 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=1,r1=3,r2= (20 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=4,r1=10,r2 (60 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=5,r1=5,r2= (32 verts)
CGAL Cache insert: hull(){multmatrix([[1,0,0,0],[0,1,0,0],[ (70 verts)
Normalized CSG tree has 2 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/hull3-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/hull3-tests-actual.png
<end of output>
Test time =   6.58 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_hull3-tests" end time: Nov 30 22:07 CST
"opencsgtest_hull3-tests" time elapsed: 00:00:06


opencsgtest_difference-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest difference-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output difference-tests-actual
284/442 Testing: opencsgtest_difference-tests
284/442 Test: opencsgtest_difference-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/difference-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_difference-tests" start time: Nov 30 22:07 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 11 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/difference-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/difference-tests-actual.png
<end of output>
Test time =   2.43 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_difference-tests" end time: Nov 30 22:07 CST
"opencsgtest_difference-tests" time elapsed: 00:00:02


opencsgtest_include-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest include-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output include-tests-actual
285/442 Testing: opencsgtest_include-tests
285/442 Test: opencsgtest_include-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/include-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_include-tests" start time: Nov 30 22:07 CST
Output:
----------------------------------------------------------
Error output: WARNING: Can't open input file `non-file'.
Normalized CSG tree has 7 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/include-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/include-tests-actual.png
<end of output>
Test time =   2.27 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_include-tests" end time: Nov 30 22:07 CST
"opencsgtest_include-tests" time elapsed: 00:00:02


opencsgtest_minkowski3-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest minkowski3-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output minkowski3-tests-actual
286/442 Testing: opencsgtest_minkowski3-tests
286/442 Test: opencsgtest_minkowski3-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/minkowski3-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_minkowski3-tests" start time: Nov 30 22:07 CST
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: cube(size=[10,10,5],center=true); (8 verts)
CGAL Cache insert: cube(size=[8,8,10],center=true); (8 verts)
CGAL Cache insert: difference(){cube(size=[10,10,5],center= (16 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=1,r1=2,r2= (14 verts)
CGAL Cache insert: minkowski(convexity=0){difference(){cube (28 verts)
CGAL Cache insert: cube(size=[10,10,5],center=false); (8 verts)
CGAL Cache insert: cube(size=[5,5,5],center=false); (8 verts)
CGAL Cache insert: difference(){cube(size=[10,10,5],center= (12 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=5,r1=5,r2= (32 verts)
CGAL Cache insert: minkowski(convexity=0){difference(){cube (48 verts)
CGAL Cache insert: minkowski(convexity=0){cube(size=[10,10, (40 verts)
CGAL Cache insert: minkowski(convexity=0); (0 verts)
Normalized CSG tree has 3 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/minkowski3-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/minkowski3-tests-actual.png
<end of output>
Test time =  27.55 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_minkowski3-tests" end time: Nov 30 22:07 CST
"opencsgtest_minkowski3-tests" time elapsed: 00:00:27


opencsgtest_surface-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest surface-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output surface-tests-actual
287/442 Testing: opencsgtest_surface-tests
287/442 Test: opencsgtest_surface-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/surface-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_surface-tests" start time: Nov 30 22:07 CST
Output:
----------------------------------------------------------
Error output: QFSFileEngine::open: No file name specified
WARNING: Can't open DAT file `'.
Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/surface-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/surface-tests-actual.png
<end of output>
Test time =   2.83 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_surface-tests" end time: Nov 30 22:07 CST
"opencsgtest_surface-tests" time elapsed: 00:00:02


opencsgtest_intersection_for-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest intersection for-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output intersection for-tests-actual
288/442 Testing: opencsgtest_intersection_for-tests
288/442 Test: opencsgtest_intersection_for-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/intersection_for-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_intersection_for-tests" start time: Nov 30 22:07 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 4 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/intersection_for-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/intersection_for-tests-actual.png
<end of output>
Test time =   2.43 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_intersection_for-tests" end time: Nov 30 22:08 CST
"opencsgtest_intersection_for-tests" time elapsed: 00:00:02


opencsgtest_assign-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest assign-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output assign-tests-actual
289/442 Testing: opencsgtest_assign-tests
289/442 Test: opencsgtest_assign-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/assign-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_assign-tests" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 12 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/assign-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/assign-tests-actual.png
<end of output>
Test time =   2.69 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_assign-tests" end time: Nov 30 22:08 CST
"opencsgtest_assign-tests" time elapsed: 00:00:02


opencsgtest_import_dxf-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest import dxf-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output import dxf-tests-actual
290/442 Testing: opencsgtest_import_dxf-tests
290/442 Test: opencsgtest_import_dxf-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/import_dxf-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_import_dxf-tests" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: ERROR: Unsupported file format while trying to import file ''
Normalized CSG tree has 8 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/import_dxf-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/import_dxf-tests-actual.png
<end of output>
Test time =   3.34 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_import_dxf-tests" end time: Nov 30 22:08 CST
"opencsgtest_import_dxf-tests" time elapsed: 00:00:03


opencsgtest_transform-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest transform-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output transform-tests-actual
291/442 Testing: opencsgtest_transform-tests
291/442 Test: opencsgtest_transform-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/transform-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_transform-tests" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 7 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/transform-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/transform-tests-actual.png
<end of output>
Test time =   2.36 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_transform-tests" end time: Nov 30 22:08 CST
"opencsgtest_transform-tests" time elapsed: 00:00:02


opencsgtest_square-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest square-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output square-tests-actual
292/442 Testing: opencsgtest_square-tests
292/442 Test: opencsgtest_square-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/square-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_square-tests" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 8 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/square-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/square-tests-actual.png
<end of output>
Test time =   2.35 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_square-tests" end time: Nov 30 22:08 CST
"opencsgtest_square-tests" time elapsed: 00:00:02


opencsgtest_2d-3d
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest 2d-3d-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output 2d-3d-actual
293/442 Testing: opencsgtest_2d-3d
293/442 Test: opencsgtest_2d-3d
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/2d-3d.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_2d-3d" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 2 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/2d-3d-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/2d-3d-actual.png
<end of output>
Test time =   2.39 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_2d-3d" end time: Nov 30 22:08 CST
"opencsgtest_2d-3d" time elapsed: 00:00:02


opencsgtest_color-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest color-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output color-tests-actual
294/442 Testing: opencsgtest_color-tests
294/442 Test: opencsgtest_color-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/color-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_color-tests" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 8 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/color-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/color-tests-actual.png
<end of output>
Test time =   3.88 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_color-tests" end time: Nov 30 22:08 CST
"opencsgtest_color-tests" time elapsed: 00:00:03


opencsgtest_disable-modifier
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest disable-modifier-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output disable-modifier-actual
295/442 Testing: opencsgtest_disable-modifier
295/442 Test: opencsgtest_disable-modifier
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/disable-modifier.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_disable-modifier" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/disable-modifier-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/disable-modifier-actual.png
<end of output>
Test time =   2.53 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_disable-modifier" end time: Nov 30 22:08 CST
"opencsgtest_disable-modifier" time elapsed: 00:00:02


opencsgtest_polygon-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest polygon-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output polygon-tests-actual
296/442 Testing: opencsgtest_polygon-tests
296/442 Test: opencsgtest_polygon-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/polygon-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_polygon-tests" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: ERROR: Unable to convert point at index 0 to a vec2 of numbers
ERROR: Unable to convert point at index 0 to a vec2 of numbers
Normalized CSG tree has 12 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/polygon-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/polygon-tests-actual.png
<end of output>
Test time =   2.09 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-tests" end time: Nov 30 22:08 CST
"opencsgtest_polygon-tests" time elapsed: 00:00:02


opencsgtest_hull2-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest hull2-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output hull2-tests-actual
297/442 Testing: opencsgtest_hull2-tests
297/442 Test: opencsgtest_hull2-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/hull2-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_hull2-tests" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=10); (34 verts)
reduce polygons: 28 -> 1
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=5); (20 verts)
CGAL Cache insert: hull(){multmatrix([[1,0,0,15],[0,1,0,10] (36 verts)
reduce polygons: 28 -> 1
CGAL Cache insert: hull(){multmatrix([[1,0,0,15],[0,1,0,10] (36 verts)
CGAL Cache insert: square(size=[2,2],center=false); (8 verts)
reduce polygons: 2 -> 1
reduce polygons: 2 -> 1
CGAL Cache insert: hull(){multmatrix([[1,0,0,15],[0,1,0,10] (9 verts)
Normalized CSG tree has 3 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/hull2-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/hull2-tests-actual.png
<end of output>
Test time =   3.99 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_hull2-tests" end time: Nov 30 22:08 CST
"opencsgtest_hull2-tests" time elapsed: 00:00:03


opencsgtest_root-modifier
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest root-modifier-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output root-modifier-actual
298/442 Testing: opencsgtest_root-modifier
298/442 Test: opencsgtest_root-modifier
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/root-modifier.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_root-modifier" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/root-modifier-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/root-modifier-actual.png
<end of output>
Test time =   2.27 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_root-modifier" end time: Nov 30 22:08 CST
"opencsgtest_root-modifier" time elapsed: 00:00:02


opencsgtest_circle-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest circle-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output circle-tests-actual
299/442 Testing: opencsgtest_circle-tests
299/442 Test: opencsgtest_circle-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/circle-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_circle-tests" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 10 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/circle-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/circle-tests-actual.png
<end of output>
Test time =   2.17 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_circle-tests" end time: Nov 30 22:08 CST
"opencsgtest_circle-tests" time elapsed: 00:00:02


opencsgtest_rotate_extrude-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest rotate extrude-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output rotate extrude-tests-actual
300/442 Testing: opencsgtest_rotate_extrude-tests
300/442 Test: opencsgtest_rotate_extrude-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/rotate_extrude-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_rotate_extrude-tests" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: cube(size=[1,1,1],center=false); (8 verts)
ERROR: rotate_extrude() is not defined for 3D child objects!
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=10); (34 verts)
reduce polygons: 28 -> 1
CGAL Cache insert: multmatrix([[1,0,0,20],[0,1,0,0],[0,0,1, (34 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=8); (30 verts)
CGAL Cache insert: difference(){circle($fn=0,$fa=12,$fs=1,r (60 verts)
reduce polygons: 56 -> 2
CGAL Cache insert: multmatrix([[1,0,0,20],[0,1,0,0],[0,0,1, (60 verts)
reduce polygons: 24 -> 1
CGAL Cache insert: multmatrix([[1,0,0,20],[0,1,0,0],[0,0,1, (30 verts)
Normalized CSG tree has 6 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/rotate_extrude-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/rotate_extrude-tests-actual.png
<end of output>
Test time =   5.09 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_rotate_extrude-tests" end time: Nov 30 22:08 CST
"opencsgtest_rotate_extrude-tests" time elapsed: 00:00:05


opencsgtest_background-modifier
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest background-modifier-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output background-modifier-actual
301/442 Testing: opencsgtest_background-modifier
301/442 Test: opencsgtest_background-modifier
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/background-modifier.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_background-modifier" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements
Compiling background (1 CSG Trees)...

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/background-modifier-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/background-modifier-actual.png
<end of output>
Test time =   3.26 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_background-modifier" end time: Nov 30 22:08 CST
"opencsgtest_background-modifier" time elapsed: 00:00:03


opencsgtest_highlight-and-background-modifier
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest highlight-and-background-modifier-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output highlight-and-background-modifier-actual
302/442 Testing: opencsgtest_highlight-and-background-modifier
302/442 Test: opencsgtest_highlight-and-background-modifier
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/highlight-and-background-modifier.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_highlight-and-background-modifier" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 2 elements
Compiling highlights (2 CSG Trees)...
Compiling background (2 CSG Trees)...

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/highlight-and-background-modifier-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/highlight-and-background-modifier-actual.png
<end of output>
Test time =   2.75 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_highlight-and-background-modifier" end time: Nov 30 22:08 CST
"opencsgtest_highlight-and-background-modifier" time elapsed: 00:00:02


opencsgtest_ifelse-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest ifelse-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output ifelse-tests-actual
303/442 Testing: opencsgtest_ifelse-tests
303/442 Test: opencsgtest_ifelse-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/ifelse-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_ifelse-tests" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: WARNING: Ignoring unknown variable 'ILLEGAL'.
Normalized CSG tree has 11 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/ifelse-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/ifelse-tests-actual.png
<end of output>
Test time =   1.62 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_ifelse-tests" end time: Nov 30 22:08 CST
"opencsgtest_ifelse-tests" time elapsed: 00:00:01


opencsgtest_minkowski2-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest minkowski2-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output minkowski2-tests-actual
304/442 Testing: opencsgtest_minkowski2-tests
304/442 Test: opencsgtest_minkowski2-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/minkowski2-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_minkowski2-tests" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: square(size=[10,10],center=true); (8 verts)
CGAL Cache insert: square(size=[8,8],center=true); (8 verts)
CGAL Cache insert: difference(){square(size=[10,10],center= (12 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=2); (11 verts)
CGAL Cache insert: minkowski(convexity=0){difference(){squa (15 verts)
CGAL Cache insert: square(size=[10,10],center=false); (8 verts)
CGAL Cache insert: square(size=[5,5],center=false); (8 verts)
CGAL Cache insert: difference(){square(size=[10,10],center= (10 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=5); (20 verts)
CGAL Cache insert: minkowski(convexity=0){difference(){squa (28 verts)
CGAL Cache insert: minkowski(convexity=0){square(size=[10,1 (24 verts)
Normalized CSG tree has 3 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/minkowski2-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/minkowski2-tests-actual.png
<end of output>
Test time =   2.38 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_minkowski2-tests" end time: Nov 30 22:08 CST
"opencsgtest_minkowski2-tests" time elapsed: 00:00:02


opencsgtest_render-tests
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest render-tests-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output render-tests-actual
305/442 Testing: opencsgtest_render-tests
305/442 Test: opencsgtest_render-tests
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/features/render-tests.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_render-tests" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: render(convexity=1); (0 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=80,r1=10,r (60 verts)
CGAL Cache insert: cube(size=[20,20,150],center=true); (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,-10],[0,1,0,-10],[0,0 (60 verts)
CGAL Cache insert: difference(){cube(size=[20,20,150],cente (28 verts)
CGAL Cache insert: group(){difference(){cube(size=[20,20,15 (28 verts)
CGAL Cache insert: render(convexity=2){group(){difference() (28 verts)
CGAL Cache insert: cube(size=[100,100,100],center=true); (8 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=110,r1=30, (60 verts)
CGAL Cache insert: difference(){cube(size=[100,100,100],cen (68 verts)
CGAL Cache insert: render(convexity=2){difference(){cube(si (68 verts)
Normalized CSG tree has 17 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/render-tests-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/render-tests-actual.png
<end of output>
Test time =   4.03 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_render-tests" end time: Nov 30 22:08 CST
"opencsgtest_render-tests" time elapsed: 00:00:04


opencsgtest_polygon-many-holes
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest polygon-many-holes-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output polygon-many-holes-actual
306/442 Testing: opencsgtest_polygon-many-holes
306/442 Test: opencsgtest_polygon-many-holes
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/polygon-many-holes.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_polygon-many-holes" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/polygon-many-holes-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/polygon-many-holes-actual.png
<end of output>
Test time =   1.70 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-many-holes" end time: Nov 30 22:08 CST
"opencsgtest_polygon-many-holes" time elapsed: 00:00:01


opencsgtest_null-polygons
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest null-polygons-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output null-polygons-actual
307/442 Testing: opencsgtest_null-polygons
307/442 Test: opencsgtest_null-polygons
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/null-polygons.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_null-polygons" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: DEPRECATED: The import_dxf() module will be removed in future releases. Use import() instead.
DEPRECATED: Support for reading files in linear_extrude will be removed in future releases. Use a child import() instead.
reduce polygons: 9 -> 1
CGAL Cache insert: import(file="../../dxf/null-polygons.dxf (15 verts)
Normalized CSG tree has 2 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/null-polygons-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/null-polygons-actual.png
<end of output>
Test time =   1.64 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_null-polygons" end time: Nov 30 22:08 CST
"opencsgtest_null-polygons" time elapsed: 00:00:01


opencsgtest_circle
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest circle-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output circle-actual
308/442 Testing: opencsgtest_circle
308/442 Test: opencsgtest_circle
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/circle.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_circle" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/circle-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/circle-actual.png
<end of output>
Test time =   1.64 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_circle" end time: Nov 30 22:08 CST
"opencsgtest_circle" time elapsed: 00:00:01


opencsgtest_circle-small
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest circle-small-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output circle-small-actual
309/442 Testing: opencsgtest_circle-small
309/442 Test: opencsgtest_circle-small
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/circle-small.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_circle-small" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/circle-small-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/circle-small-actual.png
<end of output>
Test time =   1.62 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_circle-small" end time: Nov 30 22:08 CST
"opencsgtest_circle-small" time elapsed: 00:00:01


opencsgtest_polygon-intersect
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest polygon-intersect-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output polygon-intersect-actual
310/442 Testing: opencsgtest_polygon-intersect
310/442 Test: opencsgtest_polygon-intersect
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/polygon-intersect.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_polygon-intersect" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output:  sorry, this triangulation does not deal with
 intersecting constraints
CGAL error in dxf_tesselate(): CGAL ERROR: assertion violation!
Expr: false
File: /home/don/src/CGAL-3.7/include/CGAL/Constrained_triangulation_2.h
Line: 620
Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/polygon-intersect-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/polygon-intersect-actual.png
<end of output>
Test time =   1.54 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-intersect" end time: Nov 30 22:08 CST
"opencsgtest_polygon-intersect" time elapsed: 00:00:01


opencsgtest_polygon-self-intersect
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest polygon-self-intersect-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output polygon-self-intersect-actual
311/442 Testing: opencsgtest_polygon-self-intersect
311/442 Test: opencsgtest_polygon-self-intersect
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/polygon-self-intersect.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_polygon-self-intersect" start time: Nov 30 22:08 CST
Output:
----------------------------------------------------------
Error output:  sorry, this triangulation does not deal with
 intersecting constraints
CGAL error in dxf_tesselate(): CGAL ERROR: assertion violation!
Expr: false
File: /home/don/src/CGAL-3.7/include/CGAL/Constrained_triangulation_2.h
Line: 620
Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/polygon-self-intersect-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/polygon-self-intersect-actual.png
<end of output>
Test time =   1.52 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-self-intersect" end time: Nov 30 22:09 CST
"opencsgtest_polygon-self-intersect" time elapsed: 00:00:01


opencsgtest_ellipse-arc
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest ellipse-arc-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output ellipse-arc-actual
312/442 Testing: opencsgtest_ellipse-arc
312/442 Test: opencsgtest_ellipse-arc
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/ellipse-arc.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_ellipse-arc" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/ellipse-arc-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/ellipse-arc-actual.png
<end of output>
Test time =   1.51 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_ellipse-arc" end time: Nov 30 22:09 CST
"opencsgtest_ellipse-arc" time elapsed: 00:00:01


opencsgtest_ellipse
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest ellipse-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output ellipse-actual
313/442 Testing: opencsgtest_ellipse
313/442 Test: opencsgtest_ellipse
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/ellipse.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_ellipse" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/ellipse-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/ellipse-actual.png
<end of output>
Test time =   1.63 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_ellipse" end time: Nov 30 22:09 CST
"opencsgtest_ellipse" time elapsed: 00:00:01


opencsgtest_polygon-concave-simple
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest polygon-concave-simple-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output polygon-concave-simple-actual
314/442 Testing: opencsgtest_polygon-concave-simple
314/442 Test: opencsgtest_polygon-concave-simple
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/polygon-concave-simple.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_polygon-concave-simple" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/polygon-concave-simple-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/polygon-concave-simple-actual.png
<end of output>
Test time =   1.70 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-concave-simple" end time: Nov 30 22:09 CST
"opencsgtest_polygon-concave-simple" time elapsed: 00:00:01


opencsgtest_multiple-layers
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest multiple-layers-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output multiple-layers-actual
315/442 Testing: opencsgtest_multiple-layers
315/442 Test: opencsgtest_multiple-layers
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/multiple-layers.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_multiple-layers" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/multiple-layers-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/multiple-layers-actual.png
<end of output>
Test time =   1.69 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_multiple-layers" end time: Nov 30 22:09 CST
"opencsgtest_multiple-layers" time elapsed: 00:00:01


opencsgtest_polygon8
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest polygon8-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output polygon8-actual
316/442 Testing: opencsgtest_polygon8
316/442 Test: opencsgtest_polygon8
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/polygon8.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_polygon8" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/polygon8-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/polygon8-actual.png
<end of output>
Test time =   1.58 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon8" end time: Nov 30 22:09 CST
"opencsgtest_polygon8" time elapsed: 00:00:01


opencsgtest_arc
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest arc-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output arc-actual
317/442 Testing: opencsgtest_arc
317/442 Test: opencsgtest_arc
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/arc.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_arc" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/arc-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/arc-actual.png
<end of output>
Test time =   1.53 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_arc" end time: Nov 30 22:09 CST
"opencsgtest_arc" time elapsed: 00:00:01


opencsgtest_lwpolyline-closed
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest lwpolyline-closed-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output lwpolyline-closed-actual
318/442 Testing: opencsgtest_lwpolyline-closed
318/442 Test: opencsgtest_lwpolyline-closed
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/lwpolyline-closed.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_lwpolyline-closed" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/lwpolyline-closed-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/lwpolyline-closed-actual.png
<end of output>
Test time =   1.55 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_lwpolyline-closed" end time: Nov 30 22:09 CST
"opencsgtest_lwpolyline-closed" time elapsed: 00:00:01


opencsgtest_ellipse-arc-rot
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest ellipse-arc-rot-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output ellipse-arc-rot-actual
319/442 Testing: opencsgtest_ellipse-arc-rot
319/442 Test: opencsgtest_ellipse-arc-rot
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/ellipse-arc-rot.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_ellipse-arc-rot" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/ellipse-arc-rot-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/ellipse-arc-rot-actual.png
<end of output>
Test time =   1.59 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_ellipse-arc-rot" end time: Nov 30 22:09 CST
"opencsgtest_ellipse-arc-rot" time elapsed: 00:00:01


opencsgtest_triangle-with-duplicate-vertex
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest triangle-with-duplicate-vertex-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output triangle-with-duplicate-vertex-actual
320/442 Testing: opencsgtest_triangle-with-duplicate-vertex
320/442 Test: opencsgtest_triangle-with-duplicate-vertex
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/triangle-with-duplicate-vertex.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_triangle-with-duplicate-vertex" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/triangle-with-duplicate-vertex-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/triangle-with-duplicate-vertex-actual.png
<end of output>
Test time =   1.56 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_triangle-with-duplicate-vertex" end time: Nov 30 22:09 CST
"opencsgtest_triangle-with-duplicate-vertex" time elapsed: 00:00:01


opencsgtest_polygon-holes-touch
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest polygon-holes-touch-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output polygon-holes-touch-actual
321/442 Testing: opencsgtest_polygon-holes-touch
321/442 Test: opencsgtest_polygon-holes-touch
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/polygon-holes-touch.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_polygon-holes-touch" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/polygon-holes-touch-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/polygon-holes-touch-actual.png
<end of output>
Test time =   1.62 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-holes-touch" end time: Nov 30 22:09 CST
"opencsgtest_polygon-holes-touch" time elapsed: 00:00:01


opencsgtest_polygon-overlap
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest polygon-overlap-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output polygon-overlap-actual
322/442 Testing: opencsgtest_polygon-overlap
322/442 Test: opencsgtest_polygon-overlap
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/polygon-overlap.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_polygon-overlap" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/polygon-overlap-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/polygon-overlap-actual.png
<end of output>
Test time =   1.80 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-overlap" end time: Nov 30 22:09 CST
"opencsgtest_polygon-overlap" time elapsed: 00:00:01


opencsgtest_circle-advanced
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest circle-advanced-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output circle-advanced-actual
323/442 Testing: opencsgtest_circle-advanced
323/442 Test: opencsgtest_circle-advanced
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/circle-advanced.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_circle-advanced" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/circle-advanced-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/circle-advanced-actual.png
<end of output>
Test time =   1.70 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_circle-advanced" end time: Nov 30 22:09 CST
"opencsgtest_circle-advanced" time elapsed: 00:00:01


opencsgtest_ellipse-rot
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest ellipse-rot-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output ellipse-rot-actual
324/442 Testing: opencsgtest_ellipse-rot
324/442 Test: opencsgtest_ellipse-rot
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/ellipse-rot.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_ellipse-rot" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/ellipse-rot-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/ellipse-rot-actual.png
<end of output>
Test time =   1.74 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_ellipse-rot" end time: Nov 30 22:09 CST
"opencsgtest_ellipse-rot" time elapsed: 00:00:01


opencsgtest_circle-double
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest circle-double-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output circle-double-actual
325/442 Testing: opencsgtest_circle-double
325/442 Test: opencsgtest_circle-double
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/circle-double.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_circle-double" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/circle-double-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/circle-double-actual.png
<end of output>
Test time =   1.60 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_circle-double" end time: Nov 30 22:09 CST
"opencsgtest_circle-double" time elapsed: 00:00:01


opencsgtest_polygon-concave
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest polygon-concave-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output polygon-concave-actual
326/442 Testing: opencsgtest_polygon-concave
326/442 Test: opencsgtest_polygon-concave
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/polygon-concave.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_polygon-concave" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/polygon-concave-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/polygon-concave-actual.png
<end of output>
Test time =   1.68 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-concave" end time: Nov 30 22:09 CST
"opencsgtest_polygon-concave" time elapsed: 00:00:01


opencsgtest_polygon-riser
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest polygon-riser-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output polygon-riser-actual
327/442 Testing: opencsgtest_polygon-riser
327/442 Test: opencsgtest_polygon-riser
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/polygon-riser.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_polygon-riser" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/polygon-riser-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/polygon-riser-actual.png
<end of output>
Test time =   1.61 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-riser" end time: Nov 30 22:09 CST
"opencsgtest_polygon-riser" time elapsed: 00:00:01


opencsgtest_transform-insert
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest transform-insert-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output transform-insert-actual
328/442 Testing: opencsgtest_transform-insert
328/442 Test: opencsgtest_transform-insert
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/transform-insert.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_transform-insert" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/transform-insert-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/transform-insert-actual.png
<end of output>
Test time =   1.82 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_transform-insert" end time: Nov 30 22:09 CST
"opencsgtest_transform-insert" time elapsed: 00:00:01


opencsgtest_polygons
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest polygons-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output polygons-actual
329/442 Testing: opencsgtest_polygons
329/442 Test: opencsgtest_polygons
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/polygons.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_polygons" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/polygons-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/polygons-actual.png
<end of output>
Test time =   1.56 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygons" end time: Nov 30 22:09 CST
"opencsgtest_polygons" time elapsed: 00:00:01


opencsgtest_lwpolyline
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest lwpolyline-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output lwpolyline-actual
330/442 Testing: opencsgtest_lwpolyline
330/442 Test: opencsgtest_lwpolyline
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/lwpolyline.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_lwpolyline" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/lwpolyline-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/lwpolyline-actual.png
<end of output>
Test time =   1.52 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_lwpolyline" end time: Nov 30 22:09 CST
"opencsgtest_lwpolyline" time elapsed: 00:00:01


opencsgtest_ellipse-reverse
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest ellipse-reverse-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output ellipse-reverse-actual
331/442 Testing: opencsgtest_ellipse-reverse
331/442 Test: opencsgtest_ellipse-reverse
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/ellipse-reverse.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_ellipse-reverse" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/ellipse-reverse-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/ellipse-reverse-actual.png
<end of output>
Test time =   1.67 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_ellipse-reverse" end time: Nov 30 22:09 CST
"opencsgtest_ellipse-reverse" time elapsed: 00:00:01


opencsgtest_polygon-concave-hole
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest polygon-concave-hole-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output polygon-concave-hole-actual
332/442 Testing: opencsgtest_polygon-concave-hole
332/442 Test: opencsgtest_polygon-concave-hole
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/polygon-concave-hole.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_polygon-concave-hole" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/polygon-concave-hole-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/polygon-concave-hole-actual.png
<end of output>
Test time =   1.51 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-concave-hole" end time: Nov 30 22:09 CST
"opencsgtest_polygon-concave-hole" time elapsed: 00:00:01


opencsgtest_polygon-mesh
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest polygon-mesh-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output polygon-mesh-actual
333/442 Testing: opencsgtest_polygon-mesh
333/442 Test: opencsgtest_polygon-mesh
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/polygon-mesh.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_polygon-mesh" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output:  sorry, this triangulation does not deal with
 intersecting constraints
CGAL error in dxf_tesselate(): CGAL ERROR: assertion violation!
Expr: false
File: /home/don/src/CGAL-3.7/include/CGAL/Constrained_triangulation_2.h
Line: 620
Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/polygon-mesh-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/polygon-mesh-actual.png
<end of output>
Test time =   1.56 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-mesh" end time: Nov 30 22:09 CST
"opencsgtest_polygon-mesh" time elapsed: 00:00:01


opencsgtest_lwpolyline2
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest lwpolyline2-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output lwpolyline2-actual
334/442 Testing: opencsgtest_lwpolyline2
334/442 Test: opencsgtest_lwpolyline2
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../testdata/scad/dxf/lwpolyline2.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_lwpolyline2" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/lwpolyline2-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/lwpolyline2-actual.png
<end of output>
Test time =   1.73 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_lwpolyline2" end time: Nov 30 22:09 CST
"opencsgtest_lwpolyline2" time elapsed: 00:00:01


opencsgtest_example012
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example012-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example012-actual
335/442 Testing: opencsgtest_example012
335/442 Test: opencsgtest_example012
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example012.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example012" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 2 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example012-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example012-actual.png
<end of output>
Test time =   2.20 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example012" end time: Nov 30 22:09 CST
"opencsgtest_example012" time elapsed: 00:00:02


opencsgtest_example020
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example020-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example020-actual
336/442 Testing: opencsgtest_example020
336/442 Test: opencsgtest_example020
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example020.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example020" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: reduce polygons: 4 -> 1
CGAL Cache insert: polygon(points=[[40,0],[20,0],[14.623918 (10 verts)
reduce polygons: 4 -> 1
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,0 (10 verts)
reduce polygons: 4 -> 1
CGAL Cache insert: multmatrix([[0.62349,-0.781831,0,0],[0.7 (10 verts)
reduce polygons: 4 -> 1
CGAL Cache insert: multmatrix([[-0.222521,-0.974928,0,0],[0 (10 verts)
reduce polygons: 4 -> 1
CGAL Cache insert: multmatrix([[-0.900969,-0.433884,0,0],[0 (10 verts)
reduce polygons: 4 -> 1
CGAL Cache insert: multmatrix([[-0.900969,0.433884,0,0],[-0 (10 verts)
reduce polygons: 4 -> 1
CGAL Cache insert: multmatrix([[-0.222521,0.974928,0,0],[-0 (10 verts)
reduce polygons: 4 -> 1
CGAL Cache insert: multmatrix([[0.62349,0.781831,0,0],[-0.7 (10 verts)
CGAL Cache insert: group(); (0 verts)
CGAL Cache insert: group(){multmatrix([[1,0,0,0],[0,1,0,0], (10 verts)
CGAL Cache insert: group(){multmatrix([[0.62349,-0.781831,0 (10 verts)
CGAL Cache insert: group(){multmatrix([[-0.222521,-0.974928 (10 verts)
CGAL Cache insert: group(){multmatrix([[-0.900969,-0.433884 (10 verts)
CGAL Cache insert: group(){multmatrix([[-0.900969,0.433884, (10 verts)
CGAL Cache insert: group(){multmatrix([[-0.222521,0.974928, (10 verts)
CGAL Cache insert: group(){multmatrix([[0.62349,0.781831,0, (10 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=20); (34 verts)
CGAL Cache insert: group(){group();group(){multmatrix([[1,0 (46 verts)
CGAL Cache insert: difference(){circle($fn=0,$fa=12,$fs=1,r (39 verts)
reduce polygons: 4 -> 1
CGAL Cache insert: polygon(points=[[42,0],[21,0],[15.598846 (10 verts)
reduce polygons: 4 -> 1
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,0 (10 verts)
reduce polygons: 4 -> 1
CGAL Cache insert: multmatrix([[0.62349,-0.781831,0,0],[0.7 (10 verts)
reduce polygons: 4 -> 1
CGAL Cache insert: multmatrix([[-0.222521,-0.974928,0,0],[0 (10 verts)
reduce polygons: 4 -> 1
CGAL Cache insert: multmatrix([[-0.900969,-0.433884,0,0],[0 (10 verts)
reduce polygons: 4 -> 1
CGAL Cache insert: multmatrix([[-0.900969,0.433884,0,0],[-0 (10 verts)
reduce polygons: 4 -> 1
CGAL Cache insert: multmatrix([[-0.222521,0.974928,0,0],[-0 (10 verts)
reduce polygons: 4 -> 1
CGAL Cache insert: multmatrix([[0.62349,0.781831,0,0],[-0.7 (10 verts)
CGAL Cache insert: group(){multmatrix([[1,0,0,0],[0,1,0,0], (10 verts)
CGAL Cache insert: group(){multmatrix([[0.62349,-0.781831,0 (10 verts)
CGAL Cache insert: group(){multmatrix([[-0.222521,-0.974928 (10 verts)
CGAL Cache insert: group(){multmatrix([[-0.900969,-0.433884 (10 verts)
CGAL Cache insert: group(){multmatrix([[-0.900969,0.433884, (10 verts)
CGAL Cache insert: group(){multmatrix([[-0.222521,0.974928, (10 verts)
CGAL Cache insert: group(){multmatrix([[0.62349,0.781831,0, (10 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=21); (34 verts)
CGAL Cache insert: group(){group();group(){multmatrix([[1,0 (46 verts)
CGAL Cache insert: difference(){circle($fn=0,$fa=12,$fs=1,r (39 verts)
CGAL Cache insert: polygon(points=[[100,0],[90.108707172564 (7 verts)
CGAL Cache insert: group(){polygon(points=[[100,0],[90.1087 (7 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: polygon(points=[[99.2773187264562,33.700 (8 verts)
CGAL Cache insert: group(){polygon(points=[[99.277318726456 (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: polygon(points=[[84.5828731296560,64.902 (8 verts)
CGAL Cache insert: group(){polygon(points=[[84.582873129656 (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: polygon(points=[[59.8939420434316,89.637 (8 verts)
CGAL Cache insert: group(){polygon(points=[[59.893942043431 (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: polygon(points=[[28.1233431906722,104.95 (8 verts)
CGAL Cache insert: group(){polygon(points=[[28.123343190672 (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: polygon(points=[[-7.1466161580741,109.03 (8 verts)
CGAL Cache insert: group(){polygon(points=[[-7.146616158074 (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: polygon(points=[[-41.973659637557,101.33 (8 verts)
CGAL Cache insert: group(){polygon(points=[[-41.97365963755 (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: polygon(points=[[-72.476325465304,82.643 (8 verts)
CGAL Cache insert: group(){polygon(points=[[-72.47632546530 (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: polygon(points=[[-95.262794416288,54.999 (8 verts)
CGAL Cache insert: group(){polygon(points=[[-95.26279441628 (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: polygon(points=[[-107.80945532094,21.444 (8 verts)
CGAL Cache insert: group(){polygon(points=[[-107.8094553209 (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: polygon(points=[[-108.74410972934,-14.31 (8 verts)
CGAL Cache insert: group(){polygon(points=[[-108.7441097293 (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: polygon(points=[[-98.001506989358,-48.32 (8 verts)
CGAL Cache insert: group(){polygon(points=[[-98.00150698935 (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: polygon(points=[[-76.834402475612,-76.83 (8 verts)
CGAL Cache insert: group(){polygon(points=[[-76.83440247561 (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: polygon(points=[[-47.681484003315,-96.68 (8 verts)
CGAL Cache insert: group(){polygon(points=[[-47.68148400331 (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: polygon(points=[[-13.915968832491,-105.7 (8 verts)
CGAL Cache insert: group(){polygon(points=[[-13.91596883249 (8 verts)
CGAL Cache insert: polygon(points=[[20.4535091618312,-102.8 (7 verts)
CGAL Cache insert: group(){polygon(points=[[20.453509161831 (7 verts)
CGAL Cache insert: group(){group(){polygon(points=[[100,0], (7 verts)
CGAL Cache insert: group(){group();group();group(){polygon( (8 verts)
CGAL Cache insert: group(){group();group();group(){polygon( (8 verts)
CGAL Cache insert: group(){group();group();group(){polygon( (8 verts)
CGAL Cache insert: group(){group();group();group(){polygon( (8 verts)
CGAL Cache insert: group(){group();group();group(){polygon( (8 verts)
CGAL Cache insert: group(){group();group();group(){polygon( (8 verts)
CGAL Cache insert: group(){group();group();group(){polygon( (8 verts)
CGAL Cache insert: group(){group();group();group(){polygon( (8 verts)
CGAL Cache insert: group(){group();group();group(){polygon( (8 verts)
CGAL Cache insert: group(){group();group();group(){polygon( (8 verts)
CGAL Cache insert: group(){group();group();group(){polygon( (8 verts)
CGAL Cache insert: group(){group();group();group(){polygon( (8 verts)
CGAL Cache insert: group(){group();group();group(){polygon( (8 verts)
CGAL Cache insert: group(){group();group();group(){polygon( (8 verts)
CGAL Cache insert: group(){group();group(){polygon(points=[ (7 verts)
CGAL Cache insert: group(){group(){group(){polygon(points=[ (36 verts)
Normalized CSG tree has 4 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example020-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example020-actual.png
<end of output>
Test time =   7.71 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example020" end time: Nov 30 22:09 CST
"opencsgtest_example020" time elapsed: 00:00:07


opencsgtest_example022
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example022-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example022-actual
337/442 Testing: opencsgtest_example022
337/442 Test: opencsgtest_example022
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example022.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example022" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 29 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example022-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example022-actual.png
<end of output>
Test time =   1.63 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example022" end time: Nov 30 22:09 CST
"opencsgtest_example022" time elapsed: 00:00:01


opencsgtest_example016
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example016-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example016-actual
338/442 Testing: opencsgtest_example016
338/442 Test: opencsgtest_example016
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example016.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example016" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: cube(size=[60,28,14],center=true); (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,7 (8 verts)
CGAL Cache insert: cube(size=[8,32,32],center=true); (8 verts)
CGAL Cache insert: difference(){multmatrix([[1,0,0,0],[0,1, (16 verts)
CGAL Cache insert: import(file="example016.stl",layer="",or (68 verts)
CGAL Cache insert: multmatrix([[1,0,0,-14],[0,1,0,0],[0,0,1 (68 verts)
CGAL Cache insert: group(){difference(){multmatrix([[1,0,0, (16 verts)
CGAL Cache insert: group(){multmatrix([[1,0,0,-14],[0,1,0,0 (68 verts)
CGAL Cache insert: difference(){group(){difference(){multma (52 verts)
CGAL Cache insert: render(convexity=12){difference(){group( (52 verts)
Normalized CSG tree has 5 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example016-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example016-actual.png
<end of output>
Test time =   6.64 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example016" end time: Nov 30 22:09 CST
"opencsgtest_example016" time elapsed: 00:00:06


opencsgtest_example021
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example021-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example021-actual
339/442 Testing: opencsgtest_example021
339/442 Test: opencsgtest_example021
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example021.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example021" start time: Nov 30 22:09 CST
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: cylinder($fn=0,$fa=30,$fs=1,h=62.5,r1=12 (24 verts)
CGAL Cache insert: sphere($fn=0,$fa=30,$fs=1,r=25); (72 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,6.12303e-17,-1, (24 verts)
CGAL Cache insert: multmatrix([[6.12303e-17,0,1,0],[0,1,0,0 (24 verts)
CGAL Cache insert: difference(){sphere($fn=0,$fa=30,$fs=1,r (234 verts)
CGAL Cache insert: group(){difference(){sphere($fn=0,$fa=30 (234 verts)
reduce polygons: 66 -> 2
CGAL Cache insert: projection(cut=false,convexity=0){group( (70 verts)
CGAL Cache insert: multmatrix([[0.933013,0.0669873,0.353553 (234 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,- (234 verts)
reduce polygons: 18 -> 1
CGAL Cache insert: projection(cut=true,convexity=0){multmat (24 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,- (234 verts)
reduce polygons: 39 -> 2
CGAL Cache insert: projection(cut=true,convexity=0){multmat (43 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,- (234 verts)
reduce polygons: 32 -> 2
CGAL Cache insert: projection(cut=true,convexity=0){multmat (40 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,- (234 verts)
reduce polygons: 32 -> 2
CGAL Cache insert: projection(cut=true,convexity=0){multmat (40 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,0 (234 verts)
reduce polygons: 32 -> 2
CGAL Cache insert: projection(cut=true,convexity=0){multmat (40 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,5 (234 verts)
reduce polygons: 38 -> 2
CGAL Cache insert: projection(cut=true,convexity=0){multmat (46 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,1 (234 verts)
reduce polygons: 37 -> 2
CGAL Cache insert: projection(cut=true,convexity=0){multmat (45 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,1 (234 verts)
reduce polygons: 25 -> 1
CGAL Cache insert: projection(cut=true,convexity=0){multmat (31 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,2 (234 verts)
reduce polygons: 14 -> 1
CGAL Cache insert: projection(cut=true,convexity=0){multmat (20 verts)
Normalized CSG tree has 10 elements
Compiling background (2 CSG Trees)...

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example021-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example021-actual.png
<end of output>
Test time = 125.86 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example021" end time: Nov 30 22:12 CST
"opencsgtest_example021" time elapsed: 00:02:05


opencsgtest_example008
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example008-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example008-actual
340/442 Testing: opencsgtest_example008
340/442 Test: opencsgtest_example008
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example008.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example008" start time: Nov 30 22:12 CST
Output:
----------------------------------------------------------
Error output: reduce polygons: 14 -> 1
CGAL Cache insert: import(file="example008.dxf",layer="G",o (20 verts)
reduce polygons: 10 -> 1
CGAL Cache insert: import(file="example008.dxf",layer="E",o (16 verts)
reduce polygons: 19 -> 3
CGAL Cache insert: import(file="example008.dxf",layer="B",o (21 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: import(file="example008.dxf",layer="X",o (8 verts)
Normalized CSG tree has 8 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example008-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example008-actual.png
<end of output>
Test time =   4.29 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example008" end time: Nov 30 22:12 CST
"opencsgtest_example008" time elapsed: 00:00:04


opencsgtest_example001
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example001-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example001-actual
341/442 Testing: opencsgtest_example001
341/442 Test: opencsgtest_example001
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example001.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example001" start time: Nov 30 22:12 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 4 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example001-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example001-actual.png
<end of output>
Test time =   1.77 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example001" end time: Nov 30 22:12 CST
"opencsgtest_example001" time elapsed: 00:00:01


opencsgtest_example015
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example015-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example015-actual
342/442 Testing: opencsgtest_example015
342/442 Test: opencsgtest_example015
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example015.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example015" start time: Nov 30 22:12 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 8 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example015-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example015-actual.png
<end of output>
Test time =   1.70 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example015" end time: Nov 30 22:12 CST
"opencsgtest_example015" time elapsed: 00:00:01


opencsgtest_example014
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example014-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example014-actual
343/442 Testing: opencsgtest_example014
343/442 Test: opencsgtest_example014
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example014.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example014" start time: Nov 30 22:12 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 4 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example014-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example014-actual.png
<end of output>
Test time =   1.71 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example014" end time: Nov 30 22:12 CST
"opencsgtest_example014" time elapsed: 00:00:01


opencsgtest_example003
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example003-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example003-actual
344/442 Testing: opencsgtest_example003
344/442 Test: opencsgtest_example003
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example003.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example003" start time: Nov 30 22:12 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 16 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example003-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example003-actual.png
<end of output>
Test time =   1.86 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example003" end time: Nov 30 22:12 CST
"opencsgtest_example003" time elapsed: 00:00:01


opencsgtest_example019
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example019-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example019-actual
345/442 Testing: opencsgtest_example019
345/442 Test: opencsgtest_example019
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example019.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example019" start time: Nov 30 22:12 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 41 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example019-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example019-actual.png
<end of output>
Test time =   1.62 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example019" end time: Nov 30 22:12 CST
"opencsgtest_example019" time elapsed: 00:00:01


opencsgtest_example007
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example007-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example007-actual
346/442 Testing: opencsgtest_example007
346/442 Test: opencsgtest_example007
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example007.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example007" start time: Nov 30 22:12 CST
Output:
----------------------------------------------------------
Error output: DEPRECATED: Support for reading files in rotate_extrude will be removed in future releases. Use a child import() instead.
reduce polygons: 2 -> 1
CGAL Cache insert: import(file="example007.dxf",layer="cuto (8 verts)
reduce polygons: 6 -> 1
CGAL Cache insert: import(file="example007.dxf",layer="cuto (12 verts)
Normalized CSG tree has 12 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example007-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example007-actual.png
<end of output>
Test time =   4.36 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example007" end time: Nov 30 22:12 CST
"opencsgtest_example007" time elapsed: 00:00:04


opencsgtest_example004
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example004-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example004-actual
347/442 Testing: opencsgtest_example004
347/442 Test: opencsgtest_example004
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example004.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example004" start time: Nov 30 22:12 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 2 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example004-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example004-actual.png
<end of output>
Test time =   1.57 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example004" end time: Nov 30 22:12 CST
"opencsgtest_example004" time elapsed: 00:00:01


opencsgtest_example005
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example005-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example005-actual
348/442 Testing: opencsgtest_example005
348/442 Test: opencsgtest_example005
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example005.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example005" start time: Nov 30 22:12 CST
Output:
----------------------------------------------------------
Error output: ECHO: 0, 0, 80
ECHO: 60, 69.2820323027550, 40.0000000000000
ECHO: 120, 69.2820323027551, -39.999999999999
ECHO: 180, 9.79685083057901, -80
ECHO: 240, -69.282032302755, -40.000000000000
ECHO: 300, -69.282032302755, 40.0000000000000
Normalized CSG tree has 10 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example005-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example005-actual.png
<end of output>
Test time =   1.62 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example005" end time: Nov 30 22:12 CST
"opencsgtest_example005" time elapsed: 00:00:01


opencsgtest_example013
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example013-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example013-actual
349/442 Testing: opencsgtest_example013
349/442 Test: opencsgtest_example013
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example013.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example013" start time: Nov 30 22:12 CST
Output:
----------------------------------------------------------
Error output: reduce polygons: 18 -> 1
CGAL Cache insert: import(file="example013.dxf",layer="",or (24 verts)
Normalized CSG tree has 3 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example013-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example013-actual.png
<end of output>
Test time =   2.28 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example013" end time: Nov 30 22:12 CST
"opencsgtest_example013" time elapsed: 00:00:02


opencsgtest_example011
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example011-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example011-actual
350/442 Testing: opencsgtest_example011
350/442 Test: opencsgtest_example011
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example011.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example011" start time: Nov 30 22:12 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example011-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example011-actual.png
<end of output>
Test time =   1.49 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example011" end time: Nov 30 22:12 CST
"opencsgtest_example011" time elapsed: 00:00:01


opencsgtest_example017
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example017-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example017-actual
351/442 Testing: opencsgtest_example017
351/442 Test: opencsgtest_example017
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example017.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example017" start time: Nov 30 22:12 CST
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: square(size=[6,10],center=true); (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,36],[0,0,1, (8 verts)
reduce polygons: 2 -> 1
reduce polygons: 2 -> 1
reduce polygons: 2 -> 1
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,0 (8 verts)
CGAL Cache insert: multmatrix([[-0.5,-0.866025,0,0],[0.8660 (8 verts)
CGAL Cache insert: multmatrix([[-0.5,0.866025,0,0],[-0.8660 (8 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=47); (34 verts)
CGAL Cache insert: group(){multmatrix([[1,0,0,0],[0,1,0,0], (16 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=25); (34 verts)
CGAL Cache insert: difference(){circle($fn=0,$fa=12,$fs=1,r (76 verts)
CGAL Cache insert: group(){difference(){circle($fn=0,$fa=12 (76 verts)
CGAL Cache insert: square(size=[6,15],center=true); (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,88.5],[0,0, (8 verts)
reduce polygons: 2 -> 1
reduce polygons: 2 -> 1
reduce polygons: 2 -> 1
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,0 (8 verts)
CGAL Cache insert: multmatrix([[-0.5,-0.866025,0,0],[0.8660 (8 verts)
CGAL Cache insert: multmatrix([[-0.5,0.866025,0,0],[-0.8660 (8 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=102); (34 verts)
CGAL Cache insert: group(){multmatrix([[1,0,0,0],[0,1,0,0], (16 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=75); (34 verts)
CGAL Cache insert: difference(){circle($fn=0,$fa=12,$fs=1,r (76 verts)
CGAL Cache insert: group(){difference(){circle($fn=0,$fa=12 (76 verts)
reduce polygons: 19 -> 1
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=6); (23 verts)
reduce polygons: 17 -> 1
reduce polygons: 17 -> 1
CGAL Cache insert: polygon(points=[[0,6],[6,6],[6,0],[21,0] (25 verts)
CGAL Cache insert: multmatrix([[1,0,0,43],[0,1,0,18],[0,0,1 (23 verts)
CGAL Cache insert: multmatrix([[1,0,0,83],[0,1,0,18],[0,0,1 (23 verts)
CGAL Cache insert: square(size=[9,12],center=false); (8 verts)
reduce polygons: 2 -> 1
reduce polygons: 17 -> 1
CGAL Cache insert: square(size=[12,12],center=false); (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: multmatrix([[1,0,0,-12],[0,1,0,0],[0,0,1 (8 verts)
CGAL Cache insert: intersection(){circle($fn=0,$fa=12,$fs=1 (12 verts)
reduce polygons: 6 -> 1
reduce polygons: 6 -> 1
CGAL Cache insert: difference(){polygon(points=[[0,6],[6,6] (37 verts)
CGAL Cache insert: multmatrix([[1,0,0,77],[0,1,0,0],[0,0,1, (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,86],[0,1,0,6],[0,0,1, (23 verts)
CGAL Cache insert: multmatrix([[1,0,0,6],[0,1,0,6],[0,0,1,0 (12 verts)
CGAL Cache insert: multmatrix([[1,0,0,55],[0,1,0,74],[0,0,1 (12 verts)
CGAL Cache insert: union(){difference(){polygon(points=[[0, (63 verts)
CGAL Cache insert: group(){union(){difference(){polygon(poi (63 verts)
CGAL Cache insert: square(size=[25,68],center=false); (8 verts)
reduce polygons: 28 -> 1
CGAL Cache insert: square(size=[25,25],center=false); (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,0.7,0,0],[0,0,1 (34 verts)
CGAL Cache insert: intersection(){square(size=[25,25],cente (14 verts)
reduce polygons: 8 -> 1
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,68],[0,0,1, (14 verts)
CGAL Cache insert: square(size=[12.5,25],center=false); (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,-12.5],[0,0 (8 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=12.5); (34 verts)
CGAL Cache insert: intersection(){multmatrix([[1,0,0,0],[0, (21 verts)
reduce polygons: 15 -> 1
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,93],[0,0,1, (21 verts)
Normalized CSG tree has 5 elements
Compiling background (1 CSG Trees)...

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example017-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example017-actual.png
<end of output>
Test time =   9.00 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example017" end time: Nov 30 22:12 CST
"opencsgtest_example017" time elapsed: 00:00:08


opencsgtest_example002
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example002-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example002-actual
352/442 Testing: opencsgtest_example002
352/442 Test: opencsgtest_example002
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example002.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example002" start time: Nov 30 22:12 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 10 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example002-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example002-actual.png
<end of output>
Test time =   2.16 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example002" end time: Nov 30 22:12 CST
"opencsgtest_example002" time elapsed: 00:00:02


opencsgtest_example009
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example009-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example009-actual
353/442 Testing: opencsgtest_example009
353/442 Test: opencsgtest_example009
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example009.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example009" start time: Nov 30 22:12 CST
Output:
----------------------------------------------------------
Error output: DEPRECATED: Support for reading files in rotate_extrude will be removed in future releases. Use a child import() instead.
reduce polygons: 146 -> 5
CGAL Cache insert: import(file="example009.dxf",layer="body (142 verts)
reduce polygons: 116 -> 5
CGAL Cache insert: import(file="example009.dxf",layer="plat (106 verts)
reduce polygons: 37 -> 2
CGAL Cache insert: import(file="example009.dxf",layer="fan_ (41 verts)
Normalized CSG tree has 2 elements
Compiling background (2 CSG Trees)...

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example009-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example009-actual.png
<end of output>
Test time =   8.27 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example009" end time: Nov 30 22:12 CST
"opencsgtest_example009" time elapsed: 00:00:08


opencsgtest_example018
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example018-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example018-actual
354/442 Testing: opencsgtest_example018
354/442 Test: opencsgtest_example018
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example018.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example018" start time: Nov 30 22:12 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 28 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example018-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example018-actual.png
<end of output>
Test time =   1.62 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example018" end time: Nov 30 22:12 CST
"opencsgtest_example018" time elapsed: 00:00:01


opencsgtest_example010
Expected image Actual image
OpenSCAD linux i686 software-rasterizer idwd regression opencsgtest example010-expected OpenSCAD linux i686 software-rasterizer idwd opencsgtest-output example010-actual
355/442 Testing: opencsgtest_example010
355/442 Test: opencsgtest_example010
Command: "/usr/bin/python2.6" "/home/don/src/openscad/tests/test_cmdline_tool.py" "-c" "/usr/bin/convert" "-s" "png" "/home/don/src/openscad/tests/build/opencsgtest" "/home/don/src/openscad/tests/../examples/example010.scad"
Directory: /home/don/src/openscad/tests/build
"opencsgtest_example010" start time: Nov 30 22:12 CST
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 2 elements

ImageMagick image comparison: convert  -alpha Off -compose difference -composite -threshold 10% -gaussian-blur 3x65535 -threshold 99.999% -format %[fx:w*h*mean] info:
 expected image:  /home/don/src/openscad/tests/regression/opencsgtest/example010-expected.png
 actual image:  /home/don/src/openscad/tests/build/opencsgtest-output/example010-actual.png
<end of output>
Test time =   4.53 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_example010" end time: Nov 30 22:12 CST
"opencsgtest_example010" time elapsed: 00:00:04




Failed text tests


build.make and flags.make

Ad blocker interference detected!


Wikia is a free-to-use site that makes money from advertising. We have a modified experience for viewers using ad blockers

Wikia is not accessible if you’ve made further modifications. Remove the custom ad blocker rule(s) and the page will load as expected.