Rotating Spline Tangents?



  • On 23/11/2013 at 13:17, xxxxxxxx wrote:

    User Information:
    Cinema 4D Version:   13 
    Platform:   Windows  ;   
    Language(s) :     C++  ;

    ---------
    Hi,
    I'm trying to figure out how to rotate spline tangents. But I'm stuck.
    According to this old thread. I have to use the RotAxisToMatrix() function:
    https://plugincafe.maxon.net/topic/884/202_how-to-rotate-tangents&KW=rotate+spline+tangent&PID=565#565
    But it's too vague and incomplete for me to figure it out.

    I understand that I need to create a matrix for the tangent so I can rotate it.
    But after that part I'm stuck.

        BaseObject *spline = doc->SearchObject("Spline");    //Find the spline in the OM (Not a primitive!!)  
      if(!spline) return FALSE;  
      SplineObject *sp = ToSpline(spline);                 //Cast it to a spline object type so we can work on it if desired  
        
      Vector *points = sp->GetPointW();                    //Get it's array of points  
      Tangent *tangents = sp->GetTangentW();               //Get it's array of tangents  
      LONG pointCount = sp->GetPointCount();  
      
      Vector t0 = sp->GetSplineTangent(0, 0);              //The first tangent in the spline to rotate  
            
      Real angle = 25;  
      Vector axis = t0;                                    //The axis for the new matrix?  
      Matrix newmtx;  
      newmtx = RotAxisToMatrix(axis, angle);               //Create a matrix based on t0  
      
      //What do I do next?  
      tangents[0].vl ^= ?  
      tangents[0].vr ^= ?
    

    -ScottA



  • On 23/11/2013 at 18:51, xxxxxxxx wrote:

    What do you mean by "Rotating Spline tangents" ? Rotating around the tangents axis 
    vector doesn't make much sense, so i guess you do want to rotate around that vectors 
    normal or binormal. I have never used RotAxisToMatrix(), so i cannot say much about 
    that method (I think it does the same for what I am about to describe for the z-axis of the
    matrix constructedwith the passed axis vector (which will be the z-axis in this system)). 
    I would construct a matrix for that vertex manually and then just put my desired rotation 
    on top of it (you could also use the spline helper class for the vertex matrix). In pseudo 
    code, to lazy for proper code :

    # construct vertex matrix tng = tangent.right - tagent.left nrm = tng % someUpVector brnm = tng % nrm vermg = Matrix(vertexpos, nrm, bnrm, tng) # our rot matrix rotmg = HBPtoMatrix(Vector(pi,0,0)) # put everything together, i think you might have to invert your vertex matrix for one of the # tangents, but i can't wrap my head around it, without trying it for myself. tangent.left = (vermg * rotmg).MulV(tangent.left) tangent.right = (vermg * rotmg).MulV(tangent.right)
    


  • On 23/11/2013 at 20:13, xxxxxxxx wrote:

    By rotating tangents I mean like when you select a point in a spline then rotate it with the rotate tool. The tangents will rotate around the spline point. And the R&L tangents maintain their lengths while this happens.
    I'm guessing that a matrix is being create using the R&L tangent handles. And the spline point is acting as the matrix center?

    I did attempt to use the SplineHelp class's GetMatrix() function. But the problem I ran into was after I changed the point's matrix. There's nothing in the docs that tells me how to "Set" that changed matrix back to the point to update it.
    tangent(0)->SetMg(pmtx) didn't work.

    The Rotate tool is doing exactly what I want to do with code.
    Mikael Sterner seemed to know how to do it. But he's long gone.

    -ScottA



  • On 24/11/2013 at 00:26, xxxxxxxx wrote:

    Hi,

    1. Rotating in "spline space" isn't as easy as you might think, at least when you want 
    to rotate multiple tangents accordingly. The reason is that the splines normals aren't 
    mathematically defined that way humans would consider them as normal normals (pun
     intended ;) ). The result are flipping normals if you calculate the vertex frames (frame 
    means matrix) vertex by vertex. There are several ways around that problem. The 
    easiest is called Parallel Transport Frame. The idea is simply that you don't calculate 
    each vertex frame with an arbitrary up vector but with the normal of the previous vertex. 
    For a real algorithm you will have also correct the frame torsion and recalculate the first 
    frame with the last frame if you have a closed spline.
    However also this algorithm has its problems (especially with fast turns, depending on how 
    sophisticated you build your torsion correction). There is a better (and more complicated)
    algorithm called Rotation Minimizing Frames that does give better results.

    2. Sadly maxon does not expose its spline normal calculation algorithms ('banking'). The
    vertex frames returned by the SplineHelper class are the raw frames (at least they were
    the last time I did check in R14 something).

    3. Some basic code showing rotation in global and spline space with the raw frames.

    http://codepad.org/K7GRidGo

    edit : toggle globrot = True
    edit2: i now just see that i have accidentally taken the x-axis for spline space instead of the 
    z-axis in the final tangent calculation.



  • On 24/11/2013 at 08:03, xxxxxxxx wrote:

    Thanks for the code LD.

    I'm not using SetTangents() in my code. I'm changing the point's matrix. Then trying to apply the changes to the tangents (vr & vl) directly.
    I'll play around with that approach and see if it gets me closer.

    -ScottA

    Edit-  Apparently SetTangents() is a Python only function.
    In C++ There's no such function in the SplineObject class. And it looks like we have move the vr & vl directly. The way I was doing it.
    I hate it when people post incomplete C++ code solutions. It's really frustrating.



  • On 25/11/2013 at 11:46, xxxxxxxx wrote:

    I gave up on that old thread.
    And I came up with my own solution to the problem.

    C++ version

    //This code uses a temporary null object to rotate a spline point's tangent handles  
    //I used a temporary object here because it's simpler to rotate objects than a matrix  
    //The C4D rotate tool seems to be doing a similar thing (creating a temp. matrix while rotating a spline point)  
      
      
      BaseObject *spline = doc->SearchObject("Spline"); //Find the spline in the OM (Not a primitive!!)  
      if(!spline) return FALSE;  
      SplineObject *sp = ToSpline(spline);              //Cast it to a spline object type so we can work on it if desired  
         
      Vector *points = sp->GetPointW();                 //Get it's array of points  
      Tangent *tangents = sp->GetTangentW();            //Get it's array of tangents  
      LONG pointCount = sp->GetPointCount();  
      
      AutoAlloc<SplineHelp> sh;  
      if(!sh) return FALSE;  
      sh->InitSpline(spline);  
      if(!sh->Exists()) return FALSE;  
      
      Vector t0 = sp->GetSplineTangent(0, 0);          //The first tangent in the spline to rotate  
                
      //Get the matrix of the first spline point  
      Matrix mtx = sh->GetMatrix(0);  
      
      //Create a Null object in memory  
      //There's no need to pyhsically add the object to the scene  
      //Because we will only be using it's matrix then deleting it  
      BaseObject *null = BaseObject::Alloc(Onull);  
      
      //Set the null's position and rotation matrix values to the same as the spline's point  
      null->SetMg(mtx);  
      
      //Rotate the null as desired  
      null->SetRelRot(Vector(0,0,0));  //<---Change this to rotate the tangents via the null  
      
      //Get the nulls new matrix values  
      Matrix nmtx = null->GetMg();  
               
      //Apply the null's matrix values to the spline point's tangent handles to rotate them  
      tangents[0].vl = -(nmtx).MulV(Vector(tangents[0].vl.GetLength(),0,0));  
      tangents[0].vr =  (nmtx).MulV(Vector(tangents[0].vr.GetLength(),0,0));  
      
      sp->Message(MSG_POINTS_CHANGED);  
      sp->Message(MSG_UPDATE);  
      null->Remove();  
      BaseObject::Free(null);    //Delete the memory used to allocate the null object  
      EventAdd();
    

    Python version

    #This script uses a temporary null object to rotate a spline point's tangent handles  
    #I used a temporary object here because it's simpler to rotate objects than a matrix  
    #The C4D rotate tool seems to be doing a similar thing (creating a temp. matrix while rotating a spline point)  
      
    import c4d  
    from c4d import utils  
    from c4d.utils import SplineHelp  
    def main() :  
        
      obj = doc.SearchObject("Spline")   #The spline to work on  
      if not obj: return False  
      
      sh = SplineHelp()  
      sh.InitSpline(obj, use_deformed_points=True)  
      
      #Get the first spline tangent  
      tan0 = obj.GetTangent(0)  
      
      #Get the matrix of the first spline point  
      mtx = sh.GetMatrix(0)  
      
      #Create a Null object in memory  
      #There's no need to pyhsically add the object to the scene  
      #Because we will only be using it's matrix then deleting it  
      null = c4d.BaseObject(c4d.Onull)  
      
      #Set the null's position and rotation matrix values to the same as the spline's point  
      null.SetMg(mtx)  
      
      #Rotate the null as desired  
      null.SetRelRot(c4d.Vector(0,0,0))  #<---Change this to rotate the tangents via the null  
      
      #Get the nulls new matrix values  
      nmtx = null.GetMg()          
               
      #Apply the null's matrix values to the spline point's tangent handles to rotate them  
      obj.SetTangent(0, -(nmtx).MulV(c4d.Vector(tan0["vl"].GetLength(),0,0)),  
                         (nmtx).MulV(c4d.Vector(tan0["vr"].GetLength(),0,0)))          
        
      obj.Message(c4d.MSG_POINTS_CHANGED)  
      obj.Message(c4d.MSG_UPDATE)  
      sh.FreeSpline()  
      null.Remove()  
      c4d.EventAdd()  
        
    if __name__=='__main__':  
      main()
    

    -ScottA


Log in to reply