def buildCurves(self):
for i in range(self.railSamples):
t1 = self.cos1.firstParameter + (1.0 * i *
self.paramRange(self.cos1) /
(self.railSamples - 1))
if not self.untwist:
t2 = self.cos2.firstParameter + (1.0 * i *
self.paramRange(self.cos2) /
(self.railSamples - 1))
else:
t2 = self.cos2.lastParameter - (1.0 * i *
self.paramRange(self.cos2) /
(self.railSamples - 1))
pt1 = self.cos1.valueAt(t1)
pt2 = self.cos2.valueAt(t2)
chord = pt2.sub(pt1).Length
# ip1 = cos1.tangentTo(t1,pt2)[0]
# ip2 = cos2.tangentTo(t2,pt1)[0]
ip1 = self.cos1.binormalAt(t1)
ip2 = self.cos2.binormalAt(t2)
ip1.normalize().multiply(chord / 3.0)
ip2.normalize().multiply(chord / 3.0)
poles = [pt1, pt1.add(ip1), pt2.add(ip2), pt2]
bz = Part.BezierCurve()
bz.setPoles(poles)
self.curves.append(bz)
def updateShape(self, pts):
"""Create shape for display during creation process."""
import Part
# Not quite right. draws 1 big bez. sb segmented
edges = []
if len(pts) >= 2: # allow lower degree segment
poles = pts[1:]
else:
poles = []
if self.degree:
segpoleslst = [poles[x:x+self.degree] for x in range(0, len(poles), (self.degree or 1))]
else:
segpoleslst = [pts]
startpoint = pts[0]
for segpoles in segpoleslst:
c = Part.BezierCurve() # last segment may have lower degree
c.increase(len(segpoles))
c.setPoles([startpoint] + segpoles)
edges.append(Part.Edge(c))
startpoint = segpoles[-1]
w = Part.Wire(edges)
return w
def createGeometry(self,fp):
import Part
plm = fp.Placement
if fp.Points:
startpoint=fp.Points[0]
edges = []
for segpoles in self._segpoleslst(fp):
# if len(segpoles) == fp.Degree # would skip additional poles
c = Part.BezierCurve() #last segment may have lower degree
c.increase(len(segpoles))
c.setPoles([startpoint]+segpoles)
edges.append(Part.Edge(c))
startpoint = segpoles[-1]
w = Part.Wire(edges)
if fp.Closed and w.isClosed():
try:
if hasattr(fp,"MakeFace"):
if fp.MakeFace:
w = Part.Face(w)
else:
w = Part.Face(w)
except Part.OCCError:
pass
fp.Shape = w
if hasattr(fp,"Area") and hasattr(w,"Area"):
fp.Area = w.Area
if hasattr(fp,"Length") and hasattr(w,"Length"):
fp.Length = w.Length
fp.Placement = plm
def recompute(self):
if (len(self.points) >= 2):
if self.bezcurve: self.sep.removeChild(self.bezcurve)
self.bezcurve = None
### c = Part.BSplineCurve() #!!!!!!!!!!!!!!!
c = Part.BezierCurve()
# DNC: allows to close the curve by placing ends close to each other
if (len(self.points) >= 3) and (
(self.points[0] - self.points[-1]).Length < Draft.tolerance()):
# YVH: Added a try to bypass some hazardous situations
try:
### c.interpolate(self.points[:-1], True) #!!!!!!!!!!!!
c.setPoles(self.points[:-1])
except Part.OCCError:
pass
elif self.points:
try:
### c.interpolate(self.points, False) #!!!!!!!
c.setPoles(self.points)
except Part.OCCError:
pass
c = c.toShape() #???? c = Part.Edge(c)?, c = Part.Wire(c)??
buf = c.writeInventor(2, 0.01)
#fp=open("spline.iv","w")
#fp.write(buf)
#fp.close()
try:
ivin = coin.SoInput()
ivin.setBuffer(buf)
ivob = coin.SoDB.readAll(ivin)
except:
# workaround for pivy SoInput.setBuffer() bug
import re
buf = buf.replace("\n", "")
pts = re.findall("point \[(.*?)\]", buf)[0]
pts = pts.split(",")
pc = []
for p in pts:
v = p.strip().split()
pc.append([float(v[0]), float(v[1]), float(v[2])])
coords = coin.SoCoordinate3()
coords.point.setValues(0, len(pc), pc)
line = coin.SoLineSet()
line.numVertices.setValue(-1)
self.bezcurve = coin.SoSeparator()
self.bezcurve.addChild(coords)
self.bezcurve.addChild(line)
self.sep.addChild(self.bezcurve)
else:
if ivob and ivob.getNumChildren() > 1:
self.bezcurve = ivob.getChild(1).getChild(0)
self.bezcurve.removeChild(self.bezcurve.getChild(0))
self.bezcurve.removeChild(self.bezcurve.getChild(0))
self.sep.addChild(self.bezcurve)
else:
FreeCAD.Console.PrintWarning(
"bezcurveTracker.recompute() failed to read-in Inventor string\n"
)
def recompute(self):
"""Recompute the tracker."""
if self.bezcurve:
for seg in self.bezcurve:
self.sep.removeChild(seg)
seg = None
self.bezcurve = []
if (len(self.points) >= 2):
if self.degree:
poles = self.points[1:]
segpoleslst = [poles[x:x+self.degree] for x in range(0, len(poles), (self.degree or 1))]
else:
segpoleslst = [self.points]
startpoint = self.points[0]
for segpoles in segpoleslst:
c = Part.BezierCurve() # last segment may have lower degree
c.increase(len(segpoles))
c.setPoles([startpoint] + segpoles)
c = c.toShape()
startpoint = segpoles[-1]
buf = c.writeInventor(2, 0.01)
# fp=open("spline.iv", "w")
# fp.write(buf)
# fp.close()
try:
ivin = coin.SoInput()
ivin.setBuffer(buf)
ivob = coin.SoDB.readAll(ivin)
except Exception:
# workaround for pivy SoInput.setBuffer() bug
buf = buf.replace("\n","")
pts = re.findall("point \[(.*?)\]", buf)[0]
pts = pts.split(",")
pc = []
for p in pts:
v = p.strip().split()
pc.append([float(v[0]), float(v[1]), float(v[2])])
coords = coin.SoCoordinate3()
coords.point.setValues(0, len(pc), pc)
line = coin.SoLineSet()
line.numVertices.setValue(-1)
bezcurveseg = coin.SoSeparator()
bezcurveseg.addChild(coords)
bezcurveseg.addChild(line)
self.sep.addChild(bezcurveseg)
else:
if ivob and ivob.getNumChildren() > 1:
bezcurveseg = ivob.getChild(1).getChild(0)
bezcurveseg.removeChild(bezcurveseg.getChild(0))
bezcurveseg.removeChild(bezcurveseg.getChild(0))
self.sep.addChild(bezcurveseg)
else:
FreeCAD.Console.PrintWarning("bezcurveTracker.recompute() failed to read-in Inventor string\n")
self.bezcurve.append(bezcurveseg)
def curve(self, *points):
"""Add a Bezier curve from self.pos to points[-1]
every other points are the control points of the Bezier curve (which
will thus be of degree len(points) )
"""
points = [Base.Vector(*rotate(p, self.theta)) for p in points]
bz = Part.BezierCurve()
bz.setPoles([self.pos] + points)
self.wire.append(bz)
self.pos = points[-1]
def __init__(self, edge = None):
if edge == None:
v1 = FreeCAD.Vector(0,0,0)
v2 = FreeCAD.Vector(1,0,0)
b = Part.BezierCurve()
b.setPoles([v1,v2])
self.curve = b
elif isinstance(edge, Part.Edge):
c = edge.Curve
if isinstance(c, (Part.BezierCurve, Part.BSplineCurve)):
self.curve = c
else:
bs = c.toBSpline()
self.curve = bs
elif isinstance(edge, (Part.BezierCurve, Part.BSplineCurve)):
self.curve = edge
def execute(self, fp):
self.scale1 = fp.Scale1 / 10.
self.scale2 = fp.Scale2 / 10.
self.cont1 = self.getContinuity(fp.Continuity1)
self.cont2 = self.getContinuity(fp.Continuity2)
self.reverse1 = fp.Reverse1
self.reverse2 = fp.Reverse2
self.blendDegree = 1 + self.cont1 + self.cont2
self.initEdges(fp)
#p0,p1 = self.curve1.FirstParameter, self.curve1.LastParameter
self.param1 = self.curve1.FirstParameter + fp.Parameter1 * (
self.curve1.LastParameter - self.curve1.FirstParameter)
#p0,p1 = self.curve2.FirstParameter, self.curve2.LastParameter
self.param2 = self.curve2.FirstParameter + fp.Parameter2 * (
self.curve2.LastParameter - self.curve2.FirstParameter)
self.blendPoles = self.computePoles(
) #[self.edge1.valueAt(self.param1),self.edge2.valueAt(self.param2)]
self.blendCurve = Part.BezierCurve()
self.blendCurve.increase(self.blendDegree)
self.blendCurve.setPoles(self.blendPoles)
b = self.blendCurve.toShape()
edges = [b]
if fp.AddCurves:
c1 = self.curve1.copy()
c1.segment(c1.FirstParameter, self.param1)
e1 = c1.toShape()
c2 = self.curve2.copy()
c2.segment(c2.FirstParameter, self.param2)
e2 = c2.toShape()
edges += [e1, e2]
if fp.ShowPoints:
poly = []
for e in edges:
poly.append(Part.makePolygon(e.Curve.getPoles()))
edges += poly
fp.Shape = Part.Wire(edges)
def Activated(self):
self.view = FreeCADGui.ActiveDocument.ActiveView
self.viewer = self.view.getViewer()
self.oldRadius = self.viewer.getPickRadius()
self.viewer.setPickRadius(15.0)
self.obj = FreeCAD.ActiveDocument.addObject("Part::Feature","BezierCurve")
self.stack = [FreeCAD.Vector(0,0,0)]
self.markerPos = None
self.snap = False
self.snapShape = None
self.point = FreeCAD.Vector(0,0,0)
self.curve = Part.BezierCurve()
self.clicCB = self.view.addEventCallbackPivy( coin.SoMouseButtonEvent.getClassTypeId(), self.clic_cb)
self.keyboardCB = self.view.addEventCallbackPivy( coin.SoKeyboardEvent.getClassTypeId(), self.kb_cb)
self.cursorCB = self.view.addEventCallbackPivy( coin.SoLocation2Event.getClassTypeId(), self.cursor_cb)
FreeCADGui.Selection.clearSelection()
FreeCADGui.Selection.addObserver(self)
self.nodeInit()
def Activated(self):
s = FreeCADGui.Selection.getSelectionEx()
f = selFilter.selFilter(s)
edges = f.getEdgeShapes()
vertexes = f.getVertexShapes()
for i in range(0,len(vertexes)-1,2):
pts = [vertexes[i].Point,vertexes[i+1].Point]
bez = Part.BezierCurve()
bez.setPoles(pts)
print(bez)
edges.append(bez.toShape())
for e in edges:
obj=FreeCAD.ActiveDocument.addObject("Part::FeaturePython","Spline") #add object to document
makeSpline(obj,e)
SplineVP(obj.ViewObject)
obj.ViewObject.DisplayMode = "Poles"
f.hideAll()
FreeCAD.ActiveDocument.recompute()
def bezier(self, points):
curve = Part.BezierCurve()
curve.setPoles([self.vector(coordinates) for coordinates in points])
self.components.append(curve)
self.current_position = points[-1]
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 != 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 makeBCurveEdge(Points):
geomCurve = Part.BezierCurve()
geomCurve.setPoles(Points)
edge = Part.Edge(geomCurve)
return (edge)
def make_bezier_curve(points):
geomCurve = Part.BezierCurve()
geomCurve.setPoles(points)
return geomCurve
