def getCircleFromSpline(edge):
"""Return a circle-based edge from a bspline-based edge."""
if geomType(edge) != "BSplineCurve":
return None
if len(edge.Vertexes) != 1:
return None
# get 2 points
p1 = edge.Curve.value(0)
p2 = edge.Curve.value(math.pi / 2)
# get 2 tangents
t1 = edge.Curve.tangent(0)[0]
t2 = edge.Curve.tangent(math.pi / 2)[0]
# get normal
n = p1.cross(p2)
if DraftVecUtils.isNull(n):
return None
# get rays
r1 = DraftVecUtils.rotate(t1, math.pi / 2, n)
r2 = DraftVecUtils.rotate(t2, math.pi / 2, n)
# get center (intersection of rays)
i = findIntersection(p1, p1.add(r1), p2, p2.add(r2), True, True)
if not i:
return None
c = i[0]
r = (p1.sub(c)).Length
circle = Part.makeCircle(r, c, n)
#print(circle.Curve)
return circle
def snapToPolar(self,point,last):
"snaps to polar lines from the given point"
if self.isEnabled('ortho') and (not self.mask):
if last:
vecs = []
if hasattr(FreeCAD,"DraftWorkingPlane"):
ax = [FreeCAD.DraftWorkingPlane.u,
FreeCAD.DraftWorkingPlane.v,
FreeCAD.DraftWorkingPlane.axis]
else:
ax = [FreeCAD.Vector(1,0,0),
FreeCAD.Vector(0,1,0),
FreeCAD.Vector(0,0,1)]
for a in self.polarAngles:
if a == 90:
vecs.extend([ax[0],DraftVecUtils.neg(ax[0])])
vecs.extend([ax[1],DraftVecUtils.neg(ax[1])])
else:
v = DraftVecUtils.rotate(ax[0],math.radians(a),ax[2])
vecs.extend([v,DraftVecUtils.neg(v)])
v = DraftVecUtils.rotate(ax[1],math.radians(a),ax[2])
vecs.extend([v,DraftVecUtils.neg(v)])
for v in vecs:
de = Part.Line(last,last.add(v)).toShape()
np = self.getPerpendicular(de,point)
if ((self.radius == 0) and (point.sub(last).getAngle(v) < 0.087)) \
or ((np.sub(point)).Length < self.radius):
if self.tracker:
self.tracker.setCoords(np)
self.tracker.setMarker(self.mk['parallel'])
self.tracker.on()
self.setCursor('ortho')
return np,de
return point,None
def torus(segments, rings, width, height):
"""
Function to make the faces of a torus, where every section is shifted 1/rings degrees
:param segments: Number of segment of the torus
:param rings: number of ring of each segment
:param width: width in mmm of center of the torus
:param height: height of the torus
:return: solid of the torus
"""
App.Console.PrintMessage("\n Draw torus based on " + str(segments) + " Segments, "
+ str(segments * rings) + " Faces \n")
x_base = FreeCAD.Vector(width / 2, 0, 0)
z_base = FreeCAD.Vector(height / 2, 0, 0)
total_faces = rings*segments
vertex = []
for vertex_cnt in range(total_faces):
r_angle = vertex_cnt * (2 * math.pi * (rings-1) / (rings * segments))
s_angle = vertex_cnt * (2 * math.pi / segments)
rz_base = DraftVecUtils.rotate(z_base, r_angle, FreeCAD.Vector(0, 1, 0))
vertex.append(DraftVecUtils.rotate(x_base+rz_base, s_angle))
faces = []
for face_cnt in range(total_faces):
vertex_1 = vertex[face_cnt]
vertex_2 = vertex[(face_cnt+1) % total_faces]
vertex_3 = vertex[(face_cnt + segments) % total_faces]
vertex_4 = vertex[(face_cnt + segments+1) % total_faces]
faces.append(make_face(vertex_1, vertex_2, vertex_3))
faces.append(make_face(vertex_2, vertex_3, vertex_4))
shell = Part.makeShell(faces)
solid: object = Part.makeSolid(shell)
return solid
def snapToPolar(self,point,last):
"snaps to polar lines from the given point"
if self.isEnabled('ortho') and (not self.mask):
if last:
vecs = []
if hasattr(FreeCAD,"DraftWorkingPlane"):
ax = [FreeCAD.DraftWorkingPlane.u,
FreeCAD.DraftWorkingPlane.v,
FreeCAD.DraftWorkingPlane.axis]
else:
ax = [FreeCAD.Vector(1,0,0),
FreeCAD.Vector(0,1,0),
FreeCAD.Vector(0,0,1)]
for a in self.polarAngles:
if a == 90:
vecs.extend([ax[0],DraftVecUtils.neg(ax[0])])
vecs.extend([ax[1],DraftVecUtils.neg(ax[1])])
else:
v = DraftVecUtils.rotate(ax[0],math.radians(a),ax[2])
vecs.extend([v,DraftVecUtils.neg(v)])
v = DraftVecUtils.rotate(ax[1],math.radians(a),ax[2])
vecs.extend([v,DraftVecUtils.neg(v)])
for v in vecs:
de = Part.Line(last,last.add(v)).toShape()
np = self.getPerpendicular(de,point)
if ((self.radius == 0) and (point.sub(last).getAngle(v) < 0.087)) \
or ((np.sub(point)).Length < self.radius):
if self.tracker:
self.tracker.setCoords(np)
self.tracker.setMarker(self.mk['parallel'])
self.tracker.on()
self.setCursor('ortho')
return np,de
return point,None
def angleBisection(edge1, edge2):
"""Return an edge that bisects the angle between the 2 straight edges."""
if geomType(edge1) != "Line" or geomType(edge2) != "Line":
return None
p1 = edge1.Vertexes[0].Point
p2 = edge1.Vertexes[-1].Point
p3 = edge2.Vertexes[0].Point
p4 = edge2.Vertexes[-1].Point
intersect = findIntersection(edge1, edge2, True, True)
if intersect:
line1Dir = p2.sub(p1)
angleDiff = DraftVecUtils.angle(line1Dir, p4.sub(p3))
ang = angleDiff * 0.5
origin = intersect[0]
line1Dir.normalize()
direction = DraftVecUtils.rotate(line1Dir, ang)
else:
diff = p3.sub(p1)
origin = p1.add(diff.multiply(0.5))
direction = p2.sub(p1)
direction.normalize()
return Part.LineSegment(origin, origin.add(direction)).toShape()
def numericRadius(self, rad):
"""Validate the entry radius in the user interface.
This function is called by the toolbar or taskpanel interface
when a valid radius has been entered in the input field.
"""
import DraftGeomUtils
plane = App.DraftWorkingPlane
if self.step == 1:
self.rad = rad
if len(self.tangents) == 2:
cir = DraftGeomUtils.circleFrom2tan1rad(self.tangents[0],
self.tangents[1],
rad)
if self.center:
_c = DraftGeomUtils.findClosestCircle(self.center, cir)
self.center = _c.Center
else:
self.center = cir[-1].Center
elif self.tangents and self.tanpoints:
cir = DraftGeomUtils.circleFrom1tan1pt1rad(self.tangents[0],
self.tanpoints[0],
rad)
if self.center:
_c = DraftGeomUtils.findClosestCircle(self.center, cir)
self.center = _c.Center
else:
self.center = cir[-1].Center
if self.closedCircle:
self.drawArc()
else:
self.step = 2
self.arctrack.setCenter(self.center)
self.ui.labelRadius.setText(translate("draft", "Start angle"))
self.ui.radiusValue.setToolTip(translate("draft", "Start angle"))
self.linetrack.p1(self.center)
self.linetrack.on()
self.ui.radiusValue.setText("")
self.ui.radiusValue.setFocus()
_msg(translate("draft", "Pick start angle"))
elif self.step == 2:
self.ui.labelRadius.setText(translate("draft", "Aperture angle"))
self.ui.radiusValue.setToolTip(translate("draft", "Aperture angle"))
self.firstangle = math.radians(rad)
if DraftVecUtils.equals(plane.axis, App.Vector(1, 0, 0)):
u = App.Vector(0, self.rad, 0)
else:
u = DraftVecUtils.scaleTo(App.Vector(1, 0, 0).cross(plane.axis), self.rad)
urotated = DraftVecUtils.rotate(u, math.radians(rad), plane.axis)
self.arctrack.setStartAngle(self.firstangle)
self.step = 3
self.ui.radiusValue.setText("")
self.ui.radiusValue.setFocus()
_msg(translate("draft", "Pick aperture angle"))
else:
self.updateAngle(rad)
self.angle = math.radians(rad)
self.step = 4
self.drawArc()
def circleFrom2LinesRadius(edge1, edge2, radius):
"""Retun a list of circles from two edges and one radius.
It calculates 4 centers.
"""
intsec = findIntersection(edge1, edge2, True, True)
if not intsec:
return None
intsec = intsec[0]
bis12 = angleBisection(edge1, edge2)
bis21 = Part.LineSegment(bis12.Vertexes[0].Point,
DraftVecUtils.rotate(vec(bis12), math.pi/2.0))
ang12 = abs(DraftVecUtils.angle(vec(edge1), vec(edge2)))
ang21 = math.pi - ang12
dist12 = radius / math.sin(ang12 * 0.5)
dist21 = radius / math.sin(ang21 * 0.5)
circles = []
cen = App.Vector.add(intsec, vec(bis12).multiply(dist12))
circles.append(Part.Circle(cen, NORM, radius))
cen = App.Vector.add(intsec, vec(bis12).multiply(-dist12))
circles.append(Part.Circle(cen, NORM, radius))
cen = App.Vector.add(intsec, vec(bis21).multiply(dist21))
circles.append(Part.Circle(cen, NORM, radius))
cen = App.Vector.add(intsec, vec(bis21).multiply(-dist21))
circles.append(Part.Circle(cen, NORM, radius))
return circles
def rotate_vector_from_center(vector, angle, axis, center):
"""
Needed for SubObjects modifiers.
Implemented by Dion Moult during 0.19 dev cycle (works only with Draft Wire).
"""
rv = vector.sub(center)
rv = DraftVecUtils.rotate(rv, math.radians(angle), axis)
return center.add(rv)
def getRadius(obj, delta):
"""returns a new radius for a regular polygon"""
an = math.pi / obj.FacesNumber
nr = DraftVecUtils.rotate(delta, -an)
nr.multiply(1 / math.cos(an))
nr = obj.Shape.Vertexes[0].Point.add(nr)
nr = nr.sub(obj.Placement.Base)
nr = nr.Length
if obj.DrawMode == "inscribed":
return nr
else:
return nr * math.cos(math.pi / obj.FacesNumber)
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
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
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
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
def alignToPointAndAxis(self, point, axis, offset=0, 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
def circleFrom2LinesRadius(edge1, edge2, radius):
"""circleFrom2LinesRadius(edge,edge,radius)"""
int = findIntersection(edge1, edge2, True, True)
if not int: return None
int = int[0]
bis12 = angleBisection(edge1, edge2)
bis21 = Part.LineSegment(bis12.Vertexes[0].Point,
DraftVecUtils.rotate(vec(bis12), math.pi / 2.0))
ang12 = abs(DraftVecUtils.angle(vec(edge1), vec(edge2)))
ang21 = math.pi - ang12
dist12 = radius / math.sin(ang12 * 0.5)
dist21 = radius / math.sin(ang21 * 0.5)
circles = []
cen = Vector.add(int, vec(bis12).multiply(dist12))
circles.append(Part.Circle(cen, NORM, radius))
cen = Vector.add(int, vec(bis12).multiply(-dist12))
circles.append(Part.Circle(cen, NORM, radius))
cen = Vector.add(int, vec(bis21).multiply(dist21))
circles.append(Part.Circle(cen, NORM, radius))
cen = Vector.add(int, vec(bis21).multiply(-dist21))
circles.append(Part.Circle(cen, NORM, radius))
return circles
def getSVGPlaneFromAxis(axis=FreeCAD.Vector(0, -1, 0)):
view_plane = WorkingPlane.Plane()
# axis is closed to +X axis
if axis.getAngle(FreeCAD.Vector(1, 0, 0)) < 0.00001:
view_plane.axis = FreeCAD.Vector(1, 0, 0)
view_plane.u = FreeCAD.Vector(0, 1, 0)
view_plane.v = FreeCAD.Vector(0, 0, -1)
# axis is closed to -X axis
elif axis.getAngle(FreeCAD.Vector(-1, 0, 0)) < 0.00001:
view_plane.axis = FreeCAD.Vector(-1, 0, 0)
view_plane.u = FreeCAD.Vector(0, -1, 0)
view_plane.v = FreeCAD.Vector(0, 0, -1)
else:
view_plane.axis = axis
y_axis = axis.cross(FreeCAD.Vector(1, 0, 0))
y_axis.normalize()
if y_axis.z > 0:
y_axis = y_axis.negative()
elif y_axis.y > 0:
y_axis = y_axis.negative()
view_plane.v = y_axis
view_plane.u = DraftVecUtils.rotate(view_plane.v, math.pi / 2,
view_plane.axis)
return view_plane
def make_sketch(objectslist,
autoconstraints=False,
addTo=None,
delete=False,
name="Sketch",
radiusPrecision=-1):
"""makeSketch(objectslist,[autoconstraints],[addTo],[delete],[name],[radiusPrecision])
Makes a Sketch objectslist with the given Draft objects.
Parameters
----------
objectlist: can be single or list of objects of Draft type objects,
Part::Feature, Part.Shape, or mix of them.
autoconstraints(False): if True, constraints will be automatically added to
wire nodes, rectangles and circles.
addTo(None) : if set to an existing sketch, geometry will be added to it
instead of creating a new one.
delete(False): if True, the original object will be deleted.
If set to a string 'all' the object and all its linked object will be
deleted
name('Sketch'): the name for the new sketch object
radiusPrecision(-1): If <0, disable radius constraint. If =0, add indiviaul
radius constraint. If >0, the radius will be rounded according to this
precision, and 'Equal' constraint will be added to curve with equal
radius within precision.
"""
if not App.ActiveDocument:
App.Console.PrintError("No active document. Aborting\n")
return
import Part
from Sketcher import Constraint
import Sketcher
StartPoint = 1
EndPoint = 2
MiddlePoint = 3
deletable = None
if not isinstance(objectslist, (list, tuple)):
objectslist = [objectslist]
for obj in objectslist:
if isinstance(obj, Part.Shape):
shape = obj
elif not hasattr(obj, 'Shape'):
App.Console.PrintError(translate("draft", "not shape found"))
return None
else:
shape = obj.Shape
if not DraftGeomUtils.isPlanar(shape):
App.Console.PrintError(
translate("draft", "All Shapes must be co-planar"))
return None
if addTo:
nobj = addTo
else:
nobj = App.ActiveDocument.addObject("Sketcher::SketchObject", name)
deletable = nobj
if App.GuiUp:
nobj.ViewObject.Autoconstraints = False
# Collect constraints and add in one go to improve performance
constraints = []
radiuses = {}
def addRadiusConstraint(edge):
try:
if radiusPrecision < 0:
return
if radiusPrecision == 0:
constraints.append(
Constraint('Radius', nobj.GeometryCount - 1,
edge.Curve.Radius))
return
r = round(edge.Curve.Radius, radiusPrecision)
constraints.append(
Constraint('Equal', radiuses[r], nobj.GeometryCount - 1))
except KeyError:
radiuses[r] = nobj.GeometryCount - 1
constraints.append(Constraint('Radius', nobj.GeometryCount - 1, r))
except AttributeError:
pass
def convertBezier(edge):
if DraftGeomUtils.geomType(edge) == "BezierCurve":
return (edge.Curve.toBSpline(edge.FirstParameter,
edge.LastParameter).toShape())
else:
return (edge)
rotation = None
for obj in objectslist:
ok = False
tp = utils.get_type(obj)
if tp in ["Circle", "Ellipse"]:
if obj.Shape.Edges:
if rotation is None:
rotation = obj.Placement.Rotation
edge = obj.Shape.Edges[0]
if len(edge.Vertexes) == 1:
newEdge = DraftGeomUtils.orientEdge(edge)
nobj.addGeometry(newEdge)
else:
# make new ArcOfCircle
circle = DraftGeomUtils.orientEdge(edge)
angle = edge.Placement.Rotation.Angle
axis = edge.Placement.Rotation.Axis
circle.Center = DraftVecUtils.rotate(
edge.Curve.Center, -angle, axis)
first = math.radians(obj.FirstAngle)
last = math.radians(obj.LastAngle)
arc = Part.ArcOfCircle(circle, first, last)
nobj.addGeometry(arc)
addRadiusConstraint(edge)
ok = True
elif tp == "Rectangle":
if rotation is None:
rotation = obj.Placement.Rotation
if obj.FilletRadius.Value == 0:
for edge in obj.Shape.Edges:
nobj.addGeometry(DraftGeomUtils.orientEdge(edge))
if autoconstraints:
last = nobj.GeometryCount - 1
segs = [last - 3, last - 2, last - 1, last]
if obj.Placement.Rotation.Q == (0, 0, 0, 1):
constraints.append(
Constraint("Coincident", last - 3, EndPoint,
last - 2, StartPoint))
constraints.append(
Constraint("Coincident", last - 2, EndPoint,
last - 1, StartPoint))
constraints.append(
Constraint("Coincident", last - 1, EndPoint, last,
StartPoint))
constraints.append(
Constraint("Coincident", last, EndPoint, last - 3,
StartPoint))
constraints.append(Constraint("Horizontal", last - 3))
constraints.append(Constraint("Vertical", last - 2))
constraints.append(Constraint("Horizontal", last - 1))
constraints.append(Constraint("Vertical", last))
ok = True
elif tp in ["Wire", "Polygon"]:
if obj.FilletRadius.Value == 0:
closed = False
if tp == "Polygon":
closed = True
elif hasattr(obj, "Closed"):
closed = obj.Closed
if obj.Shape.Edges:
if (len(obj.Shape.Vertexes) < 3):
e = obj.Shape.Edges[0]
nobj.addGeometry(
Part.LineSegment(e.Curve, e.FirstParameter,
e.LastParameter))
else:
# Use the first three points to make a working plane. We've already
# checked to make sure everything is coplanar
plane = Part.Plane(
*[i.Point for i in obj.Shape.Vertexes[:3]])
normal = plane.Axis
if rotation is None:
axis = App.Vector(0, 0, 1).cross(normal)
angle = DraftVecUtils.angle(
normal, App.Vector(0, 0, 1)) * App.Units.Radian
rotation = App.Rotation(axis, angle)
for edge in obj.Shape.Edges:
# edge.rotate(App.Vector(0,0,0), rotAxis, rotAngle)
edge = DraftGeomUtils.orientEdge(edge, normal)
nobj.addGeometry(edge)
if autoconstraints:
last = nobj.GeometryCount
segs = list(
range(last - len(obj.Shape.Edges), last - 1))
for seg in segs:
constraints.append(
Constraint("Coincident", seg, EndPoint,
seg + 1, StartPoint))
if DraftGeomUtils.isAligned(
nobj.Geometry[seg], "x"):
constraints.append(
Constraint("Vertical", seg))
elif DraftGeomUtils.isAligned(
nobj.Geometry[seg], "y"):
constraints.append(
Constraint("Horizontal", seg))
if closed:
constraints.append(
Constraint("Coincident", last - 1,
EndPoint, segs[0], StartPoint))
ok = True
elif tp == "BSpline":
if obj.Shape.Edges:
nobj.addGeometry(obj.Shape.Edges[0].Curve)
nobj.exposeInternalGeometry(nobj.GeometryCount - 1)
ok = True
elif tp == "BezCurve":
if obj.Shape.Edges:
bez = obj.Shape.Edges[0].Curve
bsp = bez.toBSpline(bez.FirstParameter, bez.LastParameter)
nobj.addGeometry(bsp)
nobj.exposeInternalGeometry(nobj.GeometryCount - 1)
ok = True
elif tp == 'Shape' or hasattr(obj, 'Shape'):
shape = obj if tp == 'Shape' else obj.Shape
if not DraftGeomUtils.isPlanar(shape):
App.Console.PrintError(
translate(
"draft",
"The given object is not planar and cannot be converted into a sketch."
))
return None
if rotation is None:
#rotation = obj.Placement.Rotation
norm = DraftGeomUtils.getNormal(shape)
if norm:
rotation = App.Rotation(App.Vector(0, 0, 1), norm)
else:
App.Console.PrintWarning(
translate(
"draft",
"Unable to guess the normal direction of this object"
))
rotation = App.Rotation()
norm = obj.Placement.Rotation.Axis
if not shape.Wires:
for e in shape.Edges:
# unconnected edges
newedge = convertBezier(e)
nobj.addGeometry(
DraftGeomUtils.orientEdge(newedge, norm,
make_arc=True))
addRadiusConstraint(newedge)
# if not addTo:
# nobj.Placement.Rotation = DraftGeomUtils.calculatePlacement(shape).Rotation
if autoconstraints:
for wire in shape.Wires:
last_count = nobj.GeometryCount
edges = wire.OrderedEdges
for edge in edges:
newedge = convertBezier(edge)
nobj.addGeometry(
DraftGeomUtils.orientEdge(newedge,
norm,
make_arc=True))
addRadiusConstraint(newedge)
for i, g in enumerate(nobj.Geometry[last_count:]):
if edges[i].Closed:
continue
seg = last_count + i
if DraftGeomUtils.isAligned(g, "x"):
constraints.append(Constraint("Vertical", seg))
elif DraftGeomUtils.isAligned(g, "y"):
constraints.append(Constraint("Horizontal", seg))
if seg == nobj.GeometryCount - 1:
if not wire.isClosed():
break
g2 = nobj.Geometry[last_count]
seg2 = last_count
else:
seg2 = seg + 1
g2 = nobj.Geometry[seg2]
end1 = g.value(g.LastParameter)
start2 = g2.value(g2.FirstParameter)
if DraftVecUtils.equals(end1, start2):
constraints.append(
Constraint("Coincident", seg, EndPoint, seg2,
StartPoint))
continue
end2 = g2.value(g2.LastParameter)
start1 = g.value(g.FirstParameter)
if DraftVecUtils.equals(end2, start1):
constraints.append(
Constraint("Coincident", seg, StartPoint, seg2,
EndPoint))
elif DraftVecUtils.equals(start1, start2):
constraints.append(
Constraint("Coincident", seg, StartPoint, seg2,
StartPoint))
elif DraftVecUtils.equals(end1, end2):
constraints.append(
Constraint("Coincident", seg, EndPoint, seg2,
EndPoint))
else:
for wire in shape.Wires:
for edge in wire.OrderedEdges:
newedge = convertBezier(edge)
nobj.addGeometry(
DraftGeomUtils.orientEdge(newedge,
norm,
make_arc=True))
ok = True
gui_utils.format_object(nobj, obj)
if ok and delete and hasattr(obj, 'Shape'):
doc = obj.Document
def delObj(obj):
if obj.InList:
App.Console.PrintWarning(
translate(
"draft", "Cannot delete object {} with dependency".
format(obj.Label)) + "\n")
else:
doc.removeObject(obj.Name)
try:
if delete == 'all':
objs = [obj]
while objs:
obj = objs[0]
objs = objs[1:] + obj.OutList
delObj(obj)
else:
delObj(obj)
except Exception as ex:
App.Console.PrintWarning(
translate(
"draft", "Failed to delete object {}: {}".format(
obj.Label, ex)) + "\n")
if rotation:
nobj.Placement.Rotation = rotation
else:
print("-----error!!! rotation is still None...")
nobj.addConstraint(constraints)
return nobj
def rotate(objectslist, angle, center=App.Vector(0,0,0),
axis=App.Vector(0,0,1), copy=False):
"""rotate(objects,angle,[center,axis,copy])
Rotates the objects contained in objects (that can be a list of objects
or an object) of the given angle (in degrees) around the center, using
axis as a rotation axis.
Parameters
----------
objectlist : list
angle : list
center : Base.Vector
axis : Base.Vector
If axis is omitted, the rotation will be around the vertical Z axis.
copy : bool
If copy is True, the actual objects are not moved, but copies
are created instead.
Return
----------
The objects (or their copies) are returned.
"""
import Part
utils.type_check([(copy,bool)], "rotate")
if not isinstance(objectslist,list):
objectslist = [objectslist]
objectslist.extend(groups.get_movable_children(objectslist))
newobjlist = []
newgroups = {}
objectslist = utils.filter_objects_for_modifiers(objectslist, copy)
for obj in objectslist:
newobj = None
# real_center and real_axis are introduced to take into account
# the possibility that object is inside an App::Part
if hasattr(obj, "getGlobalPlacement"):
ci = obj.getGlobalPlacement().inverse().multVec(center)
real_center = obj.Placement.multVec(ci)
ai = obj.getGlobalPlacement().inverse().Rotation.multVec(axis)
real_axis = obj.Placement.Rotation.multVec(ai)
else:
real_center = center
real_axis = axis
if copy:
newobj = make_copy.make_copy(obj)
else:
newobj = obj
if obj.isDerivedFrom("App::Annotation"):
# TODO: this is very different from how move handle annotations
# maybe we can uniform the two methods
if axis.normalize() == App.Vector(1,0,0):
newobj.ViewObject.RotationAxis = "X"
newobj.ViewObject.Rotation = angle
elif axis.normalize() == App.Vector(0,1,0):
newobj.ViewObject.RotationAxis = "Y"
newobj.ViewObject.Rotation = angle
elif axis.normalize() == App.Vector(0,-1,0):
newobj.ViewObject.RotationAxis = "Y"
newobj.ViewObject.Rotation = -angle
elif axis.normalize() == App.Vector(0,0,1):
newobj.ViewObject.RotationAxis = "Z"
newobj.ViewObject.Rotation = angle
elif axis.normalize() == App.Vector(0,0,-1):
newobj.ViewObject.RotationAxis = "Z"
newobj.ViewObject.Rotation = -angle
elif utils.get_type(obj) == "Point":
v = App.Vector(obj.X,obj.Y,obj.Z)
rv = v.sub(real_center)
rv = DraftVecUtils.rotate(rv, math.radians(angle), real_axis)
v = real_center.add(rv)
newobj.X = v.x
newobj.Y = v.y
newobj.Z = v.z
elif obj.isDerivedFrom("App::DocumentObjectGroup"):
pass
elif hasattr(obj,"Placement"):
#FreeCAD.Console.PrintMessage("placement rotation\n")
shape = Part.Shape()
shape.Placement = obj.Placement
shape.rotate(DraftVecUtils.tup(real_center), DraftVecUtils.tup(real_axis), angle)
newobj.Placement = shape.Placement
elif hasattr(obj,'Shape') and (utils.get_type(obj) not in ["WorkingPlaneProxy","BuildingPart"]):
#think it make more sense to try first to rotate placement and later to try with shape. no?
shape = obj.Shape.copy()
shape.rotate(DraftVecUtils.tup(real_center), DraftVecUtils.tup(real_axis), angle)
newobj.Shape = shape
if copy:
gui_utils.formatObject(newobj,obj)
if newobj is not None:
newobjlist.append(newobj)
if copy:
for p in obj.InList:
if p.isDerivedFrom("App::DocumentObjectGroup") and (p in objectslist):
g = newgroups.setdefault(p.Name, App.ActiveDocument.addObject(p.TypeId, p.Name))
g.addObject(newobj)
break
gui_utils.select(newobjlist)
if len(newobjlist) == 1:
return newobjlist[0]
return newobjlist
def torus():
global faces
Sides=8 # sides per ring
Rings=6 # Nof ring on the torus
Width=250 # approximately final diameter in mm
Height=Width/3.5
App.Console.PrintMessage("\n Draw Torus with " + str(Sides) + " Sides, " + str(Sides*Rings*2) +" Faces \n")
Total_lenght=0
ring_loc = []
v_cross=[]
v_cross_base = FreeCAD.Vector(Height/2,0,0)
#Make the Y / Z locations (cross section) of the Torus
for side in range(Rings):
r_angle =((side-0.5)*(2*math.pi/Rings))+(math.pi/2)
ring_loc.append(DraftVecUtils.rotate(v_cross_base,-r_angle,FreeCAD.Vector(0,1,0)))
#Make the vertex points on the Torus
v=[]
for ring_cnt in range(Rings):
vr=[]
base_vector = FreeCAD.Vector((Width-Height)/2,0,0)+ring_loc[ring_cnt]
for cnt in range(0,Sides):
if (ring_cnt % 2)==0:
r_angle=((cnt+0.5)*(2*math.pi/Sides))
else:
r_angle=(cnt*(2*math.pi/Sides))
vr.append(DraftVecUtils.rotate(base_vector,r_angle))
v.append(vr)
# Make the wires/faces
f=[]
for ring in range(Rings):
for cnt in range(Sides):
v0=v[ring][cnt]
v1 = v[ring][(cnt+1)%Sides] # % Sides --> Start at 0 when round
v2 = v[(ring+1)%Rings][(cnt+1-(ring%2))%Sides] # % 2 --> when odd ring use next vertex on next ring
f.append(make_face(v0,v1,v2)) # Up facing Triangle
v0 = v[(ring+1)%Rings][cnt] # % Rings --> start at 0 when round
v1 = v[(ring+1)%Rings][(cnt+1)%Sides] # % Sides --> Start at 0 when round
v2 = v[ring][(cnt+(ring%2))%Sides] # when even ring use next vertex on previous ring
f.append(make_face(v0,v1,v2)) # Down facing Triangle
if cnt ==0: # Loop for printing triangle information
App.Console.PrintMessage("Ring " + str(ring) + "\n")
for face_cnt in range(2):
edge_lengths=[]
for edge_cnt in range(3):
edge_lengths.append(round(f[2*ring*Sides+face_cnt%2].Edges[edge_cnt].Length,1))
App.Console.PrintMessage("Length Edge nr. " + str(edge_cnt) + " : " + str(edge_lengths[-1]) + "mm \n")
angle = round(360*math.asin((edge_lengths[0]/2)/edge_lengths[1])/math.pi,1)
App.Console.PrintMessage("Angle: " + str(angle)+ "deg , 2x " + str((180-angle)/2) + "deg --> miter: " + str(round(90-(180-angle)/2,1)) + "deg\n")
# App.Console.PrintMessage("Total Lenght Ring " + str(16*edge_lengths[0]) + "\n")
vns1 = f[2*ring*Sides].normalAt(0,0)
vns2 = f[2*ring*Sides+1].normalAt(0,0)
Angle_1_2=180-round(math.degrees(vns1.getAngle(vns2)),2)
App.Console.PrintMessage("Angle faces " + str(Angle_1_2) + " deg --> SAW angle: " + str(Angle_1_2/2) + "deg \n")
Total_lenght += 16*edge_lengths[0]
for ring_cnt in range(Rings):
vns1 = f[(2*Sides*ring_cnt)+1].normalAt(0,0)
vns2 = f[(2*Sides*((ring_cnt+1)%Rings))].normalAt(0,0)
Angle_1_2=180-round(math.degrees(vns1.getAngle(vns2)),1)
App.Console.PrintMessage("Angle faces Ring "+ str(ring_cnt) + "-" +str((ring_cnt+1)%Rings)+ " "+ str(Angle_1_2) + " deg --> SAW angle : " + str(round(Angle_1_2/2,1)) + "deg \n")
App.Console.PrintMessage("Total Length wood " + str(Total_lenght) + "mm \n")
# dist = f[0+1].distToShape(f[2*(Rings/2)].normalAt(0,0))
# App.Console.PrintMessage("Diastance between opposite faces " + str(dist) + "mm \n")
faces=f
shell=Part.makeShell(f)
solid=Part.makeSolid(shell)
Shape = solid
return Shape
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
def sphere(sides, rings, width):
""" Function to make the faces of a sphere which has to be cut to make Streptohedron
"""
App.Console.PrintMessage("\nDraw streptohedron based on " + str(sides) + " Sides, " \
+ str(sides*(rings - 1) * 2) + " Faces \n")
total_length = 0
ring_loc = []
v_cross_base = FreeCAD.Vector(width / 2, 0, 0)
cor_factor = 1 / math.cos(2 * math.pi / (sides * 2))
stri = "cor factor = {:2.2f} \n".format(cor_factor)
App.Console.PrintMessage(stri)
for ring_cnt in range(rings + 1):
r_angle = ((ring_cnt) * (math.pi / rings)) + (math.pi / 2)
vector_to_loc = DraftVecUtils.rotate(v_cross_base, -r_angle, \
FreeCAD.Vector(0, 1, 0)).scale(cor_factor, cor_factor, 1)
ring_loc.append(vector_to_loc)
vector = []
for ring_cnt in range(rings + 1):
ring_vertices = []
base_vector = ring_loc[ring_cnt]
for cnt in range(0, sides):
if (ring_cnt % 2) == 0:
r_angle = ((cnt + 0.5) * (2 * math.pi / sides))
else:
r_angle = (cnt * (2 * math.pi / sides))
ring_vertices.append(DraftVecUtils.rotate(base_vector, r_angle))
vector.append(ring_vertices)
# Make the wires/faces
faces = []
for ring in range(rings):
if ring == 0:
for cnt in range(sides):
vertex_0 = vector[ring][cnt]
vertex_1 = vector[ring + 1][(cnt) % sides]
vertex_2 = vector[(ring + 1)][(cnt + 1) % sides]
faces.append(make_face(vertex_0, vertex_1, vertex_2))
elif ring == (rings - 1):
for cnt in range(sides):
vertex_0 = vector[ring][cnt]
vertex_1 = vector[ring][(cnt + 1) % sides]
vertex_2 = vector[(ring + 1)][cnt]
faces.append(make_face(vertex_0, vertex_1, vertex_2))
else:
for cnt in range(sides):
vertex_0 = vector[ring][cnt]
# % sides --> Start at 0 when round
vertex_1 = vector[ring][(cnt + 1) % sides]
# % 2 --> when odd ring use next vertex on next ring
vertex_2 = vector[(ring + 1) % rings][(cnt + 1 - (ring % 2)) % sides]
# Up facing Triangle
faces.append(make_face(vertex_0, vertex_1, vertex_2))
# % rings --> start at 0 when round
vertex_0 = vector[(ring + 1) % rings][cnt]
# % sides --> Start at 0 when round
vertex_1 = vector[(ring + 1) % rings][(cnt + 1) % sides]
# when even ring use next vertex on previous ring
vertex_2 = vector[ring][(cnt + (ring % 2)) % sides]
# Down facing Triangle
faces.append(make_face(vertex_0, vertex_1, vertex_2))
edge_lengths = []
for edge_cnt in range(3):
edge_lengths.append(round(faces[-1].Edges[edge_cnt].Length, 1))
App.Console.PrintMessage("Length Edge nr. " + str(edge_cnt) + \
" : " + str(edge_lengths[-1]) + " mm \n")
edge_lengths.sort()
angle = 360.0 * math.asin((edge_lengths[0] / 2)/edge_lengths[1]) / math.pi
stri = "Angle : {:3.1f}° --> miter: {:3.1f}°\n".format(angle,\
90-(angle)/2)
App.Console.PrintMessage(stri)
vns1 = faces[-1].normalAt(0, 0)
vns2 = faces[-2].normalAt(0, 0)
if 0 < ring < (rings - 1):
angle_1_2 = 180 - round(math.degrees(vns1.getAngle(vns2)), 2)
else:
angle_1_2 = round(math.degrees(vns1.getAngle(vns2)), 2)
stri = "Ring : {:2d} Angle faces {:2.2f} ° --> SAW angle: {:2.2f} °\n".format(
ring, angle_1_2, angle_1_2 / 2)
App.Console.PrintMessage(stri)
total_length += (sides + 1) * edge_lengths[0]
for ring_cnt in range(rings):
if ring_cnt == 0:
vns1 = faces[0].normalAt(0, 0)
vns2 = faces[sides].normalAt(0, 0)
angle_1_2 = 180 - round(math.degrees(vns1.getAngle(vns2)), 1)
stri = "Angle faces Ring {:2d} - {:2d} {:2.2f}° --> SAW angle : {:2.2f}° \n".format(
ring_cnt, ring_cnt + 1, angle_1_2, angle_1_2 / 2)
App.Console.PrintMessage(stri)
if 0 < ring_cnt < (rings - 1):
vns1 = faces[sides + (2 * sides * (ring_cnt - 1)) + 1].normalAt(0, 0)
vns2 = faces[sides + (2 * sides * ((ring_cnt) % rings))].normalAt(0, 0)
angle_1_2 = 180 - round(math.degrees(vns1.getAngle(vns2)), 1)
stri = "Angle faces Ring {:2d} - {:2d} {:2.2f}° --> SAW angle : {:2.2f}° \n".format(
ring_cnt, ring_cnt+1, angle_1_2, angle_1_2 / 2)
App.Console.PrintMessage(stri)
stri = "Total Length wood {:3.2f} m \n".format(total_length / 1000)
App.Console.PrintMessage(stri)
shell = Part.makeShell(faces)
solid = Part.makeSolid(shell)
return solid
def rotate(objectslist,
angle,
center=App.Vector(0, 0, 0),
axis=App.Vector(0, 0, 1),
copy=False):
"""rotate(objects,angle,[center,axis,copy])
Rotates the objects contained in objects (that can be a list of objects
or an object) of the given angle (in degrees) around the center, using
axis as a rotation axis.
Parameters
----------
objectslist : list
angle : rotation angle (in degrees)
center : Base.Vector
axis : Base.Vector
If axis is omitted, the rotation will be around the vertical Z axis.
copy : bool
If copy is True, the actual objects are not moved, but copies
are created instead.
Return
----------
The objects (or their copies) are returned.
"""
import Part
utils.type_check([(copy, bool)], "rotate")
if not isinstance(objectslist, list):
objectslist = [objectslist]
objectslist.extend(groups.get_movable_children(objectslist))
newobjlist = []
newgroups = {}
objectslist = utils.filter_objects_for_modifiers(objectslist, copy)
if copy:
doc = App.ActiveDocument
for obj in objectslist:
if obj.isDerivedFrom("App::DocumentObjectGroup") \
and obj.Name not in newgroups.keys():
newgroups[obj.Name] = doc.addObject(
obj.TypeId, utils.get_real_name(obj.Name))
for obj in objectslist:
newobj = None
# real_center and real_axis are introduced to take into account
# the possibility that object is inside an App::Part
if hasattr(obj, "getGlobalPlacement"):
ci = obj.getGlobalPlacement().inverse().multVec(center)
real_center = obj.Placement.multVec(ci)
ai = obj.getGlobalPlacement().inverse().Rotation.multVec(axis)
real_axis = obj.Placement.Rotation.multVec(ai)
else:
real_center = center
real_axis = axis
if obj.isDerivedFrom("App::Annotation"):
# TODO: this is very different from how move handle annotations
# maybe we can uniform the two methods
if copy:
newobj = make_copy.make_copy(obj)
else:
newobj = obj
if axis.normalize() == App.Vector(1, 0, 0):
newobj.ViewObject.RotationAxis = "X"
newobj.ViewObject.Rotation = angle
elif axis.normalize() == App.Vector(0, 1, 0):
newobj.ViewObject.RotationAxis = "Y"
newobj.ViewObject.Rotation = angle
elif axis.normalize() == App.Vector(0, -1, 0):
newobj.ViewObject.RotationAxis = "Y"
newobj.ViewObject.Rotation = -angle
elif axis.normalize() == App.Vector(0, 0, 1):
newobj.ViewObject.RotationAxis = "Z"
newobj.ViewObject.Rotation = angle
elif axis.normalize() == App.Vector(0, 0, -1):
newobj.ViewObject.RotationAxis = "Z"
newobj.ViewObject.Rotation = -angle
elif utils.get_type(obj) == "Point":
if copy:
newobj = make_copy.make_copy(obj)
else:
newobj = obj
v = App.Vector(newobj.X, newobj.Y, newobj.Z)
rv = v.sub(real_center)
rv = DraftVecUtils.rotate(rv, math.radians(angle), real_axis)
v = real_center.add(rv)
newobj.X = v.x
newobj.Y = v.y
newobj.Z = v.z
elif obj.isDerivedFrom("App::DocumentObjectGroup"):
if copy:
newobj = newgroups[obj.Name]
else:
newobj = obj
elif hasattr(obj, "Placement"):
# App.Console.PrintMessage("placement rotation\n")
if copy:
newobj = make_copy.make_copy(obj)
else:
newobj = obj
# Workaround for `faulty` implementation of Base.Placement.rotate(center, axis, angle).
# See: https://forum.freecadweb.org/viewtopic.php?p=613196#p613196
offset_rotation = App.Placement(App.Vector(0, 0, 0),
App.Rotation(real_axis, angle),
real_center)
newobj.Placement = offset_rotation * newobj.Placement
elif hasattr(obj, "Shape"):
if copy:
newobj = make_copy.make_copy(obj)
else:
newobj = obj
shape = newobj.Shape.copy()
shape.rotate(real_center, real_axis, angle)
newobj.Shape = shape
if newobj is not None:
newobjlist.append(newobj)
if copy:
for parent in obj.InList:
if parent.isDerivedFrom("App::DocumentObjectGroup") \
and (parent in objectslist):
newgroups[parent.Name].addObject(newobj)
if utils.get_type(parent) == "Layer":
parent.Proxy.addObject(parent, newobj)
if copy and utils.get_param("selectBaseObjects", False):
gui_utils.select(objectslist)
else:
gui_utils.select(newobjlist)
if len(newobjlist) == 1:
return newobjlist[0]
return newobjlist
def action(self, arg):
"""Handle the 3D scene events.
This is installed as an EventCallback in the Inventor view.
Parameters
----------
arg: dict
Dictionary with strings that indicates the type of event received
from the 3D view.
"""
import DraftGeomUtils
plane = App.DraftWorkingPlane
if arg["Type"] == "SoKeyboardEvent":
if arg["Key"] == "ESCAPE":
self.finish()
elif arg["Type"] == "SoLocation2Event":
self.point, ctrlPoint, info = gui_tool_utils.getPoint(self, arg)
if (gui_tool_utils.hasMod(arg, gui_tool_utils.MODCONSTRAIN)
and self.constrainSeg):
dist = DraftGeomUtils.findPerpendicular(self.point,
self.shape,
self.constrainSeg[1])
else:
dist = DraftGeomUtils.findPerpendicular(self.point,
self.shape.Edges)
if dist:
self.ghost.on()
if self.mode == "Wire":
d = dist[0].negative()
v1 = DraftGeomUtils.getTangent(self.shape.Edges[0],
self.point)
v2 = DraftGeomUtils.getTangent(self.shape.Edges[dist[1]],
self.point)
a = -DraftVecUtils.angle(v1, v2, plane.axis)
self.dvec = DraftVecUtils.rotate(d, a, plane.axis)
occmode = self.ui.occOffset.isChecked()
utils.param.SetBool("Offset_OCC", occmode)
_wire = DraftGeomUtils.offsetWire(self.shape,
self.dvec,
occ=occmode)
self.ghost.update(_wire, forceclosed=occmode)
elif self.mode == "BSpline":
d = dist[0].negative()
e = self.shape.Edges[0]
basetan = DraftGeomUtils.getTangent(e, self.point)
self.npts = []
for p in self.sel.Points:
currtan = DraftGeomUtils.getTangent(e, p)
a = -DraftVecUtils.angle(currtan, basetan, plane.axis)
self.dvec = DraftVecUtils.rotate(d, a, plane.axis)
self.npts.append(p.add(self.dvec))
self.ghost.update(self.npts)
elif self.mode == "Circle":
self.dvec = self.point.sub(self.center).Length
self.ghost.setRadius(self.dvec)
self.constrainSeg = dist
self.linetrack.on()
self.linetrack.p1(self.point)
self.linetrack.p2(self.point.add(dist[0]))
self.ui.setRadiusValue(dist[0].Length, unit="Length")
else:
self.dvec = None
self.ghost.off()
self.constrainSeg = None
self.linetrack.off()
self.ui.radiusValue.setText("off")
self.ui.radiusValue.setFocus()
self.ui.radiusValue.selectAll()
if self.extendedCopy:
if not gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT):
self.finish()
gui_tool_utils.redraw3DView()
elif arg["Type"] == "SoMouseButtonEvent":
if (arg["State"] == "DOWN") and (arg["Button"] == "BUTTON1"):
copymode = False
occmode = self.ui.occOffset.isChecked()
utils.param.SetBool("Offset_OCC", occmode)
if (gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT)
or self.ui.isCopy.isChecked()):
copymode = True
Gui.addModule("Draft")
if self.npts:
# _msg("offset:npts= " + str(self.npts))
_cmd = 'Draft.offset'
_cmd += '('
_cmd += 'FreeCAD.ActiveDocument.'
_cmd += self.sel.Name + ', '
_cmd += DraftVecUtils.toString(self.npts) + ', '
_cmd += 'copy=' + str(copymode)
_cmd += ')'
_cmd_list = ['offst = ' + _cmd,
'FreeCAD.ActiveDocument.recompute()']
self.commit(translate("draft", "Offset"),
_cmd_list)
elif self.dvec:
if isinstance(self.dvec, float):
delta = str(self.dvec)
else:
delta = DraftVecUtils.toString(self.dvec)
_cmd = 'Draft.offset'
_cmd += '('
_cmd += 'FreeCAD.ActiveDocument.'
_cmd += self.sel.Name + ', '
_cmd += delta + ', '
_cmd += 'copy=' + str(copymode) + ', '
_cmd += 'occ=' + str(occmode)
_cmd += ')'
_cmd_list = ['offst = ' + _cmd,
'FreeCAD.ActiveDocument.recompute()']
self.commit(translate("draft", "Offset"),
_cmd_list)
if gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT):
self.extendedCopy = True
else:
self.finish()
def execute(self, obj):
''' this method is mandatory. It is called on Document.recompute()
'''
#FreeCAD.Console.PrintWarning("_FHPath execute()\n") #debug
# the Path needs a 'Base' object
if not obj.Base:
return
# if right type of base
if not obj.Base.isDerivedFrom("Part::Feature"):
FreeCAD.Console.PrintWarning(
translate(
"EM",
"FHPath can only be based on objects derived from Part::Feature"
))
return
# check validity
if obj.Base.Shape.isNull():
FreeCAD.Console.PrintWarning(
translate("EM", "FHPath base object shape is null"))
return
if not obj.Base.Shape.isValid():
FreeCAD.Console.PrintWarning(
translate("EM", "FHPath base object shape is invalid"))
return
if obj.Width == None or obj.Width <= 0:
obj.Width = EMFHPATH_DEF_SEGWIDTH
if obj.Height == None or obj.Height <= 0:
obj.Height = EMFHPATH_DEF_SEGHEIGHT
# the FHPath has no Placement in itself; nodes positions will be in absolute
# coordinates, as this is what FastHenry understands.
# The FHSPath Placement is kept at zero, and the 'Base'
# object Position will be used to find the absolute coordinates
# of the vertexes, and the segments cross-section orientation will be
# calculated in absolute coordinates from the Positions rotations.
# This last part is different from FHSegment.
if obj.Placement != FreeCAD.Placement():
obj.Placement = FreeCAD.Placement()
# define nodes and segments
edges_raw = []
# checking TypeId; cannot check type(obj), too generic
if obj.Base.TypeId == "Sketcher::SketchObject":
if obj.Base.Shape.ShapeType == "Wire":
edges_raw.extend(obj.Base.Shape.Edges)
# compound
elif obj.Base.TypeId == "Part::Compound":
edges_raw.extend(obj.Base.Shape.Edges)
# line or DWire (Draft Wire)
elif obj.Base.TypeId == "Part::Part2DObjectPython":
if obj.Base.Shape.ShapeType == "Wire" or obj.Base.Shape.ShapeType == "Edge":
edges_raw.extend(obj.Base.Shape.Edges)
# wire created by upgrading a set of (connected) edges
elif obj.Base.TypeId == "Part::Feature":
if obj.Base.Shape.ShapeType == "Wire":
edges_raw.extend(obj.Base.Shape.Edges)
# any other part, provided it has a 'Shape' attribute
else:
if hasattr(obj.Base, "Shape"):
edges_raw.extend(obj.Base.Shape.Edges)
else:
FreeCAD.Console.PrintWarning(
translate("EM", "Unsupported base object type for FHPath"))
return
# sort the edges. Remark: the edge list might be disconnected (e.g. can happen with a compound
# containing different edges / wires / sketches). We will join the dangling endpoints with segments later on
edges = Part.__sortEdges__(edges_raw)
if edges == []:
return
# get the max between the 'obj.Width' and the 'obj.Height'
if obj.Width > obj.Height:
geodim = obj.Width
else:
geodim = obj.Height
# scan edges and derive node positions
self.nodeCoords = []
# initialize 'lastvertex' to the position of the first vertex,
# (as if we had a previous segment)
lastvertex = edges[0].valueAt(edges[0].FirstParameter)
self.nodeCoords.append(lastvertex)
for edge in edges:
# might also rely on "edge.Curve.discretize(Deflection=geodim)"
# where Deflection is the max distance between any point on the curve,
# and the polygon approximating the curve
if type(edge.Curve) == Part.Circle:
# discretize only if required by the user, and if the curvature radius is not too small
# vs. the max between the 'obj.Width' and the 'obj.Height'
if obj.Discr <= 1 or edge.Curve.Radius < geodim * EMFHPATH_TIMESWIDTH:
ddisc = 1
else:
ddisc = obj.Discr
elif type(edge.Curve) == Part.Ellipse:
# discretize
if obj.Discr <= 1 or edge.Curve.MajorRadius < geodim * EMFHPATH_TIMESWIDTH or edge.Curve.MinorRadius < geodim * EMFHPATH_TIMESWIDTH:
ddisc = 1
else:
ddisc = obj.Discr
elif type(edge.Curve) == Part.Line:
# if Part.Line, do not discretize
ddisc = 1
else:
# if any other type of curve, discretize, no matter what.
# It will be up to the user to decide if the discretization is ok.
if obj.Discr <= 1:
ddisc = 1
else:
ddisc = obj.Discr
# check if the edge is not too short (could happen e.g. for Part.Line)
# Note that we calculate the length from 'lastvertex', as we may have skipped also
# some previous edges, if too short in their turn
if edge.Length < geodim * EMFHPATH_TIMESWIDTH:
FreeCAD.Console.PrintWarning(
translate(
"EM",
"An edge of the Base object supporting the FHPath is too short. FastHenry simulation may fail."
))
step = (edge.LastParameter - edge.FirstParameter) / ddisc
# if same the last vertex of the previous edge is coincident
# with the first vertex of the next edge, skip the vertex
if (lastvertex - edge.valueAt(
edge.FirstParameter)).Length < EMFHSEGMENT_LENTOL:
start = 1
else:
start = 0
for i in range(start, ddisc):
# always skip last vertex, will add this at the end
self.nodeCoords.append(
edge.valueAt(edge.FirstParameter + i * step))
# now add the very last vertex ('LastParameter' provides the exact position)
lastvertex = edge.valueAt(edge.LastParameter)
self.nodeCoords.append(lastvertex)
if len(self.nodeCoords) < 2:
FreeCAD.Console.PrintWarning(
translate(
"EM",
"Less than two nodes found, cannot create the FHPath"))
return
# find the cross-section orientation of the first segment, according to the 'Base' object Placement.
# If 'obj.ww' is not defined, use the FastHenry default (see makeSegShape() )
self.ww = []
if obj.ww.Length < EMFHSEGMENT_LENTOL:
# this is zero anyway (i.e. below 'EMFHSEGMENT_LENTOL')
self.ww = [Vector(0, 0, 0)]
else:
# transform 'obj.ww' according to the 'Base' Placement
# (translation is don't care, we worry about rotation)
self.ww = [obj.Base.Placement.multVec(obj.ww)]
shapes = []
# get node positions in absolute coordinates (at least two nodes exist, checked above)
n1 = getAbsCoordBodyPart(obj.Base, self.nodeCoords[0])
n2 = getAbsCoordBodyPart(obj.Base, self.nodeCoords[1])
vNext = n2 - n1
for i in range(1, len(self.nodeCoords)):
vPrev = vNext
shape = makeSegShape(n1, n2, obj.Width, obj.Height, self.ww[-1])
shapes.append(shape)
# now we must calculate the cross-section orientation
# of the next segment, i.e. update 'ww'
if i < len(self.nodeCoords) - 1:
n1 = n2
n2 = getAbsCoordBodyPart(obj.Base, self.nodeCoords[i + 1])
vNext = n2 - n1
# get angle in radians
angle = vPrev.getAngle(vNext)
# if the angle is actually greater than EMFHSEGMENT_PARTOL (i.e. the segments are not co-linear
# or almost co-linear)
if angle * FreeCAD.Units.Radian > EMFHSEGMENT_PARTOL:
normal = vPrev.cross(vNext)
# rotate 'ww'
ww = DraftVecUtils.rotate(self.ww[-1], angle, normal)
else:
# otherwise, keep the previous orientation
ww = self.ww[-1]
self.ww.append(ww)
shape = Part.makeCompound(shapes)
# now create or assign FHNodes
nodes = obj.Nodes
numnodes = len(nodes)
modified = False
import EM_FHNode
# if there are less FHNodes than required, extend them
if numnodes < len(self.nodeCoords):
modified = True
for index in range(0, len(self.nodeCoords) - numnodes):
# create a new FHNode at the nodeCoords position
node = EM_FHNode.makeFHNode(
X=self.nodeCoords[numnodes + index].x,
Y=self.nodeCoords[numnodes + index].y,
Z=self.nodeCoords[numnodes + index].z)
# insert the new node before the last (the last node always stays the same,
# to preserve FHPath attachments to other structures, if the FHPath shape changes)
nodes.insert(-1, node)
# if instead there are more FHNodes than required, must remove some of them
elif numnodes > len(self.nodeCoords):
# but do it only if there are more than two nodes left in the FHPath,
# otherwise we assume this is a temporary change of FHPath shape,
# and we preserve the end nodes (do not remove them)
if numnodes > 2:
modified = True
# scan backwards, skipping the last node (last element is 'numnodes-1',
# and range scans up to the last element before 'numnodes-len(self.nodeCoords)-1'
for index in range(numnodes - 2, len(self.nodeCoords) - 2, -1):
# remove the node from the 'nodes' list, but keeping the last node
node = nodes[index]
nodes.pop(index)
# check if we can safely remove the extra nodes from the Document;
# this can be done only if they do not belong to any other object.
# So if the 'InList' member contains one element only, this is
# the parent FHPath (we actually check for zero as well, even if
# this should never happen), so we can remove the FHNode
if len(node.InList) <= 1:
node.Document.removeObject(node.Name)
# and finally correct node positions
for node, nodeCoord in zip(nodes, self.nodeCoords):
# only if node position is not correct, change it
if (node.Proxy.getAbsCoord() -
nodeCoord).Length > EMFHSEGMENT_LENTOL:
node.Proxy.setAbsCoord(nodeCoord)
# only if we modified the list of nodes, re-assign it to the FHPath
if modified:
obj.Nodes = nodes
# shape may be None, e.g. if endpoints coincide. Do not assign in this case
if shape:
obj.Shape = shape
h = rim_h,
axis_h = axis_punta, axis_ra = axis_lateral_n,
axis_rb = None,
end_angle = end_angle,
pos_h = 1, pos_ra = 0, pos_rb = 0,
xtr_top=1, xtr_bot=1,
xtr_r_out=0, xtr_r_in=0,
pos = orotu_base_pos)
#Part.show(shp_rim_rail2)
cut_l.append(shp_rim_rail2)
rail_d = rail_r_out - rail_r_in
lock_d = (2*lock_dict['head_r'] + (rail_d))/2.
lock_pos_1_dir = DraftVecUtils.rotate(axis_lateral,
end_radangle, axis_punta)
lock_pos_1 = orotu_base_pos + DraftVecUtils.scale(lock_pos_1_dir, r_bolt2cen)
shp_lock_1 = fcfun.shp_cyl_gen (r = lock_d/2., h = rim_h, axis_h = axis_punta,
xtr_top =1, xtr_bot =1, pos = lock_pos_1,
pos_h =1)
#Part.show(shp_lock_1)
cut_l.append(shp_lock_1)
lock_pos_2_dir = DraftVecUtils.rotate(axis_lateral_n,
end_radangle, axis_punta)
lock_pos_2 = orotu_base_pos + DraftVecUtils.scale(lock_pos_2_dir, r_bolt2cen)
shp_lock_2 = fcfun.shp_cyl_gen (r = lock_d/2., h = rim_h, axis_h = axis_punta,
def getSVG(obj,
scale=1,
linewidth=0.35,
fontsize=12,
fillstyle="shape color",
direction=None,
linestyle=None,
color=None,
linespacing=None,
techdraw=False,
rotation=0,
fillSpaces=False,
override=True):
'''getSVG(object,[scale], [linewidth],[fontsize],[fillstyle],[direction],[linestyle],[color],[linespacing]):
returns a string containing a SVG representation of the given object,
with the given linewidth and fontsize (used if the given object contains
any text). You can also supply an arbitrary projection vector. the
scale parameter allows to scale linewidths down, so they are resolution-independant.'''
import Part, DraftGeomUtils
# if this is a group, gather all the svg views of its children
if hasattr(obj, "isDerivedFrom"):
if obj.isDerivedFrom("App::DocumentObjectGroup") or getType(
obj) == "Layer":
svg = ""
for child in obj.Group:
svg += getSVG(child, scale, linewidth, fontsize, fillstyle,
direction, linestyle, color, linespacing,
techdraw, rotation, fillSpaces, override)
return svg
pathdata = []
svg = ""
linewidth = float(linewidth) / scale
if not override:
if hasattr(obj, "ViewObject"):
if hasattr(obj.ViewObject, "LineWidth"):
if hasattr(obj.ViewObject.LineWidth, "Value"):
lw = obj.ViewObject.LineWidth.Value
else:
lw = obj.ViewObject.LineWidth
linewidth = lw * linewidth
fontsize = (float(fontsize) / scale) / 2
if linespacing:
linespacing = float(linespacing) / scale
else:
linespacing = 0.5
#print obj.Label," line spacing ",linespacing,"scale ",scale
pointratio = .75 # the number of times the dots are smaller than the arrow size
plane = None
if direction:
if isinstance(direction, FreeCAD.Vector):
if direction != Vector(0, 0, 0):
plane = WorkingPlane.plane()
plane.alignToPointAndAxis_SVG(Vector(0, 0, 0),
direction.negative().negative(),
0)
elif isinstance(direction, WorkingPlane.plane):
plane = direction
stroke = "#000000"
if color and override:
if "#" in color:
stroke = color
else:
stroke = getrgb(color)
elif gui:
if hasattr(obj, "ViewObject"):
if hasattr(obj.ViewObject, "LineColor"):
stroke = getrgb(obj.ViewObject.LineColor)
elif hasattr(obj.ViewObject, "TextColor"):
stroke = getrgb(obj.ViewObject.TextColor)
lstyle = "none"
if override:
lstyle = getLineStyle(linestyle, scale)
else:
if hasattr(obj, "ViewObject"):
if hasattr(obj.ViewObject, "DrawStyle"):
lstyle = getLineStyle(obj.ViewObject.DrawStyle, scale)
def getPath(edges=[], wires=[], pathname=None):
svg = "<path "
if pathname is None:
svg += 'id="%s" ' % obj.Name
elif pathname != "":
svg += 'id="%s" ' % pathname
svg += ' d="'
if not wires:
egroups = Part.sortEdges(edges)
else:
egroups = []
first = True
for w in wires:
w1 = w.copy()
if first:
first = False
else:
# invert further wires to create holes
w1 = DraftGeomUtils.invert(w1)
w1.fixWire()
egroups.append(Part.__sortEdges__(w1.Edges))
for egroupindex, edges in enumerate(egroups):
edata = ""
vs = () #skipped for the first edge
for edgeindex, e in enumerate(edges):
previousvs = vs
# vertexes of an edge (reversed if needed)
vs = e.Vertexes
if previousvs:
if (vs[0].Point - previousvs[-1].Point).Length > 1e-6:
vs.reverse()
if edgeindex == 0:
v = getProj(vs[0].Point, plane)
edata += 'M ' + str(v.x) + ' ' + str(v.y) + ' '
else:
if (vs[0].Point - previousvs[-1].Point).Length > 1e-6:
raise ValueError('edges not ordered')
iscircle = DraftGeomUtils.geomType(e) == "Circle"
isellipse = DraftGeomUtils.geomType(e) == "Ellipse"
if iscircle or isellipse:
import math
if hasattr(FreeCAD, "DraftWorkingPlane"):
drawing_plane_normal = FreeCAD.DraftWorkingPlane.axis
else:
drawing_plane_normal = FreeCAD.Vector(0, 0, 1)
if plane: drawing_plane_normal = plane.axis
c = e.Curve
if round(c.Axis.getAngle(drawing_plane_normal),
2) in [0, 3.14]:
occversion = Part.OCC_VERSION.split(".")
done = False
if (int(occversion[0]) >= 7) and (int(occversion[1]) >=
1):
# if using occ >= 7.1, use HLR algorithm
import Drawing
snip = Drawing.projectToSVG(
e, drawing_plane_normal)
if snip:
try:
a = "A " + snip.split("path d=\"")[
1].split("\"")[0].split("A")[1]
except:
pass
else:
edata += a
done = True
if not done:
if len(e.Vertexes
) == 1 and iscircle: #complete curve
svg = getCircle(e)
return svg
elif len(e.Vertexes) == 1 and isellipse:
#svg = getEllipse(e)
#return svg
endpoints = [
getProj(
c.value((c.LastParameter -
c.FirstParameter) / 2.0),
plane),
getProj(vs[-1].Point, plane)
]
else:
endpoints = [getProj(vs[-1].Point, plane)]
# arc
if iscircle:
rx = ry = c.Radius
rot = 0
else: #ellipse
rx = c.MajorRadius
ry = c.MinorRadius
rot = math.degrees(c.AngleXU * (c.Axis * \
FreeCAD.Vector(0,0,1)))
if rot > 90:
rot -= 180
if rot < -90:
rot += 180
#be careful with the sweep flag
flag_large_arc = (((e.ParameterRange[1] - \
e.ParameterRange[0]) / math.pi) % 2) > 1
#flag_sweep = (c.Axis * drawing_plane_normal >= 0) \
# == (e.LastParameter > e.FirstParameter)
# == (e.Orientation == "Forward")
# other method: check the direction of the angle between tangents
t1 = e.tangentAt(e.FirstParameter)
t2 = e.tangentAt(
e.FirstParameter +
(e.LastParameter - e.FirstParameter) / 10)
flag_sweep = (DraftVecUtils.angle(
t1, t2, drawing_plane_normal) < 0)
for v in endpoints:
edata += 'A %s %s %s %s %s %s %s ' % \
(str(rx),str(ry),str(rot),\
str(int(flag_large_arc)),\
str(int(flag_sweep)),str(v.x),str(v.y))
else:
edata += getDiscretized(e, plane)
elif DraftGeomUtils.geomType(e) == "Line":
v = getProj(vs[-1].Point, plane)
edata += 'L ' + str(v.x) + ' ' + str(v.y) + ' '
else:
bspline = e.Curve.toBSpline(e.FirstParameter,
e.LastParameter)
if bspline.Degree > 3 or bspline.isRational():
try:
bspline = bspline.approximateBSpline(
0.05, 50, 3, 'C0')
except RuntimeError:
print("Debug: unable to approximate bspline")
if bspline.Degree <= 3 and not bspline.isRational():
for bezierseg in bspline.toBezier():
if bezierseg.Degree > 3: #should not happen
raise AssertionError
elif bezierseg.Degree == 1:
edata += 'L '
elif bezierseg.Degree == 2:
edata += 'Q '
elif bezierseg.Degree == 3:
edata += 'C '
for pole in bezierseg.getPoles()[1:]:
v = getProj(pole, plane)
edata += str(v.x) + ' ' + str(v.y) + ' '
else:
print("Debug: one edge (hash ",e.hashCode(),\
") has been discretized with parameter 0.1")
for linepoint in bspline.discretize(0.1)[1:]:
v = getProj(linepoint, plane)
edata += 'L ' + str(v.x) + ' ' + str(v.y) + ' '
if fill != 'none':
edata += 'Z '
if edata in pathdata:
# do not draw a path on another identical path
return ""
else:
svg += edata
pathdata.append(edata)
svg += '" '
svg += 'stroke="' + stroke + '" '
svg += 'stroke-width="' + str(linewidth) + ' px" '
svg += 'style="stroke-width:' + str(linewidth)
svg += ';stroke-miterlimit:4'
svg += ';stroke-dasharray:' + lstyle
svg += ';fill:' + fill
try:
svg += ';fill-opacity:' + str(fill_opacity)
except NameError:
pass
svg += ';fill-rule: evenodd "'
svg += '/>\n'
return svg
def getCircle(edge):
cen = getProj(edge.Curve.Center, plane)
rad = edge.Curve.Radius
if hasattr(FreeCAD, "DraftWorkingPlane"):
drawing_plane_normal = FreeCAD.DraftWorkingPlane.axis
else:
drawing_plane_normal = FreeCAD.Vector(0, 0, 1)
if plane: drawing_plane_normal = plane.axis
if round(edge.Curve.Axis.getAngle(drawing_plane_normal),
2) in [0, 3.14]:
# perpendicular projection: circle
svg = '<circle cx="' + str(cen.x)
svg += '" cy="' + str(cen.y)
svg += '" r="' + str(rad) + '" '
else:
# any other projection: ellipse
svg = '<path d="'
svg += getDiscretized(edge, plane)
svg += '" '
svg += 'stroke="' + stroke + '" '
svg += 'stroke-width="' + str(linewidth) + ' px" '
svg += 'style="stroke-width:' + str(linewidth)
svg += ';stroke-miterlimit:4'
svg += ';stroke-dasharray:' + lstyle
svg += ';fill:' + fill + '"'
svg += '/>\n'
return svg
def getEllipse(edge):
cen = getProj(edge.Curve.Center, plane)
mir = edge.Curve.MinorRadius
mar = edge.Curve.MajorRadius
svg = '<ellipse cx="' + str(cen.x)
svg += '" cy="' + str(cen.y)
svg += '" rx="' + str(mar)
svg += '" ry="' + str(mir) + '" '
svg += 'stroke="' + stroke + '" '
svg += 'stroke-width="' + str(linewidth) + ' px" '
svg += 'style="stroke-width:' + str(linewidth)
svg += ';stroke-miterlimit:4'
svg += ';stroke-dasharray:' + lstyle
svg += ';fill:' + fill + '"'
svg += '/>\n'
return svg
def getArrow(arrowtype, point, arrowsize, color, linewidth, angle=0):
svg = ""
if gui:
if not obj.ViewObject:
return svg
if obj.ViewObject.ArrowType == "Circle":
svg += '<circle cx="' + str(point.x) + '" cy="' + str(point.y)
svg += '" r="' + str(arrowsize) + '" '
svg += 'fill="none" stroke="' + color + '" '
svg += 'style="stroke-width:' + str(
linewidth) + ';stroke-miterlimit:4;stroke-dasharray:none" '
svg += 'freecad:skip="1"'
svg += '/>\n'
elif obj.ViewObject.ArrowType == "Dot":
svg += '<circle cx="' + str(point.x) + '" cy="' + str(point.y)
svg += '" r="' + str(arrowsize) + '" '
svg += 'fill="' + color + '" stroke="none" '
svg += 'style="stroke-miterlimit:4;stroke-dasharray:none" '
svg += 'freecad:skip="1"'
svg += '/>\n'
elif obj.ViewObject.ArrowType == "Arrow":
svg += '<path transform="rotate(' + str(math.degrees(angle))
svg += ',' + str(point.x) + ',' + str(point.y) + ') '
svg += 'translate(' + str(point.x) + ',' + str(point.y) + ') '
svg += 'scale(' + str(arrowsize) + ',' + str(
arrowsize) + ')" freecad:skip="1" '
svg += 'fill="' + color + '" stroke="none" '
svg += 'style="stroke-miterlimit:4;stroke-dasharray:none" '
svg += 'd="M 0 0 L 4 1 L 4 -1 Z"/>\n'
elif obj.ViewObject.ArrowType == "Tick":
svg += '<path transform="rotate(' + str(math.degrees(angle))
svg += ',' + str(point.x) + ',' + str(point.y) + ') '
svg += 'translate(' + str(point.x) + ',' + str(point.y) + ') '
svg += 'scale(' + str(arrowsize) + ',' + str(
arrowsize) + ')" freecad:skip="1" '
svg += 'fill="' + color + '" stroke="none" '
svg += 'style="stroke-miterlimit:4;stroke-dasharray:none" '
svg += 'd="M -1 -2 L 0 2 L 1 2 L 0 -2 Z"/>\n'
elif obj.ViewObject.ArrowType == "Tick-2":
svg += '<line transform="rotate(' + str(
math.degrees(angle) + 45)
svg += ',' + str(point.x) + ',' + str(point.y) + ') '
svg += 'translate(' + str(point.x) + ',' + str(point.y) + ') '
svg += '" freecad:skip="1" '
svg += 'fill="none" stroke="' + color + '" '
svg += 'style="stroke-dasharray:none;stroke-linecap:square;'
svg += 'stroke-width:' + str(linewidth) + '" '
svg += 'x1="-' + str(arrowsize * 2) + '" y1="0" '
svg += 'x2="' + str(arrowsize * 2) + '" y2="0" />\n'
else:
print("getSVG: arrow type not implemented")
return svg
def getOvershoot(point, shootsize, color, linewidth, angle=0):
svg = '<line transform="rotate(' + str(math.degrees(angle))
svg += ',' + str(point.x) + ',' + str(point.y) + ') '
svg += 'translate(' + str(point.x) + ',' + str(point.y) + ') '
svg += '" freecad:skip="1" '
svg += 'fill="none" stroke="' + color + '" '
svg += 'style="stroke-dasharray:none;stroke-linecap:square;'
svg += 'stroke-width:' + str(linewidth) + '" '
svg += 'x1="0" y1="0" '
svg += 'x2="' + str(shootsize * -1) + '" y2="0" />\n'
return svg
def getText(tcolor,
fontsize,
fontname,
angle,
base,
text,
linespacing=0.5,
align="center",
flip=True):
if isinstance(angle, FreeCAD.Rotation):
if not plane:
angle = angle.Angle
else:
if plane.axis.getAngle(angle.Axis) < 0.001:
angle = angle.Angle
elif abs(plane.axis.getAngle(angle.Axis) - math.pi) < 0.001:
if abs(angle.Angle) > 0.1:
angle = -angle.Angle
else:
angle = angle.Angle
elif abs(plane.axis.getAngle(angle.Axis) -
math.pi / 2) < 0.001:
return "" # text is perpendicular to view, so it shouldn't appear
else:
angle = 0 #TODO maybe there is something better to do here?
if not isinstance(text, list):
text = text.split("\n")
if align.lower() == "center":
anchor = "middle"
elif align.lower() == "left":
anchor = "start"
else:
anchor = "end"
if techdraw:
svg = ""
for i in range(len(text)):
t = text[i].replace("&", "&").replace("<", "<").replace(
">", ">")
if six.PY2 and not isinstance(t, six.text_type):
t = t.decode("utf8")
# possible workaround if UTF8 is unsupported
# import unicodedata
# t = u"".join([c for c in unicodedata.normalize("NFKD",t) if not unicodedata.combining(c)]).encode("utf8")
svg += '<text stroke-width="0" stroke="' + tcolor + '" fill="' + tcolor + '" font-size="' + str(
fontsize) + '" '
svg += 'style="text-anchor:' + anchor + ';text-align:' + align.lower(
) + ';'
svg += 'font-family:' + fontname + '" '
svg += 'transform="rotate(' + str(math.degrees(angle))
svg += ',' + str(
base.x) + ',' + str(base.y - linespacing * i) + ') '
svg += 'translate(' + str(
base.x) + ',' + str(base.y - linespacing * i) + ') '
svg += 'scale(1,-1)" '
#svg += '" freecad:skip="1"'
svg += '>\n' + t + '</text>\n'
else:
svg = '<text stroke-width="0" stroke="' + tcolor + '" fill="'
svg += tcolor + '" font-size="'
svg += str(fontsize) + '" '
svg += 'style="text-anchor:' + anchor + ';text-align:' + align.lower(
) + ';'
svg += 'font-family:' + fontname + '" '
svg += 'transform="rotate(' + str(math.degrees(angle))
svg += ',' + str(base.x) + ',' + str(base.y) + ') '
if flip:
svg += 'translate(' + str(base.x) + ',' + str(base.y) + ')'
else:
svg += 'translate(' + str(base.x) + ',' + str(-base.y) + ')'
#svg += 'scale('+str(tmod/2000)+',-'+str(tmod/2000)+') '
if flip:
svg += ' scale(1,-1) '
else:
svg += ' scale(1,1) '
svg += '" freecad:skip="1"'
svg += '>\n'
if len(text) == 1:
try:
svg += text[0].replace("&", "&").replace(
"<", "<").replace(">", ">")
except:
svg += text[0].decode("utf8").replace(
"&", "&").replace("<",
"<").replace(">", ">")
else:
for i in range(len(text)):
if i == 0:
svg += '<tspan>'
else:
svg += '<tspan x="0" dy="' + str(linespacing) + '">'
try:
svg += text[i].replace("&", "&").replace(
"<", "<").replace(">", ">")
except:
svg += text[i].decode("utf8").replace(
"&", "&").replace("<",
"<").replace(">", ">")
svg += '</tspan>\n'
svg += '</text>\n'
return svg
if not obj:
pass
elif isinstance(obj, Part.Shape):
if "#" in fillstyle:
fill = fillstyle
elif fillstyle == "shape color":
fill = "#888888"
else:
fill = 'url(#' + fillstyle + ')'
svg += getPath(obj.Edges, pathname="")
elif getType(obj) in ["Dimension", "LinearDimension"]:
if gui:
if not obj.ViewObject:
print(
"export of dimensions to SVG is only available in GUI mode"
)
elif obj.ViewObject.Proxy:
if hasattr(obj.ViewObject.Proxy, "p1"):
prx = obj.ViewObject.Proxy
ts = (len(prx.string) *
obj.ViewObject.FontSize.Value) / 4.0
rm = ((prx.p3.sub(prx.p2)).Length / 2.0) - ts
p2a = getProj(
prx.p2.add(
DraftVecUtils.scaleTo(prx.p3.sub(prx.p2), rm)),
plane)
p2b = getProj(
prx.p3.add(
DraftVecUtils.scaleTo(prx.p2.sub(prx.p3), rm)),
plane)
p1 = getProj(prx.p1, plane)
p2 = getProj(prx.p2, plane)
p3 = getProj(prx.p3, plane)
p4 = getProj(prx.p4, plane)
tbase = getProj(prx.tbase, plane)
r = prx.textpos.rotation.getValue().getValue()
rv = FreeCAD.Rotation(r[0], r[1], r[2], r[3]).multVec(
FreeCAD.Vector(1, 0, 0))
angle = -DraftVecUtils.angle(getProj(rv, plane))
#angle = -DraftVecUtils.angle(p3.sub(p2))
svg = ''
nolines = False
if hasattr(obj.ViewObject, "ShowLine"):
if not obj.ViewObject.ShowLine:
nolines = True
# drawing lines
if not nolines:
svg += '<path '
if obj.ViewObject.DisplayMode == "2D":
tangle = angle
if tangle > math.pi / 2:
tangle = tangle - math.pi
#elif (tangle <= -math.pi/2) or (tangle > math.pi/2):
# tangle = tangle+math.pi
#tbase = tbase.add(DraftVecUtils.rotate(Vector(0,2/scale,0),tangle))
if rotation != 0:
#print "dim: tangle:",tangle," rot: ",rotation," text: ",prx.string
if abs(tangle + math.radians(rotation)) < 0.0001:
tangle += math.pi
tbase = tbase.add(
DraftVecUtils.rotate(
Vector(0, 2 / scale, 0), tangle))
if not nolines:
svg += 'd="M ' + str(p1.x) + ' ' + str(p1.y) + ' '
svg += 'L ' + str(p2.x) + ' ' + str(p2.y) + ' '
svg += 'L ' + str(p3.x) + ' ' + str(p3.y) + ' '
svg += 'L ' + str(p4.x) + ' ' + str(p4.y) + '" '
else:
tangle = 0
if rotation != 0:
tangle = -math.radians(rotation)
tbase = tbase.add(Vector(0, -2.0 / scale, 0))
if not nolines:
svg += 'd="M ' + str(p1.x) + ' ' + str(p1.y) + ' '
svg += 'L ' + str(p2.x) + ' ' + str(p2.y) + ' '
svg += 'L ' + str(p2a.x) + ' ' + str(p2a.y) + ' '
svg += 'M ' + str(p2b.x) + ' ' + str(p2b.y) + ' '
svg += 'L ' + str(p3.x) + ' ' + str(p3.y) + ' '
svg += 'L ' + str(p4.x) + ' ' + str(p4.y) + '" '
if not nolines:
svg += 'fill="none" stroke="'
svg += stroke + '" '
svg += 'stroke-width="' + str(linewidth) + ' px" '
svg += 'style="stroke-width:' + str(linewidth)
svg += ';stroke-miterlimit:4;stroke-dasharray:none" '
svg += 'freecad:basepoint1="' + str(p1.x) + ' ' + str(
p1.y) + '" '
svg += 'freecad:basepoint2="' + str(p4.x) + ' ' + str(
p4.y) + '" '
svg += 'freecad:dimpoint="' + str(p2.x) + ' ' + str(
p2.y) + '"'
svg += '/>\n'
# drawing dimension and extension lines overshoots
if hasattr(obj.ViewObject, "DimOvershoot"
) and obj.ViewObject.DimOvershoot.Value:
shootsize = obj.ViewObject.DimOvershoot.Value / pointratio
svg += getOvershoot(p2, shootsize, stroke,
linewidth, angle)
svg += getOvershoot(p3, shootsize, stroke,
linewidth, angle + math.pi)
if hasattr(obj.ViewObject, "ExtOvershoot"
) and obj.ViewObject.ExtOvershoot.Value:
shootsize = obj.ViewObject.ExtOvershoot.Value / pointratio
shootangle = -DraftVecUtils.angle(p1.sub(p2))
svg += getOvershoot(p2, shootsize, stroke,
linewidth, shootangle)
svg += getOvershoot(p3, shootsize, stroke,
linewidth, shootangle)
# drawing arrows
if hasattr(obj.ViewObject, "ArrowType"):
arrowsize = obj.ViewObject.ArrowSize.Value / pointratio
if hasattr(obj.ViewObject, "FlipArrows"):
if obj.ViewObject.FlipArrows:
angle = angle + math.pi
svg += getArrow(obj.ViewObject.ArrowType, p2,
arrowsize, stroke, linewidth,
angle)
svg += getArrow(obj.ViewObject.ArrowType, p3,
arrowsize, stroke, linewidth,
angle + math.pi)
# drawing text
svg += getText(stroke, fontsize, obj.ViewObject.FontName,
tangle, tbase, prx.string)
elif getType(obj) == "AngularDimension":
if gui:
if not obj.ViewObject:
print(
"export of dimensions to SVG is only available in GUI mode"
)
elif obj.ViewObject.Proxy:
if hasattr(obj.ViewObject.Proxy, "circle"):
prx = obj.ViewObject.Proxy
# drawing arc
fill = "none"
if obj.ViewObject.DisplayMode == "2D":
svg += getPath([prx.circle])
else:
if hasattr(prx, "circle1"):
svg += getPath([prx.circle1])
svg += getPath([prx.circle2])
else:
svg += getPath([prx.circle])
# drawing arrows
if hasattr(obj.ViewObject, "ArrowType"):
p2 = getProj(prx.p2, plane)
p3 = getProj(prx.p3, plane)
arrowsize = obj.ViewObject.ArrowSize.Value / pointratio
arrowlength = 4 * obj.ViewObject.ArrowSize.Value
u1 = getProj(
(prx.circle.valueAt(prx.circle.FirstParameter +
arrowlength)
).sub(
prx.circle.valueAt(
prx.circle.FirstParameter)), plane)
u2 = getProj(
(prx.circle.valueAt(prx.circle.LastParameter -
arrowlength)
).sub(prx.circle.valueAt(
prx.circle.LastParameter)), plane)
angle1 = -DraftVecUtils.angle(u1)
angle2 = -DraftVecUtils.angle(u2)
if hasattr(obj.ViewObject, "FlipArrows"):
if obj.ViewObject.FlipArrows:
angle1 = angle1 + math.pi
angle2 = angle2 + math.pi
svg += getArrow(obj.ViewObject.ArrowType, p2,
arrowsize, stroke, linewidth, angle1)
svg += getArrow(obj.ViewObject.ArrowType, p3,
arrowsize, stroke, linewidth, angle2)
# drawing text
if obj.ViewObject.DisplayMode == "2D":
t = prx.circle.tangentAt(prx.circle.FirstParameter +
(prx.circle.LastParameter -
prx.circle.FirstParameter) /
2.0)
t = getProj(t, plane)
tangle = DraftVecUtils.angle(t)
if (tangle <= -math.pi / 2) or (tangle > math.pi / 2):
tangle = tangle + math.pi
tbase = getProj(
prx.circle.valueAt(prx.circle.FirstParameter +
(prx.circle.LastParameter -
prx.circle.FirstParameter) /
2.0), plane)
tbase = tbase.add(
DraftVecUtils.rotate(Vector(0, 2.0 / scale, 0),
tangle))
#print(tbase)
else:
tangle = 0
tbase = getProj(prx.tbase, plane)
svg += getText(stroke, fontsize, obj.ViewObject.FontName,
tangle, tbase, prx.string)
elif getType(obj) == "Label":
if getattr(obj.ViewObject, "Line",
True): # some Labels may have no Line property
def format_point(coords, action='L'):
return "{action}{x},{y}".format(x=coords.x,
y=coords.y,
action=action)
# Draw multisegment line
proj_points = list(map(lambda x: getProj(x, plane), obj.Points))
path_dir_list = [format_point(proj_points[0], action='M')]
path_dir_list += map(format_point, proj_points[1:])
path_dir_str = " ".join(path_dir_list)
svg_path = '<path fill="none" stroke="{stroke}" stroke-width="{linewidth}" d="{directions}"/>'.format(
stroke=stroke, linewidth=linewidth, directions=path_dir_str)
svg += svg_path
# Draw arrow.
# We are different here from 3D view
# if Line is set to 'off', no arrow is drawn
if hasattr(obj.ViewObject, "ArrowType") and len(obj.Points) >= 2:
last_segment = FreeCAD.Vector(obj.Points[-1] - obj.Points[-2])
angle = -DraftVecUtils.angle(getProj(last_segment,
plane)) + math.pi
svg += getArrow(arrowtype=obj.ViewObject.ArrowType,
point=proj_points[-1],
arrowsize=obj.ViewObject.ArrowSize.Value /
pointratio,
color=stroke,
linewidth=linewidth,
angle=angle)
# print text
if gui:
if not obj.ViewObject:
print("export of texts to SVG is only available in GUI mode")
else:
fontname = obj.ViewObject.TextFont
position = getProj(obj.Placement.Base, plane)
rotation = obj.Placement.Rotation
justification = obj.ViewObject.TextAlignment
text = obj.Text
svg += getText(stroke, fontsize, fontname, rotation, position,
text, linespacing, justification)
elif getType(obj) in ["Annotation", "DraftText"]:
"returns an svg representation of a document annotation"
if gui:
if not obj.ViewObject:
print("export of texts to SVG is only available in GUI mode")
else:
n = obj.ViewObject.FontName
if getType(obj) == "Annotation":
p = getProj(obj.Position, plane)
r = obj.ViewObject.Rotation.getValueAs("rad")
t = obj.LabelText
else: # DraftText
p = getProj(obj.Placement.Base, plane)
r = obj.Placement.Rotation
t = obj.Text
j = obj.ViewObject.Justification
svg += getText(stroke, fontsize, n, r, p, t, linespacing, j)
elif getType(obj) == "Axis":
"returns the SVG representation of an Arch Axis system"
if gui:
if not obj.ViewObject:
print("export of axes to SVG is only available in GUI mode")
else:
vobj = obj.ViewObject
lorig = lstyle
fill = 'none'
rad = vobj.BubbleSize.Value / 2
n = 0
for e in obj.Shape.Edges:
lstyle = lorig
svg += getPath([e])
lstyle = "none"
pos = ["Start"]
if hasattr(vobj, "BubblePosition"):
if vobj.BubblePosition == "Both":
pos = ["Start", "End"]
else:
pos = [vobj.BubblePosition]
for p in pos:
if p == "Start":
p1 = e.Vertexes[0].Point
p2 = e.Vertexes[1].Point
else:
p1 = e.Vertexes[1].Point
p2 = e.Vertexes[0].Point
dv = p2.sub(p1)
dv.normalize()
center = p2.add(dv.scale(rad, rad, rad))
svg += getCircle(Part.makeCircle(rad, center))
if hasattr(vobj.Proxy, "bubbletexts"):
if len(vobj.Proxy.bubbletexts) >= n:
svg += '<text fill="' + stroke + '" '
svg += 'font-size="' + str(rad) + '" '
svg += 'style="text-anchor:middle;'
svg += 'text-align:center;'
svg += 'font-family: sans;" '
svg += 'transform="translate(' + str(
center.x +
rad / 4.0) + ',' + str(center.y -
rad / 3.0) + ') '
svg += 'scale(1,-1)"> '
svg += '<tspan>' + obj.ViewObject.Proxy.bubbletexts[
n].string.getValues()[0] + '</tspan>\n'
svg += '</text>\n'
n += 1
lstyle = lorig
elif getType(obj) == "Pipe":
fill = stroke
if obj.Base and obj.Diameter:
svg += getPath(obj.Base.Shape.Edges)
for f in obj.Shape.Faces:
if len(f.Edges) == 1:
if isinstance(f.Edges[0].Curve, Part.Circle):
svg += getCircle(f.Edges[0])
elif getType(obj) == "Rebar":
fill = "none"
if obj.Proxy:
if not hasattr(obj.Proxy, "wires"):
obj.Proxy.execute(obj)
if hasattr(obj.Proxy, "wires"):
svg += getPath(wires=obj.Proxy.wires)
elif getType(obj) == "PipeConnector":
pass
elif getType(obj) == "Space":
"returns an SVG fragment for the text of a space"
if gui:
if not obj.ViewObject:
print("export of spaces to SVG is only available in GUI mode")
else:
if fillSpaces:
if hasattr(obj, "Proxy"):
if not hasattr(obj.Proxy, "face"):
obj.Proxy.getArea(obj, notouch=True)
if hasattr(obj.Proxy, "face"):
# setting fill
if gui:
fill = getrgb(obj.ViewObject.ShapeColor,
testbw=False)
fill_opacity = 1 - (
obj.ViewObject.Transparency / 100.0)
else:
fill = "#888888"
svg += getPath(wires=[obj.Proxy.face.OuterWire])
c = getrgb(obj.ViewObject.TextColor)
n = obj.ViewObject.FontName
a = 0
if rotation != 0:
a = math.radians(rotation)
t1 = obj.ViewObject.Proxy.text1.string.getValues()
t2 = obj.ViewObject.Proxy.text2.string.getValues()
scale = obj.ViewObject.FirstLine.Value / obj.ViewObject.FontSize.Value
f1 = fontsize * scale
p2 = obj.Placement.multVec(
FreeCAD.Vector(obj.ViewObject.Proxy.coords.translation.
getValue().getValue()))
lspc = FreeCAD.Vector(obj.ViewObject.Proxy.header.translation.
getValue().getValue())
p1 = p2.add(lspc)
j = obj.ViewObject.TextAlign
t3 = getText(c,
f1,
n,
a,
getProj(p1, plane),
t1,
linespacing,
j,
flip=True)
svg += t3
if t2:
ofs = FreeCAD.Vector(0, -lspc.Length, 0)
if a:
ofs = FreeCAD.Rotation(FreeCAD.Vector(0, 0, 1),
-rotation).multVec(ofs)
t4 = getText(c,
fontsize,
n,
a,
getProj(p1, plane).add(ofs),
t2,
linespacing,
j,
flip=True)
svg += t4
elif obj.isDerivedFrom('Part::Feature'):
if obj.Shape.isNull():
return ''
# setting fill
if obj.Shape.Faces:
if gui:
try:
m = obj.ViewObject.DisplayMode
except AttributeError:
m = None
if (m != "Wireframe"):
if fillstyle == "shape color":
fill = getrgb(obj.ViewObject.ShapeColor, testbw=False)
fill_opacity = 1 - (obj.ViewObject.Transparency /
100.0)
else:
fill = 'url(#' + fillstyle + ')'
svg += getPattern(fillstyle)
else:
fill = "none"
else:
fill = "#888888"
else:
fill = 'none'
if len(obj.Shape.Vertexes) > 1:
wiredEdges = []
if obj.Shape.Faces:
for i, f in enumerate(obj.Shape.Faces):
# place outer wire first
wires = [f.OuterWire]
wires.extend([
w for w in f.Wires
if w.hashCode() != f.OuterWire.hashCode()
])
svg += getPath(wires=f.Wires,pathname='%s_f%04d' % \
(obj.Name,i))
wiredEdges.extend(f.Edges)
else:
for i, w in enumerate(obj.Shape.Wires):
svg += getPath(w.Edges,pathname='%s_w%04d' % \
(obj.Name,i))
wiredEdges.extend(w.Edges)
if len(wiredEdges) != len(obj.Shape.Edges):
for i, e in enumerate(obj.Shape.Edges):
if (DraftGeomUtils.findEdge(e, wiredEdges) is None):
svg += getPath([e],pathname='%s_nwe%04d' % \
(obj.Name,i))
else:
# closed circle or spline
if obj.Shape.Edges:
if isinstance(obj.Shape.Edges[0].Curve, Part.Circle):
svg = getCircle(obj.Shape.Edges[0])
else:
svg = getPath(obj.Shape.Edges)
if FreeCAD.GuiUp:
if hasattr(obj.ViewObject, "EndArrow") and hasattr(
obj.ViewObject,
"ArrowType") and (len(obj.Shape.Vertexes) > 1):
if obj.ViewObject.EndArrow:
p1 = getProj(obj.Shape.Vertexes[-1].Point, plane)
p2 = getProj(obj.Shape.Vertexes[-2].Point, plane)
angle = -DraftVecUtils.angle(p2.sub(p1))
arrowsize = obj.ViewObject.ArrowSize.Value / pointratio
svg += getArrow(obj.ViewObject.ArrowType, p1, arrowsize,
stroke, linewidth, angle)
# techdraw expects bottom-to-top coordinates
if techdraw:
svg = '<g transform ="scale(1,-1)">\n ' + svg + '</g>\n'
return svg
def getSVG(obj,scale=1,linewidth=0.35,fontsize=12,fillstyle="shape color",direction=None,linestyle=None,color=None,linespacing=None,techdraw=False,rotation=0):
'''getSVG(object,[scale], [linewidth],[fontsize],[fillstyle],[direction],[linestyle],[color],[linespacing]):
returns a string containing a SVG representation of the given object,
with the given linewidth and fontsize (used if the given object contains
any text). You can also supply an arbitrary projection vector. the
scale parameter allows to scale linewidths down, so they are resolution-independant.'''
# if this is a group, gather all the svg views of its children
if hasattr(obj,"isDerivedFrom"):
if obj.isDerivedFrom("App::DocumentObjectGroup"):
svg = ""
for child in obj.Group:
svg += getSVG(child,scale,linewidth,fontsize,fillstyle,direction,linestyle,color,linespacing,techdraw)
return svg
pathdata = []
svg = ""
linewidth = float(linewidth)/scale
fontsize = (float(fontsize)/scale)/2
if linespacing:
linespacing = float(linespacing)/scale
else:
linespacing = 0.5
#print obj.Label," line spacing ",linespacing,"scale ",scale
pointratio = .75 # the number of times the dots are smaller than the arrow size
plane = None
if direction:
if isinstance(direction,FreeCAD.Vector):
if direction != Vector(0,0,0):
plane = WorkingPlane.plane()
plane.alignToPointAndAxis_SVG(Vector(0,0,0),direction.negative().negative(),0)
elif isinstance(direction,WorkingPlane.plane):
plane = direction
stroke = "#000000"
if color:
if "#" in color:
stroke = color
else:
stroke = getrgb(color)
elif gui:
if hasattr(obj,"ViewObject"):
if hasattr(obj.ViewObject,"LineColor"):
stroke = getrgb(obj.ViewObject.LineColor)
def getPath(edges=[],wires=[],pathname=None):
import Part,DraftGeomUtils
svg = "<path "
if pathname is None:
svg += 'id="%s" ' % obj.Name
elif pathname != "":
svg += 'id="%s" ' % pathname
svg += ' d="'
if not wires:
egroups = Part.sortEdges(edges)
else:
egroups = []
for w in wires:
w1=w.copy()
w1.fixWire()
egroups.append(Part.__sortEdges__(w1.Edges))
for egroupindex, edges in enumerate(egroups):
edata = ""
vs=() #skipped for the first edge
for edgeindex,e in enumerate(edges):
previousvs = vs
# vertexes of an edge (reversed if needed)
vs = e.Vertexes
if previousvs:
if (vs[0].Point-previousvs[-1].Point).Length > 1e-6:
vs.reverse()
if edgeindex == 0:
v = getProj(vs[0].Point, plane)
edata += 'M '+ str(v.x) +' '+ str(v.y) + ' '
else:
if (vs[0].Point-previousvs[-1].Point).Length > 1e-6:
raise ValueError('edges not ordered')
iscircle = DraftGeomUtils.geomType(e) == "Circle"
isellipse = DraftGeomUtils.geomType(e) == "Ellipse"
if iscircle or isellipse:
import math
if hasattr(FreeCAD,"DraftWorkingPlane"):
drawing_plane_normal = FreeCAD.DraftWorkingPlane.axis
else:
drawing_plane_normal = FreeCAD.Vector(0,0,1)
if plane: drawing_plane_normal = plane.axis
c = e.Curve
if round(c.Axis.getAngle(drawing_plane_normal),2) in [0,3.14]:
occversion = Part.OCC_VERSION.split(".")
done = False
if (int(occversion[0]) >= 7) and (int(occversion[1]) >= 1):
# if using occ >= 7.1, use HLR algorithm
import Drawing
snip = Drawing.projectToSVG(e,drawing_plane_normal)
if snip:
try:
a = "A " + snip.split("path d=\"")[1].split("\"")[0].split("A")[1]
except:
pass
else:
edata += a
done = True
if not done:
if len(e.Vertexes) == 1 and iscircle: #complete curve
svg = getCircle(e)
return svg
elif len(e.Vertexes) == 1 and isellipse:
#svg = getEllipse(e)
#return svg
endpoints = (getProj(c.value((c.LastParameter-\
c.FirstParameter)/2.0), plane), \
getProj(vs[-1].Point, plane))
else:
endpoints = (getProj(vs[-1].Point), plane)
# arc
if iscircle:
rx = ry = c.Radius
rot = 0
else: #ellipse
rx = c.MajorRadius
ry = c.MinorRadius
rot = math.degrees(c.AngleXU * (c.Axis * \
FreeCAD.Vector(0,0,1)))
if rot > 90:
rot -=180
if rot < -90:
rot += 180
#be careful with the sweep flag
flag_large_arc = (((e.ParameterRange[1] - \
e.ParameterRange[0]) / math.pi) % 2) > 1
#flag_sweep = (c.Axis * drawing_plane_normal >= 0) \
# == (e.LastParameter > e.FirstParameter)
# == (e.Orientation == "Forward")
# other method: check the direction of the angle between tangents
t1 = e.tangentAt(e.FirstParameter)
t2 = e.tangentAt(e.FirstParameter + (e.LastParameter-e.FirstParameter)/10)
flag_sweep = (DraftVecUtils.angle(t1,t2,drawing_plane_normal) < 0)
for v in endpoints:
edata += 'A %s %s %s %s %s %s %s ' % \
(str(rx),str(ry),str(rot),\
str(int(flag_large_arc)),\
str(int(flag_sweep)),str(v.x),str(v.y))
else:
edata += getDiscretized(e, plane)
elif DraftGeomUtils.geomType(e) == "Line":
v = getProj(vs[-1].Point, plane)
edata += 'L '+ str(v.x) +' '+ str(v.y) + ' '
else:
bspline=e.Curve.toBSpline(e.FirstParameter,e.LastParameter)
if bspline.Degree > 3 or bspline.isRational():
try:
bspline=bspline.approximateBSpline(0.05,50, 3,'C0')
except RuntimeError:
print("Debug: unable to approximate bspline")
if bspline.Degree <= 3 and not bspline.isRational():
for bezierseg in bspline.toBezier():
if bezierseg.Degree>3: #should not happen
raise AssertionError
elif bezierseg.Degree==1:
edata +='L '
elif bezierseg.Degree==2:
edata +='Q '
elif bezierseg.Degree==3:
edata +='C '
for pole in bezierseg.getPoles()[1:]:
v = getProj(pole, plane)
edata += str(v.x) +' '+ str(v.y) + ' '
else:
print("Debug: one edge (hash ",e.hashCode(),\
") has been discretized with parameter 0.1")
for linepoint in bspline.discretize(0.1)[1:]:
v = getProj(linepoint, plane)
edata += 'L '+ str(v.x) +' '+ str(v.y) + ' '
if fill != 'none':
edata += 'Z '
if edata in pathdata:
# do not draw a path on another identical path
return ""
else:
svg += edata
pathdata.append(edata)
svg += '" '
svg += 'stroke="' + stroke + '" '
svg += 'stroke-width="' + str(linewidth) + ' px" '
svg += 'style="stroke-width:'+ str(linewidth)
svg += ';stroke-miterlimit:4'
svg += ';stroke-dasharray:' + lstyle
svg += ';fill:' + fill
try:
svg += ';fill-opacity:' + str(fill_opacity)
except NameError:
pass
svg += ';fill-rule: evenodd "'
svg += '/>\n'
return svg
def getCircle(edge):
cen = getProj(edge.Curve.Center, plane)
rad = edge.Curve.Radius
if hasattr(FreeCAD,"DraftWorkingPlane"):
drawing_plane_normal = FreeCAD.DraftWorkingPlane.axis
else:
drawing_plane_normal = FreeCAD.Vector(0,0,1)
if plane: drawing_plane_normal = plane.axis
if round(edge.Curve.Axis.getAngle(drawing_plane_normal),2) == 0:
# perpendicular projection: circle
svg = '<circle cx="' + str(cen.x)
svg += '" cy="' + str(cen.y)
svg += '" r="' + str(rad)+'" '
else:
# any other projection: ellipse
svg = '<path d="'
svg += getDiscretized(edge, plane)
svg += '" '
svg += 'stroke="' + stroke + '" '
svg += 'stroke-width="' + str(linewidth) + ' px" '
svg += 'style="stroke-width:'+ str(linewidth)
svg += ';stroke-miterlimit:4'
svg += ';stroke-dasharray:' + lstyle
svg += ';fill:' + fill + '"'
svg += '/>\n'
return svg
def getEllipse(edge):
cen = getProj(edge.Curve.Center, plane)
mir = edge.Curve.MinorRadius
mar = edge.Curve.MajorRadius
svg = '<ellipse cx="' + str(cen.x)
svg += '" cy="' + str(cen.y)
svg += '" rx="' + str(mar)
svg += '" ry="' + str(mir)+'" '
svg += 'stroke="' + stroke + '" '
svg += 'stroke-width="' + str(linewidth) + ' px" '
svg += 'style="stroke-width:'+ str(linewidth)
svg += ';stroke-miterlimit:4'
svg += ';stroke-dasharray:' + lstyle
svg += ';fill:' + fill + '"'
svg += '/>\n'
return svg
def getArrow(arrowtype,point,arrowsize,color,linewidth,angle=0):
svg = ""
if gui:
if not obj.ViewObject:
return svg
if obj.ViewObject.ArrowType == "Circle":
svg += '<circle cx="'+str(point.x)+'" cy="'+str(point.y)
svg += '" r="'+str(arrowsize)+'" '
svg += 'fill="none" stroke="'+ color + '" '
svg += 'style="stroke-width:'+ str(linewidth) + ';stroke-miterlimit:4;stroke-dasharray:none" '
svg += 'freecad:skip="1"'
svg += '/>\n'
elif obj.ViewObject.ArrowType == "Dot":
svg += '<circle cx="'+str(point.x)+'" cy="'+str(point.y)
svg += '" r="'+str(arrowsize)+'" '
svg += 'fill="'+ color +'" stroke="none" '
svg += 'style="stroke-miterlimit:4;stroke-dasharray:none" '
svg += 'freecad:skip="1"'
svg += '/>\n'
elif obj.ViewObject.ArrowType == "Arrow":
svg += '<path transform="rotate('+str(math.degrees(angle))
svg += ','+ str(point.x) + ',' + str(point.y) + ') '
svg += 'translate(' + str(point.x) + ',' + str(point.y) + ') '
svg += 'scale('+str(arrowsize)+','+str(arrowsize)+')" freecad:skip="1" '
svg += 'fill="'+ color +'" stroke="none" '
svg += 'style="stroke-miterlimit:4;stroke-dasharray:none" '
svg += 'd="M 0 0 L 4 1 L 4 -1 Z"/>\n'
elif obj.ViewObject.ArrowType == "Tick":
svg += '<path transform="rotate('+str(math.degrees(angle))
svg += ','+ str(point.x) + ',' + str(point.y) + ') '
svg += 'translate(' + str(point.x) + ',' + str(point.y) + ') '
svg += 'scale('+str(arrowsize)+','+str(arrowsize)+')" freecad:skip="1" '
svg += 'fill="'+ color +'" stroke="none" '
svg += 'style="stroke-miterlimit:4;stroke-dasharray:none" '
svg += 'd="M -1 -2 L 0 2 L 1 2 L 0 -2 Z"/>\n'
elif obj.ViewObject.ArrowType == "Tick-2":
svg += '<line transform="rotate('+str(math.degrees(angle)+45)
svg += ','+ str(point.x) + ',' + str(point.y) + ') '
svg += 'translate(' + str(point.x) + ',' + str(point.y) + ') '
svg += '" freecad:skip="1" '
svg += 'fill="none" stroke="'+ color +'" '
svg += 'style="stroke-dasharray:none;stroke-linecap:square;'
svg += 'stroke-width:'+ str(linewidth) +'" '
svg += 'x1="-'+ str(arrowsize*2) +'" y1="0" '
svg += 'x2="' + str(arrowsize*2) +'" y2="0" />\n'
else:
print("getSVG: arrow type not implemented")
return svg
def getOvershoot(point,shootsize,color,linewidth,angle=0):
svg = '<line transform="rotate('+str(math.degrees(angle))
svg += ','+ str(point.x) + ',' + str(point.y) + ') '
svg += 'translate(' + str(point.x) + ',' + str(point.y) + ') '
svg += '" freecad:skip="1" '
svg += 'fill="none" stroke="'+ color +'" '
svg += 'style="stroke-dasharray:none;stroke-linecap:square;'
svg += 'stroke-width:'+ str(linewidth) +'" '
svg += 'x1="0" y1="0" '
svg += 'x2="'+ str(shootsize*-1) +'" y2="0" />\n'
return svg
def getText(color,fontsize,fontname,angle,base,text,linespacing=0.5,align="center",flip=True):
if isinstance(angle,FreeCAD.Rotation):
if not plane:
angle = angle.Angle
else:
if plane.axis.getAngle(angle.Axis) < 0.001:
angle = angle.Angle
elif abs(plane.axis.getAngle(angle.Axis)-math.pi) < 0.001:
return "" # text is perpendicular to view, so it shouldn't appear
else:
angle = 0 #TODO maybe there is something better to do here?
if not isinstance(text,list):
text = text.split("\n")
if align.lower() == "center":
anchor = "middle"
elif align.lower() == "left":
anchor = "start"
else:
anchor = "end"
if techdraw:
svg = ""
for i in range(len(text)):
t = text[i]
if sys.version_info.major < 3 and (not isinstance(t,unicode)):
t = t.decode("utf8")
# possible workaround if UTF8 is unsupported
# import unicodedata
# t = u"".join([c for c in unicodedata.normalize("NFKD",t) if not unicodedata.combining(c)]).encode("utf8")
svg += '<text fill="' + color +'" font-size="' + str(fontsize) + '" '
svg += 'style="text-anchor:'+anchor+';text-align:'+align.lower()+';'
svg += 'font-family:'+ fontname +'" '
svg += 'transform="rotate('+str(math.degrees(angle))
svg += ','+ str(base.x) + ',' + str(base.y-linespacing*i) + ') '
svg += 'translate(' + str(base.x) + ',' + str(base.y-linespacing*i) + ') '
svg += 'scale(1,-1)" '
#svg += '" freecad:skip="1"'
svg += '>\n' + t + '</text>\n'
else:
svg = '<text fill="'
svg += color +'" font-size="'
svg += str(fontsize) + '" '
svg += 'style="text-anchor:'+anchor+';text-align:'+align.lower()+';'
svg += 'font-family:'+ fontname +'" '
svg += 'transform="rotate('+str(math.degrees(angle))
svg += ','+ str(base.x) + ',' + str(base.y) + ') '
if flip:
svg += 'translate(' + str(base.x) + ',' + str(base.y) + ')'
else:
svg += 'translate(' + str(base.x) + ',' + str(-base.y) + ')'
#svg += 'scale('+str(tmod/2000)+',-'+str(tmod/2000)+') '
if flip:
svg += ' scale(1,-1) '
else:
svg += ' scale(1,1) '
svg += '" freecad:skip="1"'
svg += '>\n'
if len(text) == 1:
try:
svg += text[0]
except:
svg += text[0].decode("utf8")
else:
for i in range(len(text)):
if i == 0:
svg += '<tspan>'
else:
svg += '<tspan x="0" dy="'+str(linespacing)+'">'
try:
svg += text[i]
except:
svg += text[i].decode("utf8")
svg += '</tspan>\n'
svg += '</text>\n'
return svg
if not obj:
pass
elif isinstance(obj,Part.Shape):
if "#" in fillstyle:
fill = fillstyle
elif fillstyle == "shape color":
fill = "#888888"
else:
fill = 'url(#'+fillstyle+')'
lstyle = getLineStyle(linestyle, scale)
svg += getPath(obj.Edges,pathname="")
elif getType(obj) == "Dimension":
if gui:
if not obj.ViewObject:
print ("export of dimensions to SVG is only available in GUI mode")
elif obj.ViewObject.Proxy:
if hasattr(obj.ViewObject.Proxy,"p1"):
prx = obj.ViewObject.Proxy
ts = (len(prx.string)*obj.ViewObject.FontSize.Value)/4.0
rm = ((prx.p3.sub(prx.p2)).Length/2.0)-ts
p2a = getProj(prx.p2.add(DraftVecUtils.scaleTo(prx.p3.sub(prx.p2),rm)), plane)
p2b = getProj(prx.p3.add(DraftVecUtils.scaleTo(prx.p2.sub(prx.p3),rm)), plane)
p1 = getProj(prx.p1, plane)
p2 = getProj(prx.p2, plane)
p3 = getProj(prx.p3, plane)
p4 = getProj(prx.p4, plane)
tbase = getProj(prx.tbase, plane)
r = prx.textpos.rotation.getValue().getValue()
rv = FreeCAD.Rotation(r[0],r[1],r[2],r[3]).multVec(FreeCAD.Vector(1,0,0))
angle = -DraftVecUtils.angle(getProj(rv, plane))
#angle = -DraftVecUtils.angle(p3.sub(p2))
# drawing lines
svg = '<path '
if obj.ViewObject.DisplayMode == "2D":
tangle = angle
if tangle > math.pi/2:
tangle = tangle-math.pi
#elif (tangle <= -math.pi/2) or (tangle > math.pi/2):
# tangle = tangle+math.pi
#tbase = tbase.add(DraftVecUtils.rotate(Vector(0,2/scale,0),tangle))
if rotation != 0:
#print "dim: tangle:",tangle," rot: ",rotation," text: ",prx.string
if abs(tangle+math.radians(rotation)) < 0.0001:
tangle += math.pi
tbase = tbase.add(DraftVecUtils.rotate(Vector(0,2/scale,0),tangle))
svg += 'd="M '+str(p1.x)+' '+str(p1.y)+' '
svg += 'L '+str(p2.x)+' '+str(p2.y)+' '
svg += 'L '+str(p3.x)+' '+str(p3.y)+' '
svg += 'L '+str(p4.x)+' '+str(p4.y)+'" '
else:
tangle = 0
if rotation != 0:
tangle = -math.radians(rotation)
tbase = tbase.add(Vector(0,-2.0/scale,0))
svg += 'd="M '+str(p1.x)+' '+str(p1.y)+' '
svg += 'L '+str(p2.x)+' '+str(p2.y)+' '
svg += 'L '+str(p2a.x)+' '+str(p2a.y)+' '
svg += 'M '+str(p2b.x)+' '+str(p2b.y)+' '
svg += 'L '+str(p3.x)+' '+str(p3.y)+' '
svg += 'L '+str(p4.x)+' '+str(p4.y)+'" '
svg += 'fill="none" stroke="'
svg += stroke + '" '
svg += 'stroke-width="' + str(linewidth) + ' px" '
svg += 'style="stroke-width:'+ str(linewidth)
svg += ';stroke-miterlimit:4;stroke-dasharray:none" '
svg += 'freecad:basepoint1="'+str(p1.x)+' '+str(p1.y)+'" '
svg += 'freecad:basepoint2="'+str(p4.x)+' '+str(p4.y)+'" '
svg += 'freecad:dimpoint="'+str(p2.x)+' '+str(p2.y)+'"'
svg += '/>\n'
# drawing dimension and extension lines overshoots
if hasattr(obj.ViewObject,"DimOvershoot") and obj.ViewObject.DimOvershoot.Value:
shootsize = obj.ViewObject.DimOvershoot.Value/pointratio
svg += getOvershoot(p2,shootsize,stroke,linewidth,angle)
svg += getOvershoot(p3,shootsize,stroke,linewidth,angle+math.pi)
if hasattr(obj.ViewObject,"ExtOvershoot") and obj.ViewObject.ExtOvershoot.Value:
shootsize = obj.ViewObject.ExtOvershoot.Value/pointratio
shootangle = -DraftVecUtils.angle(p1.sub(p2))
svg += getOvershoot(p2,shootsize,stroke,linewidth,shootangle)
svg += getOvershoot(p3,shootsize,stroke,linewidth,shootangle)
# drawing arrows
if hasattr(obj.ViewObject,"ArrowType"):
arrowsize = obj.ViewObject.ArrowSize.Value/pointratio
if hasattr(obj.ViewObject,"FlipArrows"):
if obj.ViewObject.FlipArrows:
angle = angle+math.pi
svg += getArrow(obj.ViewObject.ArrowType,p2,arrowsize,stroke,linewidth,angle)
svg += getArrow(obj.ViewObject.ArrowType,p3,arrowsize,stroke,linewidth,angle+math.pi)
# drawing text
svg += getText(stroke,fontsize,obj.ViewObject.FontName,tangle,tbase,prx.string)
elif getType(obj) == "AngularDimension":
if gui:
if not obj.ViewObject:
print ("export of dimensions to SVG is only available in GUI mode")
elif obj.ViewObject.Proxy:
if hasattr(obj.ViewObject.Proxy,"circle"):
prx = obj.ViewObject.Proxy
# drawing arc
fill= "none"
lstyle = getLineStyle(linestyle, scale)
if obj.ViewObject.DisplayMode == "2D":
svg += getPath([prx.circle])
else:
if hasattr(prx,"circle1"):
svg += getPath([prx.circle1])
svg += getPath([prx.circle2])
else:
svg += getPath([prx.circle])
# drawing arrows
if hasattr(obj.ViewObject,"ArrowType"):
p2 = getProj(prx.p2, plane)
p3 = getProj(prx.p3, plane)
arrowsize = obj.ViewObject.ArrowSize.Value/pointratio
arrowlength = 4*obj.ViewObject.ArrowSize.Value
u1 = getProj((prx.circle.valueAt(prx.circle.FirstParameter+arrowlength)).sub(prx.circle.valueAt(prx.circle.FirstParameter)), plane)
u2 = getProj((prx.circle.valueAt(prx.circle.LastParameter-arrowlength)).sub(prx.circle.valueAt(prx.circle.LastParameter)), plane)
angle1 = -DraftVecUtils.angle(u1)
angle2 = -DraftVecUtils.angle(u2)
if hasattr(obj.ViewObject,"FlipArrows"):
if obj.ViewObject.FlipArrows:
angle1 = angle1+math.pi
angle2 = angle2+math.pi
svg += getArrow(obj.ViewObject.ArrowType,p2,arrowsize,stroke,linewidth,angle1)
svg += getArrow(obj.ViewObject.ArrowType,p3,arrowsize,stroke,linewidth,angle2)
# drawing text
if obj.ViewObject.DisplayMode == "2D":
t = prx.circle.tangentAt(prx.circle.FirstParameter+(prx.circle.LastParameter-prx.circle.FirstParameter)/2.0)
t = getProj(t, plane)
tangle = DraftVecUtils.angle(t)
if (tangle <= -math.pi/2) or (tangle > math.pi/2):
tangle = tangle + math.pi
tbase = getProj(prx.circle.valueAt(prx.circle.FirstParameter+(prx.circle.LastParameter-prx.circle.FirstParameter)/2.0), plane)
tbase = tbase.add(DraftVecUtils.rotate(Vector(0,2.0/scale,0),tangle))
#print(tbase)
else:
tangle = 0
tbase = getProj(prx.tbase, plane)
svg += getText(stroke,fontsize,obj.ViewObject.FontName,tangle,tbase,prx.string)
elif getType(obj) == "Label":
if getattr(obj.ViewObject, "Line", True): # some Labels may have no Line property
def format_point(coords, action='L'):
return "{action}{x},{y}".format(
x=coords.x, y=coords.y, action=action
)
# Draw multisegment line
proj_points = list(map(lambda x: getProj(x, plane), obj.Points))
path_dir_list = [format_point(proj_points[0], action='M')]
path_dir_list += map(format_point, proj_points[1:])
path_dir_str = " ".join(path_dir_list)
svg_path = '<path fill="none" stroke="{stroke}" stroke-width="{linewidth}" d="{directions}"/>'.format(
stroke=stroke,
linewidth=linewidth,
directions=path_dir_str
)
svg += svg_path
# Draw arrow.
# We are different here from 3D view
# if Line is set to 'off', no arrow is drawn
if hasattr(obj.ViewObject, "ArrowType") and len(obj.Points) >= 2:
last_segment = FreeCAD.Vector(obj.Points[-1] - obj.Points[-2])
angle = -DraftVecUtils.angle(getProj(last_segment, plane)) + math.pi
svg += getArrow(
arrowtype=obj.ViewObject.ArrowType,
point=proj_points[-1],
arrowsize=obj.ViewObject.ArrowSize.Value/pointratio,
color=stroke,
linewidth=linewidth,
angle=angle
)
# print text
if gui:
if not obj.ViewObject:
print("export of texts to SVG is only available in GUI mode")
else:
fontname = obj.ViewObject.TextFont
position = getProj(obj.Placement.Base, plane)
rotation = obj.Placement.Rotation
justification = obj.ViewObject.TextAlignment
text = obj.Text
svg += getText(stroke, fontsize, fontname, rotation, position,
text, linespacing, justification)
elif getType(obj) in ["Annotation","DraftText"]:
"returns an svg representation of a document annotation"
if gui:
if not obj.ViewObject:
print ("export of texts to SVG is only available in GUI mode")
else:
n = obj.ViewObject.FontName
if getType(obj) == "Annotation":
p = getProj(obj.Position, plane)
r = obj.ViewObject.Rotation.getValueAs("rad")
t = obj.LabelText
else: # DraftText
p = getProj(obj.Placement.Base, plane)
r = obj.Placement.Rotation
t = obj.Text
j = obj.ViewObject.Justification
svg += getText(stroke,fontsize,n,r,p,t,linespacing,j)
elif getType(obj) == "Axis":
"returns the SVG representation of an Arch Axis system"
if gui:
if not obj.ViewObject:
print ("export of axes to SVG is only available in GUI mode")
else:
vobj = obj.ViewObject
lorig = getLineStyle(linestyle, scale)
fill = 'none'
rad = vobj.BubbleSize.Value/2
n = 0
for e in obj.Shape.Edges:
lstyle = lorig
svg += getPath([e])
lstyle = "none"
pos = ["Start"]
if hasattr(vobj,"BubblePosition"):
if vobj.BubblePosition == "Both":
pos = ["Start","End"]
else:
pos = [vobj.BubblePosition]
for p in pos:
if p == "Start":
p1 = e.Vertexes[0].Point
p2 = e.Vertexes[1].Point
else:
p1 = e.Vertexes[1].Point
p2 = e.Vertexes[0].Point
dv = p2.sub(p1)
dv.normalize()
center = p2.add(dv.scale(rad,rad,rad))
svg += getCircle(Part.makeCircle(rad,center))
if hasattr(vobj.Proxy,"bubbletexts"):
if len (vobj.Proxy.bubbletexts) >= n:
svg += '<text fill="' + stroke + '" '
svg += 'font-size="' + str(rad) + '" '
svg += 'style="text-anchor:middle;'
svg += 'text-align:center;'
svg += 'font-family: sans;" '
svg += 'transform="translate(' + str(center.x+rad/4.0) + ',' + str(center.y-rad/3.0) + ') '
svg += 'scale(1,-1)"> '
svg += '<tspan>' + obj.ViewObject.Proxy.bubbletexts[n].string.getValues()[0] + '</tspan>\n'
svg += '</text>\n'
n += 1
elif getType(obj) == "Pipe":
fill = stroke
lstyle = getLineStyle(linestyle, scale)
if obj.Base and obj.Diameter:
svg += getPath(obj.Base.Shape.Edges)
for f in obj.Shape.Faces:
if len(f.Edges) == 1:
if isinstance(f.Edges[0].Curve,Part.Circle):
svg += getCircle(f.Edges[0])
elif getType(obj) == "Rebar":
fill = "none"
lstyle = getLineStyle(linestyle, scale)
if obj.Proxy:
if not hasattr(obj.Proxy,"wires"):
obj.Proxy.execute(obj)
if hasattr(obj.Proxy,"wires"):
svg += getPath(wires=obj.Proxy.wires)
elif getType(obj) == "PipeConnector":
pass
elif getType(obj) == "Space":
"returns an SVG fragment for the text of a space"
if gui:
if not obj.ViewObject:
print ("export of spaces to SVG is only available in GUI mode")
else:
c = getrgb(obj.ViewObject.TextColor)
n = obj.ViewObject.FontName
a = 0
if rotation != 0:
a = math.radians(rotation)
t1 = obj.ViewObject.Proxy.text1.string.getValues()
t2 = obj.ViewObject.Proxy.text2.string.getValues()
scale = obj.ViewObject.FirstLine.Value/obj.ViewObject.FontSize.Value
f1 = fontsize*scale
p2 = FreeCAD.Vector(obj.ViewObject.Proxy.coords.translation.getValue().getValue())
lspc = FreeCAD.Vector(obj.ViewObject.Proxy.header.translation.getValue().getValue())
p1 = p2.add(lspc)
j = obj.ViewObject.TextAlign
svg += getText(c,f1,n,a,getProj(p1, plane),t1,linespacing,j,flip=True)
if t2:
ofs = FreeCAD.Vector(0,lspc.Length,0)
if a:
ofs = FreeCAD.Rotation(FreeCAD.Vector(0,0,1),-rotation).multVec(ofs)
svg += getText(c,fontsize,n,a,getProj(p1, plane).add(ofs),t2,linespacing,j,flip=True)
elif obj.isDerivedFrom('Part::Feature'):
if obj.Shape.isNull():
return ''
# setting fill
if obj.Shape.Faces:
if gui:
try:
m = obj.ViewObject.DisplayMode
except AttributeError:
m = None
if (m != "Wireframe"):
if fillstyle == "shape color":
fill = getrgb(obj.ViewObject.ShapeColor,testbw=False)
fill_opacity = 1 - (obj.ViewObject.Transparency / 100.0)
else:
fill = 'url(#'+fillstyle+')'
svg += getPattern(fillstyle)
else:
fill = "none"
else:
fill = "#888888"
else:
fill = 'none'
lstyle = getLineStyle(linestyle, scale)
if len(obj.Shape.Vertexes) > 1:
wiredEdges = []
if obj.Shape.Faces:
for i,f in enumerate(obj.Shape.Faces):
svg += getPath(wires=f.Wires,pathname='%s_f%04d' % \
(obj.Name,i))
wiredEdges.extend(f.Edges)
else:
for i,w in enumerate(obj.Shape.Wires):
svg += getPath(w.Edges,pathname='%s_w%04d' % \
(obj.Name,i))
wiredEdges.extend(w.Edges)
if len(wiredEdges) != len(obj.Shape.Edges):
for i,e in enumerate(obj.Shape.Edges):
if (DraftGeomUtils.findEdge(e,wiredEdges) == None):
svg += getPath([e],pathname='%s_nwe%04d' % \
(obj.Name,i))
else:
# closed circle or spline
if obj.Shape.Edges:
if isinstance(obj.Shape.Edges[0].Curve,Part.Circle):
svg = getCircle(obj.Shape.Edges[0])
else:
svg = getPath(obj.Shape.Edges)
if FreeCAD.GuiUp:
if hasattr(obj.ViewObject,"EndArrow") and hasattr(obj.ViewObject,"ArrowType") and (len(obj.Shape.Vertexes) > 1):
if obj.ViewObject.EndArrow:
p1 = getProj(obj.Shape.Vertexes[-2].Point, plane)
p2 = getProj(obj.Shape.Vertexes[-1].Point, plane)
angle = -DraftVecUtils.angle(p2.sub(p1))
arrowsize = obj.ViewObject.ArrowSize.Value/pointratio
svg += getArrow(obj.ViewObject.ArrowType,p2,arrowsize,stroke,linewidth,angle)
# techdraw expects bottom-to-top coordinates
if techdraw:
svg = '<g transform ="scale(1,-1)">'+svg+'</g>'
return svg
def _svg_dimension(obj, plane, scale, linewidth, fontsize, stroke, pointratio,
techdraw, rotation):
"""Return the SVG representation of a linear dimension."""
if not App.GuiUp:
_wrn("'{}': SVG can only be generated "
"in GUI mode".format(obj.Label))
return ""
if not hasattr(obj.ViewObject, "Proxy") or not obj.ViewObject.Proxy:
_err("'{}': doesn't have Proxy, "
"SVG cannot be generated".format(obj.Label))
return ""
vobj = obj.ViewObject
prx = vobj.Proxy
if not hasattr(prx, "p1"):
_err("'{}': doesn't have points, "
"SVG cannot be generated".format(obj.Label))
return ""
ts = len(prx.string) * vobj.FontSize.Value / 4.0
rm = (prx.p3 - prx.p2).Length / 2.0 - ts
_diff32 = prx.p3 - prx.p2
_diff23 = prx.p2 - prx.p3
_v32 = DraftVecUtils.scaleTo(_diff32, rm)
_v23 = DraftVecUtils.scaleTo(_diff23, rm)
p2a = get_proj(prx.p2 + _v32, plane)
p2b = get_proj(prx.p3 + _v23, plane)
p1 = get_proj(prx.p1, plane)
p2 = get_proj(prx.p2, plane)
p3 = get_proj(prx.p3, plane)
p4 = get_proj(prx.p4, plane)
tbase = get_proj(prx.tbase, plane)
r = prx.textpos.rotation.getValue().getValue()
_rv = App.Rotation(r[0], r[1], r[2], r[3])
rv = _rv.multVec(App.Vector(1, 0, 0))
angle = -DraftVecUtils.angle(get_proj(rv, plane))
# angle = -DraftVecUtils.angle(p3.sub(p2))
svg = ''
nolines = False
if hasattr(vobj, "ShowLine"):
if not vobj.ShowLine:
nolines = True
# drawing lines
if not nolines:
svg += '<path '
if vobj.DisplayMode == "2D":
tangle = angle
if tangle > math.pi / 2:
tangle = tangle - math.pi
# elif (tangle <= -math.pi/2) or (tangle > math.pi/2):
# tangle = tangle + math.pi
if rotation != 0:
# print("dim: tangle:", tangle,
# " rot: ", rotation,
# " text: ", prx.string)
if abs(tangle + math.radians(rotation)) < 0.0001:
tangle += math.pi
_v = App.Vector(0, 2.0 / scale, 0)
_rot = DraftVecUtils.rotate(_v, tangle)
tbase = tbase + _rot
if not nolines:
svg += 'd="M ' + str(p1.x) + ' ' + str(p1.y) + ' '
svg += 'L ' + str(p2.x) + ' ' + str(p2.y) + ' '
svg += 'L ' + str(p3.x) + ' ' + str(p3.y) + ' '
svg += 'L ' + str(p4.x) + ' ' + str(p4.y) + '" '
else:
tangle = 0
if rotation != 0:
tangle = -math.radians(rotation)
tbase = tbase + App.Vector(0, -2.0 / scale, 0)
if not nolines:
svg += 'd="M ' + str(p1.x) + ' ' + str(p1.y) + ' '
svg += 'L ' + str(p2.x) + ' ' + str(p2.y) + ' '
svg += 'L ' + str(p2a.x) + ' ' + str(p2a.y) + ' '
svg += 'M ' + str(p2b.x) + ' ' + str(p2b.y) + ' '
svg += 'L ' + str(p3.x) + ' ' + str(p3.y) + ' '
svg += 'L ' + str(p4.x) + ' ' + str(p4.y) + '" '
if not nolines:
svg += 'fill="none" stroke="'
svg += stroke + '" '
svg += 'stroke-width="' + str(linewidth) + ' px" '
svg += 'style="stroke-width:' + str(linewidth)
svg += ';stroke-miterlimit:4;stroke-dasharray:none" '
svg += 'freecad:basepoint1="' + str(p1.x) + ' ' + str(p1.y) + '" '
svg += 'freecad:basepoint2="' + str(p4.x) + ' ' + str(p4.y) + '" '
svg += 'freecad:dimpoint="' + str(p2.x) + ' ' + str(p2.y) + '"'
svg += '/>\n'
# drawing dimension and extension lines overshoots
if hasattr(vobj, "DimOvershoot") and vobj.DimOvershoot.Value:
shootsize = vobj.DimOvershoot.Value / pointratio
svg += get_overshoot(p2, shootsize, stroke, linewidth, angle)
svg += get_overshoot(p3, shootsize, stroke, linewidth,
angle + math.pi)
if hasattr(vobj, "ExtOvershoot") and vobj.ExtOvershoot.Value:
shootsize = vobj.ExtOvershoot.Value / pointratio
shootangle = -DraftVecUtils.angle(p1 - p2)
svg += get_overshoot(p2, shootsize, stroke, linewidth, shootangle)
svg += get_overshoot(p3, shootsize, stroke, linewidth, shootangle)
# drawing arrows
if hasattr(vobj, "ArrowType"):
arrowsize = vobj.ArrowSize.Value / pointratio
if hasattr(vobj, "FlipArrows"):
if vobj.FlipArrows:
angle = angle + math.pi
svg += get_arrow(obj, vobj.ArrowType, p2, arrowsize, stroke,
linewidth, angle)
svg += get_arrow(obj, vobj.ArrowType, p3, arrowsize, stroke,
linewidth, angle + math.pi)
# drawing text
svg += svgtext.get_text(plane, techdraw, stroke, fontsize, vobj.FontName,
tangle, tbase, prx.string)
return svg
def rot(ed):
return Part.LineSegment(
v1(ed),
v1(ed).add(DraftVecUtils.rotate(vec(ed), math.pi / 2))).toShape()
def get_svg(obj,
scale=1,
linewidth=0.35,
fontsize=12,
fillstyle="shape color",
direction=None,
linestyle=None,
color=None,
linespacing=None,
techdraw=False,
rotation=0,
fillspaces=False,
override=True):
"""Return a string containing an SVG representation of the object.
Paramaeters
-----------
scale: float, optional
It defaults to 1.
It allows scaling line widths down, so they are resolution-independent.
linewidth: float, optional
It defaults to 0.35.
fontsize: float, optional
It defaults to 12, which is interpreted as `pt` unit (points).
It is used if the given object contains any text.
fillstyle: str, optional
It defaults to 'shape color'.
direction: Base::Vector3, optional
It defaults to `None`.
It is an arbitrary projection vector or a `WorkingPlane.Plane`
instance.
linestyle: optional
It defaults to `None`.
color: optional
It defaults to `None`.
linespacing: float, optional
It defaults to `None`.
techdraw: bool, optional
It defaults to `False`.
If it is `True`, it sets some options for generating SVG strings
for displaying inside TechDraw.
rotation: float, optional
It defaults to 0.
fillspaces: bool, optional
It defaults to `False`.
override: bool, optional
It defaults to `True`.
"""
# If this is a group, recursively call this function to gather
# all the SVG strings from the contents of the group
if hasattr(obj, "isDerivedFrom"):
if (obj.isDerivedFrom("App::DocumentObjectGroup")
or utils.get_type(obj) == "Layer"):
svg = ""
for child in obj.Group:
svg += get_svg(child, scale, linewidth, fontsize, fillstyle,
direction, linestyle, color, linespacing,
techdraw, rotation, fillspaces, override)
return svg
pathdata = []
svg = ""
linewidth = float(linewidth) / scale
if not override:
if hasattr(obj, "ViewObject") and hasattr(obj.ViewObject, "LineWidth"):
if hasattr(obj.ViewObject.LineWidth, "Value"):
lw = obj.ViewObject.LineWidth.Value
else:
lw = obj.ViewObject.LineWidth
linewidth = lw * linewidth
fontsize = (float(fontsize) / scale) / 2
if linespacing:
linespacing = float(linespacing) / scale
else:
linespacing = 0.5
# print(obj.Label, "line spacing", linespacing, "scale", scale)
# The number of times the dots are smaller than the arrow size
pointratio = 0.75
plane = None
if direction:
if isinstance(direction, App.Vector):
if direction != App.Vector(0, 0, 0):
plane = WorkingPlane.plane()
plane.alignToPointAndAxis_SVG(App.Vector(0, 0, 0),
direction.negative().negative(),
0)
elif isinstance(direction, WorkingPlane.plane):
plane = direction
stroke = "#000000"
if color and override:
if "#" in color:
stroke = color
else:
stroke = utils.get_rgb(color)
elif App.GuiUp:
if hasattr(obj, "ViewObject"):
if hasattr(obj.ViewObject, "LineColor"):
stroke = utils.get_rgb(obj.ViewObject.LineColor)
elif hasattr(obj.ViewObject, "TextColor"):
stroke = utils.get_rgb(obj.ViewObject.TextColor)
lstyle = "none"
if override:
lstyle = get_line_style(linestyle, scale)
else:
if hasattr(obj, "ViewObject") and hasattr(obj.ViewObject, "DrawStyle"):
lstyle = get_line_style(obj.ViewObject.DrawStyle, scale)
if not obj:
pass
elif isinstance(obj, Part.Shape):
svg = _svg_shape(svg, obj, plane, fillstyle, pathdata, stroke,
linewidth, lstyle)
elif utils.get_type(obj) in ["Dimension", "LinearDimension"]:
svg = _svg_dimension(obj, plane, scale, linewidth, fontsize, stroke,
pointratio, techdraw, rotation)
elif utils.get_type(obj) == "AngularDimension":
if not App.GuiUp:
_wrn("Export of dimensions to SVG is only available in GUI mode")
if App.GuiUp:
if obj.ViewObject.Proxy:
if hasattr(obj.ViewObject.Proxy, "circle"):
prx = obj.ViewObject.Proxy
# drawing arc
fill = "none"
if obj.ViewObject.DisplayMode == "2D":
svg += get_path(obj,
plane,
fill,
pathdata,
stroke,
linewidth,
lstyle,
fill_opacity=None,
edges=[prx.circle])
else:
if hasattr(prx, "circle1"):
svg += get_path(obj,
plane,
fill,
pathdata,
stroke,
linewidth,
lstyle,
fill_opacity=None,
edges=[prx.circle1])
svg += get_path(obj,
plane,
fill,
pathdata,
stroke,
linewidth,
lstyle,
fill_opacity=None,
edges=[prx.circle2])
else:
svg += get_path(obj,
plane,
fill,
pathdata,
stroke,
linewidth,
lstyle,
fill_opacity=None,
edges=[prx.circle])
# drawing arrows
if hasattr(obj.ViewObject, "ArrowType"):
p2 = get_proj(prx.p2, plane)
p3 = get_proj(prx.p3, plane)
arrowsize = obj.ViewObject.ArrowSize.Value / pointratio
arrowlength = 4 * obj.ViewObject.ArrowSize.Value
_v1a = prx.circle.valueAt(prx.circle.FirstParameter +
arrowlength)
_v1b = prx.circle.valueAt(prx.circle.FirstParameter)
_v2a = prx.circle.valueAt(prx.circle.LastParameter -
arrowlength)
_v2b = prx.circle.valueAt(prx.circle.LastParameter)
u1 = get_proj(_v1a - _v1b, plane)
u2 = get_proj(_v2a - _v2b, plane)
angle1 = -DraftVecUtils.angle(u1)
angle2 = -DraftVecUtils.angle(u2)
if hasattr(obj.ViewObject, "FlipArrows"):
if obj.ViewObject.FlipArrows:
angle1 = angle1 + math.pi
angle2 = angle2 + math.pi
svg += get_arrow(obj, obj.ViewObject.ArrowType, p2,
arrowsize, stroke, linewidth, angle1)
svg += get_arrow(obj, obj.ViewObject.ArrowType, p3,
arrowsize, stroke, linewidth, angle2)
# drawing text
if obj.ViewObject.DisplayMode == "2D":
_diff = (prx.circle.LastParameter -
prx.circle.FirstParameter)
t = prx.circle.tangentAt(prx.circle.FirstParameter +
_diff / 2.0)
t = get_proj(t, plane)
tangle = DraftVecUtils.angle(t)
if (tangle <= -math.pi / 2) or (tangle > math.pi / 2):
tangle = tangle + math.pi
_diff = (prx.circle.LastParameter -
prx.circle.FirstParameter)
_va = prx.circle.valueAt(prx.circle.FirstParameter +
_diff / 2.0)
tbase = get_proj(_va, plane)
_v = App.Vector(0, 2.0 / scale, 0)
tbase = tbase + DraftVecUtils.rotate(_v, tangle)
# print(tbase)
else:
tangle = 0
tbase = get_proj(prx.tbase, plane)
svg += svgtext.get_text(plane, techdraw, stroke, fontsize,
obj.ViewObject.FontName, tangle,
tbase, prx.string)
elif utils.get_type(obj) == "Label":
if getattr(obj.ViewObject, "Line", True):
# Some Labels may have no Line property
# Draw multisegment line
proj_points = list(map(lambda x: get_proj(x, plane), obj.Points))
path_dir_list = [format_point(proj_points[0], action='M')]
path_dir_list += map(format_point, proj_points[1:])
path_dir_str = " ".join(path_dir_list)
svg_path = '<path '
svg_path += 'fill="none" '
svg_path += 'stroke="{}" '.format(stroke)
svg_path += 'stroke-width="{}" '.format(linewidth)
svg_path += 'd="{}"'.format(path_dir_str)
svg_path += '/>'
svg += svg_path
# Draw arrow.
# We are different here from 3D view
# if Line is set to 'off', no arrow is drawn
if hasattr(obj.ViewObject, "ArrowType") and len(obj.Points) >= 2:
last_segment = App.Vector(obj.Points[-1] - obj.Points[-2])
_v = get_proj(last_segment, plane)
angle = -DraftVecUtils.angle(_v) + math.pi
svg += get_arrow(obj, obj.ViewObject.ArrowType,
proj_points[-1],
obj.ViewObject.ArrowSize.Value / pointratio,
stroke, linewidth, angle)
if not App.GuiUp:
_wrn("Export of texts to SVG is only available in GUI mode")
# print text
if App.GuiUp:
fontname = obj.ViewObject.TextFont
position = get_proj(obj.Placement.Base, plane)
rotation = obj.Placement.Rotation
justification = obj.ViewObject.TextAlignment
text = obj.Text
svg += svgtext.get_text(plane, techdraw, stroke, fontsize,
fontname, rotation, position, text,
linespacing, justification)
elif utils.get_type(obj) in ["Annotation", "DraftText", "Text"]:
# returns an svg representation of a document annotation
if not App.GuiUp:
_wrn("Export of texts to SVG is only available in GUI mode")
if App.GuiUp:
n = obj.ViewObject.FontName
if utils.get_type(obj) == "Annotation":
p = get_proj(obj.Position, plane)
r = obj.ViewObject.Rotation.getValueAs("rad")
t = obj.LabelText
else: # DraftText (old) or Text (new, 0.19)
p = get_proj(obj.Placement.Base, plane)
r = obj.Placement.Rotation
t = obj.Text
j = obj.ViewObject.Justification
svg += svgtext.get_text(plane, techdraw, stroke, fontsize, n, r, p,
t, linespacing, j)
elif utils.get_type(obj) == "Axis":
# returns the SVG representation of an Arch Axis system
if not App.GuiUp:
_wrn("Export of axes to SVG is only available in GUI mode")
if App.GuiUp:
vobj = obj.ViewObject
lorig = lstyle
fill = 'none'
rad = vobj.BubbleSize.Value / 2
n = 0
for e in obj.Shape.Edges:
lstyle = lorig
svg += get_path(obj,
plane,
fill,
pathdata,
stroke,
linewidth,
lstyle,
fill_opacity=None,
edges=[e])
lstyle = "none"
pos = ["Start"]
if hasattr(vobj, "BubblePosition"):
if vobj.BubblePosition == "Both":
pos = ["Start", "End"]
else:
pos = [vobj.BubblePosition]
for p in pos:
if p == "Start":
p1 = e.Vertexes[0].Point
p2 = e.Vertexes[1].Point
else:
p1 = e.Vertexes[1].Point
p2 = e.Vertexes[0].Point
dv = p2.sub(p1)
dv.normalize()
center = p2.add(dv.scale(rad, rad, rad))
svg += get_circle(plane, fill, stroke, linewidth, lstyle,
Part.makeCircle(rad, center))
if (hasattr(vobj.Proxy, "bubbletexts")
and len(vobj.Proxy.bubbletexts) >= n):
bubb = vobj.Proxy.bubbletexts
svg += '<text '
svg += 'fill="{}" '.format(stroke)
svg += 'font-size="{}" '.format(rad)
svg += 'style="text-anchor:middle;'
svg += 'text-align:center;'
svg += 'font-family: sans;" '
svg += 'transform="'
svg += 'translate({},{}) '.format(
center.x + rad / 4.0, center.y - rad / 3.0)
svg += 'scale(1,-1)"> '
svg += '<tspan>'
svg += bubb[n].string.getValues()[0]
svg += '</tspan>\n'
svg += '</text>\n'
n += 1
lstyle = lorig
elif utils.get_type(obj) == "Pipe":
fill = stroke
if obj.Base and obj.Diameter:
svg += get_path(obj,
plane,
fill,
pathdata,
stroke,
linewidth,
lstyle,
fill_opacity=None,
edges=obj.Base.Shape.Edges)
for f in obj.Shape.Faces:
if len(f.Edges) == 1:
if isinstance(f.Edges[0].Curve, Part.Circle):
svg += get_circle(plane, fill, stroke, linewidth, lstyle,
f.Edges[0])
elif utils.get_type(obj) == "Rebar":
fill = "none"
basewire = obj.Base.Shape.Wires[0].copy()
# Not applying rounding because the results are not correct
# if hasattr(obj, "Rounding") and obj.Rounding:
# basewire = DraftGeomUtils.filletWire(
# basewire, obj.Rounding * obj.Diameter.Value
# )
wires = []
for placement in obj.PlacementList:
wire = basewire.copy()
wire.Placement = placement.multiply(basewire.Placement)
wires.append(wire)
svg += get_path(obj,
plane,
fill,
pathdata,
stroke,
linewidth,
lstyle,
fill_opacity=None,
wires=wires)
elif utils.get_type(obj) == "PipeConnector":
pass
elif utils.get_type(obj) == "Space":
fill_opacity = 1
# returns an SVG fragment for the text of a space
if not App.GuiUp:
_wrn("Export of spaces to SVG is only available in GUI mode")
if App.GuiUp:
vobj = obj.ViewObject
if fillspaces and hasattr(obj, "Proxy"):
if not hasattr(obj.Proxy, "face"):
obj.Proxy.getArea(obj, notouch=True)
if hasattr(obj.Proxy, "face"):
# setting fill
if App.GuiUp:
fill = utils.get_rgb(vobj.ShapeColor, testbw=False)
fill_opacity = 1 - vobj.Transparency / 100.0
else:
fill = "#888888"
svg += get_path(obj,
plane,
fill,
pathdata,
stroke,
linewidth,
lstyle,
fill_opacity=fill_opacity,
wires=[obj.Proxy.face.OuterWire])
c = utils.get_rgb(vobj.TextColor)
n = vobj.FontName
a = 0
if rotation != 0:
a = math.radians(rotation)
t1 = vobj.Proxy.text1.string.getValues()
t2 = vobj.Proxy.text2.string.getValues()
scale = vobj.FirstLine.Value / vobj.FontSize.Value
f1 = fontsize * scale
if round(plane.axis.getAngle(App.Vector(0, 0, 1)),
2) not in [0, 3.14]:
# if not in XY view, place the label at center
p2 = obj.Shape.CenterOfMass
else:
_v = vobj.Proxy.coords.translation.getValue().getValue()
p2 = obj.Placement.multVec(App.Vector(_v))
_h = vobj.Proxy.header.translation.getValue().getValue()
lspc = App.Vector(_h)
p1 = p2 + lspc
j = vobj.TextAlign
t3 = svgtext.get_text(plane,
techdraw,
c,
f1,
n,
a,
get_proj(p1, plane),
t1,
linespacing,
j,
flip=True)
svg += t3
if t2:
ofs = App.Vector(0, -lspc.Length, 0)
if a:
Z = App.Vector(0, 0, 1)
ofs = App.Rotation(Z, -rotation).multVec(ofs)
t4 = svgtext.get_text(plane,
techdraw,
c,
fontsize,
n,
a,
get_proj(p1, plane).add(ofs),
t2,
linespacing,
j,
flip=True)
svg += t4
elif hasattr(obj, 'Shape'):
# In the past we tested for a Part Feature
# elif obj.isDerivedFrom('Part::Feature'):
#
# however, this doesn't work for App::Links; instead we
# test for a 'Shape'. All Part::Features should have a Shape,
# and App::Links can have one as well.
if obj.Shape.isNull():
return ''
fill_opacity = 1
# setting fill
if obj.Shape.Faces:
if App.GuiUp:
try:
m = obj.ViewObject.DisplayMode
except AttributeError:
m = None
vobj = obj.ViewObject
if m != "Wireframe":
if fillstyle == "shape color":
fill = utils.get_rgb(vobj.ShapeColor, testbw=False)
fill_opacity = 1 - vobj.Transparency / 100.0
else:
fill = 'url(#' + fillstyle + ')'
svg += get_pattern(fillstyle)
else:
fill = "none"
else:
fill = "#888888"
else:
fill = 'none'
if len(obj.Shape.Vertexes) > 1:
wiredEdges = []
if obj.Shape.Faces:
for i, f in enumerate(obj.Shape.Faces):
# place outer wire first
wires = [f.OuterWire]
wires.extend([
w for w in f.Wires
if w.hashCode() != f.OuterWire.hashCode()
])
svg += get_path(obj,
plane,
fill,
pathdata,
stroke,
linewidth,
lstyle,
fill_opacity=fill_opacity,
wires=f.Wires,
pathname='%s_f%04d' % (obj.Name, i))
wiredEdges.extend(f.Edges)
else:
for i, w in enumerate(obj.Shape.Wires):
svg += get_path(obj,
plane,
fill,
pathdata,
stroke,
linewidth,
lstyle,
fill_opacity=fill_opacity,
edges=w.Edges,
pathname='%s_w%04d' % (obj.Name, i))
wiredEdges.extend(w.Edges)
if len(wiredEdges) != len(obj.Shape.Edges):
for i, e in enumerate(obj.Shape.Edges):
if DraftGeomUtils.findEdge(e, wiredEdges) is None:
svg += get_path(obj,
plane,
fill,
pathdata,
stroke,
linewidth,
lstyle,
fill_opacity=fill_opacity,
edges=[e],
pathname='%s_nwe%04d' % (obj.Name, i))
else:
# closed circle or spline
if obj.Shape.Edges:
if isinstance(obj.Shape.Edges[0].Curve, Part.Circle):
svg = get_circle(plane, fill, stroke, linewidth, lstyle,
obj.Shape.Edges[0])
else:
svg = get_path(obj,
plane,
fill,
pathdata,
stroke,
linewidth,
lstyle,
fill_opacity=fill_opacity,
edges=obj.Shape.Edges)
if (App.GuiUp and hasattr(obj.ViewObject, "EndArrow")
and obj.ViewObject.EndArrow
and hasattr(obj.ViewObject, "ArrowType")
and len(obj.Shape.Vertexes) > 1):
p1 = get_proj(obj.Shape.Vertexes[-1].Point, plane)
p2 = get_proj(obj.Shape.Vertexes[-2].Point, plane)
angle = -DraftVecUtils.angle(p2 - p1)
arrowsize = obj.ViewObject.ArrowSize.Value / pointratio
svg += get_arrow(obj, obj.ViewObject.ArrowType, p1, arrowsize,
stroke, linewidth, angle)
# techdraw expects bottom-to-top coordinates
if techdraw:
svg = '<g transform ="scale(1,-1)">\n ' + svg + '</g>\n'
return svg
def redraw(self, point, snapped=None, shift=False, alt=False, real=None):
"""Redraw the ghost normally."""
# initializing
reverse = False
for g in self.ghost:
g.off()
if real:
newedges = []
import DraftGeomUtils
import Part
# finding the active point
vlist = []
for e in self.edges:
vlist.append(e.Vertexes[0].Point)
vlist.append(self.edges[-1].Vertexes[-1].Point)
if shift:
npoint = self.activePoint
else:
npoint = DraftGeomUtils.findClosest(point, vlist)
if npoint > len(self.edges) / 2:
reverse = True
if alt:
reverse = not reverse
self.activePoint = npoint
# sorting out directions
if reverse and (npoint > 0):
npoint = npoint - 1
if (npoint > len(self.edges) - 1):
edge = self.edges[-1]
ghost = self.ghost[-1]
else:
edge = self.edges[npoint]
ghost = self.ghost[npoint]
if reverse:
v1 = edge.Vertexes[-1].Point
v2 = edge.Vertexes[0].Point
else:
v1 = edge.Vertexes[0].Point
v2 = edge.Vertexes[-1].Point
# snapping
if snapped:
snapped = self.doc.getObject(snapped['Object'])
if hasattr(snapped, "Shape"):
pts = []
for e in snapped.Shape.Edges:
int = DraftGeomUtils.findIntersection(edge, e, True, True)
if int:
pts.extend(int)
if pts:
point = pts[DraftGeomUtils.findClosest(point, pts)]
# modifying active edge
if DraftGeomUtils.geomType(edge) == "Line":
ve = DraftGeomUtils.vec(edge)
chord = v1.sub(point)
n = ve.cross(chord)
if n.Length == 0:
self.newpoint = point
else:
perp = ve.cross(n)
proj = DraftVecUtils.project(chord, perp)
self.newpoint = App.Vector.add(point, proj)
dist = v1.sub(self.newpoint).Length
ghost.p1(self.newpoint)
ghost.p2(v2)
self.ui.labelRadius.setText(translate("draft", "Distance"))
self.ui.radiusValue.setToolTip(
translate("draft", "The offset distance"))
if real:
if self.force:
ray = self.newpoint.sub(v1)
ray.multiply(self.force / ray.Length)
self.newpoint = App.Vector.add(v1, ray)
newedges.append(Part.LineSegment(self.newpoint, v2).toShape())
else:
center = edge.Curve.Center
rad = edge.Curve.Radius
ang1 = DraftVecUtils.angle(v2.sub(center))
ang2 = DraftVecUtils.angle(point.sub(center))
_rot_rad = DraftVecUtils.rotate(App.Vector(rad, 0, 0), -ang2)
self.newpoint = App.Vector.add(center, _rot_rad)
self.ui.labelRadius.setText(translate("draft", "Angle"))
self.ui.radiusValue.setToolTip(
translate("draft", "The offset angle"))
dist = math.degrees(-ang2)
# if ang1 > ang2:
# ang1, ang2 = ang2, ang1
# print("last calculated:",
# math.degrees(-ang1),
# math.degrees(-ang2))
ghost.setEndAngle(-ang2)
ghost.setStartAngle(-ang1)
ghost.setCenter(center)
ghost.setRadius(rad)
if real:
if self.force:
angle = math.radians(self.force)
newray = DraftVecUtils.rotate(App.Vector(rad, 0, 0),
-angle)
self.newpoint = App.Vector.add(center, newray)
chord = self.newpoint.sub(v2)
perp = chord.cross(App.Vector(0, 0, 1))
scaledperp = DraftVecUtils.scaleTo(perp, rad)
midpoint = App.Vector.add(center, scaledperp)
_sh = Part.Arc(self.newpoint, midpoint, v2).toShape()
newedges.append(_sh)
ghost.on()
# resetting the visible edges
if not reverse:
li = list(range(npoint + 1, len(self.edges)))
else:
li = list(range(npoint - 1, -1, -1))
for i in li:
edge = self.edges[i]
ghost = self.ghost[i]
if DraftGeomUtils.geomType(edge) == "Line":
ghost.p1(edge.Vertexes[0].Point)
ghost.p2(edge.Vertexes[-1].Point)
else:
ang1 = DraftVecUtils.angle(edge.Vertexes[0].Point.sub(center))
ang2 = DraftVecUtils.angle(edge.Vertexes[-1].Point.sub(center))
# if ang1 > ang2:
# ang1, ang2 = ang2, ang1
ghost.setEndAngle(-ang2)
ghost.setStartAngle(-ang1)
ghost.setCenter(edge.Curve.Center)
ghost.setRadius(edge.Curve.Radius)
if real:
newedges.append(edge)
ghost.on()
# finishing
if real:
return newedges
else:
return dist
