curve_tools/curves.py

   1 # SPDX-License-Identifier: GPL-2.0-or-later
   2
   3 from . import mathematics
   4
   5 import bpy
   6
   7
   8 class BezierPoint:
   9     @staticmethod
  10     def FromBlenderBezierPoint(blenderBezierPoint):
  11         return BezierPoint(blenderBezierPoint.handle_left, blenderBezierPoint.co, blenderBezierPoint.handle_right)
  12
  13
  14     def __init__(self, handle_left, co, handle_right):
  15         self.handle_left = handle_left
  16         self.co = co
  17         self.handle_right = handle_right
  18
  19
  20     def Copy(self):
  21         return BezierPoint(self.handle_left.copy(), self.co.copy(), self.handle_right.copy())
  22
  23     def Reversed(self):
  24         return BezierPoint(self.handle_right, self.co, self.handle_left)
  25
  26     def Reverse(self):
  27         tmp = self.handle_left
  28         self.handle_left = self.handle_right
  29         self.handle_right = tmp
  30
  31
  32 class BezierSegment:
  33     @staticmethod
  34     def FromBlenderBezierPoints(blenderBezierPoint1, blenderBezierPoint2):
  35         bp1 = BezierPoint.FromBlenderBezierPoint(blenderBezierPoint1)
  36         bp2 = BezierPoint.FromBlenderBezierPoint(blenderBezierPoint2)
  37
  38         return BezierSegment(bp1, bp2)
  39
  40
  41     def Copy(self):
  42         return BezierSegment(self.bezierPoint1.Copy(), self.bezierPoint2.Copy())
  43
  44     def Reversed(self):
  45         return BezierSegment(self.bezierPoint2.Reversed(), self.bezierPoint1.Reversed())
  46
  47     def Reverse(self):
  48         # make a copy, otherwise neighboring segment may be affected
  49         tmp = self.bezierPoint1.Copy()
  50         self.bezierPoint1 = self.bezierPoint2.Copy()
  51         self.bezierPoint2 = tmp
  52         self.bezierPoint1.Reverse()
  53         self.bezierPoint2.Reverse()
  54
  55
  56     def __init__(self, bezierPoint1, bezierPoint2):
  57         # bpy.types.BezierSplinePoint
  58         # ## NOTE/TIP: copy() helps with repeated (intersection) action -- ??
  59         self.bezierPoint1 = bezierPoint1.Copy()
  60         self.bezierPoint2 = bezierPoint2.Copy()
  61
  62         self.ctrlPnt0 = self.bezierPoint1.co
  63         self.ctrlPnt1 = self.bezierPoint1.handle_right
  64         self.ctrlPnt2 = self.bezierPoint2.handle_left
  65         self.ctrlPnt3 = self.bezierPoint2.co
  66
  67         self.coeff0 = self.ctrlPnt0
  68         self.coeff1 = self.ctrlPnt0 * (-3.0) + self.ctrlPnt1 * (+3.0)
  69         self.coeff2 = self.ctrlPnt0 * (+3.0) + self.ctrlPnt1 * (-6.0) + self.ctrlPnt2 * (+3.0)
  70         self.coeff3 = self.ctrlPnt0 * (-1.0) + self.ctrlPnt1 * (+3.0) + self.ctrlPnt2 * (-3.0) + self.ctrlPnt3
  71
  72
  73     def CalcPoint(self, parameter = 0.5):
  74         parameter2 = parameter * parameter
  75         parameter3 = parameter * parameter2
  76
  77         rvPoint = self.coeff0 + self.coeff1 * parameter + self.coeff2 * parameter2 + self.coeff3 * parameter3
  78
  79         return rvPoint
  80
  81
  82     def CalcDerivative(self, parameter = 0.5):
  83         parameter2 = parameter * parameter
  84
  85         rvPoint = self.coeff1 + self.coeff2 * parameter * 2.0 + self.coeff3 * parameter2 * 3.0
  86
  87         return rvPoint
  88
  89
  90     def CalcLength(self, nrSamples = 2):
  91         nrSamplesFloat = float(nrSamples)
  92         rvLength = 0.0
  93         for iSample in range(nrSamples):
  94             par1 = float(iSample) / nrSamplesFloat
  95             par2 = float(iSample + 1) / nrSamplesFloat
  96
  97             point1 = self.CalcPoint(parameter = par1)
  98             point2 = self.CalcPoint(parameter = par2)
  99             diff12 = point1 - point2
 100
 101             rvLength += diff12.magnitude
 102
 103         return rvLength
 104
 105
 106     #http://en.wikipedia.org/wiki/De_Casteljau's_algorithm
 107     def CalcSplitPoint(self, parameter = 0.5):
 108         par1min = 1.0 - parameter
 109
 110         bez00 = self.ctrlPnt0
 111         bez01 = self.ctrlPnt1
 112         bez02 = self.ctrlPnt2
 113         bez03 = self.ctrlPnt3
 114
 115         bez10 = bez00 * par1min + bez01 * parameter
 116         bez11 = bez01 * par1min + bez02 * parameter
 117         bez12 = bez02 * par1min + bez03 * parameter
 118
 119         bez20 = bez10 * par1min + bez11 * parameter
 120         bez21 = bez11 * par1min + bez12 * parameter
 121
 122         bez30 = bez20 * par1min + bez21 * parameter
 123
 124         bezPoint1 = BezierPoint(self.bezierPoint1.handle_left, bez00, bez10)
 125         bezPointNew = BezierPoint(bez20, bez30, bez21)
 126         bezPoint2 = BezierPoint(bez12, bez03, self.bezierPoint2.handle_right)
 127
 128         return [bezPoint1, bezPointNew, bezPoint2]
 129
 130
 131 class BezierSpline:
 132     @staticmethod
 133     def FromSegments(listSegments):
 134         rvSpline = BezierSpline(None)
 135
 136         rvSpline.segments = listSegments
 137
 138         return rvSpline
 139
 140
 141     def __init__(self, blenderBezierSpline):
 142         if not blenderBezierSpline is None:
 143             if blenderBezierSpline.type != 'BEZIER':
 144                 print("## ERROR:", "blenderBezierSpline.type != 'BEZIER'")
 145                 raise Exception("blenderBezierSpline.type != 'BEZIER'")
 146             if len(blenderBezierSpline.bezier_points) < 1:
 147                 if not blenderBezierSpline.use_cyclic_u:
 148                     print("## ERROR:", "len(blenderBezierSpline.bezier_points) < 1")
 149                     raise Exception("len(blenderBezierSpline.bezier_points) < 1")
 150
 151         self.bezierSpline = blenderBezierSpline
 152
 153         self.resolution = 12
 154         self.isCyclic = False
 155         if not self.bezierSpline is None:
 156             self.resolution = self.bezierSpline.resolution_u
 157             self.isCyclic = self.bezierSpline.use_cyclic_u
 158
 159         self.segments = self.SetupSegments()
 160
 161
 162     def __getattr__(self, attrName):
 163         if attrName == "nrSegments":
 164             return len(self.segments)
 165
 166         if attrName == "bezierPoints":
 167             rvList = []
 168
 169             for seg in self.segments: rvList.append(seg.bezierPoint1)
 170             if not self.isCyclic: rvList.append(self.segments[-1].bezierPoint2)
 171
 172             return rvList
 173
 174         if attrName == "resolutionPerSegment":
 175             try: rvResPS = int(self.resolution / self.nrSegments)
 176             except: rvResPS = 2
 177             if rvResPS < 2: rvResPS = 2
 178
 179             return rvResPS
 180
 181         if attrName == "length":
 182             return self.CalcLength()
 183
 184         return None
 185
 186
 187     def SetupSegments(self):
 188         rvSegments = []
 189         if self.bezierSpline is None: return rvSegments
 190
 191         nrBezierPoints = len(self.bezierSpline.bezier_points)
 192         for iBezierPoint in range(nrBezierPoints - 1):
 193             bezierPoint1 = self.bezierSpline.bezier_points[iBezierPoint]
 194             bezierPoint2 = self.bezierSpline.bezier_points[iBezierPoint + 1]
 195             rvSegments.append(BezierSegment.FromBlenderBezierPoints(bezierPoint1, bezierPoint2))
 196         if self.isCyclic:
 197             bezierPoint1 = self.bezierSpline.bezier_points[-1]
 198             bezierPoint2 = self.bezierSpline.bezier_points[0]
 199             rvSegments.append(BezierSegment.FromBlenderBezierPoints(bezierPoint1, bezierPoint2))
 200
 201         return rvSegments
 202
 203
 204     def UpdateSegments(self, newSegments):
 205         prevNrSegments = len(self.segments)
 206         diffNrSegments = len(newSegments) - prevNrSegments
 207         if diffNrSegments > 0:
 208             newBezierPoints = []
 209             for segment in newSegments: newBezierPoints.append(segment.bezierPoint1)
 210             if not self.isCyclic: newBezierPoints.append(newSegments[-1].bezierPoint2)
 211
 212             self.bezierSpline.bezier_points.add(diffNrSegments)
 213
 214             for i, bezPoint in enumerate(newBezierPoints):
 215                 blBezPoint = self.bezierSpline.bezier_points[i]
 216
 217                 blBezPoint.tilt = 0
 218                 blBezPoint.radius = 1.0
 219
 220                 blBezPoint.handle_left_type = 'FREE'
 221                 blBezPoint.handle_left = bezPoint.handle_left
 222                 blBezPoint.co = bezPoint.co
 223                 blBezPoint.handle_right_type = 'FREE'
 224                 blBezPoint.handle_right = bezPoint.handle_right
 225
 226             self.segments = newSegments
 227         else:
 228             print("### WARNING: UpdateSegments(): not diffNrSegments > 0")
 229
 230
 231     def Reversed(self):
 232         revSegments = []
 233
 234         for iSeg in reversed(range(self.nrSegments)): revSegments.append(self.segments[iSeg].Reversed())
 235
 236         rvSpline = BezierSpline.FromSegments(revSegments)
 237         rvSpline.resolution = self.resolution
 238         rvSpline.isCyclic = self.isCyclic
 239
 240         return rvSpline
 241
 242
 243     def Reverse(self):
 244         revSegments = []
 245
 246         for iSeg in reversed(range(self.nrSegments)):
 247             self.segments[iSeg].Reverse()
 248             revSegments.append(self.segments[iSeg])
 249
 250         self.segments = revSegments
 251
 252
 253     def CalcDivideResolution(self, segment, parameter):
 254         if not segment in self.segments:
 255             print("### WARNING: InsertPoint(): not segment in self.segments")
 256             return None
 257
 258         iSeg = self.segments.index(segment)
 259         dPar = 1.0 / self.nrSegments
 260         splinePar = dPar * (parameter + float(iSeg))
 261
 262         res1 = int(splinePar * self.resolution)
 263         if res1 < 2:
 264             print("### WARNING: CalcDivideResolution(): res1 < 2 -- res1: %d" % res1, "-- setting it to 2")
 265             res1 = 2
 266
 267         res2 = int((1.0 - splinePar) * self.resolution)
 268         if res2 < 2:
 269             print("### WARNING: CalcDivideResolution(): res2 < 2 -- res2: %d" % res2, "-- setting it to 2")
 270             res2 = 2
 271
 272         return [res1, res2]
 273         # return [self.resolution, self.resolution]
 274
 275
 276     def CalcPoint(self, parameter):
 277         nrSegs = self.nrSegments
 278
 279         segmentIndex = int(nrSegs * parameter)
 280         if segmentIndex < 0: segmentIndex = 0
 281         if segmentIndex > (nrSegs - 1): segmentIndex = nrSegs - 1
 282
 283         segmentParameter = nrSegs * parameter - segmentIndex
 284         if segmentParameter < 0.0: segmentParameter = 0.0
 285         if segmentParameter > 1.0: segmentParameter = 1.0
 286
 287         return self.segments[segmentIndex].CalcPoint(parameter = segmentParameter)
 288
 289
 290     def CalcDerivative(self, parameter):
 291         nrSegs = self.nrSegments
 292
 293         segmentIndex = int(nrSegs * parameter)
 294         if segmentIndex < 0: segmentIndex = 0
 295         if segmentIndex > (nrSegs - 1): segmentIndex = nrSegs - 1
 296
 297         segmentParameter = nrSegs * parameter - segmentIndex
 298         if segmentParameter < 0.0: segmentParameter = 0.0
 299         if segmentParameter > 1.0: segmentParameter = 1.0
 300
 301         return self.segments[segmentIndex].CalcDerivative(parameter = segmentParameter)
 302
 303
 304     def InsertPoint(self, segment, parameter):
 305         if not segment in self.segments:
 306             print("### WARNING: InsertPoint(): not segment in self.segments")
 307             return
 308         iSeg = self.segments.index(segment)
 309         nrSegments = len(self.segments)
 310
 311         splitPoints = segment.CalcSplitPoint(parameter = parameter)
 312         bezPoint1 = splitPoints[0]
 313         bezPointNew = splitPoints[1]
 314         bezPoint2 = splitPoints[2]
 315
 316         segment.bezierPoint1.handle_right = bezPoint1.handle_right
 317         segment.bezierPoint2 = bezPointNew
 318
 319         if iSeg < (nrSegments - 1):
 320             nextSeg = self.segments[iSeg + 1]
 321             nextSeg.bezierPoint1.handle_left = bezPoint2.handle_left
 322         else:
 323             if self.isCyclic:
 324                 nextSeg = self.segments[0]
 325                 nextSeg.bezierPoint1.handle_left = bezPoint2.handle_left
 326
 327
 328         newSeg = BezierSegment(bezPointNew, bezPoint2)
 329         self.segments.insert(iSeg + 1, newSeg)
 330
 331
 332     def Split(self, segment, parameter):
 333         if not segment in self.segments:
 334             print("### WARNING: InsertPoint(): not segment in self.segments")
 335             return None
 336         iSeg = self.segments.index(segment)
 337         nrSegments = len(self.segments)
 338
 339         splitPoints = segment.CalcSplitPoint(parameter = parameter)
 340         bezPoint1 = splitPoints[0]
 341         bezPointNew = splitPoints[1]
 342         bezPoint2 = splitPoints[2]
 343
 344
 345         newSpline1Segments = []
 346         for iSeg1 in range(iSeg): newSpline1Segments.append(self.segments[iSeg1])
 347         if len(newSpline1Segments) > 0: newSpline1Segments[-1].bezierPoint2.handle_right = bezPoint1.handle_right
 348         newSpline1Segments.append(BezierSegment(bezPoint1, bezPointNew))
 349
 350         newSpline2Segments = []
 351         newSpline2Segments.append(BezierSegment(bezPointNew, bezPoint2))
 352         for iSeg2 in range(iSeg + 1, nrSegments): newSpline2Segments.append(self.segments[iSeg2])
 353         if len(newSpline2Segments) > 1: newSpline2Segments[1].bezierPoint1.handle_left = newSpline2Segments[0].bezierPoint2.handle_left
 354
 355
 356         newSpline1 = BezierSpline.FromSegments(newSpline1Segments)
 357         newSpline2 = BezierSpline.FromSegments(newSpline2Segments)
 358
 359         return [newSpline1, newSpline2]
 360
 361
 362     def Join(self, spline2, mode = 'At_midpoint'):
 363         if mode == 'At_midpoint':
 364             self.JoinAtMidpoint(spline2)
 365             return
 366
 367         if mode == 'Insert_segment':
 368             self.JoinInsertSegment(spline2)
 369             return
 370
 371         print("### ERROR: Join(): unknown mode:", mode)
 372
 373
 374     def JoinAtMidpoint(self, spline2):
 375         bezPoint1 = self.segments[-1].bezierPoint2
 376         bezPoint2 = spline2.segments[0].bezierPoint1
 377
 378         mpHandleLeft = bezPoint1.handle_left.copy()
 379         mpCo = (bezPoint1.co + bezPoint2.co) * 0.5
 380         mpHandleRight = bezPoint2.handle_right.copy()
 381         mpBezPoint = BezierPoint(mpHandleLeft, mpCo, mpHandleRight)
 382
 383         self.segments[-1].bezierPoint2 = mpBezPoint
 384         spline2.segments[0].bezierPoint1 = mpBezPoint
 385         for seg2 in spline2.segments: self.segments.append(seg2)
 386
 387         self.resolution += spline2.resolution
 388         self.isCyclic = False    # is this ok?
 389
 390
 391     def JoinInsertSegment(self, spline2):
 392         self.segments.append(BezierSegment(self.segments[-1].bezierPoint2, spline2.segments[0].bezierPoint1))
 393         for seg2 in spline2.segments: self.segments.append(seg2)
 394
 395         self.resolution += spline2.resolution    # extra segment will usually be short -- impact on resolution negligible
 396
 397         self.isCyclic = False    # is this ok?
 398
 399
 400     def RefreshInScene(self):
 401         bezierPoints = self.bezierPoints
 402
 403         currNrBezierPoints = len(self.bezierSpline.bezier_points)
 404         diffNrBezierPoints = len(bezierPoints) - currNrBezierPoints
 405         if diffNrBezierPoints > 0: self.bezierSpline.bezier_points.add(diffNrBezierPoints)
 406
 407         for i, bezPoint in enumerate(bezierPoints):
 408             blBezPoint = self.bezierSpline.bezier_points[i]
 409
 410             blBezPoint.tilt = 0
 411             blBezPoint.radius = 1.0
 412
 413             blBezPoint.handle_left_type = 'FREE'
 414             blBezPoint.handle_left = bezPoint.handle_left
 415             blBezPoint.co = bezPoint.co
 416             blBezPoint.handle_right_type = 'FREE'
 417             blBezPoint.handle_right = bezPoint.handle_right
 418
 419         self.bezierSpline.use_cyclic_u = self.isCyclic
 420         self.bezierSpline.resolution_u = self.resolution
 421
 422
 423     def CalcLength(self):
 424         try: nrSamplesPerSegment = int(self.resolution / self.nrSegments)
 425         except: nrSamplesPerSegment = 2
 426         if nrSamplesPerSegment < 2: nrSamplesPerSegment = 2
 427
 428         rvLength = 0.0
 429         for segment in self.segments:
 430             rvLength += segment.CalcLength(nrSamples = nrSamplesPerSegment)
 431
 432         return rvLength
 433
 434
 435     def GetLengthIsSmallerThan(self, threshold):
 436         try: nrSamplesPerSegment = int(self.resolution / self.nrSegments)
 437         except: nrSamplesPerSegment = 2
 438         if nrSamplesPerSegment < 2: nrSamplesPerSegment = 2
 439
 440         length = 0.0
 441         for segment in self.segments:
 442             length += segment.CalcLength(nrSamples = nrSamplesPerSegment)
 443             if not length < threshold: return False
 444
 445         return True
 446
 447
 448 class Curve:
 449     def __init__(self, blenderCurve):
 450         self.curve = blenderCurve
 451         self.curveData = blenderCurve.data
 452
 453         self.splines = self.SetupSplines()
 454
 455
 456     def __getattr__(self, attrName):
 457         if attrName == "nrSplines":
 458             return len(self.splines)
 459
 460         if attrName == "length":
 461             return self.CalcLength()
 462
 463         if attrName == "worldMatrix":
 464             return self.curve.matrix_world
 465
 466         if attrName == "location":
 467             return self.curve.location
 468
 469         return None
 470
 471
 472     def SetupSplines(self):
 473         rvSplines = []
 474         for spline in self.curveData.splines:
 475             if spline.type != 'BEZIER':
 476                 print("## WARNING: only bezier splines are supported, atm; other types are ignored")
 477                 continue
 478
 479             try: newSpline = BezierSpline(spline)
 480             except:
 481                 print("## EXCEPTION: newSpline = BezierSpline(spline)")
 482                 continue
 483
 484             rvSplines.append(newSpline)
 485
 486         return rvSplines
 487
 488
 489     def RebuildInScene(self):
 490         self.curveData.splines.clear()
 491
 492         for spline in self.splines:
 493             blSpline = self.curveData.splines.new('BEZIER')
 494             blSpline.use_cyclic_u = spline.isCyclic
 495             blSpline.resolution_u = spline.resolution
 496
 497             bezierPoints = []
 498             for segment in spline.segments: bezierPoints.append(segment.bezierPoint1)
 499             if not spline.isCyclic: bezierPoints.append(spline.segments[-1].bezierPoint2)
 500             #else: print("????", "spline.isCyclic")
 501
 502             nrBezierPoints = len(bezierPoints)
 503             blSpline.bezier_points.add(nrBezierPoints - 1)
 504
 505             for i, blBezPoint in enumerate(blSpline.bezier_points):
 506                 bezPoint = bezierPoints[i]
 507
 508                 blBezPoint.tilt = 0
 509                 blBezPoint.radius = 1.0
 510
 511                 blBezPoint.handle_left_type = 'FREE'
 512                 blBezPoint.handle_left = bezPoint.handle_left
 513                 blBezPoint.co = bezPoint.co
 514                 blBezPoint.handle_right_type = 'FREE'
 515                 blBezPoint.handle_right = bezPoint.handle_right
 516
 517
 518     def CalcLength(self):
 519         rvLength = 0.0
 520         for spline in self.splines:
 521             rvLength += spline.length
 522
 523         return rvLength
 524
 525
 526     def RemoveShortSplines(self, threshold):
 527         splinesToRemove = []
 528
 529         for spline in self.splines:
 530             if spline.GetLengthIsSmallerThan(threshold): splinesToRemove.append(spline)
 531
 532         for spline in splinesToRemove: self.splines.remove(spline)
 533
 534         return len(splinesToRemove)
 535
 536
 537     def JoinNeighbouringSplines(self, startEnd, threshold, mode):
 538         nrJoins = 0
 539
 540         while True:
 541             firstPair = self.JoinGetFirstPair(startEnd, threshold)
 542             if firstPair is None: break
 543
 544             firstPair[0].Join(firstPair[1], mode)
 545             self.splines.remove(firstPair[1])
 546
 547             nrJoins += 1
 548
 549         return nrJoins
 550
 551
 552     def JoinGetFirstPair(self, startEnd, threshold):
 553         nrSplines = len(self.splines)
 554
 555         if startEnd:
 556             for iCurrentSpline in range(nrSplines):
 557                 currentSpline = self.splines[iCurrentSpline]
 558
 559                 for iNextSpline in range(iCurrentSpline + 1, nrSplines):
 560                     nextSpline = self.splines[iNextSpline]
 561
 562                     currEndPoint = currentSpline.segments[-1].bezierPoint2.co
 563                     nextStartPoint = nextSpline.segments[0].bezierPoint1.co
 564                     if mathematics.IsSamePoint(currEndPoint, nextStartPoint, threshold): return [currentSpline, nextSpline]
 565
 566                     nextEndPoint = nextSpline.segments[-1].bezierPoint2.co
 567                     currStartPoint = currentSpline.segments[0].bezierPoint1.co
 568                     if mathematics.IsSamePoint(nextEndPoint, currStartPoint, threshold): return [nextSpline, currentSpline]
 569
 570             return None
 571         else:
 572             for iCurrentSpline in range(nrSplines):
 573                 currentSpline = self.splines[iCurrentSpline]
 574
 575                 for iNextSpline in range(iCurrentSpline + 1, nrSplines):
 576                     nextSpline = self.splines[iNextSpline]
 577
 578                     currEndPoint = currentSpline.segments[-1].bezierPoint2.co
 579                     nextStartPoint = nextSpline.segments[0].bezierPoint1.co
 580                     if mathematics.IsSamePoint(currEndPoint, nextStartPoint, threshold): return [currentSpline, nextSpline]
 581
 582                     nextEndPoint = nextSpline.segments[-1].bezierPoint2.co
 583                     currStartPoint = currentSpline.segments[0].bezierPoint1.co
 584                     if mathematics.IsSamePoint(nextEndPoint, currStartPoint, threshold): return [nextSpline, currentSpline]
 585
 586                     if mathematics.IsSamePoint(currEndPoint, nextEndPoint, threshold):
 587                         nextSpline.Reverse()
 588                         #print("## ", "nextSpline.Reverse()")
 589                         return [currentSpline, nextSpline]
 590
 591                     if mathematics.IsSamePoint(currStartPoint, nextStartPoint, threshold):
 592                         currentSpline.Reverse()
 593                         #print("## ", "currentSpline.Reverse()")
 594                         return [currentSpline, nextSpline]
 595
 596             return None