Posts made by Cairyn

@zipit okaaaay I get it: you NEVER EVER sleep!

@curripod00 said in Connecting Camera Focus Distance to Null Object with Python:

camera[c4d.CAMERAOBJECT_TARGETOBJECT] = null

This line cannot work because "null" is an undefined variable name (and "camera" actually too). It references nothing.
Instead, you will need to find the actual target null by searching:

camera = doc.SearchObject("Camera")
camera[c4d.CAMERAOBJECT_TARGETOBJECT] = doc.SearchObject("Camera_Target")

(I did not test that, just slapped together from memory.)

This is still not very good code because it assumes that the new camera's name is "Camera" which is not very original and may be duplicate in the scene already. Feel free to call the camera something else by setting the name when you generate the object.

Or instead of searching, you store the objects after generation in a variable. Following code should do it (I didn't test, as I don't have Redshift):

import c4d
from c4d import gui

def main():
    def object():
        return doc.GetActiveObject()
    def tag():
        return doc.GetActiveTag()

    c4d.CallCommand(5140) # Create Camera Targeting Null
    cameraTarget = object()
    cameraTarget[c4d.NULLOBJECT_DISPLAY] = 13
    cameraTarget[c4d.NULLOBJECT_RADIUS] = 80
    cameraTarget[c4d.ID_BASEOBJECT_REL_POSITION,c4d.VECTOR_Y] = 276
    cameraTarget[c4d.ID_BASELIST_NAME] = "Camera_Target"

    c4d.CallCommand(5103) # Create Camera with Redshift Tag
    camera = object()
    camera[c4d.ID_BASEOBJECT_REL_ROTATION,c4d.VECTOR_X] = 0
    camera[c4d.ID_BASEOBJECT_REL_ROTATION,c4d.VECTOR_Y] = -0.175
    camera[c4d.ID_BASEOBJECT_REL_ROTATION,c4d.VECTOR_Z] = 0
    camera[c4d.ID_BASEOBJECT_REL_POSITION,c4d.VECTOR_X] = 0
    camera[c4d.ID_BASEOBJECT_REL_POSITION,c4d.VECTOR_Y] = 433
    camera[c4d.ID_BASEOBJECT_REL_POSITION,c4d.VECTOR_Z] = -884
    c4d.CallCommand(100004788, 50075) # New Tag
    cameratag = tag()
    cameratag[c4d.REDSHIFT_POSTEFFECTS_DOF_OVERRIDE] = True
    cameratag[c4d.REDSHIFT_POSTEFFECTS_DOF_ENABLED] = True
    cameratag[c4d.REDSHIFT_POSTEFFECTS_DOF_RADIUS] = 8.5

    camera[c4d.CAMERAOBJECT_TARGETOBJECT] = cameraTarget

if __name__=='__main__':
    main()
    c4d.EventAdd()

Learn more about Python for C4D scripting:
https://www.patreon.com/cairyn

I was curious and just tried c4d.CallCommand(12104) - it does close the GUI app even from a Python script. (And asks for unsaved content too; I suppose it won't close if you cancel but I didn't check that.)

@m_adam Thanks for the confirmation!

(I swear I'm not doing this on purpose...)

I was just playing with the render tokens in Python, and I found some strange behavior in the example py_render_token_r21.

I modified the code a little to give me three different render tokens but the PythonFrameToken function should work the same as the Maxon original. I just added a test for NOTOK here:

import c4d, time

def PythonFrameToken(data):
    """
        data[4],  # The frame number used for rendering or NOTOK if the frame is not yet recognized.
    """

    print "Token $PythonTokenFrm replaced:", str(data[4]), data[4]
    if data[4] == c4d.NOTOK:
        return "NOTOK"
    else:
        return str(data[4])

   
def PythonTimeToken(data):
    return time.strftime("%a in %B") # Weekday in Month
   
    
def PythonFirstObjectToken(data):
    obj = data[0].GetFirstObject()
    if obj == None:
        return "None"
    else:
        return obj.GetName()

            
if __name__=="__main__":
    for registeredToken in c4d.modules.tokensystem.GetAllTokenEntries():
        print registeredToken
        if registeredToken.get("_token") in ["PythonTokenFrm", "PythonTokenTime", "PythonTokenFirstObject"]:
            exit()

    c4d.plugins.RegisterToken("PythonTokenFrm", "This Python Token shows the frame", "001", PythonFrameToken)

    c4d.plugins.RegisterToken("PythonTokenTime", "This Python Token shows the time", "Sat in June", PythonTimeToken)

    c4d.plugins.RegisterToken("PythonTokenFirstObject", "This Python Token shows the name of the first object", "MyObject", PythonFirstObjectToken)

(I am aware of the problem described here:
https://plugincafe.maxon.net/topic/12162/custom-tokens-with-team-render-server
so I know this may not work on TeamRender, but I'm working on full GUI C4D so this does not apply.)

And here's the issue:
The function PythonFrameToken returns NOTOK in the crucial call. So, the file name ultimately contains "NOTOK" instead of the actual frame number.
The other two tokens work fine as expected.

Looking at the console output, PythonFrameToken is called several times; here rendering frame 15-16:

Token $PythonTokenFrm replaced: -1 -1
Token $PythonTokenFrm replaced: -1 -1
Token $PythonTokenFrm replaced: -1 -1
Token $PythonTokenFrm replaced: 15 15
Token $PythonTokenFrm replaced: -100000000 -100000000
Token $PythonTokenFrm replaced: 15 15
Token $PythonTokenFrm replaced: -100000000 -100000000
Token $PythonTokenFrm replaced: 15 15
Token $PythonTokenFrm replaced: 15 15
Token $PythonTokenFrm replaced: -100000000 -100000000
Token $PythonTokenFrm replaced: 16 16
Token $PythonTokenFrm replaced: -100000000 -100000000
Token $PythonTokenFrm replaced: 16 16
Token $PythonTokenFrm replaced: 16 16

At some point, data[4] obviously yields the correct value, but the filenames are still wrong.
It does not matter whether the path string contains a path or just a filename without path component.

This comes from an official example for R21 though - so I wonder what's wrong.

@m_magalhaes thanks, that'll do!

S22 has an FBX export (judging from the documentation). You can use FORMAT_FBX_EXPORT in the SaveDocument function. If you want to do it in Python, the function is here:
https://developers.maxon.net/docs/Cinema4DPythonSDK/html/modules/c4d.documents/index.html?highlight=savedocument#c4d.documents.SaveDocument

(that's also the API documentation; you do not need any separate development tools for simple Python dev tasks but I'm sure there is some thread here to explain how to use a separate Python IDE and connect it to C4D)

Hello;

I was just going through the standard dialogs in the Python API like MessageDialog etc (https://developers.maxon.net/docs/Cinema4DPythonSDK/html/modules/c4d.gui/index.html?highlight=selectionlistdialog#c4d.gui.SelectionListDialog ; most of which do not exist in this form in the C++ API), and there are some questions open...

1. The flag GEMB_FORCEDIALOG is unexplained (well, the explanation is "Forces dialog"). What does it actually do? I tried it in a script and see no change whether I use it or not.

2. When does a MessageDialog return GEMB_R_UNDEFINED? (Does it ever?)

3. The input dialog shows an OK and a Cancel button and can be closed with the Window Close icon. But it always returns the input string, other than RenameDialog which looks almost the same but returns None if the user presses Cancel.
   To be fair, the description does say that (no screenshot though). But what is the Cancel button for, then?

4. The ColorDialog has ominous Flags as first parameter. The doc doesn't say which flags. I have found that you can use (some of) the DR_COLORFIELD_xxx flags to hide some parts of the color gadget (most of the _NO_ ones), but not all of them. The ColorDialog always opens in the mode it was closed in; the _ENABLE_ flags do not affect the state.
   Is there a list of the flags that actually take effect? Maybe there are more than just COLORFIELD?

5. The SelectionListDialog has an X and a Y coordinate in the parameters. They don't seem to do anything, though? The menu always open at the mouse position. I would use c4d.MOUSEPOS, as for ShowPopupDialog, but the doc doesn't mention that.

(Using the newest online docs here.)

Thanks for information on these points!

I just answered this on CGSociety, as the thread was started there:

https://forums.cgsociety.org/t/help-with-the-simple-but-advanced-rig-at-the-same-time-with-xpresso-or-python-i-am-talking-about-tank-belts/2058564/12

@bentraje said in Parent Behavior on a "Script" Form:

RE: Switch that off, and my original script works fine.
Yes, I forgot to mention the PSR Constraint.
Unfortunately, I can't switch it off as it is a part of the rig (i.e. space switching feature).

I didn't mean "switch it off forever" but "switch it off to see what I mean" ;-)

I also tried the following:

1. Turn Off PSR Constraint
2. Execute Script. Works as expected
3. Turn On PSR Constraint. And the object is thrown again out of position.

Yes, because you still have changed your parent and you still take the parent's child as constraint. The moment you switch the constraint on again, you apply the transformation a second time, this time indirectly through the constraint (or rather, the constraint's target's parent).

RE: transformed twice.
Here's what I added at the end of the script

child.SetMg(overall_mat)
doc.ExecutePasses(None, True, True,True,c4d.BUILDFLAGS_0) # Applies PSR at script run time 
c4d.EventAdd()
child.SetMg(overall_mat) # Reapply Matrix basically bypass/negating the double transform

Yes... if you apply the PSR tag first, by using ExecutePasses, SetMg will take that change to the parent into account already, which cancels out the double transformation. (You don't need the first line btw, setting the child's matrix once will do.)

In the context of a script, this is okay to do. Personally, I find it a bit convoluted but I don't feel like digging for another solution.

Wdythink? I'm feeling I'm missing something out.

No, it's okay for what it does. I'd have to spend a few hours going through the usecase to fully understand the mirroring process with active constraints, so, just go ahead with your current approach.

RE: I don't know what you want to achieve
I'm creating a script that can mirror/flip a pose.

Ah. Don't the built-in mirror functions suffice? I thought there were some (but I don't animate so often so maybe I'm just mistaken).

@bentraje The script is fine (the original one I gave you). You do not need all the parent Mgs that you inserted because GetMg() is already giving you the global matrix, which includes the object's own local matrix as well as all the parent matrices.

Your problem is something completely different: You have a PSR constraint on the child's parent. Switch that off, and my original script works fine.

The reason is: (think about it first, as exercise, then return here...)

1. The script changes COG_con
2. Then it transfers the matrix to the child wrist_IK_L_con
3. Everything is fine so far
4. Now EventAdd() will re-evaluate the scene
5. Especially the PSR constraint
6. Which happens to refer to an object (wrist_IK_L_con_grp_COG_con_space_switch) that is a child of the "parent"
7. And you just changed the parent.
8. So, ultimately you have applied the parent's matrix to the child, and then AGAIN through the PSR constraint which naturally affects the child too. What you get is that the child is now transformed twice.

TL;DR the logic in your scene cannot work. I don't know what you want to achieve here so I can't advise any further.

That the current code doesn't work is obvious (after you change the "parent", you do not retrieve its matrix again so the change is not reflected in the matrix you apply to the "child").

That the code doesn't work either when you change the parent first is due to the matrices that you multiply. overall_mat contains parent_wrd_mat which is the parent's world matrix. It also contains child_offset_mat which contains the parent's inverted world matrix. Multiplying a matrix with its own inverse results in the unity matrix which amounts to no transformation at all.

So essentially you have multiplied away the parent's contribution to the overall_mat.

What you need to do is to make the explicit transformation "in the middle":

import c4d
from c4d import gui

def main():
    parent      = doc.SearchObject("parent")
    child       = doc.SearchObject("child")
    
    transformToParentSystem = ~parent.GetMg()

    # Rotating the Parent
    parent[c4d.ID_BASEOBJECT_REL_ROTATION,c4d.VECTOR_X] += c4d.utils.DegToRad(45.0)
    parent[c4d.ID_BASEOBJECT_REL_POSITION,c4d.VECTOR_X] += 123
    parent[c4d.ID_BASEOBJECT_REL_POSITION,c4d.VECTOR_Y] += -10
    parent[c4d.ID_BASEOBJECT_REL_POSITION,c4d.VECTOR_Z] += 2

    transformFromParentSystem = parent.GetMg()
    
    overall_mat = transformFromParentSystem * transformToParentSystem * child.GetMg()

    child.SetMg(overall_mat)
    c4d.EventAdd()

if __name__=='__main__':
    main()

Here, you first remember the transformation into the parent system in transformToParentSystem. Then you can make the desired transformation to the parent object. Then you remember the transformation out of the parent system in transformFromParentSystem. These two remembered matrices are now not the inverse of each other, as you have changed the parent in between!

Now, the overall matrix for the child is composed from: its own matrix, which is then transformed into the parent's system (before the change), which is then transformed out of the parent's system (after the change).

@m_adam okay, good that it's found... I guess I can go with the code above for now that excludes tags explicitly and gathers them in a different recursion.

As per the original issue (there is no function in the API that returns the currently visible tracks in timeline n), I guess I would need to make a requirement/suggestion on Maxon's site? Or is something like this planned already?

@m_adam aww, sorry I should apply for a job at Maxon, then I could comb through (edit: fleece doesn't seem to be right phrase) the source code myself

I take away the points:

• Sounds as if this was an unknown error, so I suppose S22 does not have a fix for it.
• While I didn't try anything else but layers, I gather that these functions cannot be used for any GeListHead/GeListNode combination, whatever the actual child class. Can't exempt an object from the garbage collector after all...
• As the document has inserting functions for most classes I use in this context, skipping the access to the GeListHeads in most cases, the issue is limited to layers AFAICS.
• I can use the GeListNode's InsertUnder() function to connect a node into a GeListHead. Meanwhile, I tested this method, and it looks as if InsertUnder actually recognizes the GeListHead as such, and breaks (this time correctly) the Up link of the node. So this is a workable workaround.

(Regarding the other issue with GetBranchInfo, I had added some posts to that thread (it's really the Tags structure that is affected), just if you have missed it.)

@PluginStudent Sadly, InsertLast also crashes in Python.

@zipit Yes, that was the reason I inserted the IsAlive tests... if you run the first code, you will see that the first IsAlive after the InsertFirst fails. The interesting thing is: After creating the layer object, it indeed is alive.

So, the call to InsertFirst() does not only fail, it breaks the layer object that gets passed, and ruins the whole layer list. That's a bug I'm not too excited about.

The alternative code

    root = doc.GetLayerObjectRoot()
    layer.InsertUnder(root)

does indeed work. However, since GetLayerObjectRoot() returns a GeListHead which comes with its own set of insertion functions, I do not know how stable this will be in the long term (see also the previous discussion on GeListHead in some other thread).

Personally I could live with this workaround, but the code is supposed to serve as example for Python learners, so I would prefer to use the intended functions of the proper class instead of replacements from some parent class.

I hate going back to the layers topic so soon again, but there seems to be something wrong with doc.GetLayerObjectRoot().InsertFirst(layer). After executing this function, layer is no longer alive; the layer list in the layer manager is destroyed, and C4D will crash if you try to access the layers through Python after that - in any form, even with a simple print.

Try executing this function:

def createLayerSelected():
    layer = c4d.documents.LayerObject()
    if not layer.IsAlive():
        print "Layer not created"
        return
    if layer == None: return
    doc.GetLayerObjectRoot().InsertFirst(layer)
    if not layer.IsAlive():
        print "Layer not alive after insertion"
        return
    layer[c4d.ID_BASELIST_NAME] = "New Layer"
    layer[c4d.ID_LAYER_COLOR] = c4d.Vector(
                random.randint(0,256)/256.0,
                random.randint(0,256)/256.0,
                random.randint(0,256)/256.0)
    layer[c4d.ID_LAYER_SOLO] = False
    layer[c4d.ID_LAYER_VIEW] = True
    layer[c4d.ID_LAYER_RENDER] = True
    layer[c4d.ID_LAYER_MANAGER] = True
    layer[c4d.ID_LAYER_ANIMATION] = True
    layer[c4d.ID_LAYER_GENERATORS] = True
    layer[c4d.ID_LAYER_DEFORMERS] = True
    layer[c4d.ID_LAYER_EXPRESSIONS] = True
    layer[c4d.ID_LAYER_LOCKED] = False
    layer[c4d.ID_LAYER_XREF] = True
    if not layer.IsAlive():
        print "Layer not alive after attribute setting"
        return
    doc.AddUndo(c4d.UNDOTYPE_NEW, layer)
    if not layer.IsAlive():
        print "Layer not alive after AddUndo"
        return
    # change the layer for all selected objects
    for currentObject in walkSelectedObjects():
        doc.AddUndo(c4d.UNDOTYPE_CHANGE_SMALL, currentObject)
        currentObject.SetLayerObject(layer)

The attribute setting etc pp actually does not matter, as the attempt to insert the new layer causes the trouble already (while the function returns properly, the damage is already done to the layer list).

Compare with the following version, which does not attempt to insert into the GeListHead but uses a different function to insert before the first existing layer:

def createLayerSelected2():
    layer = c4d.documents.LayerObject()
    if not layer.IsAlive():
        print "Layer not created"
        return
    if layer == None: return
    insLayer = doc.GetLayerObjectRoot().GetFirst()
    layer.InsertBefore(insLayer)
    if not layer.IsAlive():
        print "Layer not alive after insertion"
        return
    layer[c4d.ID_BASELIST_NAME] = "New Layer"
    layer[c4d.ID_LAYER_COLOR] = c4d.Vector(
                random.randint(0,256)/256.0,
                random.randint(0,256)/256.0,
                random.randint(0,256)/256.0)
    layer[c4d.ID_LAYER_SOLO] = False
    layer[c4d.ID_LAYER_VIEW] = True
    layer[c4d.ID_LAYER_RENDER] = True
    layer[c4d.ID_LAYER_MANAGER] = True
    layer[c4d.ID_LAYER_ANIMATION] = True
    layer[c4d.ID_LAYER_GENERATORS] = True
    layer[c4d.ID_LAYER_DEFORMERS] = True
    layer[c4d.ID_LAYER_EXPRESSIONS] = True
    layer[c4d.ID_LAYER_LOCKED] = False
    layer[c4d.ID_LAYER_XREF] = True
    if not layer.IsAlive():
        print "Layer not alive after attribute setting"
        return
    doc.AddUndo(c4d.UNDOTYPE_NEW, layer)
    if not layer.IsAlive():
        print "Layer not alive after AddUndo"
        return
    # change the layer for all selected objects
    for currentObject in walkSelectedObjects():
        doc.AddUndo(c4d.UNDOTYPE_CHANGE_SMALL, currentObject)
        currentObject.SetLayerObject(layer)

Naturally, this will only work when there is a layer already in the doc's layer list, which makes it unusable as a workaround. (I didn't bother with a None test here.) But the function works fine, creates the layer, inserts the layer, assigns the layer to the selected objects (sorry, walkSelectedObjects is missing as a function here, replace with GetActiveObjects), sets undos properly, and does not encounter errors.
(Yes, I know that this functionality is identical with the built-in function "New Layer from Object Selection".)

My conclusion is that doc.GetLayerObjectRoot().InsertFirst(layer) is doing some ugly stuff. I have not tried to use InsertFirst on any other GeListHeads beyond layers yet, maybe that would yield the same crashes.

You multiply all the points with the desired transformation matrix.
For the tangents, you need to bring them into the transformation center before multiplying, and afterwards you bring them back to the point (note: the new position of the point).

In short:

import c4d
from c4d import gui

def main():
    pointCount = op.GetPointCount()
    mat = c4d.utils.MatrixRotX(c4d.utils.DegToRad(45.0))
    for i in range(0,pointCount):
        point = op.GetPoint(i) #Point Vector
        tangent = op.GetTangent(i)
        vl = tangent['vl'] #Left Tangent Vector
        vr = tangent['vr'] #Right Tangent Vector
        print point
        
        vl = (vl - point) * mat
        vr = (vr - point) * mat
        point = point * mat
        vl = vl + point
        vr = vr + point
        op.SetTangent(i, vl, vr)
        op.SetPoint(i,point)
    op.Message (c4d.MSG_UPDATE)
    c4d.EventAdd()

if __name__=='__main__':
    main()

(I removed all tests for object type etc so call this only on a proper bezier curve!)

Here, I define the transformation matrix as rotation around X by 45 degrees.
Then I go through the points (your code) and do the transformation for the point and its tangents as mentioned.

The challenge may be to assemble the transformation matrix if you want a different rotation axis than X, Y, or Z... but you didn't mention what axis, so I stay with X

Learn more about Python on C4D:
https://www.patreon.com/cairyn
(Matrix transformations haven't been handled yet but will follow soon...)

Note that c4d.utils contains the most matrix building functions:
c4d.utils.MatrixRotX(w)
c4d.utils.MatrixRotY(w)
c4d.utils.MatrixRotZ(w)
c4d.utils.MatrixToRotAxis(m)
c4d.utils.RotAxisToMatrix(v, w)

etc.

https://developers.maxon.net/docs/Cinema4DPythonSDK/html/modules/c4d.utils/index.html

There is a long chapter on matrix operations in the docs:
https://developers.maxon.net/docs/Cinema4DPythonSDK/html/manuals/data_algorithms/classic_api/matrix.html?highlight=rotation
Build a matrix (for the correct reference system, center, and rotation axis) and multiply it with the points in question.

Note: If you are using Bezier splines, there are tangents. These also need to be transformed, but keep in mind that tangents are vectors starting at the point, not at the object center.