Glatte Interpolation zwischen zwei Punkten

Question

Ich versuche, in einem Netz zwischen Punkten zu interpolieren. Ich habe einige Nachforschungen angestellt und nur wenige Lösungen gefunden, aber alle von ihnen erzeugen für mich merkwürdige Ergebnisse. Ich habe versucht, Cosinus und Cubic-Interpolation, aber ganze Mesh bekommt winzige Wellen, anstatt glatt zu sein.

ich versucht, dieses

mu2 = mu*mu; 
    a0 = y3 - y2 - y0 + y1; 
    a1 = y0 - y1 - a0; 
    a2 = y2 - y0; 
    a3 = y1; 

    return(a0*mu*mu2+a1*mu2+a2*mu+a3); 

von hier: http://paulbourke.net/miscellaneous/interpolation/

ich alle Punkte ich brauche und alle arbeiten sollte, aber es ist nicht. Ich habe viel Zeit damit verbracht, es zu debuggen und nur ein Problem zu finden ist, dass es scheint, dass mu (reguläres t von 0.0 - 1.0 in der Interpolation) bei 0.0 bei P1 beginnt, wie es sollte, aber bei 1.0 ist es bei P3, während es in P2 sein sollte (Punkte P0, P1, P2, P3, wo die Interpolation zwischen P1 und P2 stattfinden soll)

Wenn es eine andere, einfachere Möglichkeit gibt, wie Interpolation zwischen zwei Punkten zu machen, lass es mich wissen. Ich möchte keine Bezier-Kurven oder ähnliches mit Kontrollpunkten machen. Ich habe nur zwei Punkte und ich kann einen Punkt auf jeder Seite wie im obigen Beispiel verwenden.

Vielen Dank für jede Hilfe Luke

Answer 1

Es scheint, dass eine Catmull-Rom-Spline für Ihre Daten geeignet wäre.

Als ein Beispiel davon in VB.NET Umsetzung:

Module Module1 

    ''' <summary> 
    ''' A class for a 2-D point and operations on it. 
    ''' </summary> 
    Class PointD 
     Property X As Double 
     Property Y As Double 

     Public Shared Operator +(p1 As PointD, p2 As PointD) As PointD 
      Return New PointD(p1.X + p2.X, p1.Y + p2.Y) 
     End Operator 

     Public Shared Operator -(p As PointD) As PointD 
      Return New PointD(-p.X, -p.Y) 
     End Operator 

     Public Shared Operator -(p1 As PointD, p2 As PointD) As PointD 
      Return New PointD(p1.X - p2.X, p1.Y - p2.Y) 
     End Operator 

     Public Shared Operator *(a As Double, p As PointD) As PointD 
      Return New PointD(a * p.X, a * p.Y) 
     End Operator 

     Public Shared Operator *(p As PointD, a As Double) As PointD 
      Return New PointD(a * p.X, a * p.Y) 
     End Operator 

     'TODO: (Optional) Add methods for magnitude, cross product and dot product. 

     Public Sub New() 
      ' empty contructor 
     End Sub 

     Public Sub New(x As Double, y As Double) 
      Me.X = x 
      Me.Y = y 
     End Sub 

     Public Overrides Function ToString() As String 
      ' use the N3 format string for tidiness in this example 
      Return $"({X:N3}, {Y:N3})" 
     End Function 

    End Class 

    ''' <summary> 
    ''' Ordinary Catmull-Rom interpolation. 
    ''' </summary> 
    ''' <param name="t">Vary from 0.0 to 1.0 to get an interpolated point between data points p1 and p2.</param> 
    ''' <param name="p0">The first control point.</param> 
    ''' <param name="p1">The first data point.</param> 
    ''' <param name="p2">The second data point.</param> 
    ''' <param name="p3">The second control point.</param> 
    ''' <returns>The interpolated point.</returns> 
    Function CatmullRomInterpolate(t As Double, p0 As PointD, p1 As PointD, p2 As PointD, p3 As PointD) As PointD 
     ' this is the regular Catmull-Rom spline 
     ' other ways of treating it can be found at: 
     ' https://stackoverflow.com/questions/9489736/catmull-rom-curve-with-no-cusps-And-no-self-intersections 
     Return 0.5 * ((2 * p1) + 
      t * (p2 - p0) + 
      Math.Pow(t, 2) * (2 * p0 - 5 * p1 + 4 * p2 - p3) + 
      Math.Pow(t, 3) * (3 * (p1 - p2) + p3 - p0)) 

    End Function 


    Sub Main() 
     ' some sample data which will produce a symmetrical wave shape... 
     Dim p0 As New PointD(-1, 1) 
     Dim p1 As New PointD(0, 0) 
     Dim p2 As New PointD(1, 0) 
     Dim p3 As New PointD(2, -1) 

     For t = 0.0 To 1.0 Step 0.1 
      Console.WriteLine(CatmullRomInterpolate(t, p0, p1, p2, p3)) 
     Next 

     Console.ReadLine() 

    End Sub 

End Module 

Je nachdem, was Sie benötigen, können Sie Catmull-rom curve with no cusps and no self-intersections nützlich finden.