ae65dc3579
Added ProjectedGlobalOrigin as centerOption for worplane constructor to differentiate between projecting the global origin and the current plane origin when creating new workplanes. Also updated projectToPlane method of Vector to only accept plane objects and it no longer does in inplace modification. Updated test converage for ProjectedOrigin and ProjectedGlobalOrigin options.
285 lines
9.1 KiB
Python
285 lines
9.1 KiB
Python
# system modules
|
|
import sys
|
|
import unittest
|
|
from tests import BaseTest
|
|
from OCC.gp import gp_Vec, gp_Pnt, gp_Ax2, gp_Circ, gp_DZ, gp_XYZ
|
|
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()),
|
|
2.)
|
|
return Shape.cast(BRepBuilderAPI_MakeEdge(circle).Edge())
|
|
|
|
def testVectorConstructors(self):
|
|
v1 = Vector(1, 2, 3)
|
|
v2 = Vector((1, 2, 3))
|
|
v3 = Vector(gp_Vec(1, 2, 3))
|
|
v4 = Vector([1,2,3])
|
|
v5 = Vector(gp_XYZ(1,2,3))
|
|
|
|
for v in [v1, v2, v3, v4, v5]:
|
|
self.assertTupleAlmostEquals((1, 2, 3), v.toTuple(), 4)
|
|
|
|
v6 = Vector((1,2))
|
|
v7 = Vector([1,2])
|
|
v8 = Vector(1,2)
|
|
|
|
for v in [v6, v7, v8]:
|
|
self.assertTupleAlmostEquals((1, 2, 0), v.toTuple(), 4)
|
|
|
|
v9 = Vector()
|
|
self.assertTupleAlmostEquals((0, 0, 0), v9.toTuple(), 4)
|
|
|
|
v9.x = 1.
|
|
v9.y = 2.
|
|
v9.z = 3.
|
|
self.assertTupleAlmostEquals((1, 2, 3), (v9.x, v9.y, v9.z), 4)
|
|
|
|
def testVertex(self):
|
|
"""
|
|
Tests basic vertex functions
|
|
"""
|
|
v = Vertex.makeVertex(1, 1, 1)
|
|
self.assertEqual(1, v.X)
|
|
self.assertEqual(Vector, type(v.Center()))
|
|
|
|
def testBasicBoundingBox(self):
|
|
v = Vertex.makeVertex(1, 1, 1)
|
|
v2 = Vertex.makeVertex(2, 2, 2)
|
|
self.assertEqual(BoundBox, type(v.BoundingBox()))
|
|
self.assertEqual(BoundBox, type(v2.BoundingBox()))
|
|
|
|
bb1 = v.BoundingBox().add(v2.BoundingBox())
|
|
|
|
# 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)
|
|
|
|
#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)
|
|
|
|
def testFaceWrapperMakePlane(self):
|
|
mplane = Face.makePlane(10, 10)
|
|
|
|
self.assertTupleAlmostEquals(
|
|
(0.0, 0.0, 1.0), mplane.normalAt().toTuple(), 3)
|
|
|
|
def testCenterOfBoundBox(self):
|
|
pass
|
|
|
|
def testCombinedCenterOfBoundBox(self):
|
|
pass
|
|
|
|
def testCompoundCenter(self):
|
|
"""
|
|
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
|
|
return Solid.makeCylinder(radius, height, pnt)
|
|
|
|
# Combine all the cylinders into a single compound
|
|
r = self.eachpoint(_cyl, True).combineSolids()
|
|
|
|
return r
|
|
|
|
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)
|
|
|
|
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.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 testVectorOperators(self):
|
|
result = Vector(1, 1, 1) + Vector(2, 2, 2)
|
|
self.assertEqual(Vector(3, 3, 3), result)
|
|
|
|
result = Vector(1, 2, 3) - Vector(3, 2, 1)
|
|
self.assertEqual(Vector(-2, 0, 2), result)
|
|
|
|
result = Vector(1, 2, 3) * 2
|
|
self.assertEqual(Vector(2, 4, 6), result)
|
|
|
|
result = Vector(2, 4, 6) / 2
|
|
self.assertEqual(Vector(1, 2, 3), result)
|
|
|
|
self.assertEqual(Vector(-1, -1, -1), -Vector(1, 1, 1))
|
|
|
|
self.assertEqual(0, abs(Vector(0, 0, 0)))
|
|
self.assertEqual(1, abs(Vector(1, 0, 0)))
|
|
self.assertEqual((1+4+9)**0.5, abs(Vector(1, 2, 3)))
|
|
|
|
def testVectorEquals(self):
|
|
a = Vector(1, 2, 3)
|
|
b = Vector(1, 2, 3)
|
|
c = Vector(1, 2, 3.000001)
|
|
self.assertEqual(a, b)
|
|
self.assertEqual(a, c)
|
|
|
|
def testVectorProject(self):
|
|
"""
|
|
Test method to project vector to plane.
|
|
"""
|
|
decimal_places = 9
|
|
|
|
normal = Vector(1, 2, 3)
|
|
base = Vector(5, 7, 9)
|
|
x_dir = Vector(1, 0, 0)
|
|
|
|
# test passing Plane object
|
|
point = Vector(10, 11, 12).projectToPlane(Plane(base, x_dir, normal))
|
|
self.assertTupleAlmostEquals(point.toTuple(), (59/7, 55/7, 51/7),
|
|
decimal_places)
|
|
|
|
def testMatrixCreationAndAccess(self):
|
|
def matrix_vals(m):
|
|
return [[m[r,c] for c in range(4)] for r in range(4)]
|
|
# default constructor creates a 4x4 identity matrix
|
|
m = Matrix()
|
|
identity = [[1., 0., 0., 0.],
|
|
[0., 1., 0., 0.],
|
|
[0., 0., 1., 0.],
|
|
[0., 0., 0., 1.]]
|
|
self.assertEqual(identity, matrix_vals(m))
|
|
|
|
vals4x4 = [[1., 0., 0., 1.],
|
|
[0., 1., 0., 2.],
|
|
[0., 0., 1., 3.],
|
|
[0., 0., 0., 1.]]
|
|
vals4x4_tuple = tuple(tuple(r) for r in vals4x4)
|
|
|
|
# test constructor with 16-value input
|
|
m = Matrix(vals4x4)
|
|
self.assertEqual(vals4x4, matrix_vals(m))
|
|
m = Matrix(vals4x4_tuple)
|
|
self.assertEqual(vals4x4, matrix_vals(m))
|
|
|
|
# test constructor with 12-value input (the last 4 are an implied
|
|
# [0,0,0,1])
|
|
m = Matrix(vals4x4[:3])
|
|
self.assertEqual(vals4x4, matrix_vals(m))
|
|
m = Matrix(vals4x4_tuple[:3])
|
|
self.assertEqual(vals4x4, matrix_vals(m))
|
|
|
|
# Test 16-value input with invalid values for the last 4
|
|
invalid = [[1., 0., 0., 1.],
|
|
[0., 1., 0., 2.],
|
|
[0., 0., 1., 3.],
|
|
[1., 2., 3., 4.]]
|
|
with self.assertRaises(ValueError):
|
|
Matrix(invalid)
|
|
|
|
# Test input with invalid size / nested types
|
|
with self.assertRaises(TypeError):
|
|
Matrix([[1, 2, 3, 4], [1, 2, 3], [1, 2, 3, 4]])
|
|
with self.assertRaises(TypeError):
|
|
Matrix([1,2,3])
|
|
|
|
# Invalid sub-type
|
|
with self.assertRaises(TypeError):
|
|
Matrix([[1, 2, 3, 4], 'abc', [1, 2, 3, 4]])
|
|
|
|
# test out-of-bounds access
|
|
m = Matrix()
|
|
with self.assertRaises(IndexError):
|
|
m[0, 4]
|
|
with self.assertRaises(IndexError):
|
|
m[4, 0]
|
|
with self.assertRaises(IndexError):
|
|
m['ab']
|
|
|
|
|
|
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)
|
|
|
|
def testVertices(self):
|
|
e = Shape.cast(BRepBuilderAPI_MakeEdge(gp_Pnt(0, 0, 0),
|
|
gp_Pnt(1, 1, 0)).Edge())
|
|
self.assertEqual(2, len(e.Vertices()))
|
|
|
|
def testPlaneEqual(self):
|
|
# default orientation
|
|
self.assertEqual(
|
|
Plane(origin=(0,0,0), xDir=(1,0,0), normal=(0,0,1)),
|
|
Plane(origin=(0,0,0), xDir=(1,0,0), normal=(0,0,1))
|
|
)
|
|
# moved origin
|
|
self.assertEqual(
|
|
Plane(origin=(2,1,-1), xDir=(1,0,0), normal=(0,0,1)),
|
|
Plane(origin=(2,1,-1), xDir=(1,0,0), normal=(0,0,1))
|
|
)
|
|
# moved x-axis
|
|
self.assertEqual(
|
|
Plane(origin=(0,0,0), xDir=(1,1,0), normal=(0,0,1)),
|
|
Plane(origin=(0,0,0), xDir=(1,1,0), normal=(0,0,1))
|
|
)
|
|
# moved z-axis
|
|
self.assertEqual(
|
|
Plane(origin=(0,0,0), xDir=(1,0,0), normal=(0,1,1)),
|
|
Plane(origin=(0,0,0), xDir=(1,0,0), normal=(0,1,1))
|
|
)
|
|
|
|
def testPlaneNotEqual(self):
|
|
# type difference
|
|
for value in [None, 0, 1, 'abc']:
|
|
self.assertNotEqual(
|
|
Plane(origin=(0,0,0), xDir=(1,0,0), normal=(0,0,1)),
|
|
value
|
|
)
|
|
# origin difference
|
|
self.assertNotEqual(
|
|
Plane(origin=(0,0,0), xDir=(1,0,0), normal=(0,0,1)),
|
|
Plane(origin=(0,0,1), xDir=(1,0,0), normal=(0,0,1))
|
|
)
|
|
# x-axis difference
|
|
self.assertNotEqual(
|
|
Plane(origin=(0,0,0), xDir=(1,0,0), normal=(0,0,1)),
|
|
Plane(origin=(0,0,0), xDir=(1,1,0), normal=(0,0,1))
|
|
)
|
|
# z-axis difference
|
|
self.assertNotEqual(
|
|
Plane(origin=(0,0,0), xDir=(1,0,0), normal=(0,0,1)),
|
|
Plane(origin=(0,0,0), xDir=(1,0,0), normal=(0,1,1))
|
|
)
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|