Posts made by Futurium

Hi,
I'm working on a code to copy take overrides from one scene to another. One script captures details from each take in my reference scene and saves them as a JSON file. Another script loads the JSON and compares all takes to identify differences in names, hierarchy, applied materials, transforms, visibility, etc.

I want the script to both print the differences between the captured JSON data and the current scene and automatically apply the take-specific changes. I assume the take hierarchy, scene objects, and materials are identical (which I verify elsewhere).

I can capture many details but struggle to compare takes with the JSON data and restore them correctly. I also suspect my code is unnecessarily long and complex for such a simple task. Could you review both my capture and restore scripts and help me get them working efficiently?

I've attached my test scenes and scripts.
Thank you in advance.

Best regards,
Tomasz

#GrabReferenceSnapshot.py
import c4d
import collections
import maxon
from c4d import utils
import json
import os

def create_snapshot(doc, filepath):
    def return_full_path_per_object(op, parent_mesh_object_name=""):
        if not op:
            return ""
        
        path_parts = []
        current = op
        
        # Build path from current object up to root
        while current:
            name = current.GetName()
            if name == parent_mesh_object_name:
                break
            path_parts.insert(0, name)
            current = current.GetUp()
        
        # Join path parts with forward slashes
        return "/".join(path_parts)
    
    def serialize_descid(desc_id):
        """Converts a c4d.DescID to a serializable format."""
        return [desc_id[i].id for i in range(desc_id.GetDepth())]

    try:
        # Ensure the main take is active
        take_data = doc.GetTakeData()
        if take_data is None:
            raise RuntimeError("No take data in the document.")
        main_take = take_data.GetMainTake()
        take_data.SetCurrentTake(main_take)
        
        # Initialize the snapshot dictionary
        snapshot = {
            'takes': {}
        }
        
        # Get takes information
        take_data = doc.GetTakeData()
        if take_data:
            main_take = take_data.GetMainTake()
            
            def process_take_changes(take):
                """Gets the overrides for a specific take."""
                if take == main_take:
                    return {"name": take.GetName(), "overrides": []}  # Skip overrides for main take
                
                take_data.SetCurrentTake(take)
                doc = c4d.documents.GetActiveDocument()
                doc.ExecutePasses(None, True, True, True, c4d.BUILDFLAGS_0)
                
                take_changes = {
                    "name": take.GetName(),
                    "overrides": []
                }
                
                # Get only the overrides for this take
                override_data = take.GetOverrides()
                if override_data:
                    for override in override_data:
                        override_obj = override.GetSceneNode()
                        if not override_obj:
                            continue
                            
                        # Log the object being processed
                        print(f"Processing override for object: {override_obj.GetName()}")
                        
                        # Use the material name as a unique identifier
                        material_name = override_obj.GetName() if isinstance(override_obj, c4d.BaseMaterial) else None
                        
                        overridden_params = override.GetAllOverrideDescID()
                        for desc_id in overridden_params:
                            description = override_obj.GetDescription(c4d.DESCFLAGS_DESC_NONE)
                            if description:
                                parameter_container = description.GetParameter(desc_id, None)
                                if parameter_container:
                                    param_name = parameter_container[c4d.DESC_NAME]
                                    value = override.GetParameter(desc_id, c4d.DESCFLAGS_GET_0)
                                    
                                    # Use return_full_path_per_object to get the object path
                                    print (f"in take{take.GetName()} checking object path for {override_obj.GetName()}")
                                    object_path = return_full_path_per_object(override_obj, "")
                                    if "/" in object_path:
                                        print (f"object_path: {object_path}")
                                    
                                    take_changes["overrides"].append({
                                        "object_name": override_obj.GetName(),
                                        "object_path": object_path,
                                        "parameter": param_name,
                                        "parameter_id": serialize_descid(desc_id),
                                        "value": str(value) if not isinstance(value, (int, float, bool, str)) else value,
                                        "material_name": material_name  # Add material name for comparison
                                    })
                                    
                                    print(f"Captured override: {param_name} = {value} for object {object_path}")
                
                return take_changes

            def process_take(take):
                if not take:
                    return
                
                # Store only serializable data
                take_info = {
                    'name': take.GetName(),
                    'parent': take.GetUp().GetName() if take.GetUp() else None,
                    'changes': process_take_changes(take)  # Capture take changes
                }
                
                # Store in snapshot using take name as key
                snapshot['takes'][take.GetName()] = take_info
                
                # Process child takes
                child = take.GetDown()
                while child:
                    process_take(child)
                    child = child.GetNext()
            
            process_take(main_take)
        
        # Save the snapshot to JSON file
        try:
            # Create all necessary directories
            os.makedirs(os.path.dirname(filepath), exist_ok=True)
            
            # Save the file
            with open(filepath, 'w', encoding='utf-8') as f:
                json.dump(snapshot, f, indent=4)
                
            return True
            
        except Exception as e:
            print(f"Error saving snapshot file: {str(e)}")
            return False
        
    except Exception as e:
        print(f"Error creating snapshot: {str(e)}")
        return False

def main():
    doc = c4d.documents.GetActiveDocument()
    
    # Get both the document name and path
    doc_name = doc.GetDocumentName()
    doc_path = doc.GetDocumentPath()
    
    full_path = os.path.join(doc_path, doc_name)
    print("full_path: " + str(full_path))
    
    project_folder = os.path.dirname(full_path)
    print("project_folder : " + str(project_folder))
    
    project_name = os.path.basename(project_folder)
    print("project_name : " + str(project_name))

    # Construct final path
    final_path = os.path.join(project_folder, "snapshots", project_name + "_final.json")
    
    print("\nPath verification:")
    print(f"Final snapshot path: {final_path}")
    
    print("\nAttempting to create final snapshot...")
    try:
        result = create_snapshot(doc, final_path)
        print(f"create_snapshot call completed. Result: {result}")
    except Exception as e:
        print(f"Error in create_snapshot: {str(e)}")
        import traceback
        print(f"Traceback:\n{traceback.format_exc()}")

if __name__ == "__main__":
    c4d.CallCommand(13957) # Clear Console
    main()

#RestoreSnapshot
import c4d
import collections
import maxon
from c4d import utils
import os
import c4d
import json

def return_full_path_per_object(op, parent_mesh_object_name=""):
    if not op:
        return ""
    
    path_parts = []
    current = op
    
    # Build path from current object up to root
    while current:
        name = current.GetName()
        if name == parent_mesh_object_name:
            break
        path_parts.insert(0, name)
        current = current.GetUp()
    
    # Join path parts with forward slashes
    return "/".join(path_parts)

def serialize_descid(desc_id):
    """Converts a c4d.DescID to a serializable format."""
    return [desc_id[i].id for i in range(desc_id.GetDepth())]

def check_takes(doc, snapshot):
    
    try:
        print("\nPerforming takes check...")
        
        take_data = doc.GetTakeData()
        if take_data is None:
            raise RuntimeError("No take data in the document.")
            
        main_take = take_data.GetMainTake()
        snapshot_takes = snapshot.get('takes', {})
        
        def get_take_overrides(take):
            """Gets the overrides for a specific take."""
            if take == main_take:
                return []  # Skip overrides for main take
            
            # Activate the take before checking its overrides
            take_data.SetCurrentTake(take)
            doc.ExecutePasses(None, True, True, True, c4d.BUILDFLAGS_0)
            
            override_data = take.GetOverrides()
            overrides = []
            
            if override_data:
                for override in override_data:
                    override_obj = override.GetSceneNode()
                    if not override_obj:
                        continue
                        
                    overridden_params = override.GetAllOverrideDescID()
                    for desc_id in overridden_params:
                        description = override_obj.GetDescription(c4d.DESCFLAGS_DESC_NONE)
                        if description:
                            parameter_container = description.GetParameter(desc_id, None)
                            if parameter_container:
                                param_name = parameter_container[c4d.DESC_NAME]
                                value = override.GetParameter(desc_id, c4d.DESCFLAGS_GET_0)
                                
                                # Get object path using the helper function
                                object_path = return_full_path_per_object(override_obj)
                                
                                # Use the material name or another unique identifier
                                material_name = override_obj.GetName() if isinstance(override_obj, c4d.BaseMaterial) else None
                                
                                overrides.append({
                                    "object_name": override_obj.GetName(),
                                    "object_path": object_path,
                                    "parameter": param_name,
                                    "parameter_id": str(desc_id),  # Convert DescID to string for comparison
                                    "value": str(value) if not isinstance(value, (int, float, bool, str)) else value,
                                    "material_name": material_name  # Add material name for comparison
                                })
            
            return overrides
        
        def compare_takes(current_take, snapshot_take_data):
            # Debugging: Print snapshot_take_data to verify its structure
            print(f"Snapshot data for take '{current_take.GetName()}': {snapshot_take_data}")

            # Ensure 'overrides' key exists in snapshot_take_data
            if 'overrides' not in snapshot_take_data:
                print(f"Error: 'overrides' key not found in snapshot data for take '{current_take.GetName()}'")
                return False

            # Initialize current_overrides with the current scene's override data
            current_overrides = []  # Ensure this is defined before use

            # Retrieve the current overrides for the take
            override_data = current_take.GetOverrides()
            if override_data:
                for override in override_data:
                    override_obj = override.GetSceneNode()
                    if not override_obj:
                        continue

                    # Use the material name as a unique identifier
                    material_name = override_obj.GetName() if isinstance(override_obj, c4d.BaseMaterial) else None

                    overridden_params = override.GetAllOverrideDescID()
                    for desc_id in overridden_params:
                        description = override_obj.GetDescription(c4d.DESCFLAGS_DESC_NONE)
                        if description:
                            parameter_container = description.GetParameter(desc_id, None)
                            if parameter_container:
                                param_name = parameter_container[c4d.DESC_NAME]
                                value = override.GetParameter(desc_id, c4d.DESCFLAGS_GET_0)

                                # Use return_full_path_per_object to get the object path
                                object_path = return_full_path_per_object(override_obj, "")

                                current_overrides.append({
                                    "object_name": override_obj.GetName(),
                                    "object_path": object_path,
                                    "parameter": param_name,
                                    "parameter_id": serialize_descid(desc_id),
                                    "value": str(value) if not isinstance(value, (int, float, bool, str)) else value,
                                    "material_name": material_name  # Add material name for comparison
                                })

            # Now compare current_overrides with snapshot_take_data['overrides']
            snapshot_overrides = snapshot_take_data['overrides']

            for curr_override, snap_override in zip(current_overrides, snapshot_overrides):
                # Compare using material names if available
                if curr_override.get('material_name') != snap_override.get('material_name'):
                    print(f"  Material name mismatch in take '{current_take.GetName()}':")
                    print(f"  Expected: {snap_override.get('material_name')}")
                    print(f"  Found: {curr_override.get('material_name')}")
                    return False

                # Compare other attributes
                if (curr_override['object_path'] != snap_override['object_path'] or
                    curr_override['parameter'] != snap_override['parameter'] or
                    curr_override['value'] != snap_override['value']):
                    print(f"  Override mismatch in take '{current_take.GetName()}':")
                    print(f"  Object: {curr_override['object_path']}")
                    print(f"  Parameter: {curr_override['parameter']}")
                    print(f"  Expected: {snap_override['value']}")
                    print(f"  Found: {curr_override['value']}")
                    return False

            return True
        
        # Start comparison with main take
        all_match = True
        
        def process_take(take):
            nonlocal all_match
            if not take:
                return
            
            take_name = take.GetName()
            if take_name not in snapshot_takes:
                print(f"\nTake not found in snapshot: {take_name}")
                all_match = False
                return
            
            # Compare current take with snapshot
            if not compare_takes(take, snapshot_takes[take_name]):
                all_match = False
            
            # Process child takes
            child = take.GetDown()
            while child:
                process_take(child)
                child = child.GetNext()
        
        try:
            # Start with main take
            process_take(main_take)
            
            # Restore main take at the end
            take_data.SetCurrentTake(main_take)
            doc.ExecutePasses(None, True, True, True, c4d.BUILDFLAGS_0)
            
            if all_match:
                print("\nAll takes match.")
            else:
                print("\nTakes check failed.")
            
            return all_match
            
        except Exception as e:
            print(f"Error during take comparison: {str(e)}")
            # Ensure main take is restored even if an error occurs
            take_data.SetCurrentTake(main_take)
            doc.ExecutePasses(None, True, True, True, c4d.BUILDFLAGS_0)
            return False
        
    except Exception as e:
        print(f"Error checking takes: {str(e)}")
        return False

def restore_snapshot(doc, snapshot_path, loose_comparison=False):

    try:
        print("Loading snapshot file...")
        # Load the snapshot file
        with open(snapshot_path, 'r', encoding='utf-8') as f:
            snapshot = json.load(f)
        
        # Ensure the main take is active
        take_data = doc.GetTakeData()
        if take_data is None:
            raise RuntimeError("No take data in the document.")
        main_take = take_data.GetMainTake()
        take_data.SetCurrentTake(main_take)
                
        # Check takes
        if not check_takes(doc, snapshot):
            return False
        
        print("Snapshot restoration check completed successfully.")
        return True
        
    except Exception as e:
        print(f"Error checking snapshot: {str(e)}")
        return False


def main():
    doc = c4d.documents.GetActiveDocument()
    
    # Get both the document name and path
    doc_name = doc.GetDocumentName()
    doc_path = doc.GetDocumentPath()
    
    full_path = os.path.join(doc_path, doc_name)
    print("full_path: " + str(full_path))
    
    project_folder = os.path.dirname(full_path)
    print("project_folder : " + str(project_folder))
    
    project_name = os.path.basename(project_folder)
    print("project_name : " + str(project_name))

    # Construct path to the snapshot we want to restore
    snapshot_path = os.path.join(project_folder, "snapshots", project_name + "_final.json")
    
    print("\nPath verification:")
    print(f"Snapshot path to restore: {snapshot_path}")
    
    # Verify the snapshot file exists
    if not os.path.exists(snapshot_path):
        print(f"Error: Snapshot file not found at {snapshot_path}")
        return
    
    print("\nAttempting to restore snapshot...")
    try:
        result = restore_snapshot(doc, snapshot_path)
        print(f"restore_snapshot call completed. Result: {result}")
    except Exception as e:
        print(f"Error in restore_snapshot: {str(e)}")
        import traceback
        print(f"Traceback:\n{traceback.format_exc()}")

if __name__ == "__main__":
    c4d.CallCommand(13957) # Clear Console
    main()

Scenes for testing:
SimpleScene4Reference.c4d
SimpleScene4Restore.c4d

Hi,
I have a simple scene with a few takes, each using a different material, and two baking sets. I’m trying to write a script that travels through the takes, accesses the corresponding baking set, bakes the textures for each take, and then moves to the next one. While I’ve written some initial code, I couldn’t find any documentation or examples specific to Redshift to help me make it work.

Could you please review my attached code and sample scene? If possible, could you provide a code snippet demonstrating how to implement this functionality?

I also have a couple of related questions:

1. Is there a way to increase baked texture brightness without altering light intensity or modifying the materials? I’d like to match the renders , where I manipulate brightness using f-Stop on Redshift camera. I understand that exposure manipulation may not work during baking, but any suggestions would be helpful.
2. All my AOVs are set up in Redshift render settings. Can they be used during the baking process?
3. When baking textures, Redshift materials using standard bluish normal maps result in green normals. Is there a way to resolve this issue?

Thank you for your assistance. I’ve attached my initial code and a sample scene for your reference.

Best regards,
Tomasz

MatBaker_SImplified.c4d

import c4d
import re

list_of_takes = []
cat_2_baker = {"RS BakeSet_WallTiles":"003","RS BakeSet_FeatureWalls":"002"}

def get_all_takes_recursively(take, takeData):
    while take:
        if "_BakeMat_" in take.GetName():
            list_of_takes.append(take)
            #print(f"Added {take.GetName()}")
        get_all_takes_recursively(take.GetDown(), takeData)
        take = take.GetNext()

def node_2_bakerset(take_name):
    match = re.search(r"_BakeMat_(\d{3})", take_name)
    if match:
        code = match.group(1)
        result = next((key for key, value in cat_2_baker.items() if value == code), None)
        return result
    else:
        return None

def bake_textures(take, bakingset_2_use):
    print (f"Baking mat {take.GetName()} using {bakingset_2_use} set")

def main():

    doc = c4d.documents.GetActiveDocument()
    if not doc:
        return

    # Get take data
    take_data = doc.GetTakeData()
    if not take_data:
        print("No take data in document")

    get_all_takes_recursively(take_data.GetMainTake(), take_data)

    for take in list_of_takes:
        #print(take.GetName())
        node_2_use = node_2_bakerset(take.GetName())
        bake_textures(take, node_2_use)

    # Create parent take for material previews
    c4d.EventAdd()

if __name__ == '__main__':
    c4d.CallCommand(13957)  # Clear Console
    main()

Hi @i_mazlov ,
Thank you for confirming my solution.
Best regards,
Tomasz

Hi @mogh,
Thank you for your suggestion. Currently, I've developed a method where I replace a spherical camera view with a standard camera, capture what's visible, and rotate until I've covered the entire area. This approach meets my goals, although I'm still assessing its efficiency. Your idea of rendering the image and selecting from it sounds like another option and might be a good alternative.

Thank you @i_mazlov

It works perfectly

Best regards,
Tomasz

Hi @i_mazlov ,

I'm writing to follow up on my previous message about the issue with 360 cameras in my code as I haven't heard back. Could you please provide any updates or further guidance?

Best regards,
Tomasz

Hi,

I want to calculate the safe frame value for all takes, where each take has a different camera and possibly different render settings. If I manually change a take and run my code, it returns the same safe frame for all other takes as for the currently selected one, which is incorrect in my case. It seems the values used for safe frame calculations are not being updated when I iterate through takes via code. What am I missing? I've attached a simple test scene to test the code.

Best regards,
Tomasz

import c4d

def grab_children_of_main_take(take_data):
    children = []
    mainTake = take_data.GetMainTake()
    take = mainTake.GetDown()

    while take is not None:
        children.append(take)
        take = take.GetNext()

    return children

def get_safe_frame_for_the_current_per_take(doc):
    bd = doc.GetRenderBaseDraw()
    safeframe = bd.GetSafeFrame()
    print(safeframe)


def main():
    c4d.CallCommand(13957)  # Clear Console
    doc = c4d.documents.GetActiveDocument()
    take_data = doc.GetTakeData()
    if take_data is None:
        raise RuntimeError("Failed to retrieve the take data.")

    children_of_main_take = grab_children_of_main_take(take_data)
    print("Returned : " + str(len(children_of_main_take)) + " children of main take")

    for child_take in children_of_main_take:
        take_data.SetCurrentTake(child_take)
        doc.ExecutePasses(bt=None, animation=True, expressions=True, caches=True, flags=c4d.BUILDFLAGS_NONE)
        current_camera = child_take.GetCamera(take_data)
        print("\n--------------------------------------------------")
        print(f"Checking take {child_take.GetName()} with camera {current_camera.GetName()}")
        get_safe_frame_for_the_current_per_take(doc)

if __name__ == '__main__':
    c4d.CallCommand(13957)  # Clear Console
    main()

SafeFrameWithTakes.c4d

Hello @ferdinand

Thank you for your guidance. I'll follow your suggestion and reach out to the support team for assistance with my query.

Best regards,
Tomasz

Hi,
One solution we offer our customers requires several thousand takes for each set of renders. Each take only needs 30 seconds for rendering, but the preparation phase, which involves processing geometry with Redshift, is much longer. On average, we use one camera for every 500 takes, and the only changes between takes are material swapping and toggling some geometry's visibility. I've developed a Python script that logs changes to takes and creates an animation frame for each, significantly speeding up the rendering process when rendering as an animation compared to individual takes. Is there a way to achieve this increased rendering speed with takes without converting them into animation frames? Do you have any other suggestions for enhancing render speed?

Best regards,
Tomasz

Hi Ilia,

Thank you for guiding me in the right direction. I've revised my code following your advice, and it's working well with standard cameras. However, it's having difficulty with 360 cameras. The code successfully identifies larger objects but struggles to detect smaller ones, even after I increased the accuracy (step=1, radius=1). Do you have any suggestions?

Best regards,
Tomasz

Hi,

I'm looking for a Python solution that can return lists of all objects visible by a camera, including both standard and Redshift Spherical cameras, and within Safe Frames. I want to include all objects, even those partially visible. I've tried using ViewportSelect (code and test scene attached) and GeCollider, but I'm not getting the results I expected, and the code runs slowly. Could you provide some suggestions and a code snippet as a starting point?
Also - for testing purposes - for the attached scene and cameras, I expect a list of specific objects (below), not all objects currently returned by my script.
Expected results:
EnSuite_Flooring_24_Reset
Bed2_Flooring_14_Reset
Landing_Flooring_30_Reset
Bed4_Flooring_18_Reset
Bed4_Flooring_18_Reset
Upstairs1_Flooring_26_Reset
Collider

Best regards,
Tomasz

import c4d
doc = c4d.documents.GetActiveDocument()
bd = doc.GetActiveBaseDraw()
frame = bd.GetFrame()

def get_flooring_objects():
    flooring_objects = []
    doc = c4d.documents.GetActiveDocument()
    helper_node = doc.SearchObject("Helpers")
    helper_categories = helper_node.GetChildren()
    for helper_cat in helper_categories:
        if helper_cat.GetName() == "_Flooring":
            flooring_objects = helper_cat.GetChildren()

    return flooring_objects

left = frame["cl"]
right = frame["cr"]
top = frame["ct"]
bottom = frame["cb"]
# Calculates the width and height of the screen
width = right - left + 1
height = bottom - top + 1

print ("width : {}, height : {}".format(width, height))

# Creates a new ViewportSelect
vpSelect = c4d.utils.ViewportSelect()
# Initialise the ViewportSelect with a list of object

ops = get_flooring_objects()
vpSelect.Init(width, height, bd, ops, c4d.Mpolyedgepoint, True, c4d.VIEWPORTSELECTFLAGS_IGNORE_HIDDEN_SEL)

our_list = []

c4d.CallCommand(13957)  # Clear Console

for w in range(width):
    for h in range(height):
        elements = vpSelect.PickObject(bd, doc, w,h, 1, c4d.VIEWPORT_PICK_FLAGS_OGL_IGNORE_Z)
        our_list.extend(elements)

name_list = []
for el in our_list:
    name_list.append(el.GetName())

unique_list = sorted(set(name_list))
for name in unique_list:
    print ("Unique name: {}".format(name))

Scene for testing : https://we.tl/t-FLqG7LPcNu

Dear Ilia,

I greatly appreciate your assistance; it was precisely what I needed. Thank you for your guidance and I wish you a wonderful day.

Best regards,
Tomasz

Hi,

I am looking for assistance in automating a specific process in Cinema 4D using Python. My current manual method involves navigating to the Mode in the Attributes Panel, selecting Modelling and Mesh checking, and then opting for Check Mesh. Following this, I choose Boundary Edges and subsequently use the 'Edge to Spline' feature, which effectively transforms these edges into a spline.

This manual method serves its purpose well; however, my goal is to streamline this process through automation. I would greatly appreciate any guidance or suggestions on how to achieve this via a Python script. Automating this task would significantly enhance efficiency in my workflow.

Thank you for your time.

Best regards,

Tomasz

That's exactly what I was looking for. Thank you, Ferdinand

Hello Ferdinand,
I'm writing to revisit the issue previously discussed. Is there now Python support for this particular issue? Currently, I have a set of template materials in the Asset Browser. I have been loading them manually as required, which is manageable but not the most efficient method. It would be great if I could grab them directly from a script, preferably by their names. If name-based referencing isn't feasible, could I use their asset IDs instead?

If this functionality is already in place, would you be able to share some code snippets? It would be greatly appreciated. Just for your reference, I'm currently using R26.107.
Best regards,
Tomasz

Thank you, Ferdinand.

It looks like the only part I missed in my code was that extra line

doc.ExecutePasses(bt=None, animation=True, expressions=True, caches=True, flags=c4d.BUILDFLAGS_NONE)

After updating the code on my side - everything seems to be working fine.
Thank you again.
Best regards,
Tomasz

Hi,
I spent some time yesterday trying to develop a Python script, which travels through takes, grabbing camera position (which is changed every time by aligning to spline tag), creating a null object and copying camera Matrix to null. The part I'm struggling with is grabbing the camera position. I either got the original camera position, before it's been modified by aligning to spline property or value 0.
Below is my code and also attached scene, which I've been using for tests.
Am I missing something obvious?

import c4d
from c4d import documents

list_of_takes = []
parent_name = "360_cams"

def GetCategory(doc):
    takeData = doc.GetTakeData()
    if takeData is None:
        return

    mainTake = takeData.GetMainTake()
    take = mainTake.GetDown()

    while take is not None:
        list_of_takes.append((take))
        take = take.GetNext()

def CreateParentObject4360CamExport(doc):
    cam_export_parent = doc.SearchObject(parent_name)
    if cam_export_parent is not None:
        cam_export_parent.Remove()

    c4d.CallCommand(5140)  # Null
    cam_export_parent = doc.SearchObject("Null");
    c4d.CallCommand(1019940)  # Reset PSR
    if cam_export_parent != None:
        cam_export_parent.SetName(parent_name)

    return cam_export_parent

def CreateCopyOfTheCamera(currentCam,currentTake, doc,take_data):
    c4d.CallCommand(5103) # Camera
    camTemp = doc.SearchObject("Camera")
    c4d.CallCommand(1019940)  # Reset PSR
    if camTemp != None:
        camTemp.SetName(currentTake.GetName())


    print("current cam : "+ currentCam.GetName() + " and position " + str(currentCam.GetMg()))
    camTemp.SetMg(currentCam.GetMg())
    c4d.EventAdd()
    return camTemp

# Main function
def main():
    doc = documents.GetActiveDocument()
    takeData = doc.GetTakeData()
    if takeData is None:
        raise RuntimeError("No take data in the document.")
    cam_export_parent = CreateParentObject4360CamExport(doc)
    main_take = takeData.GetMainTake()
    GetCategory(doc)
    for child_take in list_of_takes:
        takeLoaded = takeData.SetCurrentTake(child_take)
        if takeLoaded == True:
            currentCam = child_take.GetCamera(takeData)
            cam2NullClone = CreateCopyOfTheCamera(currentCam,child_take,doc,takeData)
            cam2NullClone.InsertUnder(cam_export_parent)
            c4d.EventAdd()

# Execute main()
if __name__=='__main__':
    c4d.CallCommand(13957) # Clear Console
    main()

Link to c4d file

Hi Manual,
This is exactly what I needed. Thank you very much.
Best regards,
Tomasz

Hi Manuel,
I've tested your solution and it works like a charm Thank you.
As a next step, I wanted to grab node transforms from takes. I tried with c4d.DescID(c4d.ID_BASEOBJECT_REL_POSITION), but I'm not able to get any data. Below is your code with added two extra lines to get the node position. I also attached a screenshot with details from one of the takes.

Can you please help with the problem?

import c4d
from c4d import gui


# as Takes are BaseList2D, we can use GetNext, GetPred, GetUp, GetDown
def GetNextTake(op):
    if op == None:
        return None
  
    if op.GetDown():
        return op.GetDown()
  
    while not op.GetNext() and op.GetUp():
        op = op.GetUp()
  
    return op.GetNext()


def main():
    takeData = doc.GetTakeData()
    
    visibilityDescID = c4d.DescID ( c4d.ID_BASEOBJECT_VISIBILITY_EDITOR)
    nodePositionAbs  = c4d.DescID ( c4d.ID_BASEOBJECT_REL_POSITION)
    currentTake = takeData.GetMainTake()
    
    while currentTake:
        overrides = currentTake.GetOverrides()
        for override in overrides:
            descIDs = override.GetAllOverrideDescID()
            if visibilityDescID in descIDs:
                print ("take name", currentTake.GetName(), "node found", override.GetName(), "original object", override.GetSceneNode().GetName(), "value",  override[visibilityDescID])
            if nodePositionAbs in descIDs:
                print ("take name", currentTake.GetName(), "node found", override.GetName(), "original object", override.GetSceneNode().GetName(), "position",  override[nodePositionAbs])

                        
        currentTake = GetNextTake(currentTake)
        
        

# Execute main()
if __name__=='__main__':
    main()

Hi Manuel,
Thank you. I'll test it and come back to you if I have any questions.
Best regards,
Tomasz