def __init__(self, start, end, start_tangent, end_tangent, segments):
self.start = Vector(start)
self.end = Vector(end)
self.start_tangent = Vector(
start_tangent) # as vector, from start point
self.end_tangent = Vector(end_tangent) # as vector, from end point
self.segments = segments
def __init__(self,
pos,
center,
start,
end,
dimstyle='angle.deg',
layer=None,
roundval=None):
"""
AngularDimension constructor.
Args:
pos: location as (x, y) tuple of dimension line, line goes through this point
center: center point as (x, y) tuple of angle
start: line from center to start is the first side of the angle
end: line from center to end is the second side of the angle
dimstyle: dimstyle name, 'Default' - style is the default value
layer: dimension line layer, override the default value of dimstyle
roundval: count of decimal places
"""
super(AngularDimension, self).__init__(dimstyle, layer, roundval)
self.dimlinepos = Vector(pos)
self.center = Vector(center)
self.start = Vector(start)
self.end = Vector(end)
def test_is_null():
v = Vector()
assert v.is_null
v1 = Vector(23.56678, 56678.56778, 2.56677) * (1.0 / 14.5667)
v2 = Vector(23.56678, 56678.56778, 2.56677) / 14.5667
result = v2 - v1
assert Vector(0, 0, 0).is_null
def transform(self, points):
rotation = radians(self.rotation)
for point in points:
if self.mirrorx:
point = Vector(point[0], -point[1])
if self.mirrory:
point = Vector(-point[0], point[1])
yield self.start + point.rot_z_rad(rotation)
def test_strtag2_vector():
assert ' 10\n1.0\n 20\n2.0\n 30\n3.0\n' == strtag2(
DXFTag(10, Vector(1, 2, 3)))
assert ' 10\n1.0\n 20\n2.0\n 30\n3.0\n' == strtag2(
DXFTag(10, Vector((1, 2, 3))))
assert ' 10\n1.0\n 20\n2.0\n 30\n0.0\n' == strtag2(DXFTag(
10, Vector(1, 2)))
assert ' 10\n1.0\n 20\n2.0\n 30\n0.0\n' == strtag2(
DXFTag(10, Vector((1, 2))))
def test_bool():
v = Vector()
assert bool(v) is False
v1 = Vector(23.56678, 56678.56778, 2.56677) * (1.0 / 14.5667)
v2 = Vector(23.56678, 56678.56778, 2.56677) / 14.5667
result = v2 - v1
assert bool(result) is False
# actual precision is abs_tol=1e-9
assert not Vector(1e-8, 0, 0).is_null
def test_strtag2_vector():
assert ' 10\n1.0\n 20\n2.0\n 30\n3.0\n' == DXFVertex(10,
Vector(1, 2,
3)).dxfstr()
assert ' 10\n1.0\n 20\n2.0\n 30\n3.0\n' == DXFVertex(
10, Vector((1, 2, 3))).dxfstr()
assert ' 10\n1.0\n 20\n2.0\n 30\n0.0\n' == DXFVertex(10,
Vector(1,
2)).dxfstr()
assert ' 10\n1.0\n 20\n2.0\n 30\n0.0\n' == DXFVertex(10, Vector(
(1, 2))).dxfstr()
def scale(self, sx=1, sy=1, sz=1):
"""
Scale mesh inplace.
"""
self.vertices = [
Vector(v[0] * sx, v[1] * sy, v[2] * sz) for v in self.vertices
]
for index, vertex in enumerate(self.vertices):
self.vertices[index] = Vector(vertex[0] * sx, vertex[1] * sy,
vertex[2] * sz)
def translate(self, x=0, y=0, z=0):
"""
Translate mesh inplace.
"""
if isinstance(x, (float, int)):
t = Vector(x, y, z)
else:
t = Vector(x)
for index, vertex in enumerate(self.vertices):
self.vertices[index] = t + vertex
def test_compare_vectors():
v1 = Vector(1, 2, 3)
# compare to tuple
assert v1 == (1, 2, 3)
# compare tuple to vector
assert (1, 2, 3) == v1
v2 = Vector(2, 3, 4)
assert v2 > v1
assert v1 < v2
def point(self, t):
"""
Returns (point, derivative1, derivative2) at BezierCurve(t)
Args:
t: parameter in range [0, 1]
Returns: (point, derivative1, derivative2)
point -- Vector(x, y, z)
derivative1 -- Vector(x, y, z)
derivative2 -- Vector(x, y, z)
"""
if t < 0. or t > 1.:
raise ValueError('parameter t in range [0, 1]')
if (1.0 - t) < 5e-6:
t = 1.0
defpoints = self._defpoints
npts = len(defpoints)
npts0 = npts - 1
point = [0., 0., 0.]
d1 = [0., 0., 0.]
d2 = [0., 0., 0.]
for axis in (0, 1, 2):
if t == 0.0:
d1[axis] = npts0 * (defpoints[1][axis] - defpoints[0][axis])
d2[axis] = npts0 * (npts0 - 1) * (defpoints[0][axis] -
2. * defpoints[1][axis] +
defpoints[2][axis])
for i in range(len(defpoints)):
tempbasis = bernstein_basis(npts0, i, t)
point[axis] += tempbasis * defpoints[i][axis]
if 0.0 < t < 1.0:
d1[axis] += ((i - npts0 * t) /
(t *
(1. - t))) * tempbasis * defpoints[i][axis]
temp1 = (i - npts0 * t)**2
temp2 = temp1 - npts0 * t**2 - i * (1. - 2. * t)
d2[axis] += (
temp2 / (t**2 *
(1. - t)**2)) * tempbasis * defpoints[i][axis]
if t == 1.0:
d1[axis] = npts0 * (defpoints[npts0][axis] -
defpoints[npts0 - 1][axis])
d2[axis] = npts0 * (npts0 -
1) * (defpoints[npts0][axis] -
2 * defpoints[npts0 - 1][axis] +
defpoints[npts0 - 2][axis])
return Vector(point), Vector(d1), Vector(d2)
def test_init_two_params():
v = Vector(1, 2)
assert v == (1, 2) # z is 0.
v = Vector(5, 6, 7) - Vector(1, 1, 1)
assert v == (4, 5, 6)
v = Vector.from_deg_angle(0)
assert v == (1, 0)
length, angle = 7, 45
v = Vector.from_deg_angle(angle, length)
x = math.cos(math.radians(angle)) * length
y = math.sin(math.radians(angle)) * length
assert v == (x, y)
def __init__(self, start=(0, 0), rotation=0., length=1., paramA=1.0, mirror=''):
self.start = Vector(start)
self.rotation = float(rotation)
self.length = float(length)
self.paramA = float(paramA)
self.mirrorx = 'x' in mirror.lower()
self.mirrory = 'y' in mirror.lower()
def set_location(self, insert, rotation=None, attachment_point=None):
self.dxf.insert = Vector(insert)
if rotation is not None:
self.set_rotation(rotation)
if attachment_point is not None:
self.dxf.attachment_point = attachment_point
return self
def __init__(self,
pos,
measure_points,
angle=0.,
dimstyle='Default',
layer=None,
roundval=None):
"""
LinearDimension Constructor.
Args:
pos: location as (x, y) tuple of dimension line, line goes through this point
measure_points: list of points as (x, y) tuples to dimension (two or more)
float angle: angle (in degree) of dimension line
dimstyle: dimstyle name, 'Default' - style is the default value
str layer: dimension line layer, override the default value of dimstyle
int roundval: count of decimal places
"""
super(LinearDimension, self).__init__(dimstyle, layer, roundval)
self.angle = angle
self.measure_points = measure_points
self.text_override = [""] * self.section_count
self.dimlinepos = Vector(pos)
self.layout = None
def __init__(self, center=(0., 0., 0.), rx=1.0, ry=1.0, startangle=0., endangle=360., rotation=0., segments=100):
self.center = Vector(center)
self.rx = float(rx)
self.ry = float(ry)
self.startangle = float(startangle)
self.endangle = float(endangle)
self.rotation = float(rotation)
self.segments = int(segments)
def append(self, point, tangent1, tangent2=None, segments=20):
"""
Append a control point with two control tangents.
Args:
point: the control point
tangent1: first control tangent as vector *left* of point
tangent2: second control tangent as vector *right* of point, if omitted tangent2 = -tangent1
segments: count of line segments for polyline approximation, count of line segments from previous
control point to this point.
"""
tangent1 = Vector(tangent1)
if tangent2 is None:
tangent2 = -tangent1
else:
tangent2 = Vector(tangent2)
self.points.append((point, tangent1, tangent2, int(segments)))
def test_vector_as_tuple():
v = Vector(1, 2, 3)
assert v[0] == 1
assert v[1] == 2
assert v[2] == 3
assert tuple(v) == (1, 2, 3)
assert isinstance(v[:2], tuple)
assert v[:2] == (1, 2)
assert v[1:] == (2, 3)
assert isinstance(v.xyz, tuple)
assert v.xyz == (1, 2, 3)
def _setup(self):
"""
Calc setup values and determines the point order of the dimension line points.
"""
self.measure_points = [Vector(point) for point in self.measure_points]
dimlineray = Ray2D(self.dimlinepos, angle=radians(self.angle))
self.dimline_points = [
self._get_point_on_dimline(point, dimlineray)
for point in self.measure_points
]
self.point_order = self._indices_of_sorted_points(self.dimline_points)
self._build_vectors()
def __init__(self,
center,
target,
length=1.,
dimstyle='Default',
layer=None,
roundval=None):
"""
Args:
center: center point of radius
target: target point of radius
length: length of radius arrow (drawing length)
dimstyle: dimstyle name, 'Default' - style is the default value
layer: dimension line layer, override the default value of dimstyle
roundval: count of decimal places
"""
super(RadialDimension, self).__init__(dimstyle, layer, roundval)
self.center = Vector(center)
self.target = Vector(target)
self.length = float(length)
def test_angle_between():
v1 = Vector(0, 1)
v2 = Vector(1, 1)
angle = v1.angle_between(v2)
assert is_close(angle, math.pi / 4)
# reverse order, same result
angle = v2.angle_between(v1)
assert is_close(angle, math.pi / 4)
def test_deep_copy():
import copy
v = Vector(1, 2, 3)
l1 = [v, v, v]
l2 = copy.copy(l1)
assert l2[0] is l2[1]
assert l2[1] is l2[2]
assert l2[0] is v
l3 = copy.deepcopy(l1)
assert l3[0] is l3[1]
assert l3[1] is l3[2]
assert l3[0] is not v
def point(self, t):
"""
Returns point at BezierCurve(t) as tuple (x, y, z)
Args:
t: parameter in range [0, 1]
Returns: Vector(x, y, z)
"""
if t < 0. or t > 1.:
raise ValueError('parameter t in range [0, 1]')
if (1.0 - t) < 5e-6:
t = 1.0
point = [0., 0., 0.]
defpoints = self._defpoints
len_defpoints = len(defpoints)
for axis in (0, 1, 2):
for i in range(len_defpoints):
bsf = bernstein_basis(len_defpoints - 1, i, t)
point[axis] += bsf * defpoints[i][axis]
return Vector(point)
def test_init_three_params():
v = Vector(1, 2, 3)
assert v == (1, 2, 3)
def test_spatial_angle():
v = Vector(3, 3, 0)
assert is_close(v.spatial_angle_deg, 45)
assert is_close(v.spatial_angle_rad, math.radians(45))
def test_get_angle():
v = Vector(3, 3)
assert is_close(v.angle_deg, 45)
assert is_close(v.angle_rad, math.radians(45))
def test_init_no_params():
v = Vector()
assert v == (0, 0, 0)
assert v == Vector()
def test_iter():
assert sum(Vector(1, 2, 3)) == 6
def test_vector_as_tuple():
v = Vector(1, 2, 3)
assert v[0] == 1
assert v[1] == 2
assert v[2] == 3
assert tuple(v) == (1, 2, 3)
def test_from_angle():
angle = math.radians(50)
length = 3.
assert Vector.from_rad_angle(angle,
length) == (math.cos(angle) * length,
math.sin(angle) * length, 0)
