1374 lines
43 KiB
Python
1374 lines
43 KiB
Python
# -*- coding: utf-8 -*-
|
|
# ***************************************************************************
|
|
# * (c) 2009, 2010 *
|
|
# * Yorik van Havre <yorik@uncreated.net>, Ken Cline <cline@frii.com> *
|
|
# * (c) 2019 Eliud Cabrera Castillo <e.cabrera-castillo@tum.de> *
|
|
# * *
|
|
# * This file is part of the FreeCAD CAx development system. *
|
|
# * *
|
|
# * This program is free software; you can redistribute it and/or modify *
|
|
# * it under the terms of the GNU Lesser General Public License (LGPL) *
|
|
# * as published by the Free Software Foundation; either version 2 of *
|
|
# * the License, or (at your option) any later version. *
|
|
# * for detail see the LICENCE text file. *
|
|
# * *
|
|
# * FreeCAD is distributed in the hope that it will be useful, *
|
|
# * but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
# * GNU Library General Public License for more details. *
|
|
# * *
|
|
# * You should have received a copy of the GNU Library General Public *
|
|
# * License along with FreeCAD; if not, write to the Free Software *
|
|
# * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
|
|
# * USA *
|
|
# * *
|
|
# ***************************************************************************
|
|
"""Provides utility functions for the Draft Workbench.
|
|
|
|
This module contains auxiliary functions which can be used
|
|
in other modules of the workbench, and which don't require
|
|
the graphical user interface (GUI).
|
|
"""
|
|
## @package utils
|
|
# \ingroup DRAFT
|
|
# \brief This module provides utility functions for the Draft Workbench
|
|
|
|
import os
|
|
from PySide import QtCore
|
|
|
|
import FreeCAD as App
|
|
import Draft_rc
|
|
|
|
from draftutils.messages import _msg, _wrn, _err, _log
|
|
from draftutils.translate import _tr
|
|
|
|
# TODO: move the functions that require the graphical interface
|
|
# This module should not import any graphical commands; those should be
|
|
# in gui_utils
|
|
if App.GuiUp:
|
|
import FreeCADGui as Gui
|
|
|
|
# The module is used to prevent complaints from code checkers (flake8)
|
|
True if Draft_rc else False
|
|
|
|
ARROW_TYPES = ["Dot", "Circle", "Arrow", "Tick", "Tick-2"]
|
|
arrowtypes = ARROW_TYPES
|
|
|
|
|
|
def string_encode_coin(ustr):
|
|
"""Encode a unicode object to be used as a string in coin.
|
|
|
|
Parameters
|
|
----------
|
|
ustr : str
|
|
A string to be encoded
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
Encoded string. If the coin version is >= 4
|
|
it will encode the string to `'utf-8'`, otherwise
|
|
it will encode it to `'latin-1'`.
|
|
"""
|
|
try:
|
|
from pivy import coin
|
|
coin4 = coin.COIN_MAJOR_VERSION >= 4
|
|
except (ImportError, AttributeError):
|
|
coin4 = False
|
|
if coin4:
|
|
return ustr.encode('utf-8')
|
|
else:
|
|
return ustr.encode('latin1')
|
|
|
|
|
|
stringencodecoin = string_encode_coin
|
|
|
|
|
|
def type_check(args_and_types, name="?"):
|
|
"""Check that the arguments are instances of certain types.
|
|
|
|
Parameters
|
|
----------
|
|
args_and_types : list
|
|
A list of tuples. The first element of a tuple is tested as being
|
|
an instance of the second element.
|
|
::
|
|
args_and_types = [(a, Type), (b, Type2), ...]
|
|
|
|
Then
|
|
::
|
|
isinstance(a, Type)
|
|
isinstance(b, Type2)
|
|
|
|
A `Type` can also be a tuple of many types, in which case
|
|
the check is done for any of them.
|
|
::
|
|
args_and_types = [(a, (Type3, int, float)), ...]
|
|
|
|
isinstance(a, (Type3, int, float))
|
|
|
|
name : str, optional
|
|
Defaults to `'?'`. The name of the check.
|
|
|
|
Raises
|
|
------
|
|
TypeError
|
|
If the first element in the tuple is not an instance of the second
|
|
element, it raises `Draft.name`.
|
|
"""
|
|
for v, t in args_and_types:
|
|
if not isinstance(v, t):
|
|
w = "typecheck[{}]: '{}' is not {}".format(name, v, t)
|
|
_wrn(w)
|
|
raise TypeError("Draft." + str(name))
|
|
|
|
|
|
typecheck = type_check
|
|
|
|
|
|
def get_param_type(param):
|
|
"""Return the type of the parameter entered.
|
|
|
|
Parameters
|
|
----------
|
|
param : str
|
|
A string that indicates a parameter in the parameter database.
|
|
|
|
Returns
|
|
-------
|
|
str or None
|
|
The returned string could be `'int'`, `'string'`, `'float'`,
|
|
`'bool'`, `'unsigned'`, depending on the parameter.
|
|
It returns `None` for unhandled situations.
|
|
"""
|
|
if param in ("dimsymbol", "dimPrecision", "dimorientation",
|
|
"precision", "defaultWP", "snapRange", "gridEvery",
|
|
"linewidth", "UiMode", "modconstrain", "modsnap",
|
|
"maxSnapEdges", "modalt", "HatchPatternResolution",
|
|
"snapStyle", "dimstyle", "gridSize"):
|
|
return "int"
|
|
elif param in ("constructiongroupname", "textfont",
|
|
"patternFile", "template", "snapModes",
|
|
"FontFile", "ClonePrefix",
|
|
"labeltype") or "inCommandShortcut" in param:
|
|
return "string"
|
|
elif param in ("textheight", "tolerance", "gridSpacing",
|
|
"arrowsize", "extlines", "dimspacing",
|
|
"dimovershoot", "extovershoot"):
|
|
return "float"
|
|
elif param in ("selectBaseObjects", "alwaysSnap", "grid",
|
|
"fillmode", "saveonexit", "maxSnap",
|
|
"SvgLinesBlack", "dxfStdSize", "showSnapBar",
|
|
"hideSnapBar", "alwaysShowGrid", "renderPolylineWidth",
|
|
"showPlaneTracker", "UsePartPrimitives",
|
|
"DiscretizeEllipses", "showUnit",
|
|
"Draft_array_fuse", "Draft_array_Link", "gridBorder"):
|
|
return "bool"
|
|
elif param in ("color", "constructioncolor",
|
|
"snapcolor", "gridColor"):
|
|
return "unsigned"
|
|
else:
|
|
return None
|
|
|
|
|
|
getParamType = get_param_type
|
|
|
|
|
|
def get_param(param, default=None):
|
|
"""Return a parameter value from the current parameter database.
|
|
|
|
The parameter database is located in the tree
|
|
::
|
|
'User parameter:BaseApp/Preferences/Mod/Draft'
|
|
|
|
In the case that `param` is `'linewidth'` or `'color'` it will get
|
|
the values from the View parameters
|
|
::
|
|
'User parameter:BaseApp/Preferences/View/DefaultShapeLineWidth'
|
|
'User parameter:BaseApp/Preferences/View/DefaultShapeLineColor'
|
|
|
|
Parameters
|
|
----------
|
|
param : str
|
|
A string that indicates a parameter in the parameter database.
|
|
|
|
default : optional
|
|
It indicates the default value of the given parameter.
|
|
It defaults to `None`, in which case it will use a specific
|
|
value depending on the type of parameter determined
|
|
with `get_param_type`.
|
|
|
|
Returns
|
|
-------
|
|
int, or str, or float, or bool
|
|
Depending on `param` and its type, by returning `ParameterGrp.GetInt`,
|
|
`ParameterGrp.GetString`, `ParameterGrp.GetFloat`,
|
|
`ParameterGrp.GetBool`, or `ParameterGrp.GetUnsinged`.
|
|
"""
|
|
draft_params = "User parameter:BaseApp/Preferences/Mod/Draft"
|
|
view_params = "User parameter:BaseApp/Preferences/View"
|
|
|
|
p = App.ParamGet(draft_params)
|
|
v = App.ParamGet(view_params)
|
|
t = getParamType(param)
|
|
# print("getting param ",param, " of type ",t, " default: ",str(default))
|
|
if t == "int":
|
|
if default is None:
|
|
default = 0
|
|
if param == "linewidth":
|
|
return v.GetInt("DefaultShapeLineWidth", default)
|
|
return p.GetInt(param, default)
|
|
elif t == "string":
|
|
if default is None:
|
|
default = ""
|
|
return p.GetString(param, default)
|
|
elif t == "float":
|
|
if default is None:
|
|
default = 0
|
|
return p.GetFloat(param, default)
|
|
elif t == "bool":
|
|
if default is None:
|
|
default = False
|
|
return p.GetBool(param, default)
|
|
elif t == "unsigned":
|
|
if default is None:
|
|
default = 0
|
|
if param == "color":
|
|
return v.GetUnsigned("DefaultShapeLineColor", default)
|
|
return p.GetUnsigned(param, default)
|
|
else:
|
|
return None
|
|
|
|
|
|
getParam = get_param
|
|
|
|
|
|
def set_param(param, value):
|
|
"""Set a Draft parameter with the given value.
|
|
|
|
The parameter database is located in the tree
|
|
::
|
|
'User parameter:BaseApp/Preferences/Mod/Draft'
|
|
|
|
In the case that `param` is `'linewidth'` or `'color'` it will set
|
|
the View parameters
|
|
::
|
|
'User parameter:BaseApp/Preferences/View/DefaultShapeLineWidth'
|
|
'User parameter:BaseApp/Preferences/View/DefaultShapeLineColor'
|
|
|
|
Parameters
|
|
----------
|
|
param : str
|
|
A string that indicates a parameter in the parameter database.
|
|
|
|
value : int, or str, or float, or bool
|
|
The appropriate value of the parameter.
|
|
Depending on `param` and its type, determined with `get_param_type`,
|
|
it sets the appropriate value by calling `ParameterGrp.SetInt`,
|
|
`ParameterGrp.SetString`, `ParameterGrp.SetFloat`,
|
|
`ParameterGrp.SetBool`, or `ParameterGrp.SetUnsinged`.
|
|
"""
|
|
draft_params = "User parameter:BaseApp/Preferences/Mod/Draft"
|
|
view_params = "User parameter:BaseApp/Preferences/View"
|
|
|
|
p = App.ParamGet(draft_params)
|
|
v = App.ParamGet(view_params)
|
|
t = getParamType(param)
|
|
|
|
if t == "int":
|
|
if param == "linewidth":
|
|
v.SetInt("DefaultShapeLineWidth", value)
|
|
else:
|
|
p.SetInt(param, value)
|
|
elif t == "string":
|
|
p.SetString(param, value)
|
|
elif t == "float":
|
|
p.SetFloat(param, value)
|
|
elif t == "bool":
|
|
p.SetBool(param, value)
|
|
elif t == "unsigned":
|
|
if param == "color":
|
|
v.SetUnsigned("DefaultShapeLineColor", value)
|
|
else:
|
|
p.SetUnsigned(param, value)
|
|
|
|
|
|
setParam = set_param
|
|
|
|
|
|
def precision():
|
|
"""Return the precision value from the parameter database.
|
|
|
|
It is the number of decimal places that a float will have.
|
|
Example
|
|
::
|
|
precision=6, 0.123456
|
|
precision=5, 0.12345
|
|
precision=4, 0.1234
|
|
|
|
Due to floating point operations there may be rounding errors.
|
|
Therefore, this precision number is used to round up values
|
|
so that all operations are consistent.
|
|
By default the precision is 6 decimal places.
|
|
|
|
Returns
|
|
-------
|
|
int
|
|
get_param("precision", 6)
|
|
"""
|
|
return getParam("precision", 6)
|
|
|
|
|
|
def tolerance():
|
|
"""Return the tolerance value from the parameter database.
|
|
|
|
This specifies a tolerance around a quantity.
|
|
::
|
|
value + tolerance
|
|
value - tolerance
|
|
|
|
By default the tolerance is 0.05.
|
|
|
|
Returns
|
|
-------
|
|
float
|
|
get_param("tolerance", 0.05)
|
|
"""
|
|
return getParam("tolerance", 0.05)
|
|
|
|
|
|
def epsilon():
|
|
"""Return a small number based on the tolerance for use in comparisons.
|
|
|
|
The epsilon value is used in floating point comparisons. Use with caution.
|
|
::
|
|
denom = 10**tolerance
|
|
num = 1
|
|
epsilon = num/denom
|
|
|
|
Returns
|
|
-------
|
|
float
|
|
1/(10**tolerance)
|
|
"""
|
|
return 1.0/(10.0**tolerance())
|
|
|
|
|
|
def get_real_name(name):
|
|
"""Strip the trailing numbers from a string to get only the letters.
|
|
|
|
Parameters
|
|
----------
|
|
name : str
|
|
A string that may have a number at the end, `Line001`.
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
A string without the numbers at the end, `Line`.
|
|
The returned string cannot be empty; it will have
|
|
at least one letter.
|
|
"""
|
|
for i in range(1, len(name)):
|
|
if name[-i] not in '1234567890':
|
|
return name[:len(name) - (i-1)]
|
|
return name
|
|
|
|
|
|
getRealName = get_real_name
|
|
|
|
|
|
def get_type(obj):
|
|
"""Return a string indicating the type of the given object.
|
|
|
|
Parameters
|
|
----------
|
|
obj : App::DocumentObject
|
|
Any type of scripted object created with Draft,
|
|
or any other workbench.
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
If `obj` has a `Proxy`, it will return the value of `obj.Proxy.Type`.
|
|
|
|
* If `obj` is a `Part.Shape`, returns `'Shape'`
|
|
* If `'Sketcher::SketchObject'`, returns `'Sketch'`
|
|
* If `'Part::Line'`, returns `'Part::Line'`
|
|
* If `'Part::Offset2D'`, returns `'Offset2D'`
|
|
* If `'Part::Feature'`, returns `'Part'`
|
|
* If `'App::Annotation'`, returns `'Annotation'`
|
|
* If `'Mesh::Feature'`, returns `'Mesh'`
|
|
* If `'Points::Feature'`, returns `'Points'`
|
|
* If `'App::DocumentObjectGroup'`, returns `'Group'`
|
|
* If `'App::Part'`, returns `'App::Part'`
|
|
|
|
In other cases, it will return `'Unknown'`,
|
|
or `None` if `obj` is `None`.
|
|
"""
|
|
import Part
|
|
if not obj:
|
|
return None
|
|
if isinstance(obj, Part.Shape):
|
|
return "Shape"
|
|
if "Proxy" in obj.PropertiesList:
|
|
if hasattr(obj.Proxy, "Type"):
|
|
return obj.Proxy.Type
|
|
if obj.isDerivedFrom("Sketcher::SketchObject"):
|
|
return "Sketch"
|
|
if (obj.TypeId == "Part::Line"):
|
|
return "Part::Line"
|
|
if (obj.TypeId == "Part::Offset2D"):
|
|
return "Offset2D"
|
|
if obj.isDerivedFrom("Part::Feature"):
|
|
return "Part"
|
|
if (obj.TypeId == "App::Annotation"):
|
|
return "Annotation"
|
|
if obj.isDerivedFrom("Mesh::Feature"):
|
|
return "Mesh"
|
|
if obj.isDerivedFrom("Points::Feature"):
|
|
return "Points"
|
|
if (obj.TypeId == "App::DocumentObjectGroup"):
|
|
return "Group"
|
|
if (obj.TypeId == "App::Part"):
|
|
return "App::Part"
|
|
return "Unknown"
|
|
|
|
|
|
getType = get_type
|
|
|
|
|
|
def get_objects_of_type(objects, typ):
|
|
"""Return only the objects that match the type in the list of objects.
|
|
|
|
Parameters
|
|
----------
|
|
objects : list of App::DocumentObject
|
|
A list of objects which will be tested.
|
|
|
|
typ : str
|
|
A string that indicates a type. This should be one of the types
|
|
that can be returned by `get_type`.
|
|
|
|
Returns
|
|
-------
|
|
list of objects
|
|
Only the objects that match `typ` will be added to the output list.
|
|
"""
|
|
objs = []
|
|
for o in objects:
|
|
if getType(o) == typ:
|
|
objs.append(o)
|
|
return objs
|
|
|
|
|
|
getObjectsOfType = get_objects_of_type
|
|
|
|
|
|
def is_clone(obj, objtype, recursive=False):
|
|
"""Return True if the given object is a clone of a certain type.
|
|
|
|
A clone is of type `'Clone'`, and has a reference
|
|
to the original object inside its `Objects` attribute,
|
|
which is an `'App::PropertyLinkListGlobal'`.
|
|
|
|
The `Objects` attribute can point to another `'Clone'` object.
|
|
If `recursive` is `True`, the function will be called recursively
|
|
to further test this clone, until the type of the original object
|
|
can be compared to `objtype`.
|
|
|
|
Parameters
|
|
----------
|
|
obj : App::DocumentObject
|
|
The clone object that will be tested for a certain type.
|
|
|
|
objtype : str or list of str
|
|
A type string such as one obtained from `get_type`.
|
|
Or a list of such types.
|
|
|
|
recursive : bool, optional
|
|
It defaults to `False`.
|
|
If it is `True`, this same function will be called recursively
|
|
with `obj.Object[0]` as input.
|
|
|
|
This option only works if `obj.Object[0]` is of type `'Clone'`,
|
|
that is, if `obj` is a clone of a clone.
|
|
|
|
Returns
|
|
-------
|
|
bool
|
|
Returns `True` if `obj` is of type `'Clone'`,
|
|
and `obj.Object[0]` is of type `objtype`.
|
|
|
|
If `objtype` is a list, then `obj.Objects[0]`
|
|
will be tested against each of the elements in the list,
|
|
and it will return `True` if at least one element matches the type.
|
|
|
|
If `obj` isn't of type `'Clone'` but has the `CloneOf` attribute,
|
|
it will also return `True`.
|
|
|
|
It returns `False` otherwise, for example,
|
|
if `obj` is not even a clone.
|
|
"""
|
|
if isinstance(objtype, list):
|
|
return any([isClone(obj, t, recursive) for t in objtype])
|
|
|
|
if getType(obj) == "Clone":
|
|
if len(obj.Objects) == 1:
|
|
if getType(obj.Objects[0]) == objtype:
|
|
return True
|
|
elif recursive and (getType(obj.Objects[0]) == "Clone"):
|
|
return isClone(obj.Objects[0], objtype, recursive)
|
|
elif hasattr(obj, "CloneOf"):
|
|
if obj.CloneOf:
|
|
return True
|
|
return False
|
|
|
|
|
|
isClone = is_clone
|
|
|
|
|
|
def get_clone_base(obj, strict=False):
|
|
"""Return the object cloned by this object, if any.
|
|
|
|
Parameters
|
|
----------
|
|
obj: App::DocumentObject
|
|
Any type of object.
|
|
|
|
strict: bool, optional
|
|
It defaults to `False`.
|
|
If it is `True`, and this object is not a clone,
|
|
this function will return `False`.
|
|
|
|
Returns
|
|
-------
|
|
App::DocumentObject
|
|
It `obj` is a `Draft Clone`, it will return the first object
|
|
that is in its `Objects` property.
|
|
|
|
If `obj` has a `CloneOf` property, it will search iteratively
|
|
inside the object pointed to by this property.
|
|
|
|
obj
|
|
If `obj` is not a `Draft Clone`, nor it has a `CloneOf` property,
|
|
it will return the same `obj`, as long as `strict` is `False`.
|
|
|
|
False
|
|
It will return `False` if `obj` is not a clone,
|
|
and `strict` is `True`.
|
|
"""
|
|
if hasattr(obj, "CloneOf"):
|
|
if obj.CloneOf:
|
|
return get_clone_base(obj.CloneOf)
|
|
if get_type(obj) == "Clone" and obj.Objects:
|
|
return obj.Objects[0]
|
|
if strict:
|
|
return False
|
|
return obj
|
|
|
|
|
|
getCloneBase = get_clone_base
|
|
|
|
|
|
def get_group_names():
|
|
"""Return a list of names of existing groups in the document.
|
|
|
|
Returns
|
|
-------
|
|
list of str
|
|
A list of names of objects that are "groups".
|
|
These are objects derived from `'App::DocumentObjectGroup'`
|
|
or which are of types `'Floor'`, `'Building'`, or `'Site'`
|
|
(from the Arch Workbench).
|
|
|
|
Otherwise, return an empty list.
|
|
"""
|
|
glist = []
|
|
doc = App.ActiveDocument
|
|
for obj in doc.Objects:
|
|
if (obj.isDerivedFrom("App::DocumentObjectGroup")
|
|
or getType(obj) in ("Floor", "Building", "Site")):
|
|
glist.append(obj.Name)
|
|
return glist
|
|
|
|
|
|
getGroupNames = get_group_names
|
|
|
|
|
|
def ungroup(obj):
|
|
"""Remove the object from any group to which it belongs.
|
|
|
|
A "group" is any object returned by `get_group_names`.
|
|
|
|
Parameters
|
|
----------
|
|
obj : App::DocumentObject
|
|
Any type of scripted object.
|
|
"""
|
|
for name in getGroupNames():
|
|
group = App.ActiveDocument.getObject(name)
|
|
if obj in group.Group:
|
|
# The list of objects cannot be modified directly,
|
|
# so a new list is created, this new list is modified,
|
|
# and then it is assigned over the older list.
|
|
objects = group.Group
|
|
objects.remove(obj)
|
|
group.Group = objects
|
|
|
|
|
|
def shapify(obj):
|
|
"""Transform a parametric object into a static, non-parametric shape.
|
|
|
|
Parameters
|
|
----------
|
|
obj : App::DocumentObject
|
|
Any type of scripted object.
|
|
|
|
This object will be removed, and a non-parametric object
|
|
with the same topological shape (`Part::TopoShape`)
|
|
will be created.
|
|
|
|
Returns
|
|
-------
|
|
Part::Feature
|
|
The new object that takes `obj.Shape` as its own.
|
|
|
|
Depending on the contents of the Shape, the resulting object
|
|
will be named `'Face'`, `'Solid'`, `'Compound'`,
|
|
`'Shell'`, `'Wire'`, `'Line'`, `'Circle'`,
|
|
or the name returned by `get_real_name(obj.Name)`.
|
|
|
|
If there is a problem with `obj.Shape`, it will return `None`,
|
|
and the original object will not be modified.
|
|
"""
|
|
try:
|
|
shape = obj.Shape
|
|
except Exception:
|
|
return None
|
|
|
|
if len(shape.Faces) == 1:
|
|
name = "Face"
|
|
elif len(shape.Solids) == 1:
|
|
name = "Solid"
|
|
elif len(shape.Solids) > 1:
|
|
name = "Compound"
|
|
elif len(shape.Faces) > 1:
|
|
name = "Shell"
|
|
elif len(shape.Wires) == 1:
|
|
name = "Wire"
|
|
elif len(shape.Edges) == 1:
|
|
import DraftGeomUtils
|
|
if DraftGeomUtils.geomType(shape.Edges[0]) == "Line":
|
|
name = "Line"
|
|
else:
|
|
name = "Circle"
|
|
else:
|
|
name = getRealName(obj.Name)
|
|
|
|
App.ActiveDocument.removeObject(obj.Name)
|
|
newobj = App.ActiveDocument.addObject("Part::Feature", name)
|
|
newobj.Shape = shape
|
|
|
|
return newobj
|
|
|
|
|
|
def get_windows(obj):
|
|
"""Return the windows and rebars inside a host.
|
|
|
|
Parameters
|
|
----------
|
|
obj : App::DocumentObject
|
|
A scripted object of type `'Wall'` or `'Structure'`
|
|
(Arch Workbench).
|
|
This will be searched for objects of type `'Window'` and `'Rebar'`,
|
|
and clones of them, and the found elements will be added
|
|
to the output list.
|
|
|
|
The function will search recursively all elements under `obj.OutList`,
|
|
in case the windows and rebars are nested under other walls
|
|
and structures.
|
|
|
|
Returns
|
|
-------
|
|
list
|
|
A list of all found windows and rebars in `obj`.
|
|
If `obj` is itself a `'Window'` or a `'Rebar'`, or a clone of them,
|
|
it will return the same `obj` element.
|
|
"""
|
|
out = []
|
|
if getType(obj) in ("Wall", "Structure"):
|
|
for o in obj.OutList:
|
|
out.extend(get_windows(o))
|
|
for i in obj.InList:
|
|
if getType(i) in ("Window") or isClone(obj, "Window"):
|
|
if hasattr(i, "Hosts"):
|
|
if obj in i.Hosts:
|
|
out.append(i)
|
|
elif getType(i) in ("Rebar") or isClone(obj, "Rebar"):
|
|
if hasattr(i, "Host"):
|
|
if obj == i.Host:
|
|
out.append(i)
|
|
elif (getType(obj) in ("Window", "Rebar")
|
|
or isClone(obj, ["Window", "Rebar"])):
|
|
out.append(obj)
|
|
return out
|
|
|
|
|
|
getWindows = get_windows
|
|
|
|
|
|
def get_group_contents(objectslist,
|
|
walls=False, addgroups=False,
|
|
spaces=False, noarchchild=False):
|
|
"""Return a list of objects from expanding the input groups.
|
|
|
|
The function accepts any type of object, although it is most useful
|
|
with "groups", as it is meant to unpack the objects inside these groups.
|
|
|
|
Parameters
|
|
----------
|
|
objectslist : list
|
|
If any object in the list is a group, its contents (`obj.Group`)
|
|
are extracted and added to the output list.
|
|
|
|
The "groups" are objects derived from `'App::DocumentObjectGroup'`,
|
|
but they can also be `'App::Part'`, or `'Building'`, `'BuildingPart'`,
|
|
`'Space'`, and `'Site'` from the Arch Workbench.
|
|
|
|
Single items that aren't groups are added to the output list
|
|
as is.
|
|
|
|
walls : bool, optional
|
|
It defaults to `False`.
|
|
If it is `True`, Wall and Structure objects (Arch Workbench)
|
|
are treated as groups; they are scanned for Window, Door,
|
|
and Rebar objects, and these are added to the output list.
|
|
|
|
addgroups : bool, optional
|
|
It defaults to `False`.
|
|
If it is `True`, the group itself is kept as part of the output list.
|
|
|
|
spaces : bool, optional
|
|
It defaults to `False`.
|
|
If it is `True`, Arch Spaces are treated as groups,
|
|
and are added to the output list.
|
|
|
|
noarchchild : bool, optional
|
|
It defaults to `False`.
|
|
If it is `True`, the objects inside Building and BuildingParts
|
|
(Arch Workbench) aren't added to the output list.
|
|
|
|
Returns
|
|
-------
|
|
list
|
|
The list of objects from each group present in `objectslist`,
|
|
plus any other individual object given in `objectslist`.
|
|
"""
|
|
newlist = []
|
|
if not isinstance(objectslist, list):
|
|
objectslist = [objectslist]
|
|
for obj in objectslist:
|
|
if obj:
|
|
if (obj.isDerivedFrom("App::DocumentObjectGroup")
|
|
or (getType(obj) in ("Building", "BuildingPart",
|
|
"Space", "Site")
|
|
and hasattr(obj, "Group"))):
|
|
if getType(obj) == "Site":
|
|
if obj.Shape:
|
|
newlist.append(obj)
|
|
if obj.isDerivedFrom("Drawing::FeaturePage"):
|
|
# skip if the group is a page
|
|
newlist.append(obj)
|
|
else:
|
|
if addgroups or (spaces and getType(obj) == "Space"):
|
|
newlist.append(obj)
|
|
if (noarchchild
|
|
and getType(obj) in ("Building", "BuildingPart")):
|
|
pass
|
|
else:
|
|
newlist.extend(getGroupContents(obj.Group,
|
|
walls, addgroups))
|
|
else:
|
|
# print("adding ", obj.Name)
|
|
newlist.append(obj)
|
|
if walls:
|
|
newlist.extend(getWindows(obj))
|
|
|
|
# Clean possible duplicates
|
|
cleanlist = []
|
|
for obj in newlist:
|
|
if obj not in cleanlist:
|
|
cleanlist.append(obj)
|
|
return cleanlist
|
|
|
|
|
|
getGroupContents = get_group_contents
|
|
|
|
|
|
def print_shape(shape):
|
|
"""Print detailed information of a topological shape.
|
|
|
|
Parameters
|
|
----------
|
|
shape : Part::TopoShape
|
|
Any topological shape in an object, usually obtained from `obj.Shape`.
|
|
"""
|
|
_msg(_tr("Solids:") + " {}".format(len(shape.Solids)))
|
|
_msg(_tr("Faces:") + " {}".format(len(shape.Faces)))
|
|
_msg(_tr("Wires:") + " {}".format(len(shape.Wires)))
|
|
_msg(_tr("Edges:") + " {}".format(len(shape.Edges)))
|
|
_msg(_tr("Vertices:") + " {}".format(len(shape.Vertexes)))
|
|
|
|
if shape.Faces:
|
|
for f in range(len(shape.Faces)):
|
|
_msg(_tr("Face") + " {}:".format(f))
|
|
for v in shape.Faces[f].Vertexes:
|
|
_msg(" {}".format(v.Point))
|
|
elif shape.Wires:
|
|
for w in range(len(shape.Wires)):
|
|
_msg(_tr("Wire") + " {}:".format(w))
|
|
for v in shape.Wires[w].Vertexes:
|
|
_msg(" {}".format(v.Point))
|
|
else:
|
|
for v in shape.Vertexes:
|
|
_msg(" {}".format(v.Point))
|
|
|
|
|
|
printShape = print_shape
|
|
|
|
|
|
def compare_objects(obj1, obj2):
|
|
"""Print the differences between 2 objects.
|
|
|
|
The two objects are compared through their `TypeId` attribute,
|
|
or by using the `get_type` function.
|
|
|
|
If they are the same type their properties are compared
|
|
looking for differences.
|
|
|
|
Neither `Shape` nor `Label` attributes are compared.
|
|
|
|
Parameters
|
|
----------
|
|
obj1 : App::DocumentObject
|
|
Any type of scripted object.
|
|
obj2 : App::DocumentObject
|
|
Any type of scripted object.
|
|
"""
|
|
if obj1.TypeId != obj2.TypeId:
|
|
_msg("'{0}' ({1}), '{2}' ({3}): ".format(obj1.Name, obj1.TypeId,
|
|
obj2.Name, obj2.TypeId)
|
|
+ _tr("different types") + " (TypeId)")
|
|
elif getType(obj1) != getType(obj2):
|
|
_msg("'{0}' ({1}), '{2}' ({3}): ".format(obj1.Name, get_type(obj1),
|
|
obj2.Name, get_type(obj2))
|
|
+ _tr("different types") + " (Proxy.Type)")
|
|
else:
|
|
for p in obj1.PropertiesList:
|
|
if p in obj2.PropertiesList:
|
|
if p in ("Shape", "Label"):
|
|
pass
|
|
elif p == "Placement":
|
|
delta = obj1.Placement.Base.sub(obj2.Placement.Base)
|
|
text = _tr("Objects have different placements. "
|
|
"Distance between the two base points: ")
|
|
_msg(text + str(delta.Length))
|
|
else:
|
|
if getattr(obj1, p) != getattr(obj2, p):
|
|
_msg("'{}' ".format(p) + _tr("has a different value"))
|
|
else:
|
|
_msg("{} ".format(p)
|
|
+ _tr("doesn't exist in one of the objects"))
|
|
|
|
|
|
compareObjects = compare_objects
|
|
|
|
|
|
def load_svg_patterns():
|
|
"""Load the default Draft SVG patterns and user defined patterns.
|
|
|
|
The SVG patterns are added as a dictionary to the `App.svgpatterns`
|
|
attribute.
|
|
"""
|
|
import importSVG
|
|
App.svgpatterns = {}
|
|
|
|
# Getting default patterns in the resource file
|
|
patfiles = QtCore.QDir(":/patterns").entryList()
|
|
for fn in patfiles:
|
|
file = ":/patterns/" + str(fn)
|
|
f = QtCore.QFile(file)
|
|
f.open(QtCore.QIODevice.ReadOnly)
|
|
p = importSVG.getContents(str(f.readAll()), 'pattern', True)
|
|
if p:
|
|
for k in p:
|
|
p[k] = [p[k], file]
|
|
App.svgpatterns.update(p)
|
|
|
|
# Get patterns in a user defined file
|
|
altpat = getParam("patternFile", "")
|
|
if os.path.isdir(altpat):
|
|
for f in os.listdir(altpat):
|
|
if f[-4:].upper() == ".SVG":
|
|
file = os.path.join(altpat, f)
|
|
p = importSVG.getContents(file, 'pattern')
|
|
if p:
|
|
for k in p:
|
|
p[k] = [p[k], file]
|
|
App.svgpatterns.update(p)
|
|
|
|
|
|
loadSvgPatterns = load_svg_patterns
|
|
|
|
|
|
def svg_patterns():
|
|
"""Return a dictionary with installed SVG patterns.
|
|
|
|
Returns
|
|
-------
|
|
dict
|
|
Returns `App.svgpatterns` if it exists.
|
|
Otherwise it calls `load_svg_patterns` to create it
|
|
before returning it.
|
|
"""
|
|
if hasattr(App, "svgpatterns"):
|
|
return App.svgpatterns
|
|
else:
|
|
loadSvgPatterns()
|
|
if hasattr(App, "svgpatterns"):
|
|
return App.svgpatterns
|
|
return {}
|
|
|
|
|
|
svgpatterns = svg_patterns
|
|
|
|
|
|
def get_rgb(color, testbw=True):
|
|
"""Return an RRGGBB value #000000 from a FreeCAD color.
|
|
|
|
Parameters
|
|
----------
|
|
testwb : bool (default = True)
|
|
pure white will be converted into pure black
|
|
"""
|
|
r = str(hex(int(color[0]*255)))[2:].zfill(2)
|
|
g = str(hex(int(color[1]*255)))[2:].zfill(2)
|
|
b = str(hex(int(color[2]*255)))[2:].zfill(2)
|
|
col = "#"+r+g+b
|
|
if testbw:
|
|
if col == "#ffffff":
|
|
# print(getParam('SvgLinesBlack'))
|
|
if getParam('SvgLinesBlack', True):
|
|
col = "#000000"
|
|
return col
|
|
|
|
|
|
getrgb = get_rgb
|
|
|
|
|
|
def get_DXF(obj,direction=None):
|
|
"""getDXF(object,[direction]): returns a DXF entity from the given
|
|
object. If direction is given, the object is projected in 2D."""
|
|
plane = None
|
|
result = ""
|
|
if obj.isDerivedFrom("Drawing::View") or obj.isDerivedFrom("TechDraw::DrawView"):
|
|
if obj.Source.isDerivedFrom("App::DocumentObjectGroup"):
|
|
for o in obj.Source.Group:
|
|
result += getDXF(o,obj.Direction)
|
|
else:
|
|
result += getDXF(obj.Source,obj.Direction)
|
|
return result
|
|
if direction:
|
|
if isinstance(direction, App.Vector):
|
|
import WorkingPlane
|
|
if direction != App.Vector(0,0,0):
|
|
plane = WorkingPlane.Plane()
|
|
plane.alignToPointAndAxis(App.Vector(0,0,0), direction)
|
|
|
|
def getProj(vec):
|
|
if not plane: return vec
|
|
nx = DraftVecUtils.project(vec,plane.u)
|
|
ny = DraftVecUtils.project(vec,plane.v)
|
|
return App.Vector(nx.Length,ny.Length,0)
|
|
|
|
if getType(obj) in ["Dimension","LinearDimension"]:
|
|
p1 = getProj(obj.Start)
|
|
p2 = getProj(obj.End)
|
|
p3 = getProj(obj.Dimline)
|
|
result += "0\nDIMENSION\n8\n0\n62\n0\n3\nStandard\n70\n1\n"
|
|
result += "10\n"+str(p3.x)+"\n20\n"+str(p3.y)+"\n30\n"+str(p3.z)+"\n"
|
|
result += "13\n"+str(p1.x)+"\n23\n"+str(p1.y)+"\n33\n"+str(p1.z)+"\n"
|
|
result += "14\n"+str(p2.x)+"\n24\n"+str(p2.y)+"\n34\n"+str(p2.z)+"\n"
|
|
|
|
elif getType(obj) == "Annotation":
|
|
p = getProj(obj.Position)
|
|
count = 0
|
|
for t in obj.LabeLtext:
|
|
result += "0\nTEXT\n8\n0\n62\n0\n"
|
|
result += "10\n"+str(p.x)+"\n20\n"+str(p.y+count)+"\n30\n"+str(p.z)+"\n"
|
|
result += "40\n1\n"
|
|
result += "1\n"+str(t)+"\n"
|
|
result += "7\nSTANDARD\n"
|
|
count += 1
|
|
|
|
elif hasattr(obj,'Shape'):
|
|
# TODO do this the Draft way, for ex. using polylines and rectangles
|
|
import Drawing
|
|
import DraftVecUtils
|
|
if not direction:
|
|
direction = App.Vector(0,0,-1)
|
|
if DraftVecUtils.isNull(direction):
|
|
direction = App.Vector(0,0,-1)
|
|
try:
|
|
d = Drawing.projectToDXF(obj.Shape,direction)
|
|
except:
|
|
print("Draft.getDXF: Unable to project ",obj.Label," to ",direction)
|
|
else:
|
|
result += d
|
|
|
|
else:
|
|
print("Draft.getDXF: Unsupported object: ",obj.Label)
|
|
|
|
return result
|
|
|
|
|
|
getDXF = get_DXF
|
|
|
|
|
|
def get_movable_children(objectslist, recursive=True):
|
|
"""Return a list of objects with child objects that move with a host.
|
|
|
|
Builds a list of objects with all child objects (`obj.OutList`)
|
|
that have their `MoveWithHost` attribute set to `True`.
|
|
This function is mostly useful for Arch Workbench objects.
|
|
|
|
Parameters
|
|
----------
|
|
objectslist : list of App::DocumentObject
|
|
A single scripted object or list of objects.
|
|
|
|
recursive : bool, optional
|
|
It defaults to `True`, in which case the function
|
|
is called recursively to also extract the children of children
|
|
objects.
|
|
Otherwise, only direct children of the input objects
|
|
are added to the output list.
|
|
|
|
Returns
|
|
-------
|
|
list
|
|
List of children objects that have their `MoveWithHost` attribute
|
|
set to `True`.
|
|
"""
|
|
added = []
|
|
if not isinstance(objectslist, list):
|
|
objectslist = [objectslist]
|
|
for obj in objectslist:
|
|
# Skips some objects that should never move their children
|
|
if getType(obj) not in ("Clone", "SectionPlane",
|
|
"Facebinder", "BuildingPart"):
|
|
children = obj.OutList
|
|
if hasattr(obj, "Proxy"):
|
|
if obj.Proxy:
|
|
if (hasattr(obj.Proxy, "getSiblings")
|
|
and getType(obj) not in ("Window")):
|
|
# children.extend(obj.Proxy.getSiblings(obj))
|
|
pass
|
|
for child in children:
|
|
if hasattr(child, "MoveWithHost"):
|
|
if child.MoveWithHost:
|
|
if hasattr(obj, "CloneOf"):
|
|
if obj.CloneOf:
|
|
if obj.CloneOf.Name != child.Name:
|
|
added.append(child)
|
|
else:
|
|
added.append(child)
|
|
else:
|
|
added.append(child)
|
|
if recursive:
|
|
added.extend(getMovableChildren(children))
|
|
return added
|
|
|
|
|
|
getMovableChildren = get_movable_children
|
|
|
|
|
|
def filter_objects_for_modifiers(objects, isCopied=False):
|
|
filteredObjects = []
|
|
for obj in objects:
|
|
if hasattr(obj, "MoveBase") and obj.MoveBase and obj.Base:
|
|
parents = []
|
|
for parent in obj.Base.InList:
|
|
if parent.isDerivedFrom("Part::Feature"):
|
|
parents.append(parent.Name)
|
|
if len(parents) > 1:
|
|
warningMessage = _tr("%s shares a base with %d other objects. Please check if you want to modify this.") % (obj.Name,len(parents) - 1)
|
|
App.Console.PrintError(warningMessage)
|
|
if App.GuiUp:
|
|
Gui.getMainWindow().showMessage(warningMessage, 0)
|
|
filteredObjects.append(obj.Base)
|
|
elif hasattr(obj,"Placement") and obj.getEditorMode("Placement") == ["ReadOnly"] and not isCopied:
|
|
App.Console.PrintError(_tr("%s cannot be modified because its placement is readonly.") % obj.Name)
|
|
continue
|
|
else:
|
|
filteredObjects.append(obj)
|
|
return filteredObjects
|
|
|
|
|
|
filterObjectsForModifiers = filter_objects_for_modifiers
|
|
|
|
|
|
def is_closed_edge(edge_index, object):
|
|
return edge_index + 1 >= len(object.Points)
|
|
|
|
|
|
isClosedEdge = is_closed_edge
|
|
|
|
|
|
def convert_draft_texts(textslist=[]):
|
|
"""
|
|
converts the given Draft texts (or all that is found
|
|
in the active document) to the new object
|
|
This function was already present at splitting time during v 0.19
|
|
"""
|
|
if not isinstance(textslist,list):
|
|
textslist = [textslist]
|
|
if not textslist:
|
|
for o in App.ActiveDocument.Objects:
|
|
if o.TypeId == "App::Annotation":
|
|
textslist.append(o)
|
|
todelete = []
|
|
for o in textslist:
|
|
l = o.Label
|
|
o.Label = l+".old"
|
|
obj = makeText(o.LabelText,point=o.Position)
|
|
obj.Label = l
|
|
todelete.append(o.Name)
|
|
for p in o.InList:
|
|
if p.isDerivedFrom("App::DocumentObjectGroup"):
|
|
if o in p.Group:
|
|
g = p.Group
|
|
g.append(obj)
|
|
p.Group = g
|
|
for n in todelete:
|
|
App.ActiveDocument.removeObject(n)
|
|
|
|
|
|
convertDraftTexts = convert_draft_texts
|
|
|
|
|
|
def utf8_decode(text):
|
|
r"""Decode the input string and return a unicode string.
|
|
|
|
Python 2:
|
|
::
|
|
str -> unicode
|
|
unicode -> unicode
|
|
|
|
Python 3:
|
|
::
|
|
str -> str
|
|
bytes -> str
|
|
|
|
It runs
|
|
::
|
|
try:
|
|
return text.decode("utf-8")
|
|
except AttributeError:
|
|
return text
|
|
|
|
Parameters
|
|
----------
|
|
text : str, unicode or bytes
|
|
A str, unicode, or bytes object that may have unicode characters
|
|
like accented characters.
|
|
|
|
In Python 2, a `bytes` object can include accented characters,
|
|
but in Python 3 it must only contain ASCII literal characters.
|
|
|
|
Returns
|
|
-------
|
|
unicode or str
|
|
In Python 2 it will try decoding the `bytes` string
|
|
and return a `'utf-8'` decoded string.
|
|
|
|
>>> "Aá".decode("utf-8")
|
|
>>> b"Aá".decode("utf-8")
|
|
u'A\xe1'
|
|
|
|
In Python 2 the unicode string is prefixed with `u`,
|
|
and unicode characters are replaced by their two-digit hexadecimal
|
|
representation, or four digit unicode escape.
|
|
|
|
>>> "AáBẃCñ".decode("utf-8")
|
|
u'A\xe1B\u1e83C\xf1'
|
|
|
|
In Python 2 it will always return a `unicode` object.
|
|
|
|
In Python 3 a regular string is already unicode encoded,
|
|
so strings have no `decode` method. In this case, `text`
|
|
will be returned as is.
|
|
|
|
In Python 3, if `text` is a `bytes` object, then it will be converted
|
|
to `str`; in this case, the `bytes` object cannot have accents,
|
|
it must only contain ASCII literal characters.
|
|
|
|
>>> b"ABC".decode("utf-8")
|
|
'ABC'
|
|
|
|
In Python 3 it will always return a `str` object, with no prefix.
|
|
"""
|
|
try:
|
|
return text.decode("utf-8")
|
|
except AttributeError:
|
|
return text
|
|
|
|
|
|
def print_header(name, description, debug=True):
|
|
"""Print a line to the console when something is called, and log it.
|
|
|
|
Parameters
|
|
----------
|
|
name: str
|
|
The name of the function or class that is being called.
|
|
This `name` will be logged in the log file, so if there are problems
|
|
the log file can be investigated for clues.
|
|
|
|
description: str
|
|
Arbitrary text that will be printed to the console
|
|
when the function or class is called.
|
|
|
|
debug: bool, optional
|
|
It defaults to `True`.
|
|
If it is `False` the `description` will not be printed
|
|
to the console.
|
|
On the other hand the `name` will always be logged.
|
|
"""
|
|
_log(name)
|
|
if debug:
|
|
_msg(16 * "-")
|
|
_msg(description)
|
|
|
|
|
|
def find_doc(doc=None):
|
|
"""Return the active document or find a document by name.
|
|
|
|
Parameters
|
|
----------
|
|
doc: App::Document or str, optional
|
|
The document that will be searched in the session.
|
|
It defaults to `None`, in which case it tries to find
|
|
the active document.
|
|
If `doc` is a string, it will try to get the document by `Name`.
|
|
|
|
Returns
|
|
-------
|
|
bool, App::Document
|
|
A tuple containing the information on whether the search
|
|
was successful. In this case, the boolean is `True`,
|
|
and the second value is the document instance.
|
|
|
|
False, None
|
|
If there is no active document, or the string in `doc`
|
|
doesn't correspond to an open document in the session.
|
|
"""
|
|
FOUND = True
|
|
|
|
if not doc:
|
|
doc = App.activeDocument()
|
|
if not doc:
|
|
return not FOUND, None
|
|
|
|
if isinstance(doc, str):
|
|
try:
|
|
doc = App.getDocument(doc)
|
|
except NameError:
|
|
_msg("document: {}".format(doc))
|
|
_err(_tr("Wrong input: unknown document."))
|
|
return not FOUND, None
|
|
|
|
return FOUND, doc
|
|
|
|
|
|
def find_object(obj, doc=None):
|
|
"""Find object in the document, inclusive by Label.
|
|
|
|
Parameters
|
|
----------
|
|
obj: App::DocumentObject or str
|
|
The object to search in `doc`.
|
|
Or if the `obj` is a string, it will search the object by `Label`.
|
|
Since Labels are not guaranteed to be unique, it will get the first
|
|
object with that label in the document.
|
|
|
|
doc: App::Document or str, optional
|
|
The document in which the object will be searched.
|
|
It defaults to `None`, in which case it tries to search in the
|
|
active document.
|
|
If `doc` is a string, it will search the document by `Name`.
|
|
|
|
Returns
|
|
-------
|
|
bool, App::DocumentObject
|
|
A tuple containing the information on whether the search
|
|
was successful. In this case, the boolean is `True`,
|
|
and the second value is the object found.
|
|
|
|
False, None
|
|
If the object doesn't exist in the document.
|
|
"""
|
|
FOUND = True
|
|
|
|
found, doc = find_doc(doc)
|
|
if not found:
|
|
_err(_tr("No active document. Aborting."))
|
|
return not FOUND, None
|
|
|
|
if isinstance(obj, str):
|
|
try:
|
|
obj = doc.getObjectsByLabel(obj)[0]
|
|
except IndexError:
|
|
return not FOUND, None
|
|
|
|
if obj not in doc.Objects:
|
|
return not FOUND, None
|
|
|
|
return FOUND, obj
|
|
|
|
|
|
def use_instead(function, version=""):
|
|
"""Print a deprecation message and suggest another function.
|
|
|
|
This function must be used inside the definition of a function
|
|
that has been considered for deprecation, so we must provide
|
|
an alternative.
|
|
::
|
|
def old_function():
|
|
use_instead('new_function', 1.0)
|
|
|
|
def someFunction():
|
|
use_instead('some_function')
|
|
|
|
Parameters
|
|
----------
|
|
function: str
|
|
The name of the function to use instead of the current one.
|
|
|
|
version: float or str, optional
|
|
It defaults to the empty string `''`.
|
|
The version where this command is to be deprecated, if it is known.
|
|
If we don't know when this command will be deprecated
|
|
then we should not give a version.
|
|
"""
|
|
text = "This function will be deprected in "
|
|
text2 = "This function will be deprected. "
|
|
text3 = "Please use "
|
|
|
|
if version:
|
|
_wrn(_tr(text) + "{}. ".format(version)
|
|
+ _tr(text3) + "'{}'.".format(function))
|
|
else:
|
|
_wrn(_tr(text2)
|
|
+ _tr(text3) + "'{}'.".format(function))
|