First attempt at python2 and python3 support in single codebase
4 tests failing on python3 (CQGI, AMF export)
This commit is contained in:
Adam Urbanczyk
@ -36,22 +36,24 @@ TEST_DEBUG_SCRIPT = textwrap.dedent(
|
||||
"""
|
||||
)
|
||||
|
||||
|
||||
class TestCQGI(BaseTest):
|
||||
def test_parser(self):
|
||||
model = cqgi.CQModel(TESTSCRIPT)
|
||||
metadata = model.metadata
|
||||
|
||||
self.assertEquals(set(metadata.parameters.keys()), {'height', 'width', 'a', 'b', 'foo'})
|
||||
self.assertEqual(set(metadata.parameters.keys()), {
|
||||
'height', 'width', 'a', 'b', 'foo'})
|
||||
|
||||
def test_build_with_debug(self):
|
||||
model = cqgi.CQModel(TEST_DEBUG_SCRIPT)
|
||||
result = model.build()
|
||||
debugItems = result.debugObjects
|
||||
self.assertTrue(len(debugItems) == 2)
|
||||
self.assertTrue( debugItems[0].object == "bar" )
|
||||
self.assertTrue( debugItems[0].args == { "color":'yellow' } )
|
||||
self.assertTrue( debugItems[1].object == 2.0 )
|
||||
self.assertTrue( debugItems[1].args == {} )
|
||||
self.assertTrue(debugItems[0].object == "bar")
|
||||
self.assertTrue(debugItems[0].args == {"color": 'yellow'})
|
||||
self.assertTrue(debugItems[1].object == 2.0)
|
||||
self.assertTrue(debugItems[1].args == {})
|
||||
|
||||
def test_build_with_empty_params(self):
|
||||
model = cqgi.CQModel(TESTSCRIPT)
|
||||
@ -77,7 +79,7 @@ class TestCQGI(BaseTest):
|
||||
a_param = model.metadata.parameters['a']
|
||||
self.assertTrue(a_param.default_value == 2.0)
|
||||
self.assertTrue(a_param.desc == 'FirstLetter')
|
||||
self.assertTrue(a_param.varType == cqgi.NumberParameterType )
|
||||
self.assertTrue(a_param.varType == cqgi.NumberParameterType)
|
||||
|
||||
def test_describe_parameter_invalid_doesnt_fail_script(self):
|
||||
script = textwrap.dedent(
|
||||
@ -88,8 +90,8 @@ class TestCQGI(BaseTest):
|
||||
)
|
||||
model = cqgi.CQModel(script)
|
||||
a_param = model.metadata.parameters['a']
|
||||
self.assertTrue(a_param.name == 'a' )
|
||||
|
||||
self.assertTrue(a_param.name == 'a')
|
||||
|
||||
def test_build_with_exception(self):
|
||||
badscript = textwrap.dedent(
|
||||
"""
|
||||
@ -127,9 +129,9 @@ class TestCQGI(BaseTest):
|
||||
|
||||
model = cqgi.CQModel(script)
|
||||
result = model.build({})
|
||||
self.assertEquals(2, len(result.results))
|
||||
self.assertEquals(1, result.results[0])
|
||||
self.assertEquals(2, result.results[1])
|
||||
self.assertEqual(2, len(result.results))
|
||||
self.assertEqual(1, result.results[0])
|
||||
self.assertEqual(2, result.results[1])
|
||||
|
||||
def test_that_assinging_number_to_string_works(self):
|
||||
script = textwrap.dedent(
|
||||
@ -138,8 +140,8 @@ class TestCQGI(BaseTest):
|
||||
build_object(h)
|
||||
"""
|
||||
)
|
||||
result = cqgi.parse(script).build( {'h': 33.33})
|
||||
self.assertEquals(result.results[0], "33.33")
|
||||
result = cqgi.parse(script).build({'h': 33.33})
|
||||
self.assertEqual(result.results[0], "33.33")
|
||||
|
||||
def test_that_assigning_string_to_number_fails(self):
|
||||
script = textwrap.dedent(
|
||||
@ -148,8 +150,9 @@ class TestCQGI(BaseTest):
|
||||
build_object(h)
|
||||
"""
|
||||
)
|
||||
result = cqgi.parse(script).build( {'h': "a string"})
|
||||
self.assertTrue(isinstance(result.exception, cqgi.InvalidParameterError))
|
||||
result = cqgi.parse(script).build({'h': "a string"})
|
||||
self.assertTrue(isinstance(result.exception,
|
||||
cqgi.InvalidParameterError))
|
||||
|
||||
def test_that_assigning_unknown_var_fails(self):
|
||||
script = textwrap.dedent(
|
||||
@ -159,8 +162,9 @@ class TestCQGI(BaseTest):
|
||||
"""
|
||||
)
|
||||
|
||||
result = cqgi.parse(script).build( {'w': "var is not there"})
|
||||
self.assertTrue(isinstance(result.exception, cqgi.InvalidParameterError))
|
||||
result = cqgi.parse(script).build({'w': "var is not there"})
|
||||
self.assertTrue(isinstance(result.exception,
|
||||
cqgi.InvalidParameterError))
|
||||
|
||||
def test_that_not_calling_build_object_raises_error(self):
|
||||
script = textwrap.dedent(
|
||||
@ -195,7 +199,7 @@ class TestCQGI(BaseTest):
|
||||
result = cqgi.parse(script).build({'h': False})
|
||||
|
||||
self.assertTrue(result.success)
|
||||
self.assertEquals(result.first_result,'*False*')
|
||||
self.assertEqual(result.first_result, '*False*')
|
||||
|
||||
def test_that_only_top_level_vars_are_detected(self):
|
||||
script = textwrap.dedent(
|
||||
@ -213,4 +217,4 @@ class TestCQGI(BaseTest):
|
||||
|
||||
model = cqgi.parse(script)
|
||||
|
||||
self.assertEquals(2, len(model.metadata.parameters))
|
||||
self.assertEqual(2, len(model.metadata.parameters))
|
||||
|
||||
@ -9,86 +9,92 @@ __author__ = 'dcowden'
|
||||
"""
|
||||
|
||||
import math
|
||||
import unittest,sys
|
||||
import unittest
|
||||
import sys
|
||||
import os.path
|
||||
|
||||
#my modules
|
||||
from tests import BaseTest,makeUnitCube,makeUnitSquareWire
|
||||
# my modules
|
||||
from tests import BaseTest, makeUnitCube, makeUnitSquareWire
|
||||
from cadquery import *
|
||||
from cadquery import selectors
|
||||
|
||||
class TestCQSelectors(BaseTest):
|
||||
|
||||
class TestCQSelectors(BaseTest):
|
||||
|
||||
def testWorkplaneCenter(self):
|
||||
"Test Moving workplane center"
|
||||
s = Workplane(Plane.XY())
|
||||
|
||||
#current point and world point should be equal
|
||||
self.assertTupleAlmostEquals((0.0,0.0,0.0),s.plane.origin.toTuple(),3)
|
||||
# current point and world point should be equal
|
||||
self.assertTupleAlmostEquals(
|
||||
(0.0, 0.0, 0.0), s.plane.origin.toTuple(), 3)
|
||||
|
||||
#move origin and confirm center moves
|
||||
s.center(-2.0,-2.0)
|
||||
# move origin and confirm center moves
|
||||
s.center(-2.0, -2.0)
|
||||
|
||||
#current point should be 0,0, but
|
||||
|
||||
self.assertTupleAlmostEquals((-2.0,-2.0,0.0),s.plane.origin.toTuple(),3)
|
||||
# current point should be 0,0, but
|
||||
|
||||
self.assertTupleAlmostEquals(
|
||||
(-2.0, -2.0, 0.0), s.plane.origin.toTuple(), 3)
|
||||
|
||||
def testVertices(self):
|
||||
t = makeUnitSquareWire() # square box
|
||||
t = makeUnitSquareWire() # square box
|
||||
c = CQ(t)
|
||||
|
||||
self.assertEqual(4,c.vertices().size() )
|
||||
self.assertEqual(4,c.edges().size() )
|
||||
self.assertEqual(0,c.vertices().edges().size() ) #no edges on any vertices
|
||||
self.assertEqual(4,c.edges().vertices().size() ) #but selecting all edges still yields all vertices
|
||||
self.assertEqual(1,c.wires().size()) #just one wire
|
||||
self.assertEqual(0,c.faces().size())
|
||||
self.assertEqual(0,c.vertices().faces().size()) #odd combinations all work but yield no results
|
||||
self.assertEqual(0,c.edges().faces().size())
|
||||
self.assertEqual(0,c.edges().vertices().faces().size())
|
||||
self.assertEqual(4, c.vertices().size())
|
||||
self.assertEqual(4, c.edges().size())
|
||||
self.assertEqual(0, c.vertices().edges().size()
|
||||
) # no edges on any vertices
|
||||
# but selecting all edges still yields all vertices
|
||||
self.assertEqual(4, c.edges().vertices().size())
|
||||
self.assertEqual(1, c.wires().size()) # just one wire
|
||||
self.assertEqual(0, c.faces().size())
|
||||
# odd combinations all work but yield no results
|
||||
self.assertEqual(0, c.vertices().faces().size())
|
||||
self.assertEqual(0, c.edges().faces().size())
|
||||
self.assertEqual(0, c.edges().vertices().faces().size())
|
||||
|
||||
def testEnd(self):
|
||||
c = CQ(makeUnitSquareWire())
|
||||
self.assertEqual(4,c.vertices().size() ) #4 because there are 4 vertices
|
||||
self.assertEqual(1,c.vertices().end().size() ) #1 because we started with 1 wire
|
||||
# 4 because there are 4 vertices
|
||||
self.assertEqual(4, c.vertices().size())
|
||||
# 1 because we started with 1 wire
|
||||
self.assertEqual(1, c.vertices().end().size())
|
||||
|
||||
def testAll(self):
|
||||
"all returns a list of CQ objects, so that you can iterate over them individually"
|
||||
c = CQ(makeUnitCube())
|
||||
self.assertEqual(6,c.faces().size())
|
||||
self.assertEqual(6,len(c.faces().all()))
|
||||
self.assertEqual(4,c.faces().all()[0].vertices().size() )
|
||||
self.assertEqual(6, c.faces().size())
|
||||
self.assertEqual(6, len(c.faces().all()))
|
||||
self.assertEqual(4, c.faces().all()[0].vertices().size())
|
||||
|
||||
def testFirst(self):
|
||||
c = CQ( makeUnitCube())
|
||||
self.assertEqual(type(c.vertices().first().val()),Vertex)
|
||||
self.assertEqual(type(c.vertices().first().first().first().val()),Vertex)
|
||||
c = CQ(makeUnitCube())
|
||||
self.assertEqual(type(c.vertices().first().val()), Vertex)
|
||||
self.assertEqual(
|
||||
type(c.vertices().first().first().first().val()), Vertex)
|
||||
|
||||
def testCompounds(self):
|
||||
c = CQ(makeUnitSquareWire())
|
||||
self.assertEqual(0,c.compounds().size() )
|
||||
self.assertEqual(0,c.shells().size() )
|
||||
self.assertEqual(0,c.solids().size() )
|
||||
self.assertEqual(0, c.compounds().size())
|
||||
self.assertEqual(0, c.shells().size())
|
||||
self.assertEqual(0, c.solids().size())
|
||||
|
||||
def testSolid(self):
|
||||
c = CQ(makeUnitCube())
|
||||
#make sure all the counts are right for a cube
|
||||
self.assertEqual(1,c.solids().size() )
|
||||
self.assertEqual(6,c.faces().size() )
|
||||
self.assertEqual(12,c.edges().size())
|
||||
self.assertEqual(8,c.vertices().size() )
|
||||
self.assertEqual(0,c.compounds().size())
|
||||
|
||||
#now any particular face should result in 4 edges and four vertices
|
||||
self.assertEqual(4,c.faces().first().edges().size() )
|
||||
self.assertEqual(1,c.faces().first().size() )
|
||||
self.assertEqual(4,c.faces().first().vertices().size() )
|
||||
|
||||
self.assertEqual(4,c.faces().last().edges().size() )
|
||||
# make sure all the counts are right for a cube
|
||||
self.assertEqual(1, c.solids().size())
|
||||
self.assertEqual(6, c.faces().size())
|
||||
self.assertEqual(12, c.edges().size())
|
||||
self.assertEqual(8, c.vertices().size())
|
||||
self.assertEqual(0, c.compounds().size())
|
||||
|
||||
# now any particular face should result in 4 edges and four vertices
|
||||
self.assertEqual(4, c.faces().first().edges().size())
|
||||
self.assertEqual(1, c.faces().first().size())
|
||||
self.assertEqual(4, c.faces().first().vertices().size())
|
||||
|
||||
self.assertEqual(4, c.faces().last().edges().size())
|
||||
|
||||
def testFaceTypesFilter(self):
|
||||
"Filters by face type"
|
||||
@ -102,16 +108,16 @@ class TestCQSelectors(BaseTest):
|
||||
def testPerpendicularDirFilter(self):
|
||||
c = CQ(makeUnitCube())
|
||||
|
||||
self.assertEqual(8,c.edges("#Z").size() ) #8 edges are perp. to z
|
||||
self.assertEqual(4, c.faces("#Z").size()) #4 faces are perp to z too!
|
||||
self.assertEqual(8, c.edges("#Z").size()) # 8 edges are perp. to z
|
||||
self.assertEqual(4, c.faces("#Z").size()) # 4 faces are perp to z too!
|
||||
|
||||
def testFaceDirFilter(self):
|
||||
c = CQ(makeUnitCube())
|
||||
#a cube has one face in each direction
|
||||
# a cube has one face in each direction
|
||||
self.assertEqual(1, c.faces("+Z").size())
|
||||
self.assertEqual(1, c.faces("-Z").size())
|
||||
self.assertEqual(1, c.faces("+X").size())
|
||||
self.assertEqual(1, c.faces("X").size()) #should be same as +X
|
||||
self.assertEqual(1, c.faces("X").size()) # should be same as +X
|
||||
self.assertEqual(1, c.faces("-X").size())
|
||||
self.assertEqual(1, c.faces("+Y").size())
|
||||
self.assertEqual(1, c.faces("-Y").size())
|
||||
@ -120,13 +126,15 @@ class TestCQSelectors(BaseTest):
|
||||
def testParallelPlaneFaceFilter(self):
|
||||
c = CQ(makeUnitCube())
|
||||
|
||||
#faces parallel to Z axis
|
||||
# faces parallel to Z axis
|
||||
self.assertEqual(2, c.faces("|Z").size())
|
||||
#TODO: provide short names for ParallelDirSelector
|
||||
self.assertEqual(2, c.faces(selectors.ParallelDirSelector(Vector((0,0,1)))).size()) #same thing as above
|
||||
self.assertEqual(2, c.faces(selectors.ParallelDirSelector(Vector((0,0,-1)))).size()) #same thing as above
|
||||
# TODO: provide short names for ParallelDirSelector
|
||||
self.assertEqual(2, c.faces(selectors.ParallelDirSelector(
|
||||
Vector((0, 0, 1)))).size()) # same thing as above
|
||||
self.assertEqual(2, c.faces(selectors.ParallelDirSelector(
|
||||
Vector((0, 0, -1)))).size()) # same thing as above
|
||||
|
||||
#just for fun, vertices on faces parallel to z
|
||||
# just for fun, vertices on faces parallel to z
|
||||
self.assertEqual(8, c.faces("|Z").vertices().size())
|
||||
|
||||
def testParallelEdgeFilter(self):
|
||||
@ -138,14 +146,14 @@ class TestCQSelectors(BaseTest):
|
||||
def testMaxDistance(self):
|
||||
c = CQ(makeUnitCube())
|
||||
|
||||
#should select the topmost face
|
||||
# should select the topmost face
|
||||
self.assertEqual(1, c.faces(">Z").size())
|
||||
self.assertEqual(4, c.faces(">Z").vertices().size())
|
||||
|
||||
#vertices should all be at z=1, if this is the top face
|
||||
self.assertEqual(4, len(c.faces(">Z").vertices().vals() ))
|
||||
# vertices should all be at z=1, if this is the top face
|
||||
self.assertEqual(4, len(c.faces(">Z").vertices().vals()))
|
||||
for v in c.faces(">Z").vertices().vals():
|
||||
self.assertAlmostEqual(1.0,v.Z,3)
|
||||
self.assertAlmostEqual(1.0, v.Z, 3)
|
||||
|
||||
# test the case of multiple objects at the same distance
|
||||
el = c.edges("<Z").vals()
|
||||
@ -154,125 +162,130 @@ class TestCQSelectors(BaseTest):
|
||||
def testMinDistance(self):
|
||||
c = CQ(makeUnitCube())
|
||||
|
||||
#should select the topmost face
|
||||
# should select the topmost face
|
||||
self.assertEqual(1, c.faces("<Z").size())
|
||||
self.assertEqual(4, c.faces("<Z").vertices().size())
|
||||
|
||||
#vertices should all be at z=1, if this is the top face
|
||||
self.assertEqual(4, len(c.faces("<Z").vertices().vals() ))
|
||||
# vertices should all be at z=1, if this is the top face
|
||||
self.assertEqual(4, len(c.faces("<Z").vertices().vals()))
|
||||
for v in c.faces("<Z").vertices().vals():
|
||||
self.assertAlmostEqual(0.0,v.Z,3)
|
||||
self.assertAlmostEqual(0.0, v.Z, 3)
|
||||
|
||||
# test the case of multiple objects at the same distance
|
||||
el = c.edges("<Z").vals()
|
||||
self.assertEqual(4, len(el))
|
||||
|
||||
|
||||
def testNthDistance(self):
|
||||
c = Workplane('XY').pushPoints([(-2,0),(2,0)]).box(1,1,1)
|
||||
|
||||
#2nd face
|
||||
val = c.faces(selectors.DirectionNthSelector(Vector(1,0,0),1)).val()
|
||||
self.assertAlmostEqual(val.Center().x,-1.5)
|
||||
|
||||
#2nd face with inversed selection vector
|
||||
val = c.faces(selectors.DirectionNthSelector(Vector(-1,0,0),1)).val()
|
||||
self.assertAlmostEqual(val.Center().x,1.5)
|
||||
|
||||
#2nd last face
|
||||
val = c.faces(selectors.DirectionNthSelector(Vector(1,0,0),-2)).val()
|
||||
self.assertAlmostEqual(val.Center().x,1.5)
|
||||
|
||||
#Last face
|
||||
val = c.faces(selectors.DirectionNthSelector(Vector(1,0,0),-1)).val()
|
||||
self.assertAlmostEqual(val.Center().x,2.5)
|
||||
|
||||
#check if the selected face if normal to the specified Vector
|
||||
self.assertAlmostEqual(val.normalAt().cross(Vector(1,0,0)).Length,0.0)
|
||||
|
||||
#repeat the test using string based selector
|
||||
|
||||
#2nd face
|
||||
c = Workplane('XY').pushPoints([(-2, 0), (2, 0)]).box(1, 1, 1)
|
||||
|
||||
# 2nd face
|
||||
val = c.faces(selectors.DirectionNthSelector(Vector(1, 0, 0), 1)).val()
|
||||
self.assertAlmostEqual(val.Center().x, -1.5)
|
||||
|
||||
# 2nd face with inversed selection vector
|
||||
val = c.faces(selectors.DirectionNthSelector(
|
||||
Vector(-1, 0, 0), 1)).val()
|
||||
self.assertAlmostEqual(val.Center().x, 1.5)
|
||||
|
||||
# 2nd last face
|
||||
val = c.faces(selectors.DirectionNthSelector(
|
||||
Vector(1, 0, 0), -2)).val()
|
||||
self.assertAlmostEqual(val.Center().x, 1.5)
|
||||
|
||||
# Last face
|
||||
val = c.faces(selectors.DirectionNthSelector(
|
||||
Vector(1, 0, 0), -1)).val()
|
||||
self.assertAlmostEqual(val.Center().x, 2.5)
|
||||
|
||||
# check if the selected face if normal to the specified Vector
|
||||
self.assertAlmostEqual(
|
||||
val.normalAt().cross(Vector(1, 0, 0)).Length, 0.0)
|
||||
|
||||
# repeat the test using string based selector
|
||||
|
||||
# 2nd face
|
||||
val = c.faces('>(1,0,0)[1]').val()
|
||||
self.assertAlmostEqual(val.Center().x,-1.5)
|
||||
self.assertAlmostEqual(val.Center().x, -1.5)
|
||||
val = c.faces('>X[1]').val()
|
||||
self.assertAlmostEqual(val.Center().x,-1.5)
|
||||
|
||||
#2nd face with inversed selection vector
|
||||
self.assertAlmostEqual(val.Center().x, -1.5)
|
||||
|
||||
# 2nd face with inversed selection vector
|
||||
val = c.faces('>(-1,0,0)[1]').val()
|
||||
self.assertAlmostEqual(val.Center().x,1.5)
|
||||
self.assertAlmostEqual(val.Center().x, 1.5)
|
||||
val = c.faces('<X[1]').val()
|
||||
self.assertAlmostEqual(val.Center().x,1.5)
|
||||
|
||||
#2nd last face
|
||||
self.assertAlmostEqual(val.Center().x, 1.5)
|
||||
|
||||
# 2nd last face
|
||||
val = c.faces('>X[-2]').val()
|
||||
self.assertAlmostEqual(val.Center().x,1.5)
|
||||
|
||||
#Last face
|
||||
self.assertAlmostEqual(val.Center().x, 1.5)
|
||||
|
||||
# Last face
|
||||
val = c.faces('>X[-1]').val()
|
||||
self.assertAlmostEqual(val.Center().x,2.5)
|
||||
|
||||
#check if the selected face if normal to the specified Vector
|
||||
self.assertAlmostEqual(val.normalAt().cross(Vector(1,0,0)).Length,0.0)
|
||||
|
||||
#test selection of multiple faces with the same distance
|
||||
self.assertAlmostEqual(val.Center().x, 2.5)
|
||||
|
||||
# check if the selected face if normal to the specified Vector
|
||||
self.assertAlmostEqual(
|
||||
val.normalAt().cross(Vector(1, 0, 0)).Length, 0.0)
|
||||
|
||||
# test selection of multiple faces with the same distance
|
||||
c = Workplane('XY')\
|
||||
.box(1,4,1,centered=(False,True,False)).faces('<Z')\
|
||||
.box(2,2,2,centered=(True,True,False)).faces('>Z')\
|
||||
.box(1,1,1,centered=(True,True,False))
|
||||
|
||||
#select 2nd from the bottom (NB python indexing is 0-based)
|
||||
.box(1, 4, 1, centered=(False, True, False)).faces('<Z')\
|
||||
.box(2, 2, 2, centered=(True, True, False)).faces('>Z')\
|
||||
.box(1, 1, 1, centered=(True, True, False))
|
||||
|
||||
# select 2nd from the bottom (NB python indexing is 0-based)
|
||||
vals = c.faces('>Z[1]').vals()
|
||||
self.assertEqual(len(vals),2)
|
||||
|
||||
self.assertEqual(len(vals), 2)
|
||||
|
||||
val = c.faces('>Z[1]').val()
|
||||
self.assertAlmostEqual(val.Center().z,1)
|
||||
|
||||
#do the same but by selecting 3rd from the top
|
||||
self.assertAlmostEqual(val.Center().z, 1)
|
||||
|
||||
# do the same but by selecting 3rd from the top
|
||||
vals = c.faces('<Z[2]').vals()
|
||||
self.assertEqual(len(vals),2)
|
||||
|
||||
self.assertEqual(len(vals), 2)
|
||||
|
||||
val = c.faces('<Z[2]').val()
|
||||
self.assertAlmostEqual(val.Center().z,1)
|
||||
|
||||
#do the same but by selecting 2nd last from the bottom
|
||||
self.assertAlmostEqual(val.Center().z, 1)
|
||||
|
||||
# do the same but by selecting 2nd last from the bottom
|
||||
vals = c.faces('<Z[-2]').vals()
|
||||
self.assertEqual(len(vals),2)
|
||||
|
||||
self.assertEqual(len(vals), 2)
|
||||
|
||||
val = c.faces('<Z[-2]').val()
|
||||
self.assertAlmostEqual(val.Center().z,1)
|
||||
|
||||
#verify that <Z[-1] is equivalent to <Z
|
||||
self.assertAlmostEqual(val.Center().z, 1)
|
||||
|
||||
# verify that <Z[-1] is equivalent to <Z
|
||||
val1 = c.faces('<Z[-1]').val()
|
||||
val2 = c.faces('<Z').val()
|
||||
self.assertTupleAlmostEquals(val1.Center().toTuple(),
|
||||
val2.Center().toTuple(),
|
||||
3)
|
||||
|
||||
#verify that >Z[-1] is equivalent to >Z
|
||||
|
||||
# verify that >Z[-1] is equivalent to >Z
|
||||
val1 = c.faces('>Z[-1]').val()
|
||||
val2 = c.faces('>Z').val()
|
||||
self.assertTupleAlmostEquals(val1.Center().toTuple(),
|
||||
val2.Center().toTuple(),
|
||||
3)
|
||||
|
||||
|
||||
def testNearestTo(self):
|
||||
c = CQ(makeUnitCube())
|
||||
|
||||
#nearest vertex to origin is (0,0,0)
|
||||
t = (0.1,0.1,0.1)
|
||||
# nearest vertex to origin is (0,0,0)
|
||||
t = (0.1, 0.1, 0.1)
|
||||
|
||||
v = c.vertices(selectors.NearestToPointSelector(t)).vals()[0]
|
||||
self.assertTupleAlmostEquals((0.0,0.0,0.0),(v.X,v.Y,v.Z),3)
|
||||
self.assertTupleAlmostEquals((0.0, 0.0, 0.0), (v.X, v.Y, v.Z), 3)
|
||||
|
||||
t = (0.1,0.1,0.2)
|
||||
#nearest edge is the vertical side edge, 0,0,0 -> 0,0,1
|
||||
t = (0.1, 0.1, 0.2)
|
||||
# nearest edge is the vertical side edge, 0,0,0 -> 0,0,1
|
||||
e = c.edges(selectors.NearestToPointSelector(t)).vals()[0]
|
||||
v = c.edges(selectors.NearestToPointSelector(t)).vertices().vals()
|
||||
self.assertEqual(2,len(v))
|
||||
self.assertEqual(2, len(v))
|
||||
|
||||
#nearest solid is myself
|
||||
# nearest solid is myself
|
||||
s = c.solids(selectors.NearestToPointSelector(t)).vals()
|
||||
self.assertEqual(1,len(s))
|
||||
self.assertEqual(1, len(s))
|
||||
|
||||
def testBox(self):
|
||||
c = CQ(makeUnitCube())
|
||||
@ -303,9 +316,11 @@ class TestCQSelectors(BaseTest):
|
||||
self.assertTupleAlmostEquals(d[2], (v.X, v.Y, v.Z), 3)
|
||||
|
||||
# test multiple vertices selection
|
||||
vl = c.vertices(selectors.BoxSelector((-0.1, -0.1, 0.9),(0.1, 1.1, 1.1))).vals()
|
||||
vl = c.vertices(selectors.BoxSelector(
|
||||
(-0.1, -0.1, 0.9), (0.1, 1.1, 1.1))).vals()
|
||||
self.assertEqual(2, len(vl))
|
||||
vl = c.vertices(selectors.BoxSelector((-0.1, -0.1, -0.1),(0.1, 1.1, 1.1))).vals()
|
||||
vl = c.vertices(selectors.BoxSelector(
|
||||
(-0.1, -0.1, -0.1), (0.1, 1.1, 1.1))).vals()
|
||||
self.assertEqual(4, len(vl))
|
||||
|
||||
# test edge selection
|
||||
@ -330,9 +345,11 @@ class TestCQSelectors(BaseTest):
|
||||
self.assertTupleAlmostEquals(d[2], (ec.x, ec.y, ec.z), 3)
|
||||
|
||||
# test multiple edge selection
|
||||
el = c.edges(selectors.BoxSelector((-0.1, -0.1, -0.1), (0.6, 0.1, 0.6))).vals()
|
||||
el = c.edges(selectors.BoxSelector(
|
||||
(-0.1, -0.1, -0.1), (0.6, 0.1, 0.6))).vals()
|
||||
self.assertEqual(2, len(el))
|
||||
el = c.edges(selectors.BoxSelector((-0.1, -0.1, -0.1), (1.1, 0.1, 0.6))).vals()
|
||||
el = c.edges(selectors.BoxSelector(
|
||||
(-0.1, -0.1, -0.1), (1.1, 0.1, 0.6))).vals()
|
||||
self.assertEqual(3, len(el))
|
||||
|
||||
# test face selection
|
||||
@ -357,17 +374,22 @@ class TestCQSelectors(BaseTest):
|
||||
self.assertTupleAlmostEquals(d[2], (fc.x, fc.y, fc.z), 3)
|
||||
|
||||
# test multiple face selection
|
||||
fl = c.faces(selectors.BoxSelector((0.4, 0.4, 0.4), (0.6, 1.1, 1.1))).vals()
|
||||
fl = c.faces(selectors.BoxSelector(
|
||||
(0.4, 0.4, 0.4), (0.6, 1.1, 1.1))).vals()
|
||||
self.assertEqual(2, len(fl))
|
||||
fl = c.faces(selectors.BoxSelector((0.4, 0.4, 0.4), (1.1, 1.1, 1.1))).vals()
|
||||
fl = c.faces(selectors.BoxSelector(
|
||||
(0.4, 0.4, 0.4), (1.1, 1.1, 1.1))).vals()
|
||||
self.assertEqual(3, len(fl))
|
||||
|
||||
# test boundingbox option
|
||||
el = c.edges(selectors.BoxSelector((-0.1, -0.1, -0.1), (1.1, 0.1, 0.6), True)).vals()
|
||||
el = c.edges(selectors.BoxSelector(
|
||||
(-0.1, -0.1, -0.1), (1.1, 0.1, 0.6), True)).vals()
|
||||
self.assertEqual(1, len(el))
|
||||
fl = c.faces(selectors.BoxSelector((0.4, 0.4, 0.4), (1.1, 1.1, 1.1), True)).vals()
|
||||
fl = c.faces(selectors.BoxSelector(
|
||||
(0.4, 0.4, 0.4), (1.1, 1.1, 1.1), True)).vals()
|
||||
self.assertEqual(0, len(fl))
|
||||
fl = c.faces(selectors.BoxSelector((-0.1, 0.4, -0.1), (1.1, 1.1, 1.1), True)).vals()
|
||||
fl = c.faces(selectors.BoxSelector(
|
||||
(-0.1, 0.4, -0.1), (1.1, 1.1, 1.1), True)).vals()
|
||||
self.assertEqual(1, len(fl))
|
||||
|
||||
def testAndSelector(self):
|
||||
@ -376,13 +398,14 @@ class TestCQSelectors(BaseTest):
|
||||
S = selectors.StringSyntaxSelector
|
||||
BS = selectors.BoxSelector
|
||||
|
||||
el = c.edges(selectors.AndSelector(S('|X'), BS((-2,-2,0.1), (2,2,2)))).vals()
|
||||
el = c.edges(selectors.AndSelector(
|
||||
S('|X'), BS((-2, -2, 0.1), (2, 2, 2)))).vals()
|
||||
self.assertEqual(2, len(el))
|
||||
|
||||
# test 'and' (intersection) operator
|
||||
el = c.edges(S('|X') & BS((-2,-2,0.1), (2,2,2))).vals()
|
||||
el = c.edges(S('|X') & BS((-2, -2, 0.1), (2, 2, 2))).vals()
|
||||
self.assertEqual(2, len(el))
|
||||
|
||||
|
||||
# test using extended string syntax
|
||||
v = c.vertices(">X and >Y").vals()
|
||||
self.assertEqual(2, len(v))
|
||||
@ -402,7 +425,7 @@ class TestCQSelectors(BaseTest):
|
||||
self.assertEqual(2, len(fl))
|
||||
el = c.edges(S("|X") + S("|Y")).vals()
|
||||
self.assertEqual(8, len(el))
|
||||
|
||||
|
||||
# test using extended string syntax
|
||||
fl = c.faces(">Z or <Z").vals()
|
||||
self.assertEqual(2, len(fl))
|
||||
@ -420,7 +443,7 @@ class TestCQSelectors(BaseTest):
|
||||
# test the subtract operator
|
||||
fl = c.faces(S("#Z") - S(">X")).vals()
|
||||
self.assertEqual(3, len(fl))
|
||||
|
||||
|
||||
# test using extended string syntax
|
||||
fl = c.faces("#Z exc >X").vals()
|
||||
self.assertEqual(3, len(fl))
|
||||
@ -440,43 +463,42 @@ class TestCQSelectors(BaseTest):
|
||||
self.assertEqual(5, len(fl))
|
||||
el = c.faces('>Z').edges(-S('>X')).vals()
|
||||
self.assertEqual(3, len(el))
|
||||
|
||||
|
||||
# test using extended string syntax
|
||||
fl = c.faces('not >Z').vals()
|
||||
self.assertEqual(5, len(fl))
|
||||
el = c.faces('>Z').edges('not >X').vals()
|
||||
self.assertEqual(3, len(el))
|
||||
|
||||
|
||||
def testComplexStringSelector(self):
|
||||
c = CQ(makeUnitCube())
|
||||
|
||||
|
||||
v = c.vertices('(>X and >Y) or (<X and <Y)').vals()
|
||||
self.assertEqual(4, len(v))
|
||||
|
||||
|
||||
def testFaceCount(self):
|
||||
c = CQ(makeUnitCube())
|
||||
self.assertEqual( 6, c.faces().size() )
|
||||
self.assertEqual( 2, c.faces("|Z").size() )
|
||||
self.assertEqual(6, c.faces().size())
|
||||
self.assertEqual(2, c.faces("|Z").size())
|
||||
|
||||
def testVertexFilter(self):
|
||||
"test selecting vertices on a face"
|
||||
c = CQ(makeUnitCube())
|
||||
|
||||
#TODO: filters work ok, but they are in global coordinates which sux. it would be nice
|
||||
#if they were available in coordinates local to the selected face
|
||||
# TODO: filters work ok, but they are in global coordinates which sux. it would be nice
|
||||
# if they were available in coordinates local to the selected face
|
||||
|
||||
v2 = c.faces("+Z").vertices("<XY")
|
||||
self.assertEqual(1,v2.size() ) #another way
|
||||
#make sure the vertex is the right one
|
||||
self.assertEqual(1, v2.size()) # another way
|
||||
# make sure the vertex is the right one
|
||||
|
||||
self.assertTupleAlmostEquals((0.0, 0.0, 1.0), v2.val().toTuple(), 3)
|
||||
|
||||
self.assertTupleAlmostEquals((0.0,0.0,1.0),v2.val().toTuple() ,3)
|
||||
|
||||
def testGrammar(self):
|
||||
"""
|
||||
Test if reasonable string selector expressions parse without an error
|
||||
"""
|
||||
|
||||
|
||||
gram = selectors._expression_grammar
|
||||
|
||||
expressions = ['+X ',
|
||||
@ -499,5 +521,5 @@ class TestCQSelectors(BaseTest):
|
||||
'(not |(1,1,0) and >(0,0,1)) exc XY and (Z or X)',
|
||||
'not ( <X or >X or <Y or >Y )']
|
||||
|
||||
for e in expressions: gram.parseString(e,parseAll=True)
|
||||
|
||||
for e in expressions:
|
||||
gram.parseString(e, parseAll=True)
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
#system modules
|
||||
# system modules
|
||||
import sys
|
||||
import unittest
|
||||
from tests import BaseTest
|
||||
@ -6,16 +6,17 @@ from OCC.gp import gp_Vec, gp_Pnt, gp_Ax2, gp_Circ, gp_DZ
|
||||
from OCC.BRepBuilderAPI import (BRepBuilderAPI_MakeVertex,
|
||||
BRepBuilderAPI_MakeEdge,
|
||||
BRepBuilderAPI_MakeFace)
|
||||
|
||||
|
||||
from OCC.GC import GC_MakeCircle
|
||||
|
||||
from cadquery import *
|
||||
|
||||
|
||||
class TestCadObjects(BaseTest):
|
||||
|
||||
|
||||
def _make_circle(self):
|
||||
|
||||
circle = gp_Circ(gp_Ax2(gp_Pnt(1, 2, 3),gp_DZ()),
|
||||
|
||||
circle = gp_Circ(gp_Ax2(gp_Pnt(1, 2, 3), gp_DZ()),
|
||||
2.)
|
||||
return Shape.cast(BRepBuilderAPI_MakeEdge(circle).Edge())
|
||||
|
||||
@ -33,34 +34,39 @@ class TestCadObjects(BaseTest):
|
||||
"""
|
||||
v = Vertex.makeVertex(1, 1, 1)
|
||||
self.assertEqual(1, v.X)
|
||||
self.assertEquals(Vector, type(v.Center()))
|
||||
self.assertEqual(Vector, type(v.Center()))
|
||||
|
||||
def testBasicBoundingBox(self):
|
||||
v = Vertex.makeVertex(1, 1, 1)
|
||||
v2 = Vertex.makeVertex(2, 2, 2)
|
||||
self.assertEquals(BoundBox, type(v.BoundingBox()))
|
||||
self.assertEquals(BoundBox, type(v2.BoundingBox()))
|
||||
self.assertEqual(BoundBox, type(v.BoundingBox()))
|
||||
self.assertEqual(BoundBox, type(v2.BoundingBox()))
|
||||
|
||||
bb1 = v.BoundingBox().add(v2.BoundingBox())
|
||||
|
||||
self.assertAlmostEquals(bb1.xlen, 1.0, 1) #OCC uses some approximations
|
||||
# OCC uses some approximations
|
||||
self.assertAlmostEqual(bb1.xlen, 1.0, 1)
|
||||
|
||||
def testEdgeWrapperCenter(self):
|
||||
e = self._make_circle()
|
||||
|
||||
|
||||
self.assertTupleAlmostEquals((1.0, 2.0, 3.0), e.Center().toTuple(), 3)
|
||||
|
||||
def testEdgeWrapperMakeCircle(self):
|
||||
halfCircleEdge = Edge.makeCircle(radius=10, pnt=(0, 0, 0), dir=(0, 0, 1), angle1=0, angle2=180)
|
||||
halfCircleEdge = Edge.makeCircle(radius=10, pnt=(
|
||||
0, 0, 0), dir=(0, 0, 1), angle1=0, angle2=180)
|
||||
|
||||
#self.assertTupleAlmostEquals((0.0, 5.0, 0.0), halfCircleEdge.CenterOfBoundBox(0.0001).toTuple(),3)
|
||||
self.assertTupleAlmostEquals((10.0, 0.0, 0.0), halfCircleEdge.startPoint().toTuple(), 3)
|
||||
self.assertTupleAlmostEquals((-10.0, 0.0, 0.0), halfCircleEdge.endPoint().toTuple(), 3)
|
||||
self.assertTupleAlmostEquals(
|
||||
(10.0, 0.0, 0.0), halfCircleEdge.startPoint().toTuple(), 3)
|
||||
self.assertTupleAlmostEquals(
|
||||
(-10.0, 0.0, 0.0), halfCircleEdge.endPoint().toTuple(), 3)
|
||||
|
||||
def testFaceWrapperMakePlane(self):
|
||||
mplane = Face.makePlane(10,10)
|
||||
mplane = Face.makePlane(10, 10)
|
||||
|
||||
self.assertTupleAlmostEquals((0.0, 0.0, 1.0), mplane.normalAt().toTuple(), 3)
|
||||
self.assertTupleAlmostEquals(
|
||||
(0.0, 0.0, 1.0), mplane.normalAt().toTuple(), 3)
|
||||
|
||||
def testCenterOfBoundBox(self):
|
||||
pass
|
||||
@ -72,6 +78,7 @@ class TestCadObjects(BaseTest):
|
||||
"""
|
||||
Tests whether or not a proper weighted center can be found for a compound
|
||||
"""
|
||||
|
||||
def cylinders(self, radius, height):
|
||||
def _cyl(pnt):
|
||||
# Inner function to build a cylinder
|
||||
@ -85,22 +92,24 @@ class TestCadObjects(BaseTest):
|
||||
Workplane.cyl = cylinders
|
||||
|
||||
# Now test. here we want weird workplane to see if the objects are transformed right
|
||||
s = Workplane("XY").rect(2.0, 3.0, forConstruction=True).vertices().cyl(0.25, 0.5)
|
||||
s = Workplane("XY").rect(
|
||||
2.0, 3.0, forConstruction=True).vertices().cyl(0.25, 0.5)
|
||||
|
||||
self.assertEquals(4, len(s.val().Solids()))
|
||||
self.assertTupleAlmostEquals((0.0, 0.0, 0.25), s.val().Center().toTuple(), 3)
|
||||
self.assertEqual(4, len(s.val().Solids()))
|
||||
self.assertTupleAlmostEquals(
|
||||
(0.0, 0.0, 0.25), s.val().Center().toTuple(), 3)
|
||||
|
||||
def testDot(self):
|
||||
v1 = Vector(2, 2, 2)
|
||||
v2 = Vector(1, -1, 1)
|
||||
self.assertEquals(2.0, v1.dot(v2))
|
||||
self.assertEqual(2.0, v1.dot(v2))
|
||||
|
||||
def testVectorAdd(self):
|
||||
result = Vector(1, 2, 0) + Vector(0, 0, 3)
|
||||
self.assertTupleAlmostEquals((1.0, 2.0, 3.0), result.toTuple(), 3)
|
||||
|
||||
def testTranslate(self):
|
||||
e = Edge.makeCircle(2,(1,2,3))
|
||||
def testTranslate(self):
|
||||
e = Edge.makeCircle(2, (1, 2, 3))
|
||||
e2 = e.translate(Vector(0, 0, 1))
|
||||
|
||||
self.assertTupleAlmostEquals((1.0, 2.0, 4.0), e2.Center().toTuple(), 3)
|
||||
@ -108,7 +117,8 @@ class TestCadObjects(BaseTest):
|
||||
def testVertices(self):
|
||||
e = Shape.cast(BRepBuilderAPI_MakeEdge(gp_Pnt(0, 0, 0),
|
||||
gp_Pnt(1, 1, 0)).Edge())
|
||||
self.assertEquals(2, len(e.Vertices()))
|
||||
self.assertEqual(2, len(e.Vertices()))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,43 +1,49 @@
|
||||
"""
|
||||
Tests basic workplane functionality
|
||||
"""
|
||||
#core modules
|
||||
import StringIO
|
||||
# core modules
|
||||
import sys
|
||||
if sys.version_info.major == 2:
|
||||
import cStringIO as StringIO
|
||||
else:
|
||||
import io as StringIO
|
||||
|
||||
#my modules
|
||||
# my modules
|
||||
from cadquery import *
|
||||
from cadquery import exporters
|
||||
from tests import BaseTest
|
||||
|
||||
|
||||
class TestExporters(BaseTest):
|
||||
|
||||
def _exportBox(self,eType,stringsToFind):
|
||||
def _exportBox(self, eType, stringsToFind):
|
||||
"""
|
||||
Exports a test object, and then looks for
|
||||
all of the supplied strings to be in the result
|
||||
returns the result in case the case wants to do more checks also
|
||||
"""
|
||||
p = Workplane("XY").box(1,2,3)
|
||||
p = Workplane("XY").box(1, 2, 3)
|
||||
s = StringIO.StringIO()
|
||||
exporters.exportShape(p,eType,s,0.1)
|
||||
exporters.exportShape(p, eType, s, 0.1)
|
||||
|
||||
result = s.getvalue()
|
||||
|
||||
|
||||
for q in stringsToFind:
|
||||
self.assertTrue(result.find(q) > -1 )
|
||||
self.assertTrue(result.find(q) > -1)
|
||||
return result
|
||||
|
||||
def testSTL(self):
|
||||
self._exportBox(exporters.ExportTypes.STL,['facet normal'])
|
||||
self._exportBox(exporters.ExportTypes.STL, ['facet normal'])
|
||||
|
||||
def testSVG(self):
|
||||
self._exportBox(exporters.ExportTypes.SVG,['<svg','<g transform'])
|
||||
self._exportBox(exporters.ExportTypes.SVG, ['<svg', '<g transform'])
|
||||
|
||||
def testAMF(self):
|
||||
self._exportBox(exporters.ExportTypes.AMF,['<amf units','</object>'])
|
||||
self._exportBox(exporters.ExportTypes.AMF, ['<amf units', '</object>'])
|
||||
|
||||
def testSTEP(self):
|
||||
self._exportBox(exporters.ExportTypes.STEP,['FILE_SCHEMA'])
|
||||
self._exportBox(exporters.ExportTypes.STEP, ['FILE_SCHEMA'])
|
||||
|
||||
def testTJS(self):
|
||||
self._exportBox(exporters.ExportTypes.TJS,['vertices','formatVersion','faces'])
|
||||
self._exportBox(exporters.ExportTypes.TJS, [
|
||||
'vertices', 'formatVersion', 'faces'])
|
||||
|
||||
@ -1,15 +1,15 @@
|
||||
"""
|
||||
Tests file importers such as STEP
|
||||
"""
|
||||
#core modules
|
||||
import StringIO
|
||||
# core modules
|
||||
import io
|
||||
|
||||
from cadquery import *
|
||||
from cadquery import exporters
|
||||
from cadquery import importers
|
||||
from tests import BaseTest
|
||||
|
||||
#where unit test output will be saved
|
||||
# where unit test output will be saved
|
||||
import sys
|
||||
if sys.platform.startswith("win"):
|
||||
OUTDIR = "c:/temp"
|
||||
@ -24,24 +24,27 @@ class TestImporters(BaseTest):
|
||||
:param importType: The type of file we're importing (STEP, STL, etc)
|
||||
:param fileName: The path and name of the file to write to
|
||||
"""
|
||||
#We're importing a STEP file
|
||||
# We're importing a STEP file
|
||||
if importType == importers.ImportTypes.STEP:
|
||||
#We first need to build a simple shape to export
|
||||
# We first need to build a simple shape to export
|
||||
shape = Workplane("XY").box(1, 2, 3).val()
|
||||
|
||||
#Export the shape to a temporary file
|
||||
# Export the shape to a temporary file
|
||||
shape.exportStep(fileName)
|
||||
|
||||
# Reimport the shape from the new STEP file
|
||||
importedShape = importers.importShape(importType,fileName)
|
||||
importedShape = importers.importShape(importType, fileName)
|
||||
|
||||
#Check to make sure we got a solid back
|
||||
# Check to make sure we got a solid back
|
||||
self.assertTrue(importedShape.val().ShapeType() == "Solid")
|
||||
|
||||
#Check the number of faces and vertices per face to make sure we have a box shape
|
||||
self.assertTrue(importedShape.faces("+X").size() == 1 and importedShape.faces("+X").vertices().size() == 4)
|
||||
self.assertTrue(importedShape.faces("+Y").size() == 1 and importedShape.faces("+Y").vertices().size() == 4)
|
||||
self.assertTrue(importedShape.faces("+Z").size() == 1 and importedShape.faces("+Z").vertices().size() == 4)
|
||||
# Check the number of faces and vertices per face to make sure we have a box shape
|
||||
self.assertTrue(importedShape.faces("+X").size() ==
|
||||
1 and importedShape.faces("+X").vertices().size() == 4)
|
||||
self.assertTrue(importedShape.faces("+Y").size() ==
|
||||
1 and importedShape.faces("+Y").vertices().size() == 4)
|
||||
self.assertTrue(importedShape.faces("+Z").size() ==
|
||||
1 and importedShape.faces("+Z").vertices().size() == 4)
|
||||
|
||||
def testSTEP(self):
|
||||
"""
|
||||
@ -49,6 +52,7 @@ class TestImporters(BaseTest):
|
||||
"""
|
||||
self.importBox(importers.ImportTypes.STEP, OUTDIR + "/tempSTEP.step")
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
import unittest
|
||||
unittest.main()
|
||||
|
||||
@ -1,11 +1,11 @@
|
||||
"""
|
||||
Tests basic workplane functionality
|
||||
"""
|
||||
#core modules
|
||||
# core modules
|
||||
|
||||
#my modules
|
||||
# my modules
|
||||
from cadquery import *
|
||||
from tests import BaseTest,toTuple
|
||||
from tests import BaseTest, toTuple
|
||||
|
||||
xAxis_ = Vector(1, 0, 0)
|
||||
yAxis_ = Vector(0, 1, 0)
|
||||
@ -14,79 +14,97 @@ xInvAxis_ = Vector(-1, 0, 0)
|
||||
yInvAxis_ = Vector(0, -1, 0)
|
||||
zInvAxis_ = Vector(0, 0, -1)
|
||||
|
||||
|
||||
class TestWorkplanes(BaseTest):
|
||||
|
||||
def testYZPlaneOrigins(self):
|
||||
#xy plane-- with origin at x=0.25
|
||||
base = Vector(0.25,0,0)
|
||||
p = Plane(base, Vector(0,1,0), Vector(1,0,0))
|
||||
# xy plane-- with origin at x=0.25
|
||||
base = Vector(0.25, 0, 0)
|
||||
p = Plane(base, Vector(0, 1, 0), Vector(1, 0, 0))
|
||||
|
||||
#origin is always (0,0,0) in local coordinates
|
||||
self.assertTupleAlmostEquals((0,0,0), p.toLocalCoords(p.origin).toTuple() ,2 )
|
||||
# origin is always (0,0,0) in local coordinates
|
||||
self.assertTupleAlmostEquals(
|
||||
(0, 0, 0), p.toLocalCoords(p.origin).toTuple(), 2)
|
||||
|
||||
#(0,0,0) is always the original base in global coordinates
|
||||
self.assertTupleAlmostEquals(base.toTuple(), p.toWorldCoords((0,0)).toTuple() ,2 )
|
||||
self.assertTupleAlmostEquals(
|
||||
base.toTuple(), p.toWorldCoords((0, 0)).toTuple(), 2)
|
||||
|
||||
def testXYPlaneOrigins(self):
|
||||
base = Vector(0,0,0.25)
|
||||
p = Plane(base, Vector(1,0,0), Vector(0,0,1))
|
||||
base = Vector(0, 0, 0.25)
|
||||
p = Plane(base, Vector(1, 0, 0), Vector(0, 0, 1))
|
||||
|
||||
#origin is always (0,0,0) in local coordinates
|
||||
self.assertTupleAlmostEquals((0,0,0), p.toLocalCoords(p.origin).toTuple() ,2 )
|
||||
# origin is always (0,0,0) in local coordinates
|
||||
self.assertTupleAlmostEquals(
|
||||
(0, 0, 0), p.toLocalCoords(p.origin).toTuple(), 2)
|
||||
|
||||
#(0,0,0) is always the original base in global coordinates
|
||||
self.assertTupleAlmostEquals(toTuple(base), p.toWorldCoords((0,0)).toTuple() ,2 )
|
||||
self.assertTupleAlmostEquals(
|
||||
toTuple(base), p.toWorldCoords((0, 0)).toTuple(), 2)
|
||||
|
||||
def testXZPlaneOrigins(self):
|
||||
base = Vector(0,0.25,0)
|
||||
p = Plane(base, Vector(0,0,1), Vector(0,1,0))
|
||||
base = Vector(0, 0.25, 0)
|
||||
p = Plane(base, Vector(0, 0, 1), Vector(0, 1, 0))
|
||||
|
||||
#(0,0,0) is always the original base in global coordinates
|
||||
self.assertTupleAlmostEquals(toTuple(base), p.toWorldCoords((0,0)).toTuple() ,2 )
|
||||
self.assertTupleAlmostEquals(
|
||||
toTuple(base), p.toWorldCoords((0, 0)).toTuple(), 2)
|
||||
|
||||
#origin is always (0,0,0) in local coordinates
|
||||
self.assertTupleAlmostEquals((0,0,0), p.toLocalCoords(p.origin).toTuple() ,2 )
|
||||
# origin is always (0,0,0) in local coordinates
|
||||
self.assertTupleAlmostEquals(
|
||||
(0, 0, 0), p.toLocalCoords(p.origin).toTuple(), 2)
|
||||
|
||||
def testPlaneBasics(self):
|
||||
p = Plane.XY()
|
||||
#local to world
|
||||
self.assertTupleAlmostEquals((1.0,1.0,0),p.toWorldCoords((1,1)).toTuple(),2 )
|
||||
self.assertTupleAlmostEquals((-1.0,-1.0,0), p.toWorldCoords((-1,-1)).toTuple(),2 )
|
||||
# local to world
|
||||
self.assertTupleAlmostEquals(
|
||||
(1.0, 1.0, 0), p.toWorldCoords((1, 1)).toTuple(), 2)
|
||||
self.assertTupleAlmostEquals(
|
||||
(-1.0, -1.0, 0), p.toWorldCoords((-1, -1)).toTuple(), 2)
|
||||
|
||||
#world to local
|
||||
self.assertTupleAlmostEquals((-1.0,-1.0), p.toLocalCoords(Vector(-1,-1,0)).toTuple() ,2 )
|
||||
self.assertTupleAlmostEquals((1.0,1.0), p.toLocalCoords(Vector(1,1,0)).toTuple() ,2 )
|
||||
# world to local
|
||||
self.assertTupleAlmostEquals(
|
||||
(-1.0, -1.0), p.toLocalCoords(Vector(-1, -1, 0)).toTuple(), 2)
|
||||
self.assertTupleAlmostEquals(
|
||||
(1.0, 1.0), p.toLocalCoords(Vector(1, 1, 0)).toTuple(), 2)
|
||||
|
||||
p = Plane.YZ()
|
||||
self.assertTupleAlmostEquals((0,1.0,1.0),p.toWorldCoords((1,1)).toTuple() ,2 )
|
||||
self.assertTupleAlmostEquals(
|
||||
(0, 1.0, 1.0), p.toWorldCoords((1, 1)).toTuple(), 2)
|
||||
|
||||
#world to local
|
||||
self.assertTupleAlmostEquals((1.0,1.0), p.toLocalCoords(Vector(0,1,1)).toTuple() ,2 )
|
||||
# world to local
|
||||
self.assertTupleAlmostEquals(
|
||||
(1.0, 1.0), p.toLocalCoords(Vector(0, 1, 1)).toTuple(), 2)
|
||||
|
||||
p = Plane.XZ()
|
||||
r = p.toWorldCoords((1,1)).toTuple()
|
||||
self.assertTupleAlmostEquals((1.0,0.0,1.0),r ,2 )
|
||||
r = p.toWorldCoords((1, 1)).toTuple()
|
||||
self.assertTupleAlmostEquals((1.0, 0.0, 1.0), r, 2)
|
||||
|
||||
#world to local
|
||||
self.assertTupleAlmostEquals((1.0,1.0), p.toLocalCoords(Vector(1,0,1)).toTuple() ,2 )
|
||||
# world to local
|
||||
self.assertTupleAlmostEquals(
|
||||
(1.0, 1.0), p.toLocalCoords(Vector(1, 0, 1)).toTuple(), 2)
|
||||
|
||||
def testOffsetPlanes(self):
|
||||
"Tests that a plane offset from the origin works ok too"
|
||||
p = Plane.XY(origin=(10.0,10.0,0))
|
||||
p = Plane.XY(origin=(10.0, 10.0, 0))
|
||||
|
||||
self.assertTupleAlmostEquals(
|
||||
(11.0, 11.0, 0.0), p.toWorldCoords((1.0, 1.0)).toTuple(), 2)
|
||||
self.assertTupleAlmostEquals((2.0, 2.0), p.toLocalCoords(
|
||||
Vector(12.0, 12.0, 0)).toTuple(), 2)
|
||||
|
||||
self.assertTupleAlmostEquals((11.0,11.0,0.0),p.toWorldCoords((1.0,1.0)).toTuple(),2 )
|
||||
self.assertTupleAlmostEquals((2.0,2.0), p.toLocalCoords(Vector(12.0,12.0,0)).toTuple() ,2 )
|
||||
# TODO test these offsets in the other dimensions too
|
||||
p = Plane.YZ(origin=(0, 2, 2))
|
||||
self.assertTupleAlmostEquals(
|
||||
(0.0, 5.0, 5.0), p.toWorldCoords((3.0, 3.0)).toTuple(), 2)
|
||||
self.assertTupleAlmostEquals((10, 10.0, 0.0), p.toLocalCoords(
|
||||
Vector(0.0, 12.0, 12.0)).toTuple(), 2)
|
||||
|
||||
#TODO test these offsets in the other dimensions too
|
||||
p = Plane.YZ(origin=(0,2,2))
|
||||
self.assertTupleAlmostEquals((0.0,5.0,5.0), p.toWorldCoords((3.0,3.0)).toTuple() ,2 )
|
||||
self.assertTupleAlmostEquals((10,10.0,0.0), p.toLocalCoords(Vector(0.0,12.0,12.0)).toTuple() ,2 )
|
||||
|
||||
p = Plane.XZ(origin=(2,0,2))
|
||||
r = p.toWorldCoords((1.0,1.0)).toTuple()
|
||||
self.assertTupleAlmostEquals((3.0,0.0,3.0),r ,2 )
|
||||
self.assertTupleAlmostEquals((10.0,10.0), p.toLocalCoords(Vector(12.0,0.0,12.0)).toTuple() ,2 )
|
||||
p = Plane.XZ(origin=(2, 0, 2))
|
||||
r = p.toWorldCoords((1.0, 1.0)).toTuple()
|
||||
self.assertTupleAlmostEquals((3.0, 0.0, 3.0), r, 2)
|
||||
self.assertTupleAlmostEquals((10.0, 10.0), p.toLocalCoords(
|
||||
Vector(12.0, 0.0, 12.0)).toTuple(), 2)
|
||||
|
||||
def testXYPlaneBasics(self):
|
||||
p = Plane.named('XY')
|
||||
|
||||
@ -4,8 +4,9 @@ import unittest
|
||||
import sys
|
||||
import os
|
||||
|
||||
|
||||
def readFileAsString(fileName):
|
||||
f= open(fileName, 'r')
|
||||
f = open(fileName, 'r')
|
||||
s = f.read()
|
||||
f.close()
|
||||
return s
|
||||
@ -37,13 +38,16 @@ def toTuple(v):
|
||||
elif type(v) == Vector:
|
||||
return v.toTuple()
|
||||
else:
|
||||
raise RuntimeError("dont know how to convert type %s to tuple" % str(type(v)) )
|
||||
raise RuntimeError(
|
||||
"dont know how to convert type %s to tuple" % str(type(v)))
|
||||
|
||||
|
||||
class BaseTest(unittest.TestCase):
|
||||
|
||||
def assertTupleAlmostEquals(self, expected, actual, places):
|
||||
for i, j in zip(actual, expected):
|
||||
self.assertAlmostEquals(i, j, places)
|
||||
self.assertAlmostEqual(i, j, places)
|
||||
|
||||
__all__ = ['TestCadObjects', 'TestCadQuery', 'TestCQSelectors', 'TestWorkplanes', 'TestExporters', 'TestCQSelectors', 'TestImporters','TestCQGI']
|
||||
|
||||
__all__ = ['TestCadObjects', 'TestCadQuery', 'TestCQSelectors', 'TestWorkplanes',
|
||||
'TestExporters', 'TestCQSelectors', 'TestImporters', 'TestCQGI']
|
||||
|
||||
Reference in New Issue
Block a user