def removeShape(objs,mark=True):
'''takes an arch object (wall or structure) built on a cubic shape, and removes
the inner shape, keeping its length, width and height as parameters.'''
import DraftGeomUtils
if not isinstance(objs,list):
objs = [objs]
for obj in objs:
if DraftGeomUtils.isCubic(obj.Shape):
dims = DraftGeomUtils.getCubicDimensions(obj.Shape)
if dims:
name = obj.Name
tp = Draft.getType(obj)
print tp
if tp == "Structure":
FreeCAD.ActiveDocument.removeObject(name)
import ArchStructure
str = ArchStructure.makeStructure(length=dims[1],width=dims[2],height=dims[3],name=name)
str.Placement = dims[0]
elif tp == "Wall":
FreeCAD.ActiveDocument.removeObject(name)
import ArchWall
length = dims[1]
width = dims[2]
v1 = Vector(length/2,0,0)
v2 = v1.negative()
v1 = dims[0].multVec(v1)
v2 = dims[0].multVec(v2)
line = Draft.makeLine(v1,v2)
wal = ArchWall.makeWall(line,width=width,height=dims[3],name=name)
else:
if mark:
obj.ViewObject.ShapeColor = (1.0,0.0,0.0,1.0)
def removeShape(objs, mark=True):
"""takes an arch object (wall or structure) built on a cubic shape, and removes
the inner shape, keeping its length, width and height as parameters."""
import DraftGeomUtils
if not isinstance(objs, list):
objs = [objs]
for obj in objs:
if DraftGeomUtils.isCubic(obj.Shape):
dims = DraftGeomUtils.getCubicDimensions(obj.Shape)
if dims:
name = obj.Name
tp = Draft.getType(obj)
print tp
if tp == "Structure":
FreeCAD.ActiveDocument.removeObject(name)
import ArchStructure
str = ArchStructure.makeStructure(length=dims[1], width=dims[2], height=dims[3], name=name)
str.Placement = dims[0]
elif tp == "Wall":
FreeCAD.ActiveDocument.removeObject(name)
import ArchWall
length = dims[1]
width = dims[2]
v1 = Vector(length / 2, 0, 0)
v2 = v1.negative()
v1 = dims[0].multVec(v1)
v2 = dims[0].multVec(v2)
line = Draft.makeLine(v1, v2)
wal = ArchWall.makeWall(line, width=width, height=dims[3], name=name)
else:
if mark:
obj.ViewObject.ShapeColor = (1.0, 0.0, 0.0, 1.0)
def getExtrusionData(self,obj):
"""returns (shape,extrusion vector,placement) or None"""
import Part,DraftGeomUtils
data = ArchComponent.Component.getExtrusionData(self,obj)
if data:
if not isinstance(data[0],list):
# multifuses not considered here
return data
length = obj.Length.Value
width = obj.Width.Value
height = obj.Height.Value
if not height:
for p in obj.InList:
if Draft.getType(p) in ["Floor","BuildingPart"]:
if p.Height.Value:
height = p.Height.Value
if not height:
return None
if obj.Normal == Vector(0,0,0):
normal = Vector(0,0,1)
else:
normal = Vector(obj.Normal)
base = None
placement = None
self.basewires = None
# build wall layers
layers = []
if hasattr(obj,"Material"):
if obj.Material:
if hasattr(obj.Material,"Materials"):
varwidth = 0
restwidth = width - sum(obj.Material.Thicknesses)
if restwidth > 0:
varwidth = [t for t in obj.Material.Thicknesses if t == 0]
if varwidth:
varwidth = restwidth/len(varwidth)
for t in obj.Material.Thicknesses:
if t:
layers.append(t)
elif varwidth:
layers.append(varwidth)
if obj.Base:
if obj.Base.isDerivedFrom("Part::Feature"):
if obj.Base.Shape:
if obj.Base.Shape.Solids:
return None
elif obj.Face > 0:
if len(obj.Base.Shape.Faces) >= obj.Face:
face = obj.Base.Shape.Faces[obj.Face-1]
# this wall is based on a specific face of its base object
normal = face.normalAt(0,0)
if normal.getAngle(Vector(0,0,1)) > math.pi/4:
normal.multiply(width)
base = face.extrude(normal)
if obj.Align == "Center":
base.translate(normal.negative().multiply(0.5))
elif obj.Align == "Right":
base.translate(normal.negative())
else:
normal.multiply(height)
base = face.extrude(normal)
base,placement = self.rebase(base)
return (base,normal,placement)
elif obj.Base.Shape.Faces:
if not DraftGeomUtils.isCoplanar(obj.Base.Shape.Faces):
return None
else:
base,placement = self.rebase(obj.Base.Shape)
elif len(obj.Base.Shape.Edges) == 1:
self.basewires = [Part.Wire(obj.Base.Shape.Edges)]
else:
# self.basewires = obj.Base.Shape.Wires
self.basewires = []
for cluster in Part.getSortedClusters(obj.Base.Shape.Edges):
for c in Part.sortEdges(cluster):
self.basewires.append(Part.Wire(c))
if self.basewires and width:
if (len(self.basewires) == 1) and layers:
self.basewires = [self.basewires[0] for l in layers]
layeroffset = 0
baseface = None
for i,wire in enumerate(self.basewires):
e = wire.Edges[0]
if isinstance(e.Curve,Part.Circle):
dvec = e.Vertexes[0].Point.sub(e.Curve.Center)
else:
dvec = DraftGeomUtils.vec(wire.Edges[0]).cross(normal)
if not DraftVecUtils.isNull(dvec):
dvec.normalize()
sh = None
if obj.Align == "Left":
off = obj.Offset.Value
if layers:
off = off+layeroffset
dvec.multiply(layers[i])
layeroffset += layers[i]
else:
dvec.multiply(width)
if off:
dvec2 = DraftVecUtils.scaleTo(dvec,off)
wire = DraftGeomUtils.offsetWire(wire,dvec2)
w2 = DraftGeomUtils.offsetWire(wire,dvec)
w1 = Part.Wire(Part.__sortEdges__(wire.Edges))
sh = DraftGeomUtils.bind(w1,w2)
elif obj.Align == "Right":
dvec = dvec.negative()
off = obj.Offset.Value
if layers:
off = off+layeroffset
dvec.multiply(layers[i])
layeroffset += layers[i]
else:
dvec.multiply(width)
if off:
dvec2 = DraftVecUtils.scaleTo(dvec,off)
wire = DraftGeomUtils.offsetWire(wire,dvec2)
w2 = DraftGeomUtils.offsetWire(wire,dvec)
w1 = Part.Wire(Part.__sortEdges__(wire.Edges))
sh = DraftGeomUtils.bind(w1,w2)
elif obj.Align == "Center":
if layers:
off = width/2-layeroffset
d1 = Vector(dvec).multiply(off)
w1 = DraftGeomUtils.offsetWire(wire,d1)
layeroffset += layers[i]
off = width/2-layeroffset
d1 = Vector(dvec).multiply(off)
w2 = DraftGeomUtils.offsetWire(wire,d1)
else:
dvec.multiply(width/2)
w1 = DraftGeomUtils.offsetWire(wire,dvec)
dvec = dvec.negative()
w2 = DraftGeomUtils.offsetWire(wire,dvec)
sh = DraftGeomUtils.bind(w1,w2)
if sh:
sh.fix(0.1,0,1) # fixes self-intersecting wires
f = Part.Face(sh)
if baseface:
if layers:
baseface.append(f)
else:
baseface = baseface.fuse(f)
# baseface = baseface.removeSplitter()
s = DraftGeomUtils.removeSplitter(baseface)
if s:
baseface = s
else:
if layers:
baseface = [f]
else:
baseface = f
if baseface:
base,placement = self.rebase(baseface)
else:
if layers:
totalwidth = sum(layers)
offset = 0
base = []
for l in layers:
l2 = length/2 or 0.5
w1 = -totalwidth/2 + offset
w2 = w1 + l
v1 = Vector(-l2,w1,0)
v2 = Vector(l2,w1,0)
v3 = Vector(l2,w2,0)
v4 = Vector(-l2,w2,0)
base.append(Part.Face(Part.makePolygon([v1,v2,v3,v4,v1])))
offset += l
else:
l2 = length/2 or 0.5
w2 = width/2 or 0.5
v1 = Vector(-l2,-w2,0)
v2 = Vector(l2,-w2,0)
v3 = Vector(l2,w2,0)
v4 = Vector(-l2,w2,0)
base = Part.Face(Part.makePolygon([v1,v2,v3,v4,v1]))
placement = FreeCAD.Placement()
if base and placement:
extrusion = normal.multiply(height)
return (base,extrusion,placement)
return None
class plane:
"""A WorkPlane object.
Attributes
----------
doc : App::Document
The active document. Reset view when `doc` changes.
weak : bool
It is `True` if the plane has been defined by `setup()`
or has been reset. A weak plane can be changed
(it is the "auto" mode), while a strong plane will keep
its position until weakened (it is "locked")
u : Base::Vector3
An axis (vector) that helps define the working plane.
v : Base::Vector3
An axis (vector) that helps define the working plane.
axis : Base::Vector3
A vector that is supposed to be perpendicular to `u` and `v`;
it is helpful although redundant.
position : Base::Vector3
A point, which the plane goes through,
that helps define the working plane.
stored : bool
A placeholder for a stored state.
"""
def __init__(self,
u=Vector(1, 0, 0), v=Vector(0, 1, 0), w=Vector(0, 0, 1),
pos=Vector(0, 0, 0)):
"""Initialize the working plane.
Parameters
----------
u : Base::Vector3, optional
An axis (vector) that helps define the working plane.
It defaults to `(1, 0, 0)`, or the +X axis.
v : Base::Vector3, optional
An axis (vector) that helps define the working plane.
It defaults to `(0, 1, 0)`, or the +Y axis.
w : Base::Vector3, optional
An axis that is supposed to be perpendicular to `u` and `v`;
it is redundant.
It defaults to `(0, 0, 1)`, or the +Z axis.
pos : Base::Vector3, optional
A point through which the plane goes through.
It defaults to the origin `(0, 0, 0)`.
"""
# keep track of active document. Reset view when doc changes.
self.doc = None
self.weak = True
self.u = u
self.v = v
self.axis = w
self.position = pos
# a placeholder for a stored state
self.stored = None
def __repr__(self):
"""Show the string representation of the object."""
text = "Workplane"
text += " x=" + str(DraftVecUtils.rounded(self.u))
text += " y=" + str(DraftVecUtils.rounded(self.v))
text += " z=" + str(DraftVecUtils.rounded(self.axis))
return text
def copy(self):
"""Return a new plane that is a copy of the present object."""
return plane(u=self.u, v=self.v, w=self.axis, pos=self.position)
def offsetToPoint(self, p, direction=None):
"""Return the signed distance from a point to the plane.
Parameters
----------
p : Base::Vector3
The external point to consider.
direction : Base::Vector3, optional
The unit vector that indicates the direction of the distance.
It defaults to `None`, which then uses the `plane.axis` (normal)
value, meaning that the measured distance is perpendicular
to the plane.
Returns
-------
float
The distance from the point to the plane.
Notes
-----
The signed distance `d`, from `p` to the plane, is such that
::
x = p + d*direction,
where `x` is a point that lies on the plane.
The `direction` is a unit vector that specifies the direction
in which the distance is measured.
It defaults to `plane.axis`,
meaning that it is the perpendicular distance.
A picture will help explain the computation
::
p
//|
/ / |
d / / | axis
/ / |
/ / |
-------- plane -----x-----c-----a--------
The points are as follows
* `p` is an arbitrary point outside the plane.
* `c` is a known point on the plane,
for example, `plane.position`.
* `x` is the intercept on the plane from `p` in
the desired `direction`.
* `a` is the perpendicular intercept on the plane,
i.e. along `plane.axis`.
The distance is calculated through the dot product
of the vector `pc` (going from point `p` to point `c`,
both of which are known) with the unit vector `direction`
(which is provided or defaults to `plane.axis`).
::
d = pc . direction
d = (c - p) . direction
**Warning:** this implementation doesn't calculate the entire
distance `|xp|`, only the distance `|pc|` projected onto `|xp|`.
Trigonometric relationships
---------------------------
In 2D the distances can be calculated by trigonometric relationships
::
|ap| = |cp| cos(apc) = |xp| cos(apx)
Then the desired distance is `d = |xp|`
::
|xp| = |cp| cos(apc) / cos(apx)
The cosines can be obtained from the definition of the dot product
::
A . B = |A||B| cos(angleAB)
If one vector is a unit vector
::
A . uB = |A| cos(angleAB)
cp . axis = |cp| cos(apc)
and if both vectors are unit vectors
::
uA . uB = cos(angleAB).
direction . axis = cos(apx)
Then
::
d = (cp . axis) / (direction . axis)
**Note:** for 2D these trigonometric operations
produce the full `|xp|` distance.
"""
if direction is None:
direction = self.axis
return direction.dot(self.position.sub(p))
def projectPoint(self, p, direction=None):
"""Project a point onto the plane, by default orthogonally.
Parameters
----------
p : Base::Vector3
The point to project.
direction : Base::Vector3, optional
The unit vector that indicates the direction of projection.
It defaults to `None`, which then uses the `plane.axis` (normal)
value, meaning that the point is projected perpendicularly
to the plane.
Returns
-------
Base::Vector3
The projected vector, scaled to the appropriate distance.
"""
if not direction:
direction = self.axis
lp = self.getLocalCoords(p)
gp = self.getGlobalCoords(Vector(lp.x, lp.y, 0))
a = direction.getAngle(gp.sub(p))
if a > math.pi/2:
direction = direction.negative()
a = math.pi - a
ld = self.getLocalRot(direction)
gd = self.getGlobalRot(Vector(ld.x, ld.y, 0))
hyp = abs(math.tan(a) * lp.z)
return gp.add(DraftVecUtils.scaleTo(gd, hyp))
def projectPointOld(self, p, direction=None):
"""Project a point onto the plane. OBSOLETE.
Parameters
----------
p : Base::Vector3
The point to project.
direction : Base::Vector3, optional
The unit vector that indicates the direction of projection.
It defaults to `None`, which then uses the `plane.axis` (normal)
value, meaning that the point is projected perpendicularly
to the plane.
Returns
-------
Base::Vector3
The projected point,
or the original point if the angle between the `direction`
and the `plane.axis` is 90 degrees.
"""
if not direction:
direction = self.axis
t = Vector(direction)
# t.normalize()
a = round(t.getAngle(self.axis), DraftVecUtils.precision())
pp = round((math.pi)/2, DraftVecUtils.precision())
if a == pp:
return p
t.multiply(self.offsetToPoint(p, direction))
return p.add(t)
def alignToPointAndAxis(self, point, axis, offset=0, upvec=None):
"""Align the working plane to a point and an axis (vector).
Set `v` as the cross product of `axis` with `(1, 0, 0)` or `+X`,
and `u` as `v` rotated -90 degrees around the `axis`.
Also set `weak` to `False`.
Parameters
----------
point : Base::Vector3
The new `position` of the plane, adjusted by
the `offset`.
axis : Base::Vector3
A vector whose unit vector will be used as the new `axis`
of the plane.
If it is very close to the `X` or `-X` axes,
it will use this axis exactly, and will adjust `u` and `v`
to `+Y` and `+Z`, or `-Y` and `+Z`, respectively.
offset : float, optional
Defaults to zero. A value which will be used to offset
the plane in the direction of its `axis`.
upvec : Base::Vector3, optional
Defaults to `None`.
If it exists, its unit vector will be used as `v`,
and will set `u` as the cross product of `v` with `axis`.
"""
self.doc = FreeCAD.ActiveDocument
self.axis = axis
self.axis.normalize()
if axis.getAngle(Vector(1, 0, 0)) < 0.00001:
self.axis = Vector(1, 0, 0)
self.u = Vector(0, 1, 0)
self.v = Vector(0, 0, 1)
elif axis.getAngle(Vector(-1, 0, 0)) < 0.00001:
self.axis = Vector(-1, 0, 0)
self.u = Vector(0, -1, 0)
self.v = Vector(0, 0, 1)
elif upvec:
self.v = upvec
self.v.normalize()
self.u = self.v.cross(self.axis)
else:
self.v = axis.cross(Vector(1, 0, 0))
self.v.normalize()
self.u = DraftVecUtils.rotate(self.v, -math.pi/2, self.axis)
offsetVector = Vector(axis)
offsetVector.multiply(offset)
self.position = point.add(offsetVector)
self.weak = False
# FCC.PrintMessage("(position = " + str(self.position) + ")\n")
# FCC.PrintMessage(self.__repr__() + "\n")
def alignToPointAndAxis_SVG(self, point, axis, offset=0):
"""Align the working plane to a point and an axis (vector).
It aligns `u` and `v` based on the magnitude of the components
of `axis`.
Also set `weak` to `False`.
Parameters
----------
point : Base::Vector3
The new `position` of the plane, adjusted by
the `offset`.
axis : Base::Vector3
A vector whose unit vector will be used as the new `axis`
of the plane.
The magnitudes of the `x`, `y`, `z` components of the axis
determine the orientation of `u` and `v` of the plane.
offset : float, optional
Defaults to zero. A value which will be used to offset
the plane in the direction of its `axis`.
Cases
-----
The `u` and `v` are always calculated the same
* `u` is the cross product of the positive or negative of `axis`
with a `reference vector`.
::
u = [+1|-1] axis.cross(ref_vec)
* `v` is `u` rotated 90 degrees around `axis`.
Whether the `axis` is positive or negative, and which reference
vector is used, depends on the absolute values of the `x`, `y`, `z`
components of the `axis` unit vector.
#. If `x > y`, and `y > z`
The reference vector is +Z
::
u = -1 axis.cross(+Z)
#. If `y > z`, and `z >= x`
The reference vector is +X.
::
u = -1 axis.cross(+X)
#. If `y >= x`, and `x > z`
The reference vector is +Z.
::
u = +1 axis.cross(+Z)
#. If `x > z`, and `z >= y`
The reference vector is +Y.
::
u = +1 axis.cross(+Y)
#. If `z >= y`, and `y > x`
The reference vector is +X.
::
u = +1 axis.cross(+X)
#. otherwise
The reference vector is +Y.
::
u = -1 axis.cross(+Y)
"""
self.doc = FreeCAD.ActiveDocument
self.axis = axis
self.axis.normalize()
ref_vec = Vector(0.0, 1.0, 0.0)
if ((abs(axis.x) > abs(axis.y)) and (abs(axis.y) > abs(axis.z))):
ref_vec = Vector(0.0, 0., 1.0)
self.u = axis.negative().cross(ref_vec)
self.u.normalize()
self.v = DraftVecUtils.rotate(self.u, math.pi/2, self.axis)
# projcase = "Case new"
elif ((abs(axis.y) > abs(axis.z)) and (abs(axis.z) >= abs(axis.x))):
ref_vec = Vector(1.0, 0.0, 0.0)
self.u = axis.negative().cross(ref_vec)
self.u.normalize()
self.v = DraftVecUtils.rotate(self.u, math.pi/2, self.axis)
# projcase = "Y>Z, View Y"
elif ((abs(axis.y) >= abs(axis.x)) and (abs(axis.x) > abs(axis.z))):
ref_vec = Vector(0.0, 0., 1.0)
self.u = axis.cross(ref_vec)
self.u.normalize()
self.v = DraftVecUtils.rotate(self.u, math.pi/2, self.axis)
# projcase = "ehem. XY, Case XY"
elif ((abs(axis.x) > abs(axis.z)) and (abs(axis.z) >= abs(axis.y))):
self.u = axis.cross(ref_vec)
self.u.normalize()
self.v = DraftVecUtils.rotate(self.u, math.pi/2, self.axis)
# projcase = "X>Z, View X"
elif ((abs(axis.z) >= abs(axis.y)) and (abs(axis.y) > abs(axis.x))):
ref_vec = Vector(1.0, 0., 0.0)
self.u = axis.cross(ref_vec)
self.u.normalize()
self.v = DraftVecUtils.rotate(self.u, math.pi/2, self.axis)
# projcase = "Y>X, Case YZ"
else:
self.u = axis.negative().cross(ref_vec)
self.u.normalize()
self.v = DraftVecUtils.rotate(self.u, math.pi/2, self.axis)
# projcase = "else"
# spat_vec = self.u.cross(self.v)
# spat_res = spat_vec.dot(axis)
# FCC.PrintMessage(projcase + " spat Prod = " + str(spat_res) + "\n")
offsetVector = Vector(axis)
offsetVector.multiply(offset)
self.position = point.add(offsetVector)
self.weak = False
# FCC.PrintMessage("(position = " + str(self.position) + ")\n")
# FCC.PrintMessage(self.__repr__() + "\n")
def alignToCurve(self, shape, offset=0):
"""Align plane to curve. NOT YET IMPLEMENTED.
Parameters
----------
shape : Part.Shape
A curve that will serve to align the plane.
It can be an `'Edge'` or `'Wire'`.
offset : float
Defaults to zero. A value which will be used to offset
the plane in the direction of its `axis`.
Returns
-------
False
Returns `False` if the shape is null.
Currently it always returns `False`.
"""
if shape.isNull():
return False
elif shape.ShapeType == 'Edge':
# ??? TODO: process curve here. look at shape.edges[0].Curve
return False
elif shape.ShapeType == 'Wire':
# ??? TODO: determine if edges define a plane
return False
else:
return False
def alignToEdges(self, edges):
"""Align plane to two edges.
Uses the two points of the first edge to define the direction
of the unit vector `u`, the other two points of the other edge
to define the other unit vector `v`, and then the cross product
of `u` with `v` to define the `axis`.
Parameters
----------
edges : list
A list of two edges.
Returns
-------
False
Return `False` if `edges` is a list of more than 2 elements.
"""
# use a list of edges to find a plane position
if len(edges) > 2:
return False
# for axes systems, we suppose the 2 first edges are parallel
# ??? TODO: exclude other cases first
v1 = edges[0].Vertexes[-1].Point.sub(edges[0].Vertexes[0].Point)
v2 = edges[1].Vertexes[0].Point.sub(edges[0].Vertexes[0].Point)
v3 = v1.cross(v2)
v1.normalize()
v2.normalize()
v3.normalize()
# print(v1,v2,v3)
self.u = v1
self.v = v2
self.axis = v3
def alignToFace(self, shape, offset=0):
"""Align the plane to a face.
It uses the center of mass of the face as `position`,
and its normal in the center of the face as `axis`,
then calls `alignToPointAndAxis(position, axis, offset)`.
If the face is a quadrilateral, then it adjusts the position
of the plane according to its reported X direction and Y direction.
Also set `weak` to `False`.
Parameter
--------
shape : Part.Face
A shape of type `'Face'`.
offset : float
Defaults to zero. A value which will be used to offset
the plane in the direction of its `axis`.
Returns
-------
bool
`True` if the operation was successful, and `False` if the shape
is not a `'Face'`.
See Also
--------
alignToPointAndAxis, DraftGeomUtils.getQuad
"""
# Set face to the unique selected face, if found
if shape.ShapeType == 'Face':
self.alignToPointAndAxis(shape.Faces[0].CenterOfMass,
shape.Faces[0].normalAt(0, 0),
offset)
import DraftGeomUtils
q = DraftGeomUtils.getQuad(shape)
if q:
self.u = q[1]
self.v = q[2]
if not DraftVecUtils.equals(self.u.cross(self.v), self.axis):
self.u = q[2]
self.v = q[1]
if DraftVecUtils.equals(self.u, Vector(0, 0, 1)):
# the X axis is vertical: rotate 90 degrees
self.u, self.v = self.v.negative(), self.u
elif DraftVecUtils.equals(self.u, Vector(0, 0, -1)):
self.u, self.v = self.v, self.u.negative()
self.weak = False
return True
else:
return False
def alignTo3Points(self, p1, p2, p3, offset=0):
"""Align the plane to three points.
It makes a closed quadrilateral face with the three points,
and then calls `alignToFace(shape, offset)`.
Parameter
---------
p1 : Base::Vector3
The first point.
p2 : Base::Vector3
The second point.
p3 : Base::Vector3
The third point.
offset : float
Defaults to zero. A value which will be used to offset
the plane in the direction of its `axis`.
Returns
-------
bool
`True` if the operation was successful, and `False` otherwise.
"""
import Part
w = Part.makePolygon([p1, p2, p3, p1])
f = Part.Face(w)
return self.alignToFace(f, offset)
def alignToSelection(self, offset=0):
"""Align the plane to a selection if it defines a plane.
If the selection uniquely defines a plane it will be used.
Currently it only works with one object selected, a `'Face'`.
It extracts the shape of the object or subobject
and then calls `alignToFace(shape, offset)`.
This method only works when `FreeCAD.GuiUp` is `True`,
that is, when the graphical interface is loaded.
Parameter
---------
offset : float
Defaults to zero. A value which will be used to offset
the plane in the direction of its `axis`.
Returns
-------
bool
`True` if the operation was successful, and `False` otherwise.
It returns `False` if the selection has no elements,
or if it has more than one element,
or if the object is not derived from `'Part::Feature'`
or if the object doesn't have a `Shape`.
To do
-----
The method returns `False` if the selection list has more than
one element.
The method should search the list for objects like faces, points,
edges, wires, etc., and call the appropriate aligning submethod.
The method could work for curves (`'Edge'` or `'Wire'`) but
`alignToCurve()` isn't fully implemented.
When the interface is not loaded it should fail and print
a message, `FreeCAD.Console.PrintError()`.
See also
--------
alignToFace, alignToCurve
"""
import FreeCADGui
sex = FreeCADGui.Selection.getSelectionEx(FreeCAD.ActiveDocument.Name)
if len(sex) == 0:
return False
elif len(sex) == 1:
if (not sex[0].Object.isDerivedFrom("Part::Feature")
or not sex[0].Object.Shape):
return False
return (self.alignToFace(sex[0].Object.Shape, offset)
or (len(sex[0].SubObjects) == 1
and self.alignToFace(sex[0].SubObjects[0], offset))
or self.alignToCurve(sex[0].Object.Shape, offset))
else:
# len(sex) > 2, look for point and line, three points, etc.
return False
def setup(self, direction=None, point=None, upvec=None, force=False):
"""Setup the working plane if it exists but is undefined.
If `direction` and `point` are present,
it calls `alignToPointAndAxis(point, direction, 0, upvec)`.
Otherwise, it gets the camera orientation to define
a working plane that is perpendicular to the current view,
centered at the origin, and with `v` pointing up on the screen.
This method only works when the `weak` attribute is `True`.
This method also sets `weak` to `True`.
This method only works when `FreeCAD.GuiUp` is `True`,
that is, when the graphical interface is loaded.
Otherwise it fails silently.
Parameters
----------
direction : Base::Vector3, optional
It defaults to `None`. It is the new `axis` of the plane.
point : Base::Vector3, optional
It defaults to `None`. It is the new `position` of the plane.
upvec : Base::Vector3, optional
It defaults to `None`. It is the new `v` orientation of the plane.
force : Bool
If True, it sets the plane even if the plane is not in weak mode
To do
-----
When the interface is not loaded it should fail and print
a message, `FreeCAD.Console.PrintError()`.
"""
if self.weak or force:
if direction and point:
self.alignToPointAndAxis(point, direction, 0, upvec)
else:
try:
import FreeCADGui
from pivy import coin
view = FreeCADGui.ActiveDocument.ActiveView
camera = view.getCameraNode()
rot = camera.getField("orientation").getValue()
coin_up = coin.SbVec3f(0, 1, 0)
upvec = Vector(rot.multVec(coin_up).getValue())
vdir = view.getViewDirection()
# The angle is between 0 and 180 degrees.
angle = vdir.getAngle(self.axis)
if (angle > 0.001) and (angle < 3.14159):
# don't change the plane if it is already
# perpendicular to the current view
self.alignToPointAndAxis(Vector(0, 0, 0),
vdir.negative(), 0, upvec)
except:
pass
if force:
self.weak = False
else:
self.weak = True
def reset(self):
"""Reset the plane.
Set the `doc` attribute to `None`, and `weak` to `True`.
"""
self.doc = None
self.weak = True
def getRotation(self):
"""Return a placement describing the plane orientation only.
If `FreeCAD.GuiUp` is `True`, that is, if the graphical interface
is loaded, it will test if the active object is an `Arch` container
and will calculate the placement accordingly.
Returns
-------
Base::Placement
A placement, comprised of a `Base` (`Base::Vector3`),
and a `Rotation` (`Base::Rotation`).
"""
m = DraftVecUtils.getPlaneRotation(self.u, self.v, self.axis)
p = FreeCAD.Placement(m)
# Arch active container
if FreeCAD.GuiUp:
import FreeCADGui
view = FreeCADGui.ActiveDocument.ActiveView
if view:
a = view.getActiveObject("Arch")
if a:
p = a.Placement.inverse().multiply(p)
return p
def getPlacement(self, rotated=False):
"""Return the placement of the plane.
Parameters
----------
rotated : bool, optional
It defaults to `False`. If it is `True`, it switches `axis`
with `-v` to produce a rotated placement.
Returns
-------
Base::Placement
A placement, comprised of a `Base` (`Base::Vector3`),
and a `Rotation` (`Base::Rotation`).
"""
if rotated:
m = FreeCAD.Matrix(
self.u.x, self.axis.x, -self.v.x, self.position.x,
self.u.y, self.axis.y, -self.v.y, self.position.y,
self.u.z, self.axis.z, -self.v.z, self.position.z,
0.0, 0.0, 0.0, 1.0)
else:
m = FreeCAD.Matrix(
self.u.x, self.v.x, self.axis.x, self.position.x,
self.u.y, self.v.y, self.axis.y, self.position.y,
self.u.z, self.v.z, self.axis.z, self.position.z,
0.0, 0.0, 0.0, 1.0)
p = FreeCAD.Placement(m)
# Arch active container if based on App Part
# if FreeCAD.GuiUp:
# import FreeCADGui
# view = FreeCADGui.ActiveDocument.ActiveView
# a = view.getActiveObject("Arch")
# if a:
# p = a.Placement.inverse().multiply(p)
return p
def getNormal(self):
"""Return the normal vector of the plane (axis).
Returns
-------
Base::Vector3
The `axis` attribute of the plane.
"""
n = self.axis
# Arch active container if based on App Part
# if FreeCAD.GuiUp:
# import FreeCADGui
# view = FreeCADGui.ActiveDocument.ActiveView
# a = view.getActiveObject("Arch")
# if a:
# n = a.Placement.inverse().Rotation.multVec(n)
return n
def setFromPlacement(self, pl, rebase=False):
"""Set the plane from a placement.
It normally uses only the rotation, unless `rebase` is `True`.
Parameters
----------
pl : Base::Placement or Base::Matrix4D
A placement, comprised of a `Base` (`Base::Vector3`),
and a `Rotation` (`Base::Rotation`),
or a `Base::Matrix4D` that defines a placement.
rebase : bool, optional
It defaults to `False`.
If `True`, it will use `pl.Base` as the new `position`
of the plane. Otherwise it will only consider `pl.Rotation`.
To do
-----
If `pl` is a `Base::Matrix4D`, it shouldn't try to use `pl.Base`
because a matrix has no `Base`.
"""
rot = FreeCAD.Placement(pl).Rotation
self.u = rot.multVec(FreeCAD.Vector(1, 0, 0))
self.v = rot.multVec(FreeCAD.Vector(0, 1, 0))
self.axis = rot.multVec(FreeCAD.Vector(0, 0, 1))
if rebase:
self.position = pl.Base
def inverse(self):
"""Invert the direction of the plane.
It inverts the `u` and `axis` vectors.
"""
self.u = self.u.negative()
self.axis = self.axis.negative()
def save(self):
"""Store the plane attributes.
Store `u`, `v`, `axis`, `position` and `weak`
in a list in `stored`.
"""
self.stored = [self.u, self.v, self.axis, self.position, self.weak]
def restore(self):
"""Restore the plane attributes that were saved.
Restores the attributes `u`, `v`, `axis`, `position` and `weak`
from `stored`, and set `stored` to `None`.
"""
if self.stored:
self.u = self.stored[0]
self.v = self.stored[1]
self.axis = self.stored[2]
self.position = self.stored[3]
self.weak = self.stored[4]
self.stored = None
def getLocalCoords(self, point):
"""Return the coordinates of the given point, from the plane.
If the `point` was constructed using the plane as origin,
return the relative coordinates from the `point` to the plane.
A vector is calculated from the plane's `position`
to the external `point`, and this vector is projected onto
each of the `u`, `v` and `axis` of the plane to determine
the local, relative vector.
Parameters
----------
point : Base::Vector3
The point external to the plane.
Returns
-------
Base::Vector3
The relative coordinates of the point from the plane.
See also
--------
getGlobalCoords, getLocalRot, getGlobalRot
Notes
-----
The following graphic explains the coordinates.
::
g GlobalCoords (1, 11)
|
|
|
(n) p point (1, 6)
| LocalCoords (1, 1)
|
----plane--------c-------- position (0, 5)
In the graphic
* `p` is an arbitrary point, external to the plane
* `c` is the plane's `position`
* `g` is the global coordinates of `p` when added to the plane
* `n` is the relative coordinates of `p` when referred to the plane
To do
-----
Maybe a better name would be getRelativeCoords?
"""
pt = point.sub(self.position)
xv = DraftVecUtils.project(pt, self.u)
x = xv.Length
# If the angle between the projection xv and u
# is larger than 1 radian (57.29 degrees), use the negative
# of the magnitude. Why exactly 1 radian?
if xv.getAngle(self.u) > 1:
x = -x
yv = DraftVecUtils.project(pt, self.v)
y = yv.Length
if yv.getAngle(self.v) > 1:
y = -y
zv = DraftVecUtils.project(pt, self.axis)
z = zv.Length
if zv.getAngle(self.axis) > 1:
z = -z
return Vector(x, y, z)
def getGlobalCoords(self, point):
"""Return the coordinates of the given point, added to the plane.
If the `point` was constructed using the plane as origin,
return the absolute coordinates from the `point`
to the global origin.
The `u`, `v`, and `axis` vectors scale the components of `point`,
and the result is added to the planes `position`.
Parameters
----------
point : Base::Vector3
The external point.
Returns
-------
Base::Vector3
The coordinates of the point from the absolute origin.
See also
--------
getLocalCoords, getLocalRot, getGlobalRot
Notes
-----
The following graphic explains the coordinates.
::
g GlobalCoords (1, 11)
|
|
|
(n) p point (1, 6)
| LocalCoords (1, 1)
|
----plane--------c-------- position (0, 5)
In the graphic
* `p` is an arbitrary point, external to the plane
* `c` is the plane's `position`
* `g` is the global coordinates of `p` when added to the plane
* `n` is the relative coordinates of `p` when referred to the plane
"""
vx = Vector(self.u).multiply(point.x)
vy = Vector(self.v).multiply(point.y)
vz = Vector(self.axis).multiply(point.z)
pt = (vx.add(vy)).add(vz)
return pt.add(self.position)
def getLocalRot(self, point):
"""Like getLocalCoords, but doesn't use the plane's position.
If the `point` was constructed using the plane as origin,
return the relative coordinates from the `point` to the plane.
However, in this case, the plane is assumed to have its `position`
at the global origin, therefore, the returned coordinates
will only consider the orientation of the plane.
The external `point` is a vector, which is projected onto
each of the `u`, `v` and `axis` of the plane to determine
the local, relative vector.
Parameters
----------
point : Base::Vector3
The point external to the plane.
Returns
-------
Base::Vector3
The relative coordinates of the point from the plane,
if the plane had its `position` at the global origin.
See also
--------
getLocalCoords, getGlobalCoords, getGlobalRot
"""
xv = DraftVecUtils.project(point, self.u)
x = xv.Length
if xv.getAngle(self.u) > 1:
x = -x
yv = DraftVecUtils.project(point, self.v)
y = yv.Length
if yv.getAngle(self.v) > 1:
y = -y
zv = DraftVecUtils.project(point, self.axis)
z = zv.Length
if zv.getAngle(self.axis) > 1:
z = -z
return Vector(x, y, z)
def getGlobalRot(self, point):
"""Like getGlobalCoords, but doesn't use the plane's position.
If the `point` was constructed using the plane as origin,
return the absolute coordinates from the `point`
to the global origin.
However, in this case, the plane is assumed to have its `position`
at the global origin, therefore, the returned coordinates
will only consider the orientation of the plane.
The `u`, `v`, and `axis` vectors scale the components of `point`.
Parameters
----------
point : Base::Vector3
The external point.
Returns
-------
Base::Vector3
The coordinates of the point from the absolute origin.
See also
--------
getGlobalCoords, getLocalCoords, getLocalRot
"""
vx = Vector(self.u).multiply(point.x)
vy = Vector(self.v).multiply(point.y)
vz = Vector(self.axis).multiply(point.z)
pt = (vx.add(vy)).add(vz)
return pt
def getClosestAxis(self, point):
"""Return the closest axis of the plane to the given point (vector).
It tests the angle that the `point` vector makes with the unit vectors
`u`, `v`, and `axis`, as well their negatives.
The smallest angle indicates the closest axis.
Parameters
----------
point : Base::Vector3
The external point to test.
Returns
-------
str
* It is `'x'` if the closest axis is `u` or `-u`.
* It is `'y'` if the closest axis is `v` or `-v`.
* It is `'z'` if the closest axis is `axis` or `-axis`.
"""
ax = point.getAngle(self.u)
ay = point.getAngle(self.v)
az = point.getAngle(self.axis)
bx = point.getAngle(self.u.negative())
by = point.getAngle(self.v.negative())
bz = point.getAngle(self.axis.negative())
b = min(ax, ay, az, bx, by, bz)
if b in [ax, bx]:
return "x"
elif b in [ay, by]:
return "y"
elif b in [az, bz]:
return "z"
else:
return None
def isGlobal(self):
"""Return True if the plane axes are equal to the global axes.
Return `False` if any of `u`, `v`, or `axis` does not correspond
to `+X`, `+Y`, or `+Z`, respectively.
"""
if self.u != Vector(1, 0, 0):
return False
if self.v != Vector(0, 1, 0):
return False
if self.axis != Vector(0, 0, 1):
return False
return True
def isOrtho(self):
"""Return True if the plane axes are orthogonal with the global axes.
Orthogonal means that the angle between `u` and the global axis `+Y`
is a multiple of 90 degrees, meaning 0, -90, 90, -180, 180,
-270, 270, or 360 degrees.
And similarly for `v` and `axis`.
All three axes should be orthogonal to the `+Y` axis.
Due to rounding errors, the angle difference is rounded
to 6 decimal digits to do the test.
Returns
-------
bool
Returns `True` if all three `u`, `v`, and `axis`
are orthogonal with the global axis `+Y`.
Otherwise it returns `False`.
"""
ortho = [0, -1.570796, 1.570796,
-3.141593, 3.141593,
-4.712389, 4.712389, 6.283185]
# Shouldn't the angle difference be calculated with
# the other global axes `+X` and `+Z` as well?
if round(self.u.getAngle(Vector(0, 1, 0)), 6) in ortho:
if round(self.v.getAngle(Vector(0, 1, 0)), 6) in ortho:
if round(self.axis.getAngle(Vector(0, 1, 0)), 6) in ortho:
return True
return False
def getDeviation(self):
"""Return the angle between the u axis and the horizontal plane.
It defines a projection of `u` on the horizontal plane
(without a Z component), and then measures the angle between
this projection and `u`.
It also considers the cross product of the projection
and `u` to determine the sign of the angle.
Returns
-------
float
Angle between the `u` vector, and a projected vector
on the global horizontal plane.
See also
--------
DraftVecUtils.angle
"""
proj = Vector(self.u.x, self.u.y, 0)
if self.u.getAngle(proj) == 0:
return 0
else:
norm = proj.cross(self.u)
return DraftVecUtils.angle(self.u, proj, norm)
class plane:
'''A WorkPlane object'''
def __init__(self,
u=Vector(1, 0, 0),
v=Vector(0, 1, 0),
w=Vector(0, 0, 1),
pos=Vector(0, 0, 0)):
# keep track of active document. Reset view when doc changes.
self.doc = None
# self.weak is true if the plane has been defined by self.setup or has been reset
self.weak = True
# u, v axes and position define plane, perpendicular axis is handy, though redundant.
self.u = u
self.v = v
self.axis = w
self.position = pos
# a placeholder for a stored state
self.stored = None
def __repr__(self):
return "Workplane x=" + str(DraftVecUtils.rounded(
self.u)) + " y=" + str(DraftVecUtils.rounded(
self.v)) + " z=" + str(DraftVecUtils.rounded(self.axis))
def offsetToPoint(self, p, direction=None):
'''
Return the signed distance from p to the plane, such
that p + offsetToPoint(p)*direction lies on the plane.
direction defaults to -plane.axis
'''
'''
A picture will help explain the computation:
p
//|
/ / |
/ / |
/ / |
/ / |
-------------------- plane -----c-----x-----a--------
Here p is the specified point,
c is a point (in this case plane.position) on the plane
x is the intercept on the plane from p in the specified direction, and
a is the perpendicular intercept on the plane (i.e. along plane.axis)
Using vertival bars to denote the length operator,
|ap| = |cp| * cos(apc) = |xp| * cos(apx)
so
|xp| = |cp| * cos(apc) / cos(apx)
= (cp . axis) / (direction . axis)
'''
if direction == None: direction = self.axis
return direction.dot(self.position.sub(p))
def projectPoint(self, p, direction=None):
'''project point onto plane, default direction is orthogonal'''
if not direction:
direction = self.axis
lp = self.getLocalCoords(p)
gp = self.getGlobalCoords(Vector(lp.x, lp.y, 0))
a = direction.getAngle(gp.sub(p))
if a > math.pi / 2:
direction = direction.negative()
a = math.pi - a
ld = self.getLocalRot(direction)
gd = self.getGlobalRot(Vector(ld.x, ld.y, 0))
hyp = abs(math.tan(a) * lp.z)
return gp.add(DraftVecUtils.scaleTo(gd, hyp))
def projectPointOld(self, p, direction=None):
'''project point onto plane, default direction is orthogonal. Obsolete'''
if not direction:
direction = self.axis
t = Vector(direction)
#t.normalize()
a = round(t.getAngle(self.axis), DraftVecUtils.precision())
pp = round((math.pi) / 2, DraftVecUtils.precision())
if a == pp:
return p
t.multiply(self.offsetToPoint(p, direction))
return p.add(t)
def alignToPointAndAxis(self, point, axis, offset, upvec=None):
self.doc = FreeCAD.ActiveDocument
self.axis = axis
self.axis.normalize()
if (DraftVecUtils.equals(axis, Vector(1, 0, 0))):
self.u = Vector(0, 1, 0)
self.v = Vector(0, 0, 1)
elif (DraftVecUtils.equals(axis, Vector(-1, 0, 0))):
self.u = Vector(0, -1, 0)
self.v = Vector(0, 0, 1)
elif upvec:
self.v = upvec
self.v.normalize()
self.u = self.v.cross(self.axis)
else:
self.v = axis.cross(Vector(1, 0, 0))
self.v.normalize()
self.u = DraftVecUtils.rotate(self.v, -math.pi / 2, self.axis)
offsetVector = Vector(axis)
offsetVector.multiply(offset)
self.position = point.add(offsetVector)
self.weak = False
# FreeCAD.Console.PrintMessage("(position = " + str(self.position) + ")\n")
# FreeCAD.Console.PrintMessage("Current workplane: x="+str(DraftVecUtils.rounded(self.u))+" y="+str(DraftVecUtils.rounded(self.v))+" z="+str(DraftVecUtils.rounded(self.axis))+"\n")
def alignToCurve(self, shape, offset):
if shape.ShapeType == 'Edge':
#??? TODO: process curve here. look at shape.edges[0].Curve
return False
elif shape.ShapeType == 'Wire':
#??? TODO: determine if edges define a plane
return False
else:
return False
def alignToEdges(self, edges):
# use a list of edges to find a plane position
if len(edges) > 2:
return False
# for axes systems, we suppose the 2 first edges are parallel
# ??? TODO: exclude other cases first
v1 = edges[0].Vertexes[-1].Point.sub(edges[0].Vertexes[0].Point)
v2 = edges[1].Vertexes[0].Point.sub(edges[0].Vertexes[0].Point)
v3 = v1.cross(v2)
v1.normalize()
v2.normalize()
v3.normalize()
#print v1,v2,v3
self.u = v1
self.v = v2
self.axis = v3
def alignToFace(self, shape, offset=0):
# Set face to the unique selected face, if found
if shape.ShapeType == 'Face':
#we should really use face.tangentAt to get u and v here, and implement alignToUVPoint
self.alignToPointAndAxis(shape.Faces[0].CenterOfMass,
shape.Faces[0].normalAt(0, 0), offset)
return True
else:
return False
def alignToSelection(self, offset):
'''If selection uniquely defines a plane, align working plane to it. Return success (bool)'''
sex = FreeCADGui.Selection.getSelectionEx(FreeCAD.ActiveDocument.Name)
if len(sex) == 0:
return False
elif len(sex) == 1:
if not sex[0].Object.isDerivedFrom("Part::Shape"):
return False
return self.alignToCurve(sex[0].Object.Shape, offset) \
or self.alignToFace(sex[0].Object.Shape, offset) \
or (len(sex[0].SubObjects) == 1 and self.alignToFace(sex[0].SubObjects[0], offset))
else:
# len(sex) > 2, look for point and line, three points, etc.
return False
def setup(self, direction=None, point=None, upvec=None):
'''If working plane is undefined, define it!'''
if self.weak:
if direction and point:
self.alignToPointAndAxis(point, direction, 0, upvec)
else:
try:
from pivy import coin
rot = FreeCADGui.ActiveDocument.ActiveView.getCameraNode(
).getField("orientation").getValue()
upvec = Vector(
rot.multVec(coin.SbVec3f(0, 1, 0)).getValue())
vdir = FreeCADGui.ActiveDocument.ActiveView.getViewDirection(
)
self.alignToPointAndAxis(Vector(0, 0, 0), vdir.negative(),
0, upvec)
except:
print "Draft: Unable to align the working plane to the current view"
self.weak = True
def reset(self):
self.doc = None
self.weak = True
def getRotation(self):
"returns a placement describing the working plane orientation ONLY"
m = DraftVecUtils.getPlaneRotation(self.u, self.v, self.axis)
return FreeCAD.Placement(m)
def getPlacement(self, rotated=False):
"returns the placement of the working plane"
if rotated:
m = FreeCAD.Matrix(self.u.x, self.axis.x, -self.v.x,
self.position.x, self.u.y, self.axis.y,
-self.v.y, self.position.y, self.u.z,
self.axis.z, -self.v.z, self.position.z, 0.0,
0.0, 0.0, 1.0)
else:
m = FreeCAD.Matrix(self.u.x, self.v.x, self.axis.x,
self.position.x, self.u.y, self.v.y,
self.axis.y, self.position.y, self.u.z,
self.v.z, self.axis.z, self.position.z, 0.0,
0.0, 0.0, 1.0)
return FreeCAD.Placement(m)
def setFromPlacement(self, pl):
"sets the working plane from a placement (rotaton ONLY)"
rot = FreeCAD.Placement(pl).Rotation
self.u = rot.multVec(FreeCAD.Vector(1, 0, 0))
self.v = rot.multVec(FreeCAD.Vector(0, 1, 0))
self.axis = rot.multVec(FreeCAD.Vector(0, 0, 1))
def save(self):
"stores the current plane state"
self.stored = [self.u, self.v, self.axis, self.position, self.weak]
def restore(self):
"restores a previously saved plane state, if exists"
if self.stored:
self.u = self.stored[0]
self.v = self.stored[1]
self.axis = self.stored[2]
self.position = self.stored[3]
self.weak = self.stored[4]
self.stored = None
def getLocalCoords(self, point):
"returns the coordinates of a given point on the working plane"
pt = point.sub(self.position)
xv = DraftVecUtils.project(pt, self.u)
x = xv.Length
if xv.getAngle(self.u) > 1:
x = -x
yv = DraftVecUtils.project(pt, self.v)
y = yv.Length
if yv.getAngle(self.v) > 1:
y = -y
zv = DraftVecUtils.project(pt, self.axis)
z = zv.Length
if zv.getAngle(self.axis) > 1:
z = -z
return Vector(x, y, z)
def getGlobalCoords(self, point):
"returns the global coordinates of the given point, taken relatively to this working plane"
vx = Vector(self.u).multiply(point.x)
vy = Vector(self.v).multiply(point.y)
vz = Vector(self.axis).multiply(point.z)
pt = (vx.add(vy)).add(vz)
return pt.add(self.position)
def getLocalRot(self, point):
"Same as getLocalCoords, but discards the WP position"
xv = DraftVecUtils.project(point, self.u)
x = xv.Length
if xv.getAngle(self.u) > 1:
x = -x
yv = DraftVecUtils.project(point, self.v)
y = yv.Length
if yv.getAngle(self.v) > 1:
y = -y
zv = DraftVecUtils.project(point, self.axis)
z = zv.Length
if zv.getAngle(self.axis) > 1:
z = -z
return Vector(x, y, z)
def getGlobalRot(self, point):
"Same as getGlobalCoords, but discards the WP position"
vx = Vector(self.u).multiply(point.x)
vy = Vector(self.v).multiply(point.y)
vz = Vector(self.axis).multiply(point.z)
pt = (vx.add(vy)).add(vz)
return pt
def getClosestAxis(self, point):
"returns which of the workingplane axes is closest from the given vector"
ax = point.getAngle(self.u)
ay = point.getAngle(self.v)
az = point.getAngle(self.axis)
bx = point.getAngle(self.u.negative())
by = point.getAngle(self.v.negative())
bz = point.getAngle(self.axis.negative())
b = min(ax, ay, az, bx, by, bz)
if b in [ax, bx]:
return "x"
elif b in [ay, by]:
return "y"
elif b in [az, bz]:
return "z"
else:
return None
def isGlobal(self):
"returns True if the plane axes are equal to the global axes"
if self.u != Vector(1, 0, 0):
return False
if self.v != Vector(0, 1, 0):
return False
if self.axis != Vector(0, 0, 1):
return False
return True
def isOrtho(self):
"returns True if the plane axes are following the global axes"
if round(self.u.getAngle(Vector(0, 1, 0)), 6) in [
0, -1.570796, 1.570796, -3.141593, 3.141593, -4.712389,
4.712389, 6.283185
]:
if round(self.v.getAngle(Vector(0, 1, 0)), 6) in [
0, -1.570796, 1.570796, -3.141593, 3.141593, -4.712389,
4.712389, 6.283185
]:
if round(self.axis.getAngle(Vector(0, 1, 0)), 6) in [
0, -1.570796, 1.570796, -3.141593, 3.141593, -4.712389,
4.712389, 6.283185
]:
return True
return False
def getDeviation(self):
"returns the deviation angle between the u axis and the horizontal plane"
proj = Vector(self.u.x, self.u.y, 0)
if self.u.getAngle(proj) == 0:
return 0
else:
norm = proj.cross(self.u)
return DraftVecUtils.angle(self.u, proj, norm)
def getExtrusionData(self,obj):
"""returns (shape,extrusion vector,placement) or None"""
import Part,DraftGeomUtils
data = ArchComponent.Component.getExtrusionData(self,obj)
if data:
if not isinstance(data[0],list):
# multifuses not considered here
return data
length = obj.Length.Value
width = obj.Width.Value
height = obj.Height.Value
if not height:
for p in obj.InList:
if Draft.getType(p) in ["Floor","BuildingPart"]:
if p.Height.Value:
height = p.Height.Value
if not height:
return None
if obj.Normal == Vector(0,0,0):
normal = Vector(0,0,1)
else:
normal = Vector(obj.Normal)
base = None
placement = None
self.basewires = None
# build wall layers
layers = []
if hasattr(obj,"Material"):
if obj.Material:
if hasattr(obj.Material,"Materials"):
varwidth = 0
restwidth = width - sum(obj.Material.Thicknesses)
if restwidth > 0:
varwidth = [t for t in obj.Material.Thicknesses if t == 0]
if varwidth:
varwidth = restwidth/len(varwidth)
for t in obj.Material.Thicknesses:
if t:
layers.append(t)
elif varwidth:
layers.append(varwidth)
if obj.Base:
if obj.Base.isDerivedFrom("Part::Feature"):
if obj.Base.Shape:
if obj.Base.Shape.Solids:
return None
elif obj.Face > 0:
if len(obj.Base.Shape.Faces) >= obj.Face:
face = obj.Base.Shape.Faces[obj.Face-1]
# this wall is based on a specific face of its base object
if obj.Normal != Vector(0,0,0):
normal = face.normalAt(0,0)
if normal.getAngle(Vector(0,0,1)) > math.pi/4:
normal.multiply(width)
base = face.extrude(normal)
if obj.Align == "Center":
base.translate(normal.negative().multiply(0.5))
elif obj.Align == "Right":
base.translate(normal.negative())
else:
normal.multiply(height)
base = face.extrude(normal)
base,placement = self.rebase(base)
return (base,normal,placement)
elif obj.Base.Shape.Faces:
if not DraftGeomUtils.isCoplanar(obj.Base.Shape.Faces):
return None
else:
base,placement = self.rebase(obj.Base.Shape)
elif len(obj.Base.Shape.Edges) == 1:
self.basewires = [Part.Wire(obj.Base.Shape.Edges)]
else:
# self.basewires = obj.Base.Shape.Wires
self.basewires = []
for cluster in Part.getSortedClusters(obj.Base.Shape.Edges):
for c in Part.sortEdges(cluster):
self.basewires.append(Part.Wire(c))
if self.basewires and width:
if (len(self.basewires) == 1) and layers:
self.basewires = [self.basewires[0] for l in layers]
layeroffset = 0
baseface = None
for i,wire in enumerate(self.basewires):
e = wire.Edges[0]
if isinstance(e.Curve,Part.Circle):
dvec = e.Vertexes[0].Point.sub(e.Curve.Center)
else:
dvec = DraftGeomUtils.vec(wire.Edges[0]).cross(normal)
if not DraftVecUtils.isNull(dvec):
dvec.normalize()
sh = None
if obj.Align == "Left":
off = obj.Offset.Value
if layers:
off = off+layeroffset
dvec.multiply(layers[i])
layeroffset += layers[i]
else:
dvec.multiply(width)
if off:
dvec2 = DraftVecUtils.scaleTo(dvec,off)
wire = DraftGeomUtils.offsetWire(wire,dvec2)
w2 = DraftGeomUtils.offsetWire(wire,dvec)
w1 = Part.Wire(Part.__sortEdges__(wire.Edges))
sh = DraftGeomUtils.bind(w1,w2)
elif obj.Align == "Right":
dvec = dvec.negative()
off = obj.Offset.Value
if layers:
off = off+layeroffset
dvec.multiply(layers[i])
layeroffset += layers[i]
else:
dvec.multiply(width)
if off:
dvec2 = DraftVecUtils.scaleTo(dvec,off)
wire = DraftGeomUtils.offsetWire(wire,dvec2)
w2 = DraftGeomUtils.offsetWire(wire,dvec)
w1 = Part.Wire(Part.__sortEdges__(wire.Edges))
sh = DraftGeomUtils.bind(w1,w2)
elif obj.Align == "Center":
if layers:
off = width/2-layeroffset
d1 = Vector(dvec).multiply(off)
w1 = DraftGeomUtils.offsetWire(wire,d1)
layeroffset += layers[i]
off = width/2-layeroffset
d1 = Vector(dvec).multiply(off)
w2 = DraftGeomUtils.offsetWire(wire,d1)
else:
dvec.multiply(width/2)
w1 = DraftGeomUtils.offsetWire(wire,dvec)
dvec = dvec.negative()
w2 = DraftGeomUtils.offsetWire(wire,dvec)
sh = DraftGeomUtils.bind(w1,w2)
if sh:
sh.fix(0.1,0,1) # fixes self-intersecting wires
f = Part.Face(sh)
if baseface:
if layers:
baseface.append(f)
else:
baseface = baseface.fuse(f)
# baseface = baseface.removeSplitter()
s = DraftGeomUtils.removeSplitter(baseface)
if s:
baseface = s
else:
if layers:
baseface = [f]
else:
baseface = f
if baseface:
base,placement = self.rebase(baseface)
else:
if layers:
totalwidth = sum(layers)
offset = 0
base = []
for l in layers:
l2 = length/2 or 0.5
w1 = -totalwidth/2 + offset
w2 = w1 + l
v1 = Vector(-l2,w1,0)
v2 = Vector(l2,w1,0)
v3 = Vector(l2,w2,0)
v4 = Vector(-l2,w2,0)
base.append(Part.Face(Part.makePolygon([v1,v2,v3,v4,v1])))
offset += l
else:
l2 = length/2 or 0.5
w2 = width/2 or 0.5
v1 = Vector(-l2,-w2,0)
v2 = Vector(l2,-w2,0)
v3 = Vector(l2,w2,0)
v4 = Vector(-l2,w2,0)
base = Part.Face(Part.makePolygon([v1,v2,v3,v4,v1]))
placement = FreeCAD.Placement()
if base and placement:
extrusion = normal.multiply(height)
if placement.Rotation.Angle > 0:
extrusion = placement.inverse().Rotation.multVec(extrusion)
return (base,extrusion,placement)
return None
def execute(self, obj):
"creates the panel shape"
if self.clone(obj):
return
import Part, DraftGeomUtils
# base tests
if obj.Base:
if obj.Base.isDerivedFrom("Part::Feature"):
if obj.Base.Shape.isNull():
return
elif obj.Base.isDerivedFrom("Mesh::Feature"):
if not obj.Base.Mesh.isSolid():
return
else:
if obj.Length.Value:
length = obj.Length.Value
else:
return
if obj.Width.Value:
width = obj.Width.Value
else:
return
if obj.Thickness.Value:
thickness = obj.Thickness.Value
else:
if not obj.Base:
return
elif obj.Base.isDerivedFrom("Part::Feature"):
if not obj.Base.Shape.Solids:
return
# creating base shape
pl = obj.Placement
base = None
normal = None
if hasattr(obj, "Normal"):
if obj.Normal.Length > 0:
normal = Vector(obj.Normal)
normal.normalize()
normal.multiply(thickness)
baseprofile = None
if obj.Base:
base = obj.Base.Shape.copy()
if not base.Solids:
p = FreeCAD.Placement(obj.Base.Placement)
if base.Faces:
baseprofile = base
if not normal:
normal = baseprofile.Faces[0].normalAt(
0, 0).multiply(thickness)
base = base.extrude(normal)
elif base.Wires:
fm = False
if hasattr(obj, "FaceMaker"):
if obj.FaceMaker != "None":
try:
base = Part.makeFace(
base.Wires,
"Part::FaceMaker" + str(obj.FaceMaker))
fm = True
except:
FreeCAD.Console.PrintError(
translate("Arch",
"Facemaker returned an error") +
"\n")
return
if not fm:
closed = True
for w in base.Wires:
if not w.isClosed():
closed = False
if closed:
baseprofile = ArchCommands.makeFace(base.Wires)
if not normal:
normal = baseprofile.normalAt(
0, 0).multiply(thickness)
base = baseprofile.extrude(normal)
elif obj.Base.isDerivedFrom("Mesh::Feature"):
if obj.Base.Mesh.isSolid():
if obj.Base.Mesh.countComponents() == 1:
sh = ArchCommands.getShapeFromMesh(obj.Base.Mesh)
if sh.isClosed() and sh.isValid() and sh.Solids:
base = sh
else:
if not normal:
normal = Vector(0, 0, 1).multiply(thickness)
l2 = length / 2 or 0.5
w2 = width / 2 or 0.5
v1 = Vector(-l2, -w2, 0)
v2 = Vector(l2, -w2, 0)
v3 = Vector(l2, w2, 0)
v4 = Vector(-l2, w2, 0)
base = Part.makePolygon([v1, v2, v3, v4, v1])
baseprofile = Part.Face(base)
base = baseprofile.extrude(normal)
if hasattr(obj, "Area"):
if baseprofile:
obj.Area = baseprofile.Area
if hasattr(obj, "WaveLength"):
if baseprofile and obj.WaveLength.Value and obj.WaveHeight.Value:
# corrugated element
bb = baseprofile.BoundBox
bb.enlarge(bb.DiagonalLength)
p1 = Vector(bb.getPoint(0).x, bb.getPoint(0).y, bb.Center.z)
if obj.WaveType == "Curved":
p2 = p1.add(
Vector(obj.WaveLength.Value / 2, 0,
obj.WaveHeight.Value))
p3 = p2.add(
Vector(obj.WaveLength.Value / 2, 0,
-obj.WaveHeight.Value))
e1 = Part.Arc(p1, p2, p3).toShape()
p4 = p3.add(
Vector(obj.WaveLength.Value / 2, 0,
-obj.WaveHeight.Value))
p5 = p4.add(
Vector(obj.WaveLength.Value / 2, 0,
obj.WaveHeight.Value))
e2 = Part.Arc(p3, p4, p5).toShape()
else:
if obj.WaveHeight.Value < obj.WaveLength.Value:
p2 = p1.add(
Vector(obj.WaveHeight.Value, 0,
obj.WaveHeight.Value))
p3 = p2.add(
Vector(
obj.WaveLength.Value -
2 * obj.WaveHeight.Value, 0, 0))
p4 = p3.add(
Vector(obj.WaveHeight.Value, 0,
-obj.WaveHeight.Value))
e1 = Part.makePolygon([p1, p2, p3, p4])
p5 = p4.add(
Vector(obj.WaveHeight.Value, 0,
-obj.WaveHeight.Value))
p6 = p5.add(
Vector(
obj.WaveLength.Value -
2 * obj.WaveHeight.Value, 0, 0))
p7 = p6.add(
Vector(obj.WaveHeight.Value, 0,
obj.WaveHeight.Value))
e2 = Part.makePolygon([p4, p5, p6, p7])
else:
p2 = p1.add(
Vector(obj.WaveLength.Value / 2, 0,
obj.WaveHeight.Value))
p3 = p2.add(
Vector(obj.WaveLength.Value / 2, 0,
-obj.WaveHeight.Value))
e1 = Part.makePolygon([p1, p2, p3])
p4 = p3.add(
Vector(obj.WaveLength.Value / 2, 0,
-obj.WaveHeight.Value))
p5 = p4.add(
Vector(obj.WaveLength.Value / 2, 0,
obj.WaveHeight.Value))
e2 = Part.makePolygon([p3, p4, p5])
edges = [e1, e2]
for i in range(int(bb.XLength / (obj.WaveLength.Value * 2))):
e1 = e1.copy()
e1.translate(Vector(obj.WaveLength.Value * 2, 0, 0))
e2 = e2.copy()
e2.translate(Vector(obj.WaveLength.Value * 2, 0, 0))
edges.extend([e1, e2])
basewire = Part.Wire(edges)
baseface = basewire.extrude(Vector(0, bb.YLength, 0))
base = baseface.extrude(Vector(0, 0, thickness))
rot = FreeCAD.Rotation(FreeCAD.Vector(0, 0, 1), normal)
base.rotate(bb.Center, rot.Axis, math.degrees(rot.Angle))
if obj.WaveDirection.Value:
base.rotate(bb.Center, normal, obj.WaveDirection.Value)
n1 = normal.negative().normalize().multiply(
obj.WaveHeight.Value * 2)
self.vol = baseprofile.copy()
self.vol.translate(n1)
self.vol = self.vol.extrude(n1.negative().multiply(2))
base = self.vol.common(base)
base = base.removeSplitter()
if not base:
FreeCAD.Console.PrintError(
transpate("Arch", "Error computing shape of ") +
obj.Label + "\n")
return False
if base and (obj.Sheets > 1) and normal and thickness:
bases = [base]
for i in range(1, obj.Sheets):
n = FreeCAD.Vector(normal).normalize().multiply(i * thickness)
b = base.copy()
b.translate(n)
bases.append(b)
base = Part.makeCompound(bases)
if base and normal and hasattr(obj, "Offset"):
if obj.Offset.Value:
v = DraftVecUtils.scaleTo(normal, obj.Offset.Value)
base.translate(v)
# process subshapes
base = self.processSubShapes(obj, base, pl)
# applying
if base:
if not base.isNull():
if base.isValid() and base.Solids:
if base.Volume < 0:
base.reverse()
if base.Volume < 0:
FreeCAD.Console.PrintError(
translate("Arch", "Couldn't compute a shape"))
return
base = base.removeSplitter()
obj.Shape = base
if not pl.isNull():
obj.Placement = pl
def getExtrusionData(self,obj):
"""returns (shape,extrusion vector,placement) or None"""
import Part,DraftGeomUtils
data = ArchComponent.Component.getExtrusionData(self,obj)
if data:
if not isinstance(data[0],list):
# multifuses not considered here
return data
length = obj.Length.Value
width = obj.Width.Value
height = obj.Height.Value
if not height:
for p in obj.InList:
if Draft.getType(p) == "Floor":
if p.Height.Value:
height = p.Height.Value
if obj.Normal == Vector(0,0,0):
normal = Vector(0,0,1)
else:
normal = Vector(obj.Normal)
base = None
placement = None
basewires = None
if obj.Base:
if obj.Base.isDerivedFrom("Part::Feature"):
if obj.Base.Shape:
if obj.Base.Shape.Solids:
return None
elif obj.Face > 0:
if len(obj.Base.Shape.Faces) >= obj.Face:
face = obj.Base.Shape.Faces[obj.Face-1]
# this wall is based on a specific face of its base object
normal = face.normalAt(0,0)
if normal.getAngle(Vector(0,0,1)) > math.pi/4:
normal.multiply(width)
base = face.extrude(normal)
if obj.Align == "Center":
base.translate(normal.negative().multiply(0.5))
elif obj.Align == "Right":
base.translate(normal.negative())
else:
normal.multiply(height)
base = face.extrude(normal)
base,placement = self.rebase(base)
return (base,normal,placement)
elif obj.Base.Shape.Faces:
if not DraftGeomUtils.isCoplanar(obj.Base.Shape.Faces):
return None
else:
base,placement = self.rebase(obj.Base.Shape)
elif obj.Base.Shape.Wires:
basewires = obj.Base.Shape.Wires
elif len(obj.Base.Shape.Edges) == 1:
basewires = [Part.Wire(obj.Base.Shape.Edges)]
if basewires and width:
baseface = None
for wire in basewires:
e = wire.Edges[0]
if isinstance(e.Curve,Part.Circle):
dvec = e.Vertexes[0].Point.sub(e.Curve.Center)
else:
dvec = DraftGeomUtils.vec(wire.Edges[0]).cross(normal)
if not DraftVecUtils.isNull(dvec):
dvec.normalize()
sh = None
if obj.Align == "Left":
dvec.multiply(width)
if obj.Offset.Value:
dvec2 = DraftVecUtils.scaleTo(dvec,obj.Offset.Value)
wire = DraftGeomUtils.offsetWire(wire,dvec2)
w2 = DraftGeomUtils.offsetWire(wire,dvec)
w1 = Part.Wire(Part.__sortEdges__(wire.Edges))
sh = DraftGeomUtils.bind(w1,w2)
elif obj.Align == "Right":
dvec.multiply(width)
dvec = dvec.negative()
if obj.Offset.Value:
dvec2 = DraftVecUtils.scaleTo(dvec,obj.Offset.Value)
wire = DraftGeomUtils.offsetWire(wire,dvec2)
w2 = DraftGeomUtils.offsetWire(wire,dvec)
w1 = Part.Wire(Part.__sortEdges__(wire.Edges))
sh = DraftGeomUtils.bind(w1,w2)
elif obj.Align == "Center":
dvec.multiply(width/2)
w1 = DraftGeomUtils.offsetWire(wire,dvec)
dvec = dvec.negative()
w2 = DraftGeomUtils.offsetWire(wire,dvec)
sh = DraftGeomUtils.bind(w1,w2)
if sh:
sh.fix(0.1,0,1) # fixes self-intersecting wires
f = Part.Face(sh)
if baseface:
baseface = baseface.fuse(f)
else:
baseface = f
if baseface:
base,placement = self.rebase(baseface)
else:
l2 = length/2 or 0.5
w2 = width/2 or 0.5
v1 = Vector(-l2,-w2,0)
v2 = Vector(l2,-w2,0)
v3 = Vector(l2,w2,0)
v4 = Vector(-l2,w2,0)
base = Part.Face(Part.makePolygon([v1,v2,v3,v4,v1]))
placement = FreeCAD.Placement()
if base and placement:
extrusion = normal.multiply(height)
return (base,extrusion,placement)
return None
def execute(self,obj):
"creates the panel shape"
if self.clone(obj):
return
import Part, DraftGeomUtils
# base tests
if obj.Base:
if obj.Base.isDerivedFrom("Part::Feature"):
if obj.Base.Shape.isNull():
return
elif obj.Base.isDerivedFrom("Mesh::Feature"):
if not obj.Base.Mesh.isSolid():
return
else:
if obj.Length.Value:
length = obj.Length.Value
else:
return
if obj.Width.Value:
width = obj.Width.Value
else:
return
if obj.Thickness.Value:
thickness = obj.Thickness.Value
else:
if not obj.Base:
return
elif obj.Base.isDerivedFrom("Part::Feature"):
if not obj.Base.Shape.Solids:
return
# creating base shape
pl = obj.Placement
base = None
normal = None
baseprofile = None
if obj.Base:
base = obj.Base.Shape.copy()
if not base.Solids:
p = FreeCAD.Placement(obj.Base.Placement)
if base.Faces:
baseprofile = base
normal = baseprofile.Faces[0].normalAt(0,0).multiply(thickness)
base = base.extrude(normal)
elif base.Wires:
closed = True
for w in base.Wires:
if not w.isClosed():
closed = False
if closed:
baseprofile = ArchCommands.makeFace(base.Wires)
normal = baseprofile.normalAt(0,0).multiply(thickness)
base = baseprofile.extrude(normal)
elif obj.Base.isDerivedFrom("Mesh::Feature"):
if obj.Base.Mesh.isSolid():
if obj.Base.Mesh.countComponents() == 1:
sh = ArchCommands.getShapeFromMesh(obj.Base.Mesh)
if sh.isClosed() and sh.isValid() and sh.Solids:
base = sh
else:
normal = Vector(0,0,1).multiply(thickness)
l2 = length/2 or 0.5
w2 = width/2 or 0.5
v1 = Vector(-l2,-w2,0)
v2 = Vector(l2,-w2,0)
v3 = Vector(l2,w2,0)
v4 = Vector(-l2,w2,0)
base = Part.makePolygon([v1,v2,v3,v4,v1])
baseprofile = Part.Face(base)
base = baseprofile.extrude(normal)
if hasattr(obj,"Area"):
if baseprofile:
obj.Area = baseprofile.Area
if hasattr(obj,"WaveLength"):
if baseprofile and obj.WaveLength.Value and obj.WaveHeight.Value:
# corrugated element
bb = baseprofile.BoundBox
bb.enlarge(bb.DiagonalLength)
p1 = Vector(bb.getPoint(0).x,bb.getPoint(0).y,bb.Center.z)
if obj.WaveType == "Curved":
p2 = p1.add(Vector(obj.WaveLength.Value/2,0,obj.WaveHeight.Value))
p3 = p2.add(Vector(obj.WaveLength.Value/2,0,-obj.WaveHeight.Value))
e1 = Part.Arc(p1,p2,p3).toShape()
p4 = p3.add(Vector(obj.WaveLength.Value/2,0,-obj.WaveHeight.Value))
p5 = p4.add(Vector(obj.WaveLength.Value/2,0,obj.WaveHeight.Value))
e2 = Part.Arc(p3,p4,p5).toShape()
else:
if obj.WaveHeight.Value < obj.WaveLength.Value:
p2 = p1.add(Vector(obj.WaveHeight.Value,0,obj.WaveHeight.Value))
p3 = p2.add(Vector(obj.WaveLength.Value-2*obj.WaveHeight.Value,0,0))
p4 = p3.add(Vector(obj.WaveHeight.Value,0,-obj.WaveHeight.Value))
e1 = Part.makePolygon([p1,p2,p3,p4])
p5 = p4.add(Vector(obj.WaveHeight.Value,0,-obj.WaveHeight.Value))
p6 = p5.add(Vector(obj.WaveLength.Value-2*obj.WaveHeight.Value,0,0))
p7 = p6.add(Vector(obj.WaveHeight.Value,0,obj.WaveHeight.Value))
e2 = Part.makePolygon([p4,p5,p6,p7])
else:
p2 = p1.add(Vector(obj.WaveLength.Value/2,0,obj.WaveHeight.Value))
p3 = p2.add(Vector(obj.WaveLength.Value/2,0,-obj.WaveHeight.Value))
e1 = Part.makePolygon([p1,p2,p3])
p4 = p3.add(Vector(obj.WaveLength.Value/2,0,-obj.WaveHeight.Value))
p5 = p4.add(Vector(obj.WaveLength.Value/2,0,obj.WaveHeight.Value))
e2 = Part.makePolygon([p3,p4,p5])
edges = [e1,e2]
for i in range(int(bb.XLength/(obj.WaveLength.Value*2))):
e1 = e1.copy()
e1.translate(Vector(obj.WaveLength.Value*2,0,0))
e2 = e2.copy()
e2.translate(Vector(obj.WaveLength.Value*2,0,0))
edges.extend([e1,e2])
basewire = Part.Wire(edges)
baseface = basewire.extrude(Vector(0,bb.YLength,0))
base = baseface.extrude(Vector(0,0,thickness))
rot = FreeCAD.Rotation(FreeCAD.Vector(0,0,1),normal)
base.rotate(bb.Center,rot.Axis,math.degrees(rot.Angle))
if obj.WaveDirection.Value:
base.rotate(bb.Center,normal,obj.WaveDirection.Value)
n1 = normal.negative().normalize().multiply(obj.WaveHeight.Value*2)
self.vol = baseprofile.copy()
self.vol.translate(n1)
self.vol = self.vol.extrude(n1.negative().multiply(2))
base = self.vol.common(base)
base = base.removeSplitter()
if not base:
FreeCAD.Console.PrintError(transpate("Arch","Error computing shape of ")+obj.Label+"\n")
return False
if base and (obj.Sheets > 1) and normal and thickness:
bases = [base]
for i in range(1,obj.Sheets):
n = FreeCAD.Vector(normal).normalize().multiply(i*thickness)
b = base.copy()
b.translate(n)
bases.append(b)
base = Part.makeCompound(bases)
if base and normal and hasattr(obj,"Offset"):
if obj.Offset.Value:
v = DraftVecUtils.scaleTo(normal,obj.Offset.Value)
base.translate(v)
# process subshapes
base = self.processSubShapes(obj,base,pl)
# applying
if base:
if not base.isNull():
if base.isValid() and base.Solids:
if base.Volume < 0:
base.reverse()
if base.Volume < 0:
FreeCAD.Console.PrintError(translate("Arch","Couldn't compute a shape"))
return
base = base.removeSplitter()
obj.Shape = base
if not pl.isNull():
obj.Placement = pl
class plane:
'''A WorkPlane object'''
def __init__(self,u=Vector(1,0,0),v=Vector(0,1,0),w=Vector(0,0,1),pos=Vector(0,0,0)):
# keep track of active document. Reset view when doc changes.
self.doc = None
# self.weak is true if the plane has been defined by self.setup or has been reset
self.weak = True
# u, v axes and position define plane, perpendicular axis is handy, though redundant.
self.u = u
self.v = v
self.axis = w
self.position = pos
# a placeholder for a stored state
self.stored = None
def __repr__(self):
return "Workplane x="+str(DraftVecUtils.rounded(self.u))+" y="+str(DraftVecUtils.rounded(self.v))+" z="+str(DraftVecUtils.rounded(self.axis))
def copy(self):
return plane(u=self.u,v=self.v,w=self.axis,pos=self.position)
def offsetToPoint(self, p, direction=None):
'''
Return the signed distance from p to the plane, such
that p + offsetToPoint(p)*direction lies on the plane.
direction defaults to -plane.axis
'''
'''
A picture will help explain the computation:
p
//|
/ / |
/ / |
/ / |
/ / |
-------------------- plane -----c-----x-----a--------
Here p is the specified point,
c is a point (in this case plane.position) on the plane
x is the intercept on the plane from p in the specified direction, and
a is the perpendicular intercept on the plane (i.e. along plane.axis)
Using vertival bars to denote the length operator,
|ap| = |cp| * cos(apc) = |xp| * cos(apx)
so
|xp| = |cp| * cos(apc) / cos(apx)
= (cp . axis) / (direction . axis)
'''
if direction == None: direction = self.axis
return direction.dot(self.position.sub(p))
def projectPoint(self, p, direction=None):
'''project point onto plane, default direction is orthogonal'''
if not direction:
direction = self.axis
lp = self.getLocalCoords(p)
gp = self.getGlobalCoords(Vector(lp.x,lp.y,0))
a = direction.getAngle(gp.sub(p))
if a > math.pi/2:
direction = direction.negative()
a = math.pi - a
ld = self.getLocalRot(direction)
gd = self.getGlobalRot(Vector(ld.x,ld.y,0))
hyp = abs(math.tan(a) * lp.z)
return gp.add(DraftVecUtils.scaleTo(gd,hyp))
def projectPointOld(self, p, direction=None):
'''project point onto plane, default direction is orthogonal. Obsolete'''
if not direction:
direction = self.axis
t = Vector(direction)
#t.normalize()
a = round(t.getAngle(self.axis),DraftVecUtils.precision())
pp = round((math.pi)/2,DraftVecUtils.precision())
if a == pp:
return p
t.multiply(self.offsetToPoint(p, direction))
return p.add(t)
def alignToPointAndAxis(self, point, axis, offset=0, upvec=None):
self.doc = FreeCAD.ActiveDocument
self.axis = axis;
self.axis.normalize()
if axis.getAngle(Vector(1,0,0)) < 0.00001:
self.axis = Vector(1,0,0)
self.u = Vector(0,1,0)
self.v = Vector(0,0,1)
elif axis.getAngle(Vector(-1,0,0)) < 0.00001:
self.axis = Vector(-1,0,0)
self.u = Vector(0,-1,0)
self.v = Vector(0,0,1)
elif upvec:
self.v = upvec
self.v.normalize()
self.u = self.v.cross(self.axis)
else:
self.v = axis.cross(Vector(1,0,0))
self.v.normalize()
self.u = DraftVecUtils.rotate(self.v, -math.pi/2, self.axis)
offsetVector = Vector(axis); offsetVector.multiply(offset)
self.position = point.add(offsetVector)
self.weak = False
# FreeCAD.Console.PrintMessage("(position = " + str(self.position) + ")\n")
# FreeCAD.Console.PrintMessage("Current workplane: x="+str(DraftVecUtils.rounded(self.u))+" y="+str(DraftVecUtils.rounded(self.v))+" z="+str(DraftVecUtils.rounded(self.axis))+"\n")
def alignToPointAndAxis_SVG(self, point, axis, offset):
# based on cases table
self.doc = FreeCAD.ActiveDocument
self.axis = axis;
self.axis.normalize()
ref_vec = Vector(0.0, 1.0, 0.0)
if ((abs(axis.x) > abs(axis.y)) and (abs(axis.y) > abs(axis.z))):
ref_vec = Vector(0.0, 0., 1.0)
self.u = axis.negative().cross(ref_vec)
self.u.normalize()
self.v = DraftVecUtils.rotate(self.u, math.pi/2, self.axis)
#projcase = "Case new"
elif ((abs(axis.y) > abs(axis.z)) and (abs(axis.z) >= abs(axis.x))):
ref_vec = Vector(1.0, 0.0, 0.0)
self.u = axis.negative().cross(ref_vec)
self.u.normalize()
self.v = DraftVecUtils.rotate(self.u, math.pi/2, self.axis)
#projcase = "Y>Z, View Y"
elif ((abs(axis.y) >= abs(axis.x)) and (abs(axis.x) > abs(axis.z))):
ref_vec = Vector(0.0, 0., 1.0)
self.u = axis.cross(ref_vec)
self.u.normalize()
self.v = DraftVecUtils.rotate(self.u, math.pi/2, self.axis)
#projcase = "ehem. XY, Case XY"
elif ((abs(axis.x) > abs(axis.z)) and (abs(axis.z) >= abs(axis.y))):
self.u = axis.cross(ref_vec)
self.u.normalize()
self.v = DraftVecUtils.rotate(self.u, math.pi/2, self.axis)
#projcase = "X>Z, View X"
elif ((abs(axis.z) >= abs(axis.y)) and (abs(axis.y) > abs(axis.x))):
ref_vec = Vector(1.0, 0., 0.0)
self.u = axis.cross(ref_vec)
self.u.normalize()
self.v = DraftVecUtils.rotate(self.u, math.pi/2, self.axis)
#projcase = "Y>X, Case YZ"
else:
self.u = axis.negative().cross(ref_vec)
self.u.normalize()
self.v = DraftVecUtils.rotate(self.u, math.pi/2, self.axis)
#projcase = "else"
#spat_vec = self.u.cross(self.v)
#spat_res = spat_vec.dot(axis)
#FreeCAD.Console.PrintMessage(projcase + " spat Prod = " + str(spat_res) + "\n")
offsetVector = Vector(axis); offsetVector.multiply(offset)
self.position = point.add(offsetVector)
self.weak = False
# FreeCAD.Console.PrintMessage("(position = " + str(self.position) + ")\n")
# FreeCAD.Console.PrintMessage("Current workplane: x="+str(DraftVecUtils.rounded(self.u))+" y="+str(DraftVecUtils.rounded(self.v))+" z="+str(DraftVecUtils.rounded(self.axis))+"\n")
def alignToCurve(self, shape, offset):
if shape.ShapeType == 'Edge':
#??? TODO: process curve here. look at shape.edges[0].Curve
return False
elif shape.ShapeType == 'Wire':
#??? TODO: determine if edges define a plane
return False
else:
return False
def alignToEdges(self,edges):
# use a list of edges to find a plane position
if len(edges) > 2:
return False
# for axes systems, we suppose the 2 first edges are parallel
# ??? TODO: exclude other cases first
v1 = edges[0].Vertexes[-1].Point.sub(edges[0].Vertexes[0].Point)
v2 = edges[1].Vertexes[0].Point.sub(edges[0].Vertexes[0].Point)
v3 = v1.cross(v2)
v1.normalize()
v2.normalize()
v3.normalize()
#print v1,v2,v3
self.u = v1
self.v = v2
self.axis = v3
def alignToFace(self, shape, offset=0):
# Set face to the unique selected face, if found
if shape.ShapeType == 'Face':
self.alignToPointAndAxis(shape.Faces[0].CenterOfMass, shape.Faces[0].normalAt(0,0), offset)
import DraftGeomUtils
q = DraftGeomUtils.getQuad(shape)
if q:
self.u = q[1]
self.v = q[2]
if not DraftVecUtils.equals(self.u.cross(self.v),self.axis):
self.u = q[2]
self.v = q[1]
if DraftVecUtils.equals(self.u,Vector(0,0,1)):
# the X axis is vertical: rotate 90 degrees
self.u,self.v = self.v.negative(),self.u
elif DraftVecUtils.equals(self.u,Vector(0,0,-1)):
self.u,self.v = self.v,self.u.negative()
self.weak = False
return True
else:
return False
def alignTo3Points(self,p1,p2,p3,offset=0):
import Part
w = Part.makePolygon([p1,p2,p3,p1])
f = Part.Face(w)
return self.alignToFace(f,offset)
def alignToSelection(self, offset):
'''If selection uniquely defines a plane, align working plane to it. Return success (bool)'''
import FreeCADGui
sex = FreeCADGui.Selection.getSelectionEx(FreeCAD.ActiveDocument.Name)
if len(sex) == 0:
return False
elif len(sex) == 1:
if not sex[0].Object.isDerivedFrom("Part::Shape"):
return False
return self.alignToCurve(sex[0].Object.Shape, offset) \
or self.alignToFace(sex[0].Object.Shape, offset) \
or (len(sex[0].SubObjects) == 1 and self.alignToFace(sex[0].SubObjects[0], offset))
else:
# len(sex) > 2, look for point and line, three points, etc.
return False
def setup(self, direction=None, point=None, upvec=None):
'''If working plane is undefined, define it!'''
if self.weak:
if direction and point:
self.alignToPointAndAxis(point, direction, 0, upvec)
else:
try:
import FreeCADGui
from pivy import coin
rot = FreeCADGui.ActiveDocument.ActiveView.getCameraNode().getField("orientation").getValue()
upvec = Vector(rot.multVec(coin.SbVec3f(0,1,0)).getValue())
vdir = FreeCADGui.ActiveDocument.ActiveView.getViewDirection()
self.alignToPointAndAxis(Vector(0,0,0), vdir.negative(), 0, upvec)
except:
pass
self.weak = True
def reset(self):
self.doc = None
self.weak = True
def getRotation(self):
"returns a placement describing the working plane orientation ONLY"
m = DraftVecUtils.getPlaneRotation(self.u,self.v,self.axis)
p = FreeCAD.Placement(m)
# Arch active container
if FreeCAD.GuiUp:
import FreeCADGui
if FreeCADGui.ActiveDocument.ActiveView:
a = FreeCADGui.ActiveDocument.ActiveView.getActiveObject("Arch")
if a:
p = a.Placement.inverse().multiply(p)
return p
def getPlacement(self,rotated=False):
"returns the placement of the working plane"
if rotated:
m = FreeCAD.Matrix(
self.u.x,self.axis.x,-self.v.x,self.position.x,
self.u.y,self.axis.y,-self.v.y,self.position.y,
self.u.z,self.axis.z,-self.v.z,self.position.z,
0.0,0.0,0.0,1.0)
else:
m = FreeCAD.Matrix(
self.u.x,self.v.x,self.axis.x,self.position.x,
self.u.y,self.v.y,self.axis.y,self.position.y,
self.u.z,self.v.z,self.axis.z,self.position.z,
0.0,0.0,0.0,1.0)
p = FreeCAD.Placement(m)
# Arch active container if based on App Part
#if FreeCAD.GuiUp:
# import FreeCADGui
# a = FreeCADGui.ActiveDocument.ActiveView.getActiveObject("Arch")
# if a:
# p = a.Placement.inverse().multiply(p)
return p
def getNormal(self):
n = self.axis
# Arch active container if based on App Part
#if FreeCAD.GuiUp:
# import FreeCADGui
# a = FreeCADGui.ActiveDocument.ActiveView.getActiveObject("Arch")
# if a:
# n = a.Placement.inverse().Rotation.multVec(n)
return n
def setFromPlacement(self,pl,rebase=False):
"sets the working plane from a placement (rotaton ONLY, unless rebase=True)"
rot = FreeCAD.Placement(pl).Rotation
self.u = rot.multVec(FreeCAD.Vector(1,0,0))
self.v = rot.multVec(FreeCAD.Vector(0,1,0))
self.axis = rot.multVec(FreeCAD.Vector(0,0,1))
if rebase:
self.position = pl.Base
def inverse(self):
"inverts the direction of the working plane"
self.u = self.u.negative()
self.axis = self.axis.negative()
def save(self):
"stores the current plane state"
self.stored = [self.u,self.v,self.axis,self.position,self.weak]
def restore(self):
"restores a previously saved plane state, if exists"
if self.stored:
self.u = self.stored[0]
self.v = self.stored[1]
self.axis = self.stored[2]
self.position = self.stored[3]
self.weak = self.stored[4]
self.stored = None
def getLocalCoords(self,point):
"returns the coordinates of a given point on the working plane"
pt = point.sub(self.position)
xv = DraftVecUtils.project(pt,self.u)
x = xv.Length
if xv.getAngle(self.u) > 1:
x = -x
yv = DraftVecUtils.project(pt,self.v)
y = yv.Length
if yv.getAngle(self.v) > 1:
y = -y
zv = DraftVecUtils.project(pt,self.axis)
z = zv.Length
if zv.getAngle(self.axis) > 1:
z = -z
return Vector(x,y,z)
def getGlobalCoords(self,point):
"returns the global coordinates of the given point, taken relatively to this working plane"
vx = Vector(self.u).multiply(point.x)
vy = Vector(self.v).multiply(point.y)
vz = Vector(self.axis).multiply(point.z)
pt = (vx.add(vy)).add(vz)
return pt.add(self.position)
def getLocalRot(self,point):
"Same as getLocalCoords, but discards the WP position"
xv = DraftVecUtils.project(point,self.u)
x = xv.Length
if xv.getAngle(self.u) > 1:
x = -x
yv = DraftVecUtils.project(point,self.v)
y = yv.Length
if yv.getAngle(self.v) > 1:
y = -y
zv = DraftVecUtils.project(point,self.axis)
z = zv.Length
if zv.getAngle(self.axis) > 1:
z = -z
return Vector(x,y,z)
def getGlobalRot(self,point):
"Same as getGlobalCoords, but discards the WP position"
vx = Vector(self.u).multiply(point.x)
vy = Vector(self.v).multiply(point.y)
vz = Vector(self.axis).multiply(point.z)
pt = (vx.add(vy)).add(vz)
return pt
def getClosestAxis(self,point):
"returns which of the workingplane axes is closest from the given vector"
ax = point.getAngle(self.u)
ay = point.getAngle(self.v)
az = point.getAngle(self.axis)
bx = point.getAngle(self.u.negative())
by = point.getAngle(self.v.negative())
bz = point.getAngle(self.axis.negative())
b = min(ax,ay,az,bx,by,bz)
if b in [ax,bx]:
return "x"
elif b in [ay,by]:
return "y"
elif b in [az,bz]:
return "z"
else:
return None
def isGlobal(self):
"returns True if the plane axes are equal to the global axes"
if self.u != Vector(1,0,0):
return False
if self.v != Vector(0,1,0):
return False
if self.axis != Vector(0,0,1):
return False
return True
def isOrtho(self):
"returns True if the plane axes are following the global axes"
if round(self.u.getAngle(Vector(0,1,0)),6) in [0,-1.570796,1.570796,-3.141593,3.141593,-4.712389,4.712389,6.283185]:
if round(self.v.getAngle(Vector(0,1,0)),6) in [0,-1.570796,1.570796,-3.141593,3.141593,-4.712389,4.712389,6.283185]:
if round(self.axis.getAngle(Vector(0,1,0)),6) in [0,-1.570796,1.570796,-3.141593,3.141593,-4.712389,4.712389,6.283185]:
return True
return False
def getDeviation(self):
"returns the deviation angle between the u axis and the horizontal plane"
proj = Vector(self.u.x,self.u.y,0)
if self.u.getAngle(proj) == 0:
return 0
else:
norm = proj.cross(self.u)
return DraftVecUtils.angle(self.u,proj,norm)
class plane:
'''A WorkPlane object'''
def __init__(self):
# keep track of active document. Reset view when doc changes.
self.doc = None
# self.weak is true if the plane has been defined by self.setup or has been reset
self.weak = True
# u, v axes and position define plane, perpendicular axis is handy, though redundant.
self.u = Vector(1,0,0)
self.v = Vector(0,1,0)
self.axis = Vector(0,0,1)
self.position = Vector(0,0,0)
# a placeholder for a stored state
self.stored = None
def __repr__(self):
return "Workplane x="+str(DraftVecUtils.rounded(self.u))+" y="+str(DraftVecUtils.rounded(self.v))+" z="+str(DraftVecUtils.rounded(self.axis))
def offsetToPoint(self, p, direction=None):
'''
Return the signed distance from p to the plane, such
that p + offsetToPoint(p)*direction lies on the plane.
direction defaults to -plane.axis
'''
'''
A picture will help explain the computation:
p
//|
/ / |
/ / |
/ / |
/ / |
-------------------- plane -----c-----x-----a--------
Here p is the specified point,
c is a point (in this case plane.position) on the plane
x is the intercept on the plane from p in the specified direction, and
a is the perpendicular intercept on the plane (i.e. along plane.axis)
Using vertival bars to denote the length operator,
|ap| = |cp| * cos(apc) = |xp| * cos(apx)
so
|xp| = |cp| * cos(apc) / cos(apx)
= (cp . axis) / (direction . axis)
'''
if direction == None: direction = self.axis
return direction.dot(self.position.sub(p))
def projectPoint(self, p, direction=None):
'''project point onto plane, default direction is orthogonal'''
if not direction:
direction = self.axis
lp = self.getLocalCoords(p)
gp = self.getGlobalCoords(Vector(lp.x,lp.y,0))
a = direction.getAngle(gp.sub(p))
if a > math.pi/2:
direction = direction.negative()
a = math.pi - a
ld = self.getLocalRot(direction)
gd = self.getGlobalRot(Vector(ld.x,ld.y,0))
hyp = abs(math.tan(a) * lp.z)
return gp.add(DraftVecUtils.scaleTo(gd,hyp))
def projectPointOld(self, p, direction=None):
'''project point onto plane, default direction is orthogonal. Obsolete'''
if not direction:
direction = self.axis
t = Vector(direction)
#t.normalize()
a = round(t.getAngle(self.axis),DraftVecUtils.precision())
pp = round((math.pi)/2,DraftVecUtils.precision())
if a == pp:
return p
t.multiply(self.offsetToPoint(p, direction))
return p.add(t)
def alignToPointAndAxis(self, point, axis, offset, upvec=None):
self.doc = FreeCAD.ActiveDocument
self.axis = axis;
self.axis.normalize()
if (DraftVecUtils.equals(axis, Vector(1,0,0))):
self.u = Vector(0,1,0)
self.v = Vector(0,0,1)
elif (DraftVecUtils.equals(axis, Vector(-1,0,0))):
self.u = Vector(0,-1,0)
self.v = Vector(0,0,1)
elif upvec:
self.v = upvec
self.v.normalize()
self.u = self.v.cross(self.axis)
else:
self.v = axis.cross(Vector(1,0,0))
self.v.normalize()
self.u = DraftVecUtils.rotate(self.v, -math.pi/2, self.axis)
offsetVector = Vector(axis); offsetVector.multiply(offset)
self.position = point.add(offsetVector)
self.weak = False
# FreeCAD.Console.PrintMessage("(position = " + str(self.position) + ")\n")
# FreeCAD.Console.PrintMessage("Current workplane: x="+str(DraftVecUtils.rounded(self.u))+" y="+str(DraftVecUtils.rounded(self.v))+" z="+str(DraftVecUtils.rounded(self.axis))+"\n")
def alignToCurve(self, shape, offset):
if shape.ShapeType == 'Edge':
#??? TODO: process curve here. look at shape.edges[0].Curve
return False
elif shape.ShapeType == 'Wire':
#??? TODO: determine if edges define a plane
return False
else:
return False
def alignToEdges(self,edges):
# use a list of edges to find a plane position
if len(edges) > 2:
return False
# for axes systems, we suppose the 2 first edges are parallel
# ??? TODO: exclude other cases first
v1 = edges[0].Vertexes[-1].Point.sub(edges[0].Vertexes[0].Point)
v2 = edges[1].Vertexes[0].Point.sub(edges[0].Vertexes[0].Point)
v3 = v1.cross(v2)
v1.normalize()
v2.normalize()
v3.normalize()
#print v1,v2,v3
self.u = v1
self.v = v2
self.axis = v3
def alignToFace(self, shape, offset=0):
# Set face to the unique selected face, if found
if shape.ShapeType == 'Face':
#we should really use face.tangentAt to get u and v here, and implement alignToUVPoint
self.alignToPointAndAxis(shape.Faces[0].CenterOfMass, shape.Faces[0].normalAt(0,0), offset)
return True
else:
return False
def alignToSelection(self, offset):
'''If selection uniquely defines a plane, align working plane to it. Return success (bool)'''
sex = FreeCADGui.Selection.getSelectionEx(FreeCAD.ActiveDocument.Name)
if len(sex) == 0:
return False
elif len(sex) == 1:
if not sex[0].Object.isDerivedFrom("Part::Shape"):
return False
return self.alignToCurve(sex[0].Object.Shape, offset) \
or self.alignToFace(sex[0].Object.Shape, offset) \
or (len(sex[0].SubObjects) == 1 and self.alignToFace(sex[0].SubObjects[0], offset))
else:
# len(sex) > 2, look for point and line, three points, etc.
return False
def setup(self, direction=None, point=None, upvec=None):
'''If working plane is undefined, define it!'''
if self.weak:
if direction and point:
self.alignToPointAndAxis(point, direction, 0, upvec)
else:
try:
from pivy import coin
rot = FreeCADGui.ActiveDocument.ActiveView.getCameraNode().getField("orientation").getValue()
upvec = Vector(rot.multVec(coin.SbVec3f(0,1,0)).getValue())
vdir = FreeCADGui.ActiveDocument.ActiveView.getViewDirection()
self.alignToPointAndAxis(Vector(0,0,0), vdir.negative(), 0, upvec)
except:
print "Draft: Unable to align the working plane to the current view"
self.weak = True
def reset(self):
self.doc = None
self.weak = True
def getRotation(self):
"returns a placement describing the working plane orientation ONLY"
m = DraftVecUtils.getPlaneRotation(self.u,self.v,self.axis)
return FreeCAD.Placement(m)
def getPlacement(self,rotated=False):
"returns the placement of the working plane"
if rotated:
m = FreeCAD.Matrix(
self.u.x,self.axis.x,-self.v.x,self.position.x,
self.u.y,self.axis.y,-self.v.y,self.position.y,
self.u.z,self.axis.z,-self.v.z,self.position.z,
0.0,0.0,0.0,1.0)
else:
m = FreeCAD.Matrix(
self.u.x,self.v.x,self.axis.x,self.position.x,
self.u.y,self.v.y,self.axis.y,self.position.y,
self.u.z,self.v.z,self.axis.z,self.position.z,
0.0,0.0,0.0,1.0)
return FreeCAD.Placement(m)
def setFromPlacement(self,pl):
"sets the working plane from a placement (rotaton ONLY)"
rot = FreeCAD.Placement(pl).Rotation
self.u = rot.multVec(FreeCAD.Vector(1,0,0))
self.v = rot.multVec(FreeCAD.Vector(0,1,0))
self.axis = rot.multVec(FreeCAD.Vector(0,0,1))
def save(self):
"stores the current plane state"
self.stored = [self.u,self.v,self.axis,self.position,self.weak]
def restore(self):
"restores a previously saved plane state, if exists"
if self.stored:
self.u = self.stored[0]
self.v = self.stored[1]
self.axis = self.stored[2]
self.position = self.stored[3]
self.weak = self.stored[4]
self.stored = None
def getLocalCoords(self,point):
"returns the coordinates of a given point on the working plane"
pt = point.sub(self.position)
xv = DraftVecUtils.project(pt,self.u)
x = xv.Length
if xv.getAngle(self.u) > 1:
x = -x
yv = DraftVecUtils.project(pt,self.v)
y = yv.Length
if yv.getAngle(self.v) > 1:
y = -y
zv = DraftVecUtils.project(pt,self.axis)
z = zv.Length
if zv.getAngle(self.axis) > 1:
z = -z
return Vector(x,y,z)
def getGlobalCoords(self,point):
"returns the global coordinates of the given point, taken relatively to this working plane"
vx = Vector(self.u).multiply(point.x)
vy = Vector(self.v).multiply(point.y)
vz = Vector(self.axis).multiply(point.z)
pt = (vx.add(vy)).add(vz)
return pt.add(self.position)
def getLocalRot(self,point):
"Same as getLocalCoords, but discards the WP position"
xv = DraftVecUtils.project(point,self.u)
x = xv.Length
if xv.getAngle(self.u) > 1:
x = -x
yv = DraftVecUtils.project(point,self.v)
y = yv.Length
if yv.getAngle(self.v) > 1:
y = -y
zv = DraftVecUtils.project(point,self.axis)
z = zv.Length
if zv.getAngle(self.axis) > 1:
z = -z
return Vector(x,y,z)
def getGlobalRot(self,point):
"Same as getGlobalCoords, but discards the WP position"
vx = Vector(self.u).multiply(point.x)
vy = Vector(self.v).multiply(point.y)
vz = Vector(self.axis).multiply(point.z)
pt = (vx.add(vy)).add(vz)
return pt
def getClosestAxis(self,point):
"returns which of the workingplane axes is closest from the given vector"
ax = point.getAngle(self.u)
ay = point.getAngle(self.v)
az = point.getAngle(self.axis)
bx = point.getAngle(self.u.negative())
by = point.getAngle(self.v.negative())
bz = point.getAngle(self.axis.negative())
b = min(ax,ay,az,bx,by,bz)
if b in [ax,bx]:
return "x"
elif b in [ay,by]:
return "y"
elif b in [az,bz]:
return "z"
else:
return None
def isGlobal(self):
"returns True if the plane axes are equal to the global axes"
if self.u != Vector(1,0,0):
return False
if self.v != Vector(0,1,0):
return False
if self.axis != Vector(0,0,1):
return False
return True
