Path: Refactor and upgradeExtensions feature, and apply to Adaptive op
Path: Refactor `Extensions` Gui code into independent module. Move the `Extensions` Gui code to independent module so access to other operations will be easier. Path: Add `Extensions` feature to Adaptive operation Path: Isolate Adaptive GUI elements in preparation of Adaptive unit tests Path: Implement `PathLog` debug module Path: Implement `translate()` for multi-language message support Path: Fix `StockType`check bug Path: Relocate `getCutRegionWires()` to `FeatureExtensions` module Path: Add `Extensions` property checks on document restored Path: Improve `Extend Outline` feature implementation Path: Initialize a waterline type extension Path: Add enable/disable extensions feature. It is quite possible that many complex faces exist that have large quantities of both simple and complex edges. For this reason, a manual push button to enable Extensions is useful so the users machine is not bogged down with extra or unnecessary computing time. Extensions are not necessary at all times. This commit also includes an edge count threshold that will disable the Extensions feature temporarily upon initial loading of the Task Panel. The manual enable button will do just that. Path: Add enable extensions warning label Path: Shorten enable/disable Extensions button message Path: Remove run-time added Task Panel elements - this QButton and QLabel were moved to UI panel directly. Path: Add include/ignore Edges button Path: Improve extension preview rendering Path: Fixes for `useOutline` modification and updates Path: Add internal feature to cache calculated extensions for reuse Path: Add `SetupProperties()` function and connect to GUI command Path: Add `Avoid Face` extension to ignore base face. This feature allows for some simple access to the exterior of a selected face without clearing the face itself. This will allow for an exterior clearing operation in a simple manner. Path: Fix bug restricting extensions on internal closed-wires
This commit is contained in:
Russell Johnson
612
src/Mod/Path/PathScripts/PathFeatureExtensions.py
Normal file
612
src/Mod/Path/PathScripts/PathFeatureExtensions.py
Normal file
@@ -0,0 +1,612 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# ***************************************************************************
|
||||
# * Copyright (c) 2019 sliptonic <shopinthewoods@gmail.com> *
|
||||
# * *
|
||||
# * 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. *
|
||||
# * *
|
||||
# * This program 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 this program; if not, write to the Free Software *
|
||||
# * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
|
||||
# * USA *
|
||||
# * *
|
||||
# ***************************************************************************
|
||||
|
||||
import FreeCAD
|
||||
import PathScripts.PathGeom as PathGeom
|
||||
import PathScripts.PathLog as PathLog
|
||||
import Part
|
||||
import math
|
||||
|
||||
# lazily loaded modules
|
||||
from lazy_loader.lazy_loader import LazyLoader
|
||||
PathUtils = LazyLoader('PathScripts.PathUtils', globals(), 'PathScripts.PathUtils')
|
||||
|
||||
from PySide import QtCore
|
||||
|
||||
__title__ = "Path Features Extensions"
|
||||
__author__ = "sliptonic (Brad Collette)"
|
||||
__url__ = "https://www.freecadweb.org"
|
||||
__doc__ = "Class and implementation of face extensions features."
|
||||
|
||||
PathLog.setLevel(PathLog.Level.INFO, PathLog.thisModule())
|
||||
# PathLog.trackModule(PathLog.thisModule())
|
||||
|
||||
|
||||
# Qt translation handling
|
||||
def translate(context, text, disambig=None):
|
||||
return QtCore.QCoreApplication.translate(context, text, disambig)
|
||||
|
||||
|
||||
def endPoints(edgeOrWire):
|
||||
'''endPoints(edgeOrWire) ... return the first and last point of the wire or the edge, assuming the argument is not a closed wire.'''
|
||||
if Part.Wire == type(edgeOrWire):
|
||||
# edges = edgeOrWire.Edges
|
||||
pts = [e.valueAt(e.FirstParameter) for e in edgeOrWire.Edges]
|
||||
pts.extend([e.valueAt(e.LastParameter) for e in edgeOrWire.Edges])
|
||||
unique = []
|
||||
for p in pts:
|
||||
cnt = len([p2 for p2 in pts if PathGeom.pointsCoincide(p, p2)])
|
||||
if 1 == cnt:
|
||||
unique.append(p)
|
||||
|
||||
return unique
|
||||
|
||||
pfirst = edgeOrWire.valueAt(edgeOrWire.FirstParameter)
|
||||
plast = edgeOrWire.valueAt(edgeOrWire.LastParameter)
|
||||
if PathGeom.pointsCoincide(pfirst, plast):
|
||||
return None
|
||||
|
||||
return [pfirst, plast]
|
||||
|
||||
|
||||
def includesPoint(p, pts):
|
||||
'''includesPoint(p, pts) ... answer True if the collection of pts includes the point p'''
|
||||
for pt in pts:
|
||||
if PathGeom.pointsCoincide(p, pt):
|
||||
return True
|
||||
|
||||
return False
|
||||
|
||||
|
||||
def selectOffsetWire(feature, wires):
|
||||
'''selectOffsetWire(feature, wires) ... returns the Wire in wires which is does not intersect with feature'''
|
||||
closest = None
|
||||
for w in wires:
|
||||
dist = feature.distToShape(w)[0]
|
||||
if closest is None or dist > closest[0]: # pylint: disable=unsubscriptable-object
|
||||
closest = (dist, w)
|
||||
|
||||
if closest is not None:
|
||||
return closest[1]
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def extendWire(feature, wire, length):
|
||||
'''extendWire(wire, length) ... return a closed Wire which extends wire by length'''
|
||||
PathLog.track(length)
|
||||
|
||||
if not length or length == 0:
|
||||
return None
|
||||
|
||||
try:
|
||||
off2D = wire.makeOffset2D(length)
|
||||
except FreeCAD.Base.FreeCADError as ee:
|
||||
return None
|
||||
endPts = endPoints(wire) # Asumes wire is NOT closed
|
||||
if endPts:
|
||||
edges = [e for e in off2D.Edges if Part.Circle != type(e.Curve) or not includesPoint(e.Curve.Center, endPts)]
|
||||
wires = [Part.Wire(e) for e in Part.sortEdges(edges)]
|
||||
offset = selectOffsetWire(feature, wires)
|
||||
ePts = endPoints(offset)
|
||||
if ePts and len(ePts) > 1:
|
||||
l0 = (ePts[0] - endPts[0]).Length
|
||||
l1 = (ePts[1] - endPts[0]).Length
|
||||
edges = wire.Edges
|
||||
if l0 < l1:
|
||||
edges.append(Part.Edge(Part.LineSegment(endPts[0], ePts[0])))
|
||||
edges.extend(offset.Edges)
|
||||
edges.append(Part.Edge(Part.LineSegment(endPts[1], ePts[1])))
|
||||
else:
|
||||
edges.append(Part.Edge(Part.LineSegment(endPts[1], ePts[0])))
|
||||
edges.extend(offset.Edges)
|
||||
edges.append(Part.Edge(Part.LineSegment(endPts[0], ePts[1])))
|
||||
|
||||
return Part.Wire(edges)
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def createExtension(obj, extObj, extFeature, extSub):
|
||||
return Extension(obj,
|
||||
extObj,
|
||||
extFeature,
|
||||
extSub,
|
||||
obj.ExtensionLengthDefault,
|
||||
Extension.DirectionNormal)
|
||||
|
||||
|
||||
def readObjExtensionFeature(obj):
|
||||
"""readObjExtensionFeature(obj)...
|
||||
Return three item string tuples (base name, feature, subfeature) extracted from obj.ExtensionFeature"""
|
||||
extensions = []
|
||||
|
||||
for extObj, features in obj.ExtensionFeature:
|
||||
for sub in features:
|
||||
extFeature, extSub = sub.split(':')
|
||||
extensions.append((extObj.Name, extFeature, extSub))
|
||||
return extensions
|
||||
|
||||
|
||||
def getExtensions(obj):
|
||||
PathLog.debug("getExtenstions()")
|
||||
extensions = []
|
||||
i = 0
|
||||
|
||||
for extObj, features in obj.ExtensionFeature:
|
||||
for sub in features:
|
||||
extFeature, extSub = sub.split(':')
|
||||
extensions.append(createExtension(obj, extObj, extFeature, extSub))
|
||||
i = i + 1
|
||||
return extensions
|
||||
|
||||
|
||||
def setExtensions(obj, extensions):
|
||||
PathLog.track(obj.Label, len(extensions))
|
||||
obj.ExtensionFeature = [(ext.obj, ext.getSubLink()) for ext in extensions]
|
||||
|
||||
|
||||
class Extension(object):
|
||||
DirectionNormal = 0
|
||||
DirectionX = 1
|
||||
DirectionY = 2
|
||||
|
||||
def __init__(self, op, obj, feature, sub, length, direction):
|
||||
PathLog.debug("Extension(%s, %s, %s, %.2f, %s" % (obj.Label, feature, sub, length, direction))
|
||||
self.op = op
|
||||
self.obj = obj
|
||||
self.feature = feature
|
||||
self.sub = sub
|
||||
self.length = length
|
||||
self.direction = direction
|
||||
self.extFaces = None
|
||||
self.isDebug = True if PathLog.getLevel(PathLog.thisModule()) == 4 else False
|
||||
|
||||
self.avoid = False
|
||||
if sub.startswith("Avoid_"):
|
||||
self.avoid = True
|
||||
|
||||
self.wire = None
|
||||
|
||||
def getSubLink(self):
|
||||
return "%s:%s" % (self.feature, self.sub)
|
||||
|
||||
def _extendEdge(self, feature, e0, direction):
|
||||
PathLog.track(feature, e0, direction)
|
||||
if isinstance(e0.Curve, Part.Line) or isinstance(e0.Curve, Part.LineSegment):
|
||||
e2 = e0.copy()
|
||||
off = self.length.Value * direction
|
||||
e2.translate(off)
|
||||
e2 = PathGeom.flipEdge(e2)
|
||||
e1 = Part.Edge(Part.LineSegment(e0.valueAt(e0.LastParameter), e2.valueAt(e2.FirstParameter)))
|
||||
e3 = Part.Edge(Part.LineSegment(e2.valueAt(e2.LastParameter), e0.valueAt(e0.FirstParameter)))
|
||||
wire = Part.Wire([e0, e1, e2, e3])
|
||||
self.wire = wire
|
||||
return wire
|
||||
|
||||
return extendWire(feature, Part.Wire([e0]), self.length.Value)
|
||||
|
||||
def _getEdgeNumbers(self):
|
||||
if 'Wire' in self.sub:
|
||||
numbers = [nr for nr in self.sub[5:-1].split(',')]
|
||||
else:
|
||||
numbers = [self.sub[4:]]
|
||||
|
||||
PathLog.debug("_getEdgeNumbers() -> %s" % numbers)
|
||||
return numbers
|
||||
|
||||
def _getEdgeNames(self):
|
||||
return ["Edge%s" % nr for nr in self._getEdgeNumbers()]
|
||||
|
||||
def _getEdges(self):
|
||||
return [self.obj.Shape.getElement(sub) for sub in self._getEdgeNames()]
|
||||
|
||||
def _getDirectedNormal(self, p0, normal):
|
||||
poffPlus = p0 + 0.01 * normal
|
||||
poffMinus = p0 - 0.01 * normal
|
||||
if not self.obj.Shape.isInside(poffPlus, 0.005, True):
|
||||
return normal
|
||||
|
||||
if not self.obj.Shape.isInside(poffMinus, 0.005, True):
|
||||
return normal.negative()
|
||||
|
||||
return None
|
||||
|
||||
def _getDirection(self, wire):
|
||||
e0 = wire.Edges[0]
|
||||
midparam = e0.FirstParameter + 0.5 * (e0.LastParameter - e0.FirstParameter)
|
||||
tangent = e0.tangentAt(midparam)
|
||||
PathLog.track('tangent', tangent, self.feature, self.sub)
|
||||
normal = tangent.cross(FreeCAD.Vector(0, 0, 1))
|
||||
if PathGeom.pointsCoincide(normal, FreeCAD.Vector(0, 0, 0)):
|
||||
return None
|
||||
|
||||
return self._getDirectedNormal(e0.valueAt(midparam), normal.normalize())
|
||||
|
||||
def getExtensionFaces(self, extensionWire):
|
||||
'''getExtensionFace(extensionWire)...
|
||||
A public helper method to retrieve the requested extension as a face,
|
||||
rather than a wire becuase some extensions require a face shape
|
||||
for definition that allows for two wires for boundary definition.
|
||||
'''
|
||||
|
||||
if self.extFaces:
|
||||
return self.extFaces
|
||||
|
||||
return [Part.Face(extensionWire)]
|
||||
|
||||
def getWire(self):
|
||||
'''getWire()... Public method to retrieve the extension area, pertaining to the feature
|
||||
and sub element provided at class instantiation, as a closed wire. If no closed wire
|
||||
is possible, a `None` value is returned.'''
|
||||
|
||||
if self.sub[:6] == "Avoid_":
|
||||
feature = self.obj.Shape.getElement(self.feature)
|
||||
self.extFaces = [Part.Face(feature.Wires[0])]
|
||||
return feature.Wires[0]
|
||||
if self.sub[:7] == "Extend_":
|
||||
rtn = self._getOutlineWire()
|
||||
if rtn:
|
||||
return rtn
|
||||
else:
|
||||
PathLog.debug("no Outline Wire")
|
||||
return None
|
||||
if self.sub[:10] == "Waterline_":
|
||||
rtn = self._getWaterlineWire()
|
||||
if rtn:
|
||||
return rtn
|
||||
else:
|
||||
PathLog.debug("no Waterline Wire")
|
||||
return None
|
||||
else:
|
||||
return self._getRegularWire()
|
||||
|
||||
def _getRegularWire(self):
|
||||
'''_getRegularWire()... Private method to retrieve the extension area, pertaining to the feature
|
||||
and sub element provided at class instantiation, as a closed wire. If no closed wire
|
||||
is possible, a `None` value is returned.'''
|
||||
PathLog.track()
|
||||
|
||||
length = self.length.Value
|
||||
if PathGeom.isRoughly(0, length) or not self.sub:
|
||||
PathLog.debug("no extension, length=%.2f, sub=%s" % (length, self.sub))
|
||||
return None
|
||||
|
||||
feature = self.obj.Shape.getElement(self.feature)
|
||||
edges = self._getEdges()
|
||||
sub = Part.Wire(Part.sortEdges(edges)[0])
|
||||
|
||||
if 1 == len(edges):
|
||||
PathLog.debug("Extending single edge wire")
|
||||
edge = edges[0]
|
||||
if Part.Circle == type(edge.Curve):
|
||||
circle = edge.Curve
|
||||
# for a circle we have to figure out if it's a hole or a cylinder
|
||||
p0 = edge.valueAt(edge.FirstParameter)
|
||||
normal = (edge.Curve.Center - p0).normalize()
|
||||
direction = self._getDirectedNormal(p0, normal)
|
||||
if direction is None:
|
||||
return None
|
||||
|
||||
if PathGeom.pointsCoincide(normal, direction):
|
||||
r = circle.Radius - length
|
||||
else:
|
||||
r = circle.Radius + length
|
||||
|
||||
# assuming the offset produces a valid circle - go for it
|
||||
if r > 0:
|
||||
e3 = Part.makeCircle(r, circle.Center, circle.Axis, edge.FirstParameter * 180 / math.pi, edge.LastParameter * 180 / math.pi)
|
||||
if endPoints(edge):
|
||||
# need to construct the arc slice
|
||||
e0 = Part.makeLine(edge.valueAt(edge.FirstParameter), e3.valueAt(e3.FirstParameter))
|
||||
e2 = Part.makeLine(edge.valueAt(edge.LastParameter), e3.valueAt(e3.LastParameter))
|
||||
return Part.Wire([e0, edge, e2, e3])
|
||||
|
||||
extWire = Part.Wire([e3])
|
||||
self.extFaces = [self._makeCircularExtFace(edge, extWire)]
|
||||
return extWire
|
||||
|
||||
# the extension is bigger than the hole - so let's just cover the whole hole
|
||||
if endPoints(edge):
|
||||
# if the resulting arc is smaller than the radius, create a pie slice
|
||||
PathLog.track()
|
||||
center = circle.Center
|
||||
e0 = Part.makeLine(center, edge.valueAt(edge.FirstParameter))
|
||||
e2 = Part.makeLine(edge.valueAt(edge.LastParameter), center)
|
||||
return Part.Wire([e0, edge, e2])
|
||||
|
||||
PathLog.track()
|
||||
return Part.Wire([edge])
|
||||
|
||||
else:
|
||||
PathLog.track(self.feature, self.sub, type(edge.Curve), endPoints(edge))
|
||||
direction = self._getDirection(sub)
|
||||
if direction is None:
|
||||
return None
|
||||
|
||||
# return self._extendEdge(feature, edge, direction)
|
||||
return self._extendEdge(feature, edges[0], direction)
|
||||
elif sub.isClosed():
|
||||
PathLog.debug("Extending multi-edge closed wire")
|
||||
subFace = Part.Face(sub)
|
||||
featFace = Part.Face(feature.Wires[0])
|
||||
isOutside = True
|
||||
if not PathGeom.isRoughly(featFace.Area, subFace.Area):
|
||||
length = -1.0 * length
|
||||
isOutside = False
|
||||
|
||||
try:
|
||||
off2D = sub.makeOffset2D(length)
|
||||
except FreeCAD.Base.FreeCADError as ee:
|
||||
return None
|
||||
|
||||
if isOutside:
|
||||
self.extFaces = [Part.Face(off2D).cut(featFace)]
|
||||
else:
|
||||
self.extFaces = [subFace.cut(Part.Face(off2D))]
|
||||
return off2D
|
||||
|
||||
PathLog.debug("Extending multi-edge open wire")
|
||||
return extendWire(feature, sub, length)
|
||||
|
||||
def _getOutlineWire(self):
|
||||
'''_getOutlineWire()... Private method to retrieve an extended outline extension area,
|
||||
pertaining to the feature and sub element provided at class instantiation, as a closed wire.
|
||||
If no closed wire is possible, a `None` value is returned.'''
|
||||
PathLog.track()
|
||||
|
||||
baseShape = self.obj.Shape
|
||||
face = baseShape.getElement(self.feature)
|
||||
useOutline = False
|
||||
msg = translate("PathAdaptive", "Extend Outline error")
|
||||
|
||||
if hasattr(self.op, "UseOutline"):
|
||||
useOutline = self.op.UseOutline
|
||||
|
||||
if useOutline:
|
||||
outFace = Part.Face(face.Wires[0])
|
||||
rawFace = getExtendOutlineFace(baseShape, outFace, self.length)
|
||||
|
||||
if rawFace:
|
||||
extFace = rawFace.cut(outFace)
|
||||
else:
|
||||
PathLog.error(msg + " 1")
|
||||
extFace = outFace
|
||||
else:
|
||||
rawFace = getExtendOutlineFace(baseShape, face, self.length)
|
||||
|
||||
if rawFace:
|
||||
extFace = rawFace.cut(face)
|
||||
else:
|
||||
PathLog.error(msg + " 2")
|
||||
extFace = face
|
||||
|
||||
# Debug
|
||||
# Part.show(extFace)
|
||||
# FreeCAD.ActiveDocument.ActiveObject.Label = "outline_wire"
|
||||
|
||||
if len(extFace.Wires) > 0:
|
||||
self.extFaces = [f for f in extFace.Faces]
|
||||
return extFace.Wires[0]
|
||||
|
||||
return None
|
||||
|
||||
def _getWaterlineWire(self):
|
||||
'''_getWaterlineWire()... Private method to retrieve a waterline extension area,
|
||||
pertaining to the feature and sub element provided at class instantiation, as a closed wire.
|
||||
Only waterline faces touching source face are returned as part of the waterline extension area.
|
||||
If no closed wire is possible, a `None` value is returned.'''
|
||||
PathLog.track()
|
||||
|
||||
msg = translate("PathFeatureExtensions", "Waterline error")
|
||||
useOutline = False
|
||||
if hasattr(self.op, "UseOutline"):
|
||||
useOutline = self.op.UseOutline
|
||||
|
||||
baseShape = self.obj.Shape
|
||||
if useOutline:
|
||||
face = Part.Face(baseShape.getElement(self.feature).Wire1)
|
||||
else:
|
||||
face = baseShape.getElement(self.feature)
|
||||
|
||||
rawFace = getWaterlineFace(baseShape, face)
|
||||
|
||||
if not rawFace:
|
||||
PathLog.error(msg + " 1")
|
||||
return None
|
||||
|
||||
if rawFace:
|
||||
extFace = rawFace.cut(face)
|
||||
else:
|
||||
PathLog.error(msg + " 2")
|
||||
extFace = face
|
||||
|
||||
# Debug
|
||||
# Part.show(extFace)
|
||||
# FreeCAD.ActiveDocument.ActiveObject.Label = "waterline_face"
|
||||
|
||||
if len(extFace.Wires) > 0:
|
||||
self.extFaces = [f for f in extFace.Faces]
|
||||
return extFace.Wires[0]
|
||||
|
||||
return None
|
||||
|
||||
def _makeCircularExtFace(self, edge, extWire):
|
||||
'''_makeCircularExtensionFace(edge, extWire)...
|
||||
Create proper circular extension face shape. Incoming edge is expected to be a circle.
|
||||
'''
|
||||
# Add original outer wire to cut faces if necessary
|
||||
edgeFace = Part.Face(Part.Wire([edge]))
|
||||
edgeFace.translate(FreeCAD.Vector(0.0, 0.0, 0.0 - edgeFace.BoundBox.ZMin))
|
||||
extWireFace = Part.Face(extWire)
|
||||
extWireFace.translate(FreeCAD.Vector(0.0, 0.0, 0.0 - extWireFace.BoundBox.ZMin))
|
||||
|
||||
if extWireFace.Area >= edgeFace.Area:
|
||||
extensionFace = extWireFace.cut(edgeFace)
|
||||
else:
|
||||
extensionFace = edgeFace.cut(extWireFace)
|
||||
extensionFace.translate(FreeCAD.Vector(0.0, 0.0, edge.BoundBox.ZMin))
|
||||
|
||||
return extensionFace
|
||||
# Eclass
|
||||
|
||||
|
||||
def initialize_properties(obj):
|
||||
"""initialize_properties(obj)... Adds feature propeties to object argument"""
|
||||
if not hasattr(obj, 'ExtensionLengthDefault'):
|
||||
obj.addProperty('App::PropertyDistance', 'ExtensionLengthDefault', 'Extension', QtCore.QT_TRANSLATE_NOOP('PathPocketShape', 'Default length of extensions.'))
|
||||
if not hasattr(obj, 'ExtensionFeature'):
|
||||
obj.addProperty('App::PropertyLinkSubListGlobal', 'ExtensionFeature', 'Extension', QtCore.QT_TRANSLATE_NOOP('PathPocketShape', 'List of features to extend.'))
|
||||
if not hasattr(obj, 'ExtensionCorners'):
|
||||
obj.addProperty('App::PropertyBool', 'ExtensionCorners', 'Extension', QtCore.QT_TRANSLATE_NOOP('PathPocketShape', 'When enabled connected extension edges are combined to wires.'))
|
||||
obj.ExtensionCorners = True
|
||||
|
||||
obj.setEditorMode('ExtensionFeature', 2)
|
||||
|
||||
|
||||
def set_default_property_values(obj, job):
|
||||
"""set_default_property_values(obj, job) ... set default values for feature properties"""
|
||||
obj.ExtensionCorners = True
|
||||
obj.setExpression('ExtensionLengthDefault', 'OpToolDiameter / 2.0')
|
||||
|
||||
|
||||
def SetupProperties():
|
||||
"""SetupProperties()... Returns list of feature property names"""
|
||||
setup = ['ExtensionLengthDefault', 'ExtensionFeature',
|
||||
'ExtensionCorners']
|
||||
return setup
|
||||
|
||||
|
||||
# Extend outline face generation function
|
||||
def getExtendOutlineFace(base_shape, face, extension, remHoles=False, offset_tolerance=1e-4):
|
||||
"""getExtendOutlineFace(obj, base_shape, face, extension, remHoles) ...
|
||||
Creates an extended face for the pocket, taking into consideration lateral
|
||||
collision with the greater base shape.
|
||||
Arguments are:
|
||||
parent base shape of face,
|
||||
target face,
|
||||
extension magnitude,
|
||||
remove holes boolean,
|
||||
offset tolerance = 1e-4 default
|
||||
The default value of 1e-4 for offset tolerance is the same default value
|
||||
at getOffsetArea() function definition.
|
||||
Return is an all access face extending the specified extension value from the source face.
|
||||
"""
|
||||
|
||||
# Make offset face per user-specified extension distance so as to allow full clearing of face where possible.
|
||||
offset_face = PathUtils.getOffsetArea(face,
|
||||
extension,
|
||||
removeHoles=remHoles,
|
||||
plane=face,
|
||||
tolerance=offset_tolerance)
|
||||
if not offset_face:
|
||||
PathLog.error("Failed to offset a selected face.")
|
||||
return None
|
||||
|
||||
# Apply collision detection by limiting extended face using base shape
|
||||
depth = 0.2
|
||||
offset_ext = offset_face.extrude(FreeCAD.Vector(0.0, 0.0, depth))
|
||||
face_del = offset_face.extrude(FreeCAD.Vector(0.0, 0.0, -1.0 * depth))
|
||||
clear = base_shape.cut(face_del)
|
||||
available = offset_ext.cut(clear)
|
||||
available.removeSplitter()
|
||||
|
||||
# Debug
|
||||
# Part.show(available)
|
||||
# FreeCAD.ActiveDocument.ActiveObject.Label = "available"
|
||||
|
||||
# Identify bottom face of available volume
|
||||
zmin = available.BoundBox.ZMax
|
||||
bottom_faces = list()
|
||||
for f in available.Faces:
|
||||
bbx = f.BoundBox
|
||||
zNorm = abs(f.normalAt(0.0, 0.0).z)
|
||||
if (PathGeom.isRoughly(zNorm, 1.0) and
|
||||
PathGeom.isRoughly(bbx.ZMax - bbx.ZMin, 0.0) and
|
||||
PathGeom.isRoughly(bbx.ZMin, face.BoundBox.ZMin)):
|
||||
if bbx.ZMin < zmin:
|
||||
bottom_faces.append(f)
|
||||
|
||||
if bottom_faces:
|
||||
extended = None
|
||||
for bf in bottom_faces:
|
||||
# Drop travel face to same height as source face
|
||||
diff = face.BoundBox.ZMax - bf.BoundBox.ZMax
|
||||
bf.translate(FreeCAD.Vector(0.0, 0.0, diff))
|
||||
cmn = bf.common(face)
|
||||
if hasattr(cmn, "Area") and cmn.Area > 0.0:
|
||||
extended = bf
|
||||
|
||||
return extended
|
||||
|
||||
PathLog.error("No bottom face for extend outline.")
|
||||
return None
|
||||
|
||||
# Waterline extension face generation function
|
||||
def getWaterlineFace(base_shape, face):
|
||||
"""getWaterlineFace(base_shape, face) ...
|
||||
Creates a waterline extension face for the target face,
|
||||
taking into consideration the greater base shape.
|
||||
Arguments are: parent base shape and target face.
|
||||
Return is a waterline face at height of the target face.
|
||||
"""
|
||||
faceHeight = face.BoundBox.ZMin
|
||||
|
||||
# Get envelope of model to height of face, then fuse with model and refine the shape
|
||||
baseBB = base_shape.BoundBox
|
||||
depthparams = PathUtils.depth_params(
|
||||
clearance_height=faceHeight,
|
||||
safe_height=faceHeight,
|
||||
start_depth=faceHeight,
|
||||
step_down=math.floor(faceHeight - baseBB.ZMin + 2.0),
|
||||
z_finish_step=0.0,
|
||||
final_depth=baseBB.ZMin,
|
||||
user_depths=None)
|
||||
env = PathUtils.getEnvelope(partshape=base_shape, subshape=None, depthparams=depthparams)
|
||||
# Get top face(s) of envelope at face height
|
||||
rawList = list()
|
||||
for f in env.Faces:
|
||||
if PathGeom.isRoughly(f.BoundBox.ZMin, faceHeight):
|
||||
rawList.append(f)
|
||||
# make compound and extrude downward
|
||||
rawComp = Part.makeCompound(rawList)
|
||||
rawCompExtNeg = rawComp.extrude(FreeCAD.Vector(0.0, 0.0, baseBB.ZMin - faceHeight - 1.0))
|
||||
# Cut off bottom of base shape at face height
|
||||
topSolid = base_shape.cut(rawCompExtNeg)
|
||||
|
||||
# Get intersection with base shape
|
||||
# The commented version returns waterlines that only intersects horizontal faces at same height as target face
|
||||
# cmn = base_shape.common(rawComp)
|
||||
# waterlineShape = cmn.cut(topSolid)
|
||||
# return waterlineShape
|
||||
|
||||
# This version returns more of a true waterline flowing from target face
|
||||
waterlineShape = rawComp.cut(topSolid)
|
||||
faces = list()
|
||||
for f in waterlineShape.Faces:
|
||||
cmn = face.common(f)
|
||||
if hasattr(cmn, "Area") and cmn.Area > 0.0:
|
||||
faces.append(f)
|
||||
if faces:
|
||||
return Part.makeCompound(faces)
|
||||
|
||||
return None
|
||||
Reference in New Issue
Block a user