merged AIRCAPs feature ForceInterpolate and sortEdges

Author: chbergmann

CurvedSegment.py

@@ -34,7 +34,8 @@ def __init__(self,
                  DistributionReverse = False,
                  LoftMaxDegree=5,
                  MaxLoftSize=16,
-                 Path=None):
+                 Path=None,
+                 ForceInterpolated = False):
         CurvedShapes.addObjectProperty(fp,"App::PropertyLink",  "Shape1",     "CurvedSegment",   "The first object of the segment").Shape1 = shape1
         CurvedShapes.addObjectProperty(fp,"App::PropertyLink",  "Shape2",     "CurvedSegment",   "The last object of the segment").Shape2 = shape2
         CurvedShapes.addObjectProperty(fp,"App::PropertyLinkList",  "Hullcurves",   "CurvedSegment",   "Bounding curves").Hullcurves = hullcurves        
@@ -51,6 +52,7 @@ def __init__(self,
         CurvedShapes.addObjectProperty(fp,"App::PropertyInteger", "LoftMaxDegree", "CurvedSegment",   "Max Degree for Surface or Solid").LoftMaxDegree = LoftMaxDegree
         CurvedShapes.addObjectProperty(fp,"App::PropertyInteger", "MaxLoftSize", "CurvedSegment",   "Max Size of a Loft in Segments.").MaxLoftSize = MaxLoftSize
         CurvedShapes.addObjectProperty(fp,"App::PropertyLink",  "Path",     "CurvedSegment",   "Sweep path").Path = Path
+        CurvedShapes.addObjectProperty(fp,"App::PropertyBool", "ForceInterpolated","CurvedSegment",  "Force Interpolation of sketches").ForceInterpolated = ForceInterpolated
         fp.Distribution = ['linear', 'parabolic', 'x³', 'sinusoidal', 'asinusoidal', 'elliptic']
         fp.Distribution = Distribution
         self.doScaleXYZ = []
@@ -71,52 +73,57 @@ def execute(self, fp):
 
         if fp.InterpolationPoints <= 1:
             return
+
+        try:
+            self.update = False
+            if fp.NormalShape1 == Vector(0,0,0):        
+                fp.NormalShape1 = CurvedShapes.getNormal(fp.Shape1)
 
-        self.update = False
-        if fp.NormalShape1 == Vector(0,0,0):        
-            fp.NormalShape1 = CurvedShapes.getNormal(fp.Shape1)
-        
-        if fp.NormalShape2 == Vector(0,0,0):    
-            fp.NormalShape2 = CurvedShapes.getNormal(fp.Shape2)
-        
-        self.doScaleXYZ = []
-        self.doScaleXYZsum = [False, False, False]
-        for h in fp.Hullcurves:
-            bbox = h.Shape.BoundBox
-            doScale = [False, False, False]
+            if fp.NormalShape2 == Vector(0,0,0):    
+                fp.NormalShape2 = CurvedShapes.getNormal(fp.Shape2)
 
-            if bbox.XLength > epsilon: 
-                doScale[0] = True 
-                self.doScaleXYZsum[0] = True
-        
-            if bbox.YLength > epsilon: 
-                doScale[1] = True 
-                self.doScaleXYZsum[1] = True
-        
-            if bbox.ZLength > epsilon: 
-                doScale[2] = True 
-                self.doScaleXYZsum[2] = True
-        
-            self.doScaleXYZ.append(doScale)
-        
-        if fp.Items > 0:
-            self.makeRibs(fp)
-        
-        self.update = True
+            self.doScaleXYZ = []
+            self.doScaleXYZsum = [False, False, False]
+            for h in fp.Hullcurves:
+                bbox = h.Shape.BoundBox
+                doScale = [False, False, False]
+                
+                if bbox.XLength > epsilon: 
+                    doScale[0] = True 
+                    self.doScaleXYZsum[0] = True
+            
+                if bbox.YLength > epsilon: 
+                    doScale[1] = True 
+                    self.doScaleXYZsum[1] = True
+            
+                if bbox.ZLength > epsilon: 
+                    doScale[2] = True 
+                    self.doScaleXYZsum[2] = True
+            
+                self.doScaleXYZ.append(doScale)
+            
+            if fp.Items > 0:
+                self.makeRibs(fp)
+            self.update = True
+        except Exception as ex:
+            self.update = True
+            raise ex
 
 
-    def onChanged(self, fp, prop):
-        #backwards compatiblity
+    def onChanged(self, fp, prop):   
         if not hasattr(fp, 'LoftMaxDegree'):
             CurvedShapes.addObjectProperty(fp, "App::PropertyInteger", "LoftMaxDegree", "CurvedSegment",   "Max Degree for Surface or Solid", init_val=5) # backwards compatibility - this upgrades older documents
         if not hasattr(fp, 'MaxLoftSize'):
             CurvedShapes.addObjectProperty(fp,"App::PropertyInteger", "MaxLoftSize", "CurvedSegment",   "Max Size of a Loft in Segments.", init_val=-1) # backwards compatibility - this upgrades older documents
         if not hasattr(fp, 'Path'):
             CurvedShapes.addObjectProperty(fp,"App::PropertyLink",  "Path",     "CurvedSegment",   "Sweep path", init_val=None) # backwards compatibility - this upgrades older documents
- 
+        if not hasattr(fp, 'ForceInterpolated'):
+            CurvedShapes.addObjectProperty(fp,"App::PropertyBool", "ForceInterpolated","CurvedSegment",  "Force Interpolation of sketches", init_val=False) # backwards compatibility - this upgrades older documents
+
+            
     def makeRibs(self, fp):
         interpolate = False
-        if len(fp.Shape1.Shape.Edges) != len(fp.Shape2.Shape.Edges):
+        if fp.ForceInterpolated or len(fp.Shape1.Shape.Edges) != len(fp.Shape2.Shape.Edges):
             interpolate = True
         else:
             for e in range(0, len(fp.Shape1.Shape.Edges)):
@@ -305,14 +312,16 @@ def makeRibsSameShape(fp, items, alongNormal, makeStartEnd = False):
     return ribs
 
 
-def makeRibsInterpolate(fp, items, alongNormal, makeStartEnd = False):       
-    len1 = len(fp.Shape1.Shape.Edges)
-    len2 = len(fp.Shape2.Shape.Edges)
+def makeRibsInterpolate(fp, items, alongNormal, makeStartEnd = False):
+    s1=fp.Shape1.Shape.toNurbs()
+    s2=fp.Shape2.Shape.toNurbs()
+    len1 = len(s1.Edges)
+    len2 = len(s2.Edges)
 
     nr_edges = int(len1 * len2 / math.gcd(len1, len2))
 
-    pointslist1 = EdgesToPoints(fp.Shape1.Shape, int(nr_edges / len1), int(fp.InterpolationPoints))
-    pointslist2 = EdgesToPoints(fp.Shape2.Shape, int(nr_edges / len2), int(fp.InterpolationPoints), fp.TwistReverse)
+    pointslist1 = EdgesToPoints(s1, int(nr_edges / len1), int(fp.InterpolationPoints))
+    pointslist2 = EdgesToPoints(s2, int(nr_edges / len2), int(fp.InterpolationPoints), fp.TwistReverse)
 
     ribs = []
     if makeStartEnd:
@@ -322,8 +331,8 @@ def makeRibsInterpolate(fp, items, alongNormal, makeStartEnd = False):
         start = 1
         end = items + 1 
 
-    base1=fp.Shape1.Placement.Base
-    base2=fp.Shape2.Placement.Base
+    base1=s1.Placement.Base
+    base2=s2.Placement.Base
     offset=base2-base1
     for i in range(start, end):
         if hasattr(fp, "Distribution"):
@@ -336,6 +345,8 @@ def makeRibsInterpolate(fp, items, alongNormal, makeStartEnd = False):
         for l in range(0, len(pointslist1)):
             points1 = pointslist1[l]
             points2 = pointslist2[l]
+            if(fp.TwistReverse):
+                points2.reverse()
 
             newpoles = []
             for p in range(0, fp.InterpolationPoints):
@@ -344,10 +355,7 @@ def makeRibsInterpolate(fp, items, alongNormal, makeStartEnd = False):
                 else:
                     newpoles.append(vectorMiddlePlane(points1[p], points2[p], fraction, plane)-fraction*offset)
                 # coordinate has fraction*offset substracted to force the shape to be centered on itself, important for later rotation on path
-        
-            if fp.TwistReverse:
-                newpoles.reverse()
-
+            
             bc = Part.BSplineCurve()
             bc.approximate(newpoles)
             newshape.append(bc)
@@ -377,14 +385,14 @@ def makeRibsInterpolate(fp, items, alongNormal, makeStartEnd = False):
 
 def EdgesToPoints(shape, nr_frac, points_per_edge, twistReverse = False):  
     edges = [] 
-    redges = shape.Edges.copy()
+    sortedEdges=sum(Part.sortEdges(shape.Edges),[])
     if twistReverse:
-        redges.reverse()
+        sortedEdges.reverse()
 
     if nr_frac == 1:
-        edges = redges
+        edges = sortedEdges
     else:
-        for edge in redges:
+        for edge in sortedEdges:
             edge1 = edge
             for f in range(0, nr_frac - 1):
                 wires1 = edge1.split(edge1.FirstParameter + (edge1.LastParameter - edge1.FirstParameter) / nr_frac)

CurvedShapes.py

@@ -390,10 +390,11 @@ def makeCurvedSegment(Shape1 = None,
                     DistributionReverse = False,
                     LoftMaxDegree=5,
                     MaxLoftSize=16,
-                    Path = None):
+                    Path = None,
+                    ForceInterpolated=False):
     import CurvedSegment
     obj = FreeCAD.ActiveDocument.addObject("Part::FeaturePython","CurvedSegment")
-    CurvedSegment.CurvedSegment(obj, Shape1, Shape2, Hullcurves, NormalShape1, NormalShape2, Items, Surface, Solid, InterpolationPoints, Twist, TwistReverse, Distribution, DistributionReverse, LoftMaxDegree, MaxLoftSize, Path)
+    CurvedSegment.CurvedSegment(obj, Shape1, Shape2, Hullcurves, NormalShape1, NormalShape2, Items, Surface, Solid, InterpolationPoints, Twist, TwistReverse, Distribution, DistributionReverse, LoftMaxDegree, MaxLoftSize, Path, ForceInterpolated)
     if FreeCAD.GuiUp:
         CurvedSegment.CurvedSegmentViewProvider(obj.ViewObject)
     FreeCAD.ActiveDocument.recompute()

InterpolatedMiddle.py

@@ -57,17 +57,20 @@ def execute(self, fp):
 
         if fp.InterpolationPoints <= 1:
             return
-            
-        self.update = False
-        if fp.NormalShape1 == Vector(0,0,0):        
-            fp.NormalShape1 = CurvedShapes.getNormal(fp.Shape1)
-        
-        if fp.NormalShape2 == Vector(0,0,0):    
-            fp.NormalShape2 = CurvedShapes.getNormal(fp.Shape2)
-        
-        self.makeRibs(fp)
 
-        self.update = True
+        try:
+            self.update = False
+            if fp.NormalShape1 == Vector(0,0,0):        
+                fp.NormalShape1 = CurvedShapes.getNormal(fp.Shape1)
+            
+            if fp.NormalShape2 == Vector(0,0,0):    
+                fp.NormalShape2 = CurvedShapes.getNormal(fp.Shape2)
+            
+            self.makeRibs(fp)
+            self.update = True
+        except Exception as ex:
+            self.update = True
+            raise ex
 
 
     def onChanged(self, fp, prop):

LIESMICH.md

@@ -104,6 +104,7 @@ Wenn Hullcurves verwendet werden und die Objekte nicht rechtwinklig zum Path ang
 
 ### ![](./Resources/icons/curvedSegment.svg) Curved Segment
 Interpoliert zwischen zwei 2D Kurven. Die interpolieren Kurven können innerhalb von Hüllkurven angeordnet werden.  
+Dieses tool funktioniert nicht mit allen beliebigen Kurven. Die Parameter TwistReverse und ForceInterploate können das Ergebis evtl. verbessern.
 
 ![CurvedSegment](Examples/CurvedSegment.jpg)
 ![CurvedSegment2](Examples/CurvedSegment2.jpg)
@@ -135,21 +136,7 @@ Interpoliert zwischen zwei 2D Kurven und ordnet diese rechwinklig zu einer Kurve
 Zuerst zwei 2D Kurven auswählen, dann eine Kurve, die als Path verwendet wird, dann optional noch eine oder mehrere Hüllkurven. Danach das Curved Segment Werkzeug verwenden. 
 
 #### Parameters
-- Shape1: Das erste Object des Segments
-- Shape2: Das letzte Object des Segments
-- Hullcurves: Keine, eine oder mehrere Hüllkurven. Alle Hüllkurven sollten in der XY, XZ oder YZ Raumebene liegen.   
-- NormalShape1: Richtung, in der die Array Elemente von Shape1 aus aufgebaut werden (wird automatisch berechnet)
-- NormalShape2: Richtung, in der die Array Elemente von Shape2 aus aufgebaut werden (wird automatisch berechnet)
-- Items: Anzahl der Array Elemente
-- makeSurface: Eine Oberfläche erstellen
-- makeSolid: Einen Festkörper erstellen (funktioniert nur, wenn Base eine geschlossene Form ist)
-- InterpolationPoints: Wenn Shape1 und Shape2 verschiedenartige Objekte sind, werden die Kurven in diese Anzahl von Einzelpunkten zerlegt  
-- Twist: (Winkel in Grad) kann eine Rotation zwischen Shape1 unf Shape2 kompensieren
-- TwistReverse: wenn True, wird die Drehrichtung geändert
-- Distribution: Algorithmus zur Berechnung der Distanz zwischen den Elementen. Default ist 'linear'. Weitere Möglichkeiten: parabolic (x²), x³, sinusoidal, elliptic
-- DistributionReverse: Kehrt die Richtung des Distrubution Algorithmus um
-- LoftMaxDegree: Gradzahl für die Erstellung von Oberflächen und Festkörpern.
-- MaxLoftSize: Maximale Anzahl von Elementen für die Erstellung von Oberfächen und Festkörpern 
+wie bei Curved Segment
 - Path: Kurve, an der die Segmente rechtwinkling ausgerichtet werden.
 
 

README.md

@@ -110,7 +110,8 @@ The first curve that you select for Curved Path Array creation will be the base
 The parameters ScaleX, ScaleY and ScaleZ have been added because you may want to rescale the items only in one direction, but the hullcurves normally cover 2 or three room directions.  
 
 ### ![curvedSegmentIcon](./Resources/icons/curvedSegment.svg) Curved Segment
-Interpolates between two 2D curves. The interpolated curves can be resized in the bounds of some hullcurves.  
+Interpolates between two 2D curves. The interpolated curves can be resized in the bounds of some hullcurves.
+This does not work for all kinds of shapes. The result may look distorted if the two shapes are too different. The parameters TwistReverse and ForceInterpolated may help to get better results.  
 
 ![CurvedSegment](Examples/CurvedSegment.jpg)
 ![CurvedSegment2](Examples/CurvedSegment2.jpg)
@@ -134,29 +135,16 @@ Select two 2D shapes first. The curved segment will be created between them. If
 - DistributionReverse: Reverses the direction of the Distribution algorithm
 - LoftMaxDegree: degree for surface or solid creation. Play with this parameter if your surface or solid looks distorted
 - MaxLoftSize: Maximum size of a loft segment. The surface is created by creating a loft over many array items, however OpenCascade gets very slow and produces artefacts towards the end of the loft when the array gets too large. Therefore the array gets split up intp sub-arrays of up to MaxLoftSize items. Play with this value if a split between segements ends up in a inconvenient spot. Sensible values are between 10 and 50.
+- ForceInterpolated: By default, CurvedSegment tries a more direct transition from the first to the second object if the objects have the same number of points and lines and interpolates intermediate shapes if they don't. In case the direct approach does not work because the type or order of lines does not match, interpolation can be forced with this parameter even if the number of points is equal. This should only be needed in rare cases.
 
 ### ![curvedSegmentIcon](./Resources/icons/CurvedPathSegment.svg) Curved Path Segment
 Interpolates between two 2D curves and sweeps the elements around a path curve. The interpolated curves can be resized in the bounds of some hullcurves.  
 
 Select two 2D shapes first, then a sweep path curve. The curved segment will be created between them. If you want to use hullcurves, select them also. Then create the Curved Segment.
 
 #### Parameters
-- Shape1: The first object of the segment
-- Shape2: The last object of the segment
-- Hullcurves: List of one or more bounding curves in XY, XZ or YZ plane (optional)
-- NormalShape1: Direction axis of Shape1 (auto computed)
-- NormalShape2: Direction axis of Shape2 (auto computed)
-- Items: Nr. of items between the segments
-- makeSurface: make a surface over the array items
-- makeSolid: make a solid if Base is a closed shape
-- InterpolationPoints: ignored if Shape1 and Shape2 have the same number of edges and poles. Otherwise all edges will be split (discretized) into this number of points
-- Twist: twist into the shape around the profiles normal axis. Useful for example for threaded parts.
-- TwistReverse: Reverses the rotation of one Shape. This is for correcting misalignment between the shapes, use this if the entire shape is inversed on itself (wasp-tail)
+same as in Curved Segment
 - Path: Sweep path - similar to "Path" in CurvedPathArray. If a path is specified, it supersedes the position and orientation of Shape1 and Shape2. CurvedSegment then behaves like CurvedPathArray but with a blend between a beginning and end profile.
-- Distribution: Algorithm for distance between array elements. Default is 'linear'. Also selectable: parabolic (x²), x³, sinusoidal, elliptic
-- DistributionReverse: Reverses the direction of the Distribution algorithm
-- LoftMaxDegree: degree for surface or solid creation. Play with this parameter if your surface or solid looks distorted
-- MaxLoftSize: Maximum size of a loft segment. The surface is created by creating a loft over many array items, however OpenCascade gets very slow and produces artefacts towards the end of the loft when the array gets too large. Therefore the array gets split up intp sub-arrays of up to MaxLoftSize items. Play with this value if a split between segements ends up in a inconvenient spot. Sensible values are between 10 and 50.
 
 
 ### ![CornerShapeIcon](./Resources/icons/CornerShape.svg) Interpolated Middle

package.xml

@@ -2,8 +2,8 @@
 <package format="1" xmlns="https://wiki.freecad.org/Package_Metadata">
   <name>Curved Shapes</name>
   <description>Create 3D shapes from 2D curves.</description>
-  <version>1.00.11</version>
-  <date>2024-10-13</date>
+  <version>1.00.12</version>
+  <date>2024-10-14</date>
   <maintainer email="[email protected]">Christi</maintainer>
   <license file="LICENSE">LGPL-2.1</license>
   <url type="repository" branch="master">https://github.com/chbergmann/CurvedShapesWorkbench</url>