def make_text(string, placement=None, screen=False):
"""Create a Text object containing the given list of strings.
The current color and text height and font specified in preferences
are used.
Parameters
----------
string: str, or list of str
String to display on screen.
If it is a list, each element in the list represents a new text line.
placement: Base::Placement, Base::Vector3, or Base::Rotation, optional
It defaults to `None`.
If it is provided, it is the placement of the new text.
The input could be a full placement, just a vector indicating
the translation, or just a rotation.
screen: bool, optional
It defaults to `False`, in which case the text is placed in 3D space
oriented like any other object, on top of a given plane,
by the default the XY plane.
If it is `True`, the text will always face perpendicularly
to the camera direction, that is, it will be flat on the screen.
Returns
-------
App::FeaturePython
A scripted object of type `'Text'`.
This object does not have a `Shape` attribute, as the text is created
on screen by Coin (pivy).
None
If there is a problem it will return `None`.
"""
_name = "make_text"
utils.print_header(_name, "Text")
found, doc = utils.find_doc(App.activeDocument())
if not found:
_err(translate("draft", "No active document. Aborting."))
return None
_msg("string: {}".format(string))
try:
utils.type_check([(string, (str, list))], name=_name)
except TypeError:
_err(
translate(
"draft",
"Wrong input: must be a list of strings or a single string."))
return None
if (type(string) is list
and not all(isinstance(element, str) for element in string)):
_err(
translate(
"draft",
"Wrong input: must be a list of strings or a single string."))
return None
_msg("placement: {}".format(placement))
if not placement:
placement = App.Placement()
try:
utils.type_check([(placement,
(App.Placement, App.Vector, App.Rotation))],
name=_name)
except TypeError:
_err(
translate(
"draft",
"Wrong input: must be a placement, a vector, or a rotation."))
return None
# Convert the vector or rotation to a full placement
if isinstance(placement, App.Vector):
placement = App.Placement(placement, App.Rotation())
elif isinstance(placement, App.Rotation):
placement = App.Placement(App.Vector(), placement)
new_obj = doc.addObject("App::FeaturePython", "Text")
Text(new_obj)
new_obj.Text = string
new_obj.Placement = placement
if App.GuiUp:
ViewProviderText(new_obj.ViewObject)
h = utils.get_param("textheight", 2)
new_obj.ViewObject.DisplayMode = "3D text"
if screen:
_msg("screen: {}".format(screen))
new_obj.ViewObject.DisplayMode = "2D text"
h = h * 10
new_obj.ViewObject.FontSize = h
new_obj.ViewObject.FontName = utils.get_param("textfont", "")
new_obj.ViewObject.LineSpacing = 1
gui_utils.format_object(new_obj)
gui_utils.select(new_obj)
return new_obj
def make_bspline(pointslist, closed=False, placement=None, face=None, support=None):
"""make_bspline(pointslist, [closed], [placement])
Creates a B-Spline object from the given list of vectors.
Parameters
----------
pointlist : [Base.Vector]
List of points to create the polyline.
Instead of a pointslist, you can also pass a Part Wire.
TODO: Change the name so!
closed : bool
If closed is True or first and last points are identical,
the created BSpline will be closed.
placement : Base.Placement
If a placement is given, it is used.
face : Bool
If face is False, the rectangle is shown as a wireframe,
otherwise as a face.
support :
TODO: Describe
"""
if not App.ActiveDocument:
App.Console.PrintError("No active document. Aborting\n")
return
if not isinstance(pointslist,list):
nlist = []
for v in pointslist.Vertexes:
nlist.append(v.Point)
pointslist = nlist
if len(pointslist) < 2:
_err = "Draft.makeBSpline: not enough points"
App.Console.PrintError(translate("draft", _err)+"\n")
return
if (pointslist[0] == pointslist[-1]):
if len(pointslist) > 2:
closed = True
pointslist.pop()
_err = "Draft.makeBSpline: Equal endpoints forced Closed"
App.Console.PrintWarning(translate("Draft", _err) + _err + "\n")
else:
# len == 2 and first == last GIGO
_err = "Draft.makeBSpline: Invalid pointslist"
App.Console.PrintError(translate("Draft", _err)+"\n")
return
# should have sensible parms from here on
if placement:
utils.type_check([(placement,App.Placement)], "make_bspline")
if len(pointslist) == 2: fname = "Line"
else: fname = "BSpline"
obj = App.ActiveDocument.addObject("Part::Part2DObjectPython",fname)
BSpline(obj)
obj.Closed = closed
obj.Points = pointslist
obj.Support = support
if face != None:
obj.MakeFace = face
if placement: obj.Placement = placement
if App.GuiUp:
ViewProviderBSpline(obj.ViewObject)
gui_utils.format_object(obj)
gui_utils.select(obj)
return obj
def make_dimension(p1, p2, p3=None, p4=None):
"""Create one of three types of dimension objects.
In all dimensions the p3 parameter defines a point through which
the dimension line will go through.
The current line width and color will be used.
Linear dimension
----------------
- (p1, p2, p3): a simple linear dimension from p1 to p2
- (object, i1, i2, p3): creates a linked dimension to the provided
object (edge), measuring the distance between its vertices
indexed i1 and i2
Circular dimension
------------------
- (arc, i1, mode, p3): creates a linked dimension to the given arc
object, i1 is the index of the arc edge that will be measured;
mode is either "radius" or "diameter".
"""
if not App.ActiveDocument:
_err("No active document. Aborting")
return None
new_obj = App.ActiveDocument.addObject("App::FeaturePython",
"Dimension")
LinearDimension(new_obj)
if App.GuiUp:
ViewProviderLinearDimension(new_obj.ViewObject)
if isinstance(p1, App.Vector) and isinstance(p2, App.Vector):
# Measure a straight distance between p1 and p2
new_obj.Start = p1
new_obj.End = p2
if not p3:
p3 = p2.sub(p1)
p3.multiply(0.5)
p3 = p1.add(p3)
elif isinstance(p2, int) and isinstance(p3, int):
# p1 is an object, and measure the distance between vertices p2 and p3
# of this object
linked = []
idx = (p2, p3)
linked.append((p1, "Vertex" + str(p2 + 1)))
linked.append((p1, "Vertex" + str(p3 + 1)))
new_obj.LinkedGeometry = linked
new_obj.Support = p1
# p4, and now p3, is the point through which the dimension line
# will go through
p3 = p4
if not p3:
# When used from the GUI command, this will never run
# because p4 will always be assinged to a vector,
# so p3 will never be `None`.
# Moreover, `new_obj.Base` doesn't exist, and certainly `Shape`
# doesn't exist, so if this ever runs it will be an error.
v1 = new_obj.Base.Shape.Vertexes[idx[0]].Point
v2 = new_obj.Base.Shape.Vertexes[idx[1]].Point
p3 = v2.sub(v1)
p3.multiply(0.5)
p3 = v1.add(p3)
elif isinstance(p3, str):
# If the original p3 is a string, we are measuring a circular arc
# p2 should be an integer number starting from 0
linked = []
linked.append((p1, "Edge" + str(p2 + 1)))
if p3 == "radius":
# linked.append((p1, "Center"))
if App.GuiUp:
new_obj.ViewObject.Override = "R $dim"
new_obj.Diameter = False
elif p3 == "diameter":
# linked.append((p1, "Diameter"))
if App.GuiUp:
new_obj.ViewObject.Override = "Ø $dim"
new_obj.Diameter = True
new_obj.LinkedGeometry = linked
new_obj.Support = p1
# p4, and now p3, is the point through which the dimension line
# will go through
p3 = p4
if not p3:
p3 = p1.Shape.Edges[p2].Curve.Center.add(App.Vector(1, 0, 0))
# This p3 is the point through which the dimension line will pass,
# but this may not be the original p3, it could have been p4
# depending on the first three parameter values
new_obj.Dimline = p3
if hasattr(App, "DraftWorkingPlane"):
normal = App.DraftWorkingPlane.axis
else:
normal = App.Vector(0, 0, 1)
if App.GuiUp:
# invert the normal if we are viewing it from the back
vnorm = gui_utils.get3DView().getViewDirection()
if vnorm.getAngle(normal) < math.pi/2:
normal = normal.negative()
new_obj.Normal = normal
if App.GuiUp:
gui_utils.format_object(new_obj)
gui_utils.select(new_obj)
return new_obj
def make_angular_dimension(center=App.Vector(0, 0, 0),
angles=[0, 90],
dim_line=App.Vector(10, 10, 0), normal=None):
"""Create an angular dimension from the given center and angles.
Parameters
----------
center: Base::Vector3, optional
It defaults to the origin `Vector(0, 0, 0)`.
Center of the dimension line, which is a circular arc.
angles: list of two floats, optional
It defaults to `[0, 90]`.
It is a list of two angles, given in degrees, that determine
the apperture of the dimension line, that is, of the circular arc.
It is drawn counter-clockwise.
::
angles = [0 90]
angles = [330 60] # the arc crosses the X axis
angles = [-30 60] # same angle
dim_line: Base::Vector3, optional
It defaults to `Vector(10, 10, 0)`.
This is a point through which the extension of the dimension line
will pass. This defines the radius of the dimension line,
the circular arc.
normal: Base::Vector3, optional
It defaults to `None`, in which case the `normal` is taken
from the currently active `App.DraftWorkingPlane.axis`.
If the working plane is not available, then the `normal`
defaults to +Z or `Vector(0, 0, 1)`.
Returns
-------
App::FeaturePython
A scripted object of type `'AngularDimension'`.
This object does not have a `Shape` attribute, as the text and lines
are created on screen by Coin (pivy).
None
If there is a problem it will return `None`.
"""
_name = "make_angular_dimension"
utils.print_header(_name, "Angular dimension")
found, doc = utils.find_doc(App.activeDocument())
if not found:
_err(_tr("No active document. Aborting."))
return None
_msg("center: {}".format(center))
try:
utils.type_check([(center, App.Vector)], name=_name)
except TypeError:
_err(_tr("Wrong input: must be a vector."))
return None
_msg("angles: {}".format(angles))
try:
utils.type_check([(angles, (tuple, list))], name=_name)
if len(angles) != 2:
_err(_tr("Wrong input: must be a list with two angles."))
return None
ang1, ang2 = angles
utils.type_check([(ang1, (int, float)),
(ang2, (int, float))], name=_name)
except TypeError:
_err(_tr("Wrong input: must be a list with two angles."))
return None
# If the angle is larger than 360 degrees, make sure
# it is smaller than 360
for n in range(len(angles)):
if angles[n] > 360:
angles[n] = angles[n] - 360
_msg("dim_line: {}".format(dim_line))
try:
utils.type_check([(dim_line, App.Vector)], name=_name)
except TypeError:
_err(_tr("Wrong input: must be a vector."))
return None
_msg("normal: {}".format(normal))
if normal:
try:
utils.type_check([(dim_line, App.Vector)], name=_name)
except TypeError:
_err(_tr("Wrong input: must be a vector."))
return None
if not normal:
if hasattr(App, "DraftWorkingPlane"):
normal = App.DraftWorkingPlane.axis
else:
normal = App.Vector(0, 0, 1)
new_obj = App.ActiveDocument.addObject("App::FeaturePython",
"Dimension")
AngularDimension(new_obj)
new_obj.Center = center
new_obj.FirstAngle = angles[0]
new_obj.LastAngle = angles[1]
new_obj.Dimline = dim_line
if App.GuiUp:
ViewProviderAngularDimension(new_obj.ViewObject)
# Invert the normal if we are viewing it from the back.
# This is determined by the angle between the current
# 3D view and the provided normal being below 90 degrees
vnorm = gui_utils.get3DView().getViewDirection()
if vnorm.getAngle(normal) < math.pi/2:
normal = normal.negative()
new_obj.Normal = normal
if App.GuiUp:
gui_utils.format_object(new_obj)
gui_utils.select(new_obj)
return new_obj
def make_bezcurve(pointslist,
closed=False,
placement=None,
face=None,
support=None,
degree=None):
"""make_bezcurve(pointslist, [closed], [placement])
Creates a Bezier Curve object from the given list of vectors.
Parameters
----------
pointlist : [Base.Vector]
List of points to create the polyline.
Instead of a pointslist, you can also pass a Part Wire.
TODO: Change the name so!
closed : bool
If closed is True or first and last points are identical,
the created BSpline will be closed.
placement : Base.Placement
If a placement is given, it is used.
face : Bool
If face is False, the rectangle is shown as a wireframe,
otherwise as a face.
support :
TODO: Describe
degree : int
Degree of the BezCurve
"""
if not App.ActiveDocument:
App.Console.PrintError("No active document. Aborting\n")
return
if not isinstance(pointslist, list):
nlist = []
for v in pointslist.Vertexes:
nlist.append(v.Point)
pointslist = nlist
if placement:
utils.type_check([(placement, App.Placement)], "make_bezcurve")
if len(pointslist) == 2: fname = "Line"
else: fname = "BezCurve"
obj = App.ActiveDocument.addObject("Part::Part2DObjectPython", fname)
BezCurve(obj)
obj.Points = pointslist
if degree:
obj.Degree = degree
else:
import Part
obj.Degree = min((len(pointslist) - (1 * (not closed))),
Part.BezierCurve().MaxDegree)
obj.Closed = closed
obj.Support = support
if face is not None:
obj.MakeFace = face
obj.Proxy.resetcontinuity(obj)
if placement: obj.Placement = placement
if App.GuiUp:
ViewProviderBezCurve(obj.ViewObject)
# if not face: obj.ViewObject.DisplayMode = "Wireframe"
# obj.ViewObject.DisplayMode = "Wireframe"
gui_utils.format_object(obj)
gui_utils.select(obj)
return obj
def make_label(target_point=App.Vector(0, 0, 0),
placement=App.Vector(30, 30, 0),
target_object=None,
subelements=None,
label_type="Custom",
custom_text="Label",
direction="Horizontal",
distance=-10,
points=None):
"""Create a Label object containing different types of information.
The current color and text height and font specified in preferences
are used.
Parameters
----------
target_point: Base::Vector3, optional
It defaults to the origin `App.Vector(0, 0, 0)`.
This is the point which is pointed to by the label's leader line.
This point can be adorned with a marker like an arrow or circle.
placement: Base::Placement, Base::Vector3, or Base::Rotation, optional
It defaults to `App.Vector(30, 30, 0)`.
If it is provided, it defines the base point of the textual
label.
The input could be a full placement, just a vector indicating
the translation, or just a rotation.
target_object: Part::Feature or str, optional
It defaults to `None`.
If it exists it should be an object which will be used to provide
information to the label, as long as `label_type` is different
from `'Custom'`.
If it is a string, it must be the `Label` of that object.
Since a `Label` is not guaranteed to be unique in a document,
it will use the first object found with this `Label`.
subelements: str, optional
It defaults to `None`.
If `subelements` is provided, `target_object` should be provided
as well, otherwise it is ignored.
It should be a string indicating a subelement name, either
`'VertexN'`, `'EdgeN'`, or `'FaceN'` which should exist
within `target_object`.
In this case `'N'` is an integer that indicates the specific number
of vertex, edge, or face in `target_object`.
Both `target_object` and `subelements` are used to link the label
to a particular object, or to the particular vertex, edge, or face,
and get information from them.
::
make_label(..., target_object=App.ActiveDocument.Box)
make_label(..., target_object="My box", subelements="Face3")
These two parameters can be can be obtained from the `Gui::Selection`
module.
::
sel_object = Gui.Selection.getSelectionEx()[0]
target_object = sel_object.Object
subelements = sel_object.SubElementNames[0]
label_type: str, optional
It defaults to `'Custom'`.
It can be `'Custom'`, `'Name'`, `'Label'`, `'Position'`,
`'Length'`, `'Area'`, `'Volume'`, `'Tag'`, or `'Material'`.
It indicates the type of information that will be shown in the label.
Only `'Custom'` allows you to manually set the text
by defining `custom_text`. The other types take their information
from the object included in `target`.
- `'Position'` will show the base position of the target object,
or of the indicated `'VertexN'` in `target`.
- `'Length'` will show the `Length` of the target object's `Shape`,
or of the indicated `'EdgeN'` in `target`.
- `'Area'` will show the `Area` of the target object's `Shape`,
or of the indicated `'FaceN'` in `target`.
custom_text: str, optional
It defaults to `'Label'`.
It is the text that will be displayed by the label when
`label_type` is `'Custom'`.
direction: str, optional
It defaults to `'Horizontal'`.
It can be `'Horizontal'`, `'Vertical'`, or `'Custom'`.
It indicates the direction of the straight segment of the leader line
that ends up next to the textual label.
If `'Custom'` is selected, the leader line can be manually drawn
by specifying the value of `points`.
Normally, the leader line has only three points, but with `'Custom'`
you can specify as many points as needed.
distance: int, float, Base::Quantity, optional
It defaults to -10.
It indicates the length of the horizontal or vertical segment
of the leader line.
The leader line is composed of two segments, the first segment is
inclined, while the second segment is either horizontal or vertical
depending on the value of `direction`.
::
T
|
|
o------- L text
The `oL` segment's length is defined by `distance`
while the `oT` segment is automatically calculated depending
on the values of `placement` (L) and `distance` (o).
This `distance` is oriented, meaning that if it is positive
the segment will be to the right and above of the textual
label, depending on if `direction` is `'Horizontal'` or `'Vertical'`,
respectively.
If it is negative, the segment will be to the left
and below of the text.
points: list of Base::Vector3, optional
It defaults to `None`.
It is a list of vectors defining the shape of the leader line;
the list must have at least two points.
This argument must be used together with `direction='Custom'`
to display this custom leader.
However, notice that if the Label's `StraightDirection` property
is later changed to `'Horizontal'` or `'Vertical'`,
the custom point list will be overwritten with a new,
automatically calculated three-point list.
For the object to use custom points, `StraightDirection`
must remain `'Custom'`, and then the `Points` property
can be overwritten by a suitable list of points.
Returns
-------
App::FeaturePython
A scripted object of type `'Label'`.
This object does not have a `Shape` attribute, as the text and lines
are created on screen by Coin (pivy).
None
If there is a problem it will return `None`.
"""
_name = "make_label"
utils.print_header(_name, "Label")
found, doc = utils.find_doc(App.activeDocument())
if not found:
_err(translate("draft", "No active document. Aborting."))
return None
_msg("target_point: {}".format(target_point))
if not target_point:
target_point = App.Vector(0, 0, 0)
try:
utils.type_check([(target_point, App.Vector)], name=_name)
except TypeError:
_err(translate("draft", "Wrong input: must be a vector."))
return None
_msg("placement: {}".format(placement))
if not placement:
placement = App.Placement()
try:
utils.type_check([(placement,
(App.Placement, App.Vector, App.Rotation))],
name=_name)
except TypeError:
_err(
translate(
"draft",
"Wrong input: must be a placement, a vector, or a rotation."))
return None
# Convert the vector or rotation to a full placement
if isinstance(placement, App.Vector):
placement = App.Placement(placement, App.Rotation())
elif isinstance(placement, App.Rotation):
placement = App.Placement(App.Vector(), placement)
if isinstance(target_object, str):
target_object_str = target_object
if target_object:
if isinstance(target_object, (list, tuple)):
_msg("target_object: {}".format(target_object))
_err(translate("draft", "Wrong input: object must not be a list."))
return None
found, target_object = utils.find_object(target_object, doc)
if not found:
_msg("target_object: {}".format(target_object_str))
_err(translate("draft", "Wrong input: object not in document."))
return None
_msg("target_object: {}".format(target_object.Label))
if target_object and subelements:
_msg("subelements: {}".format(subelements))
try:
# Make a list
if isinstance(subelements, str):
subelements = [subelements]
utils.type_check([(subelements, (list, tuple, str))], name=_name)
except TypeError:
_err(
translate(
"draft",
"Wrong input: must be a list or tuple of strings, or a single string."
))
return None
# The subelements list is used to build a special list
# called a LinkSub, which includes the target_object
# and the subelements.
# Single: (target_object, "Edge1")
# Multiple: (target_object, ("Edge1", "Edge2"))
for sub in subelements:
_sub = target_object.getSubObject(sub)
if not _sub:
_err("subelement: {}".format(sub))
_err(
translate("draft",
"Wrong input: subelement not in object."))
return None
_msg("label_type: {}".format(label_type))
if not label_type:
label_type = "Custom"
try:
utils.type_check([(label_type, str)], name=_name)
except TypeError:
_err(
translate(
"draft",
"Wrong input: must be a string, 'Custom', 'Name', 'Label', 'Position', 'Length', 'Area', 'Volume', 'Tag', or 'Material'."
))
return None
if label_type not in ("Custom", "Name", "Label", "Position", "Length",
"Area", "Volume", "Tag", "Material"):
_err(
translate(
"draft",
"Wrong input: must be a string, 'Custom', 'Name', 'Label', 'Position', 'Length', 'Area', 'Volume', 'Tag', or 'Material'."
))
return None
_msg("custom_text: {}".format(custom_text))
if not custom_text:
custom_text = "Label"
try:
utils.type_check([(custom_text, str)], name=_name)
except TypeError:
_err(translate("draft", "Wrong input: must be a string."))
return None
_msg("direction: {}".format(direction))
if not direction:
direction = "Horizontal"
try:
utils.type_check([(direction, str)], name=_name)
except TypeError:
_err(
translate(
"draft",
"Wrong input: must be a string, 'Horizontal', 'Vertical', or 'Custom'."
))
return None
if direction not in ("Horizontal", "Vertical", "Custom"):
_err(
translate(
"draft",
"Wrong input: must be a string, 'Horizontal', 'Vertical', or 'Custom'."
))
return None
_msg("distance: {}".format(distance))
if not distance:
distance = 1
try:
utils.type_check([(distance, (int, float))], name=_name)
except TypeError:
_err(translate("draft", "Wrong input: must be a number."))
return None
if points:
_msg("points: {}".format(points))
_err_msg = translate(
"draft", "Wrong input: must be a list of at least two vectors.")
try:
utils.type_check([(points, (tuple, list))], name=_name)
except TypeError:
_err(_err_msg)
return None
if len(points) < 2:
_err(_err_msg)
return None
if not all(isinstance(p, App.Vector) for p in points):
_err(_err_msg)
return None
new_obj = doc.addObject("App::FeaturePython", "dLabel")
Label(new_obj)
new_obj.TargetPoint = target_point
new_obj.Placement = placement
if target_object:
if subelements:
new_obj.Target = [target_object, subelements]
else:
new_obj.Target = [target_object, []]
new_obj.LabelType = label_type
new_obj.CustomText = custom_text
new_obj.StraightDirection = direction
new_obj.StraightDistance = distance
if points:
if direction != "Custom":
_wrn(
translate("draft",
"Direction is not 'Custom'; points won't be used."))
new_obj.Points = points
if App.GuiUp:
ViewProviderLabel(new_obj.ViewObject)
h = utils.get_param("textheight", 0.20)
new_obj.ViewObject.TextSize = h
gui_utils.format_object(new_obj)
gui_utils.select(new_obj)
return new_obj
def make_clone(obj, delta=None, forcedraft=False):
"""clone(obj,[delta,forcedraft])
Makes a clone of the given object(s).
The clone is an exact, linked copy of the given object. If the original
object changes, the final object changes too.
Parameters
----------
obj :
delta : Base.Vector
Delta Vector to move the clone from the original position.
forcedraft : bool
If forcedraft is True, the resulting object is a Draft clone
even if the input object is an Arch object.
"""
prefix = utils.get_param("ClonePrefix", "")
cl = None
if prefix:
prefix = prefix.strip() + " "
if not isinstance(obj, list):
obj = [obj]
if (len(obj) == 1) and obj[0].isDerivedFrom("Part::Part2DObject"):
cl = App.ActiveDocument.addObject("Part::Part2DObjectPython",
"Clone2D")
cl.Label = prefix + obj[0].Label + " (2D)"
elif (len(obj) == 1) and (hasattr(obj[0], "CloneOf") or (utils.get_type(
obj[0]) == "BuildingPart")) and (not forcedraft):
# arch objects can be clones
import Arch
if utils.get_type(obj[0]) == "BuildingPart":
cl = Arch.makeComponent()
else:
try:
clonefunc = getattr(Arch, "make" + obj[0].Proxy.Type)
except Exception:
pass # not a standard Arch object... Fall back to Draft mode
else:
cl = clonefunc()
if cl:
base = utils.get_clone_base(obj[0])
cl.Label = prefix + base.Label
cl.CloneOf = base
if hasattr(cl, "Material") and hasattr(obj[0], "Material"):
cl.Material = obj[0].Material
if utils.get_type(obj[0]) != "BuildingPart":
cl.Placement = obj[0].Placement
try:
cl.Role = base.Role
cl.Description = base.Description
cl.Tag = base.Tag
except Exception:
pass
if App.GuiUp:
gui_utils.format_object(cl, base)
cl.ViewObject.DiffuseColor = base.ViewObject.DiffuseColor
if utils.get_type(obj[0]) in ["Window", "BuildingPart"]:
ToDo.delay(Arch.recolorize, cl)
gui_utils.select(cl)
return cl
# fall back to Draft clone mode
if not cl:
cl = App.ActiveDocument.addObject("Part::FeaturePython", "Clone")
cl.addExtension("Part::AttachExtensionPython")
cl.Label = prefix + obj[0].Label
Clone(cl)
if App.GuiUp:
ViewProviderClone(cl.ViewObject)
cl.Objects = obj
if delta:
cl.Placement.move(delta)
elif (len(obj) == 1) and hasattr(obj[0], "Placement"):
cl.Placement = obj[0].Placement
gui_utils.format_object(cl, obj[0])
if hasattr(cl, "LongName") and hasattr(obj[0], "LongName"):
cl.LongName = obj[0].LongName
if App.GuiUp and (len(obj) > 1):
cl.ViewObject.Proxy.resetColors(cl.ViewObject)
gui_utils.select(cl)
return cl
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
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 scale(objectslist,
scale=App.Vector(1, 1, 1),
center=App.Vector(0, 0, 0),
copy=False):
"""scale(objects, scale, [center], copy)
Scales the objects contained in objects (that can be a list of objects or
an object) of the given around given center.
Parameters
----------
objectlist : list
scale : Base.Vector
Scale factors defined by a given vector (in X, Y, Z directions).
objectlist : Base.Vector
Center of the scale operation.
copy : bool
If copy is True, the actual objects are not scaled, but copies
are created instead.
Return
----------
The objects (or their copies) are returned.
"""
if not isinstance(objectslist, list):
objectslist = [objectslist]
newobjlist = []
for obj in objectslist:
if copy:
newobj = make_copy.make_copy(obj)
else:
newobj = obj
if hasattr(obj, 'Shape'):
scaled_shape = obj.Shape.copy()
m = App.Matrix()
m.move(center.negative())
m.scale(scale.x, scale.y, scale.z)
m.move(center)
scaled_shape = scaled_shape.transformGeometry(m)
if utils.get_type(obj) == "Rectangle":
p = []
for v in scaled_shape.Vertexes:
p.append(v.Point)
pl = obj.Placement.copy()
pl.Base = p[0]
diag = p[2].sub(p[0])
bb = p[1].sub(p[0])
bh = p[3].sub(p[0])
nb = DraftVecUtils.project(diag, bb)
nh = DraftVecUtils.project(diag, bh)
if obj.Length < 0: l = -nb.Length
else: l = nb.Length
if obj.Height < 0: h = -nh.Length
else: h = nh.Length
newobj.Length = l
newobj.Height = h
tr = p[0].sub(obj.Shape.Vertexes[0].Point) # unused?
newobj.Placement = pl
elif utils.get_type(obj) == "Wire" or utils.get_type(obj) == "BSpline":
for index, point in enumerate(newobj.Points):
scale_vertex(newobj, index, scale, center)
elif hasattr(obj, 'Shape'):
newobj.Shape = scaled_shape
elif hasattr(obj, "Position"):
d = obj.Position.sub(center)
newobj.Position = center.add(
App.Vector(d.x * scale.x, d.y * scale.y, d.z * scale.z))
elif hasattr(obj, "Placement"):
d = obj.Placement.Base.sub(center)
newobj.Placement.Base = center.add(
App.Vector(d.x * scale.x, d.y * scale.y, d.z * scale.z))
if hasattr(obj, "Height"):
obj.setExpression('Height', None)
obj.Height = obj.Height * scale.y
if hasattr(obj, "Width"):
obj.setExpression('Width', None)
obj.Width = obj.Width * scale.x
if hasattr(obj, "XSize"):
obj.setExpression('XSize', None)
obj.XSize = obj.XSize * scale.x
if hasattr(obj, "YSize"):
obj.setExpression('YSize', None)
obj.YSize = obj.YSize * scale.y
if obj.ViewObject and hasattr(obj.ViewObject, "FontSize"):
obj.ViewObject.FontSize = obj.ViewObject.FontSize * scale.y
if copy:
gui_utils.format_object(newobj, obj)
newobjlist.append(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 make_fillet(objs, radius=100, chamfer=False, delete=False):
"""Create a fillet between two lines or Part.Edges.
Parameters
----------
objs: list
List of two objects of type wire, or edges.
radius: float, optional
It defaults to 100. The curvature of the fillet.
chamfer: bool, optional
It defaults to `False`. If it is `True` it no longer produces
a rounded fillet but a chamfer (straight edge)
with the value of the `radius`.
delete: bool, optional
It defaults to `False`. If it is `True` it will delete
the pair of objects that are used to create the fillet.
Otherwise, the original objects will still be there.
Returns
-------
Part::Part2DObjectPython
The object of Proxy type `'Fillet'`.
It returns `None` if it fails producing the object.
"""
_name = "make_fillet"
utils.print_header(_name, "Fillet")
if len(objs) != 2:
_err(translate("draft", "Two elements are needed."))
return None
e1, e2 = _extract_edges(objs)
edges = DraftGeomUtils.fillet([e1, e2], radius, chamfer)
if len(edges) < 3:
_err(
translate("draft", "Radius is too large") +
", r={}".format(radius))
return None
lengths = [edges[0].Length, edges[1].Length, edges[2].Length]
_msg(
translate("draft", "Segment") + " 1, " +
translate("draft", "length:") + " {}".format(lengths[0]))
_msg(
translate("draft", "Segment") + " 2, " +
translate("draft", "length:") + " {}".format(lengths[1]))
_msg(
translate("draft", "Segment") + " 3, " +
translate("draft", "length:") + " {}".format(lengths[2]))
try:
wire = Part.Wire(edges)
except Part.OCCError:
return None
_doc = App.activeDocument()
obj = _doc.addObject("Part::Part2DObjectPython", "Fillet")
fillet.Fillet(obj)
obj.Shape = wire
obj.Length = wire.Length
obj.Start = wire.Vertexes[0].Point
obj.End = wire.Vertexes[-1].Point
obj.FilletRadius = radius
if delete:
_doc.removeObject(objs[0].Name)
_doc.removeObject(objs[1].Name)
_msg(translate("draft", "Removed original objects."))
if App.GuiUp:
view_fillet.ViewProviderFillet(obj.ViewObject)
gui_utils.format_object(obj)
gui_utils.select(obj)
gui_utils.autogroup(obj)
return obj
def mirror(objlist, p1, p2):
"""Create a mirror object from the provided list and line.
It creates a `Part::Mirroring` object from the given `objlist` using
a plane that is defined by the two given points `p1` and `p2`,
and either
- the Draft working plane normal, or
- the negative normal provided by the camera direction
if the working plane normal does not exist and the graphical interface
is available.
If neither of these two is available, it uses as normal the +Z vector.
Parameters
----------
objlist: single object or a list of objects
A single object or a list of objects.
p1: Base::Vector3
Point 1 of the mirror plane. It is also used as the `Placement.Base`
of the resulting object.
p2: Base::Vector3
Point 1 of the mirror plane.
Returns
-------
None
If the operation fails.
list
List of `Part::Mirroring` objects, or a single one
depending on the input `objlist`.
To Do
-----
Implement a mirror tool specific to the workbench that does not
just use `Part::Mirroring`. It should create a derived object,
that is, it should work similar to `Draft.offset`.
"""
utils.print_header('mirror', "Create mirror")
if not objlist:
_err(_tr("No object given"))
return
if p1 == p2:
_err(_tr("The two points are coincident"))
return
if not isinstance(objlist, list):
objlist = [objlist]
if hasattr(App, "DraftWorkingPlane"):
norm = App.DraftWorkingPlane.getNormal()
elif App.GuiUp:
norm = Gui.ActiveDocument.ActiveView.getViewDirection().negative()
else:
norm = App.Vector(0, 0, 1)
pnorm = p2.sub(p1).cross(norm).normalize()
result = []
for obj in objlist:
mir = App.ActiveDocument.addObject("Part::Mirroring", "mirror")
mir.Label = obj.Label + _tr(" (mirrored)")
mir.Source = obj
mir.Base = p1
mir.Normal = pnorm
gui_utils.format_object(mir, obj)
result.append(mir)
if len(result) == 1:
result = result[0]
gui_utils.select(result)
return result
def make_circle(radius,
placement=None,
face=None,
startangle=None,
endangle=None,
support=None):
"""make_circle(radius, [placement, face, startangle, endangle])
or make_circle(edge,[face]):
Creates a circle object with given parameters.
Parameters
----------
radius : the radius of the circle.
placement :
If placement is given, it is used.
face : Bool
If face is False, the circle is shown as a wireframe,
otherwise as a face.
startangle : start angle of the arc (in degrees)
endangle : end angle of the arc (in degrees)
if startangle and endangle are equal, a circle is created,
if they are different an arc is created
edge : edge.Curve must be a 'Part.Circle'
the circle is created from the given edge
support :
TODO: Describe
"""
if not App.ActiveDocument:
App.Console.PrintError("No active document. Aborting\n")
return
if placement:
utils.type_check([(placement, App.Placement)], "make_circle")
if startangle != endangle:
_name = "Arc"
else:
_name = "Circle"
obj = App.ActiveDocument.addObject("Part::Part2DObjectPython", _name)
Circle(obj)
if face is not None:
obj.MakeFace = face
if isinstance(radius, Part.Edge):
edge = radius
if DraftGeomUtils.geomType(edge) == "Circle":
obj.Radius = edge.Curve.Radius
placement = App.Placement(edge.Placement)
delta = edge.Curve.Center.sub(placement.Base)
placement.move(delta)
# Rotation of the edge
rotOk = App.Rotation(edge.Curve.XAxis, edge.Curve.YAxis,
edge.Curve.Axis, "ZXY")
placement.Rotation = rotOk
if len(edge.Vertexes) > 1:
v0 = edge.Curve.XAxis
v1 = (edge.Vertexes[0].Point).sub(edge.Curve.Center)
v2 = (edge.Vertexes[-1].Point).sub(edge.Curve.Center)
# Angle between edge.Curve.XAxis and the vector from center to start of arc
a0 = math.degrees(App.Vector.getAngle(v0, v1))
# Angle between edge.Curve.XAxis and the vector from center to end of arc
a1 = math.degrees(App.Vector.getAngle(v0, v2))
obj.FirstAngle = a0
obj.LastAngle = a1
else:
obj.Radius = radius
if (startangle is not None) and (endangle is not None):
if startangle == -0: startangle = 0
obj.FirstAngle = startangle
obj.LastAngle = endangle
obj.Support = support
if placement:
obj.Placement = placement
if App.GuiUp:
ViewProviderDraft(obj.ViewObject)
gui_utils.format_object(obj)
gui_utils.select(obj)
return obj
def make_wire(pointslist,
closed=False,
placement=None,
face=None,
support=None,
bs2wire=False):
"""make_wire(pointslist, [closed], [placement])
Creates a Wire object from the given list of vectors. If face is
true (and wire is closed), the wire will appear filled. Instead of
a pointslist, you can also pass a Part Wire.
Parameters
----------
pointslist : [Base.Vector]
List of points to create the polyline
closed : bool
If closed is True or first and last points are identical,
the created polyline will be closed.
placement : Base.Placement
If a placement is given, it is used.
face : Bool
If face is False, the rectangle is shown as a wireframe,
otherwise as a face.
support :
TODO: Describe
bs2wire : bool
TODO: Describe
"""
if not App.ActiveDocument:
App.Console.PrintError("No active document. Aborting\n")
return None
import Part
if isinstance(pointslist, (list, tuple)):
for pnt in pointslist:
if not isinstance(pnt, App.Vector):
App.Console.PrintError(
"Items must be Base.Vector objects, not {}\n".format(
type(pnt)))
return None
elif isinstance(pointslist, Part.Wire):
for edge in pointslist.Edges:
if not DraftGeomUtils.is_straight_line(edge):
App.Console.PrintError("All edges must be straight lines\n")
return None
closed = pointslist.isClosed()
pointslist = [v.Point for v in pointslist.OrderedVertexes]
else:
App.Console.PrintError("Can't make Draft Wire from {}\n".format(
type(pointslist)))
return None
if len(pointslist) == 0:
App.Console.PrintWarning("Draft Wire created with empty point list\n")
if placement:
utils.type_check([(placement, App.Placement)], "make_wire")
ipl = placement.inverse()
if not bs2wire:
pointslist = [ipl.multVec(p) for p in pointslist]
if len(pointslist) == 2:
fname = "Line"
else:
fname = "Wire"
obj = App.ActiveDocument.addObject("Part::Part2DObjectPython", fname)
Wire(obj)
obj.Points = pointslist
obj.Closed = closed
obj.Support = support
if face is not None:
obj.MakeFace = face
if placement:
obj.Placement = placement
if App.GuiUp:
ViewProviderWire(obj.ViewObject)
gui_utils.format_object(obj)
gui_utils.select(obj)
return obj
def make_array(base_object,
arg1, arg2, arg3,
arg4=None, arg5=None, arg6=None,
use_link=True):
"""Create a Draft Array of the given object.
Rectangular array
-----------------
make_array(object, xvector, yvector, xnum, ynum)
make_array(object, xvector, yvector, zvector, xnum, ynum, znum)
xnum of iterations in the x direction
at xvector distance between iterations, same for y direction
with yvector and ynum, same for z direction with zvector and znum.
Polar array
-----------
make_array(object, center, totalangle, totalnum) for polar array, or
center is a vector, totalangle is the angle to cover (in degrees)
and totalnum is the number of objects, including the original.
Circular array
--------------
make_array(object, rdistance, tdistance, axis, center, ncircles, symmetry)
In case of a circular array, rdistance is the distance of the
circles, tdistance is the distance within circles, axis the rotation-axis,
center the center of rotation, ncircles the number of circles
and symmetry the number of symmetry-axis of the distribution.
To Do
-----
The `Array` class currently handles three types of arrays,
orthogonal, polar, and circular. In the future, probably they should be
split in separate classes so that they are easier to manage.
"""
found, doc = utils.find_doc(App.activeDocument())
if not found:
_err(translate("draft","No active document. Aborting."))
return None
if use_link:
# The Array class must be called in this special way
# to make it a LinkArray
new_obj = doc.addObject("Part::FeaturePython", "Array",
Array(None), None, True)
else:
new_obj = doc.addObject("Part::FeaturePython", "Array")
Array(new_obj)
new_obj.Base = base_object
if arg6:
if isinstance(arg1, (int, float, App.Units.Quantity)):
new_obj.ArrayType = "circular"
new_obj.RadialDistance = arg1
new_obj.TangentialDistance = arg2
new_obj.Axis = arg3
new_obj.Center = arg4
new_obj.NumberCircles = arg5
new_obj.Symmetry = arg6
else:
new_obj.ArrayType = "ortho"
new_obj.IntervalX = arg1
new_obj.IntervalY = arg2
new_obj.IntervalZ = arg3
new_obj.NumberX = arg4
new_obj.NumberY = arg5
new_obj.NumberZ = arg6
elif arg4:
new_obj.ArrayType = "ortho"
new_obj.IntervalX = arg1
new_obj.IntervalY = arg2
new_obj.NumberX = arg3
new_obj.NumberY = arg4
else:
new_obj.ArrayType = "polar"
new_obj.Center = arg1
new_obj.Angle = arg2
new_obj.NumberPolar = arg3
if App.GuiUp:
if use_link:
ViewProviderDraftLink(new_obj.ViewObject)
else:
ViewProviderDraftArray(new_obj.ViewObject)
gui_utils.format_object(new_obj, new_obj.Base)
if hasattr(new_obj.Base.ViewObject, "DiffuseColor"):
if len(new_obj.Base.ViewObject.DiffuseColor) > 1:
new_obj.ViewObject.Proxy.resetColors(new_obj.ViewObject)
new_obj.Base.ViewObject.hide()
gui_utils.select(new_obj)
return new_obj
def make_wire(pointslist,
closed=False,
placement=None,
face=None,
support=None,
bs2wire=False):
"""makeWire(pointslist,[closed],[placement])
Creates a Wire object from the given list of vectors. If face is
true (and wire is closed), the wire will appear filled. Instead of
a pointslist, you can also pass a Part Wire.
Parameters
----------
pointlist : [Base.Vector]
List of points to create the polyline
closed : bool
If closed is True or first and last points are identical,
the created polyline will be closed.
placement : Base.Placement
If a placement is given, it is used.
face : Bool
If face is False, the rectangle is shown as a wireframe,
otherwise as a face.
support :
TODO: Describe
bs2wire : bool
TODO: Describe
"""
if not App.ActiveDocument:
App.Console.PrintError("No active document. Aborting\n")
return
import Part
if not isinstance(pointslist, list):
e = pointslist.Wires[0].Edges
pointslist = Part.Wire(Part.__sortEdges__(e))
nlist = []
for v in pointslist.Vertexes:
nlist.append(v.Point)
if DraftGeomUtils.isReallyClosed(pointslist):
closed = True
pointslist = nlist
if len(pointslist) == 0:
print("Invalid input points: ", pointslist)
#print(pointslist)
#print(closed)
if placement:
utils.type_check([(placement, App.Placement)], "make_wire")
ipl = placement.inverse()
if not bs2wire:
pointslist = [ipl.multVec(p) for p in pointslist]
if len(pointslist) == 2:
fname = "Line"
else:
fname = "Wire"
obj = App.ActiveDocument.addObject("Part::Part2DObjectPython", fname)
Wire(obj)
obj.Points = pointslist
obj.Closed = closed
obj.Support = support
if face != None:
obj.MakeFace = face
if placement:
obj.Placement = placement
if App.GuiUp:
ViewProviderWire(obj.ViewObject)
gui_utils.format_object(obj)
gui_utils.select(obj)
return obj
def make_dimension(p1, p2, p3=None, p4=None):
"""makeDimension(p1,p2,[p3]) or makeDimension(object,i1,i2,p3)
or makeDimension(objlist,indices,p3): Creates a Dimension object with
the dimension line passign through p3.The current line width and color
will be used. There are multiple ways to create a dimension, depending on
the arguments you pass to it:
- (p1,p2,p3): creates a standard dimension from p1 to p2
- (object,i1,i2,p3): creates a linked dimension to the given object,
measuring the distance between its vertices indexed i1 and i2
- (object,i1,mode,p3): creates a linked dimension
to the given object, i1 is the index of the (curved) edge to measure,
and mode is either "radius" or "diameter".
"""
if not App.ActiveDocument:
App.Console.PrintError("No active document. Aborting\n")
return
obj = App.ActiveDocument.addObject("App::FeaturePython", "Dimension")
LinearDimension(obj)
if App.GuiUp:
ViewProviderLinearDimension(obj.ViewObject)
if isinstance(p1, App.Vector) and isinstance(p2, App.Vector):
obj.Start = p1
obj.End = p2
if not p3:
p3 = p2.sub(p1)
p3.multiply(0.5)
p3 = p1.add(p3)
elif isinstance(p2, int) and isinstance(p3, int):
l = []
idx = (p2, p3)
l.append((p1, "Vertex" + str(p2 + 1)))
l.append((p1, "Vertex" + str(p3 + 1)))
obj.LinkedGeometry = l
obj.Support = p1
p3 = p4
if not p3:
v1 = obj.Base.Shape.Vertexes[idx[0]].Point
v2 = obj.Base.Shape.Vertexes[idx[1]].Point
p3 = v2.sub(v1)
p3.multiply(0.5)
p3 = v1.add(p3)
elif isinstance(p3, str):
l = []
l.append((p1, "Edge" + str(p2 + 1)))
if p3 == "radius":
#l.append((p1,"Center"))
if App.GuiUp:
obj.ViewObject.Override = "R $dim"
obj.Diameter = False
elif p3 == "diameter":
#l.append((p1,"Diameter"))
if App.GuiUp:
obj.ViewObject.Override = "Ø $dim"
obj.Diameter = True
obj.LinkedGeometry = l
obj.Support = p1
p3 = p4
if not p3:
p3 = p1.Shape.Edges[p2].Curve.Center.add(App.Vector(1, 0, 0))
obj.Dimline = p3
if hasattr(App, "DraftWorkingPlane"):
normal = App.DraftWorkingPlane.axis
else:
normal = App.Vector(0, 0, 1)
if App.GuiUp:
# invert the normal if we are viewing it from the back
vnorm = gui_utils.get3DView().getViewDirection()
if vnorm.getAngle(normal) < math.pi / 2:
normal = normal.negative()
obj.Normal = normal
if App.GuiUp:
gui_utils.format_object(obj)
gui_utils.select(obj)
return obj
def make_point_array(base_object, point_object, extra=None, use_link=True):
"""Make a Draft PointArray object.
Distribute copies of a `base_object` in the points
defined by `point_object`.
Parameters
----------
base_object: Part::Feature or str
Any of object that has a `Part::TopoShape` that can be duplicated.
This means most 2D and 3D objects produced with any workbench.
If it is a string, it must be the `Label` of that object.
Since a label is not guaranteed to be unique in a document,
it will use the first object found with this label.
point_object: Part::Feature or str
An object that is a type of container for holding points.
This object must have one of the following properties `Geometry`,
`Links`, or `Components`, which themselves must contain objects
with `X`, `Y`, and `Z` properties.
This object could be:
- A `Sketcher::SketchObject`, as it has a `Geometry` property.
The sketch can contain different elements but it must contain
at least one `Part::GeomPoint`.
- A `Part::Compound`, as it has a `Links` property. The compound
can contain different elements but it must contain at least
one object that has `X`, `Y`, and `Z` properties,
like a `Draft Point` or a `Part::Vertex`.
- A `Draft Block`, as it has a `Components` property. This `Block`
behaves essentially the same as a `Part::Compound`. It must
contain at least a point or vertex object.
extra: Base::Placement, Base::Vector3, or Base::Rotation, optional
It defaults to `None`.
If it is provided, it is an additional placement that is applied
to each copy of the array.
The input could be a full placement, just a vector indicating
the additional translation, or just a rotation.
Returns
-------
Part::FeaturePython
A scripted object of type `'PointArray'`.
Its `Shape` is a compound of the copies of the original object.
None
If there is a problem it will return `None`.
"""
_name = "make_point_array"
utils.print_header(_name, "Point array")
found, doc = utils.find_doc(App.activeDocument())
if not found:
_err(_tr("No active document. Aborting."))
return None
if isinstance(base_object, str):
base_object_str = base_object
found, base_object = utils.find_object(base_object, doc)
if not found:
_msg("base_object: {}".format(base_object_str))
_err(_tr("Wrong input: object not in document."))
return None
_msg("base_object: {}".format(base_object.Label))
if isinstance(point_object, str):
point_object_str = point_object
found, point_object = utils.find_object(point_object, doc)
if not found:
_msg("point_object: {}".format(point_object_str))
_err(_tr("Wrong input: object not in document."))
return None
_msg("point_object: {}".format(point_object.Label))
if (not hasattr(point_object, "Geometry")
and not hasattr(point_object, "Links")
and not hasattr(point_object, "Components")):
_err(
_tr("Wrong input: point object doesn't have "
"'Geometry', 'Links', or 'Components'."))
return None
_msg("extra: {}".format(extra))
if not extra:
extra = App.Placement()
try:
utils.type_check([(extra, (App.Placement, App.Vector, App.Rotation))],
name=_name)
except TypeError:
_err(
_tr("Wrong input: must be a placement, a vector, "
"or a rotation."))
return None
# Convert the vector or rotation to a full placement
if isinstance(extra, App.Vector):
extra = App.Placement(extra, App.Rotation())
elif isinstance(extra, App.Rotation):
extra = App.Placement(App.Vector(), extra)
if use_link:
# The PointArray class must be called in this special way
# to make it a LinkArray
new_obj = doc.addObject("Part::FeaturePython", "PointArray",
PointArray(None), None, True)
else:
new_obj = doc.addObject("Part::FeaturePython", "PointArray")
PointArray(new_obj)
new_obj.Base = base_object
new_obj.PointObject = point_object
new_obj.ExtraPlacement = extra
if App.GuiUp:
if use_link:
ViewProviderDraftLink(new_obj.ViewObject)
else:
ViewProviderDraftArray(new_obj.ViewObject)
gui_utils.format_object(new_obj, new_obj.Base)
if hasattr(new_obj.Base.ViewObject, "DiffuseColor"):
if len(new_obj.Base.ViewObject.DiffuseColor) > 1:
new_obj.ViewObject.Proxy.resetColors(new_obj.ViewObject)
new_obj.Base.ViewObject.hide()
gui_utils.select(new_obj)
return new_obj