Export Spline Points CSV

2024-01-23 14:42 UTC gpt-4 Open in ChatGPT ↗

Im using this code to export the points of a spline in Cinema 4d each frame to a csv file. I need everything to be included in one file. All the coordinates, for each point, for each frame.

import c4d import csv import os

def find_export_object(root): # Recursively search for the object named ‘Export’ in the hierarchy if root is not None: if root.GetName() == ‘Export’: return root for child in root.GetChildren(): found_object = find_export_object(child) if found_object is not None: return found_object return None

def export_to_csv(csv_filename, frame, points): try: # Open the CSV file in append mode with open(csv_filename, ‘a’, newline=”) as csvfile: csvwriter = csv.writer(csvfile) # Loop through each point and write its coordinates for index, point in enumerate(points): x = point.x y = point.y z = point.z csvwriter.writerow([frame, index, x, y, z]) print(f’Frame {frame} data appended to {csv_filename}’) except Exception as e: print(f’Error: {e}’)

def get_next_filename(base_path, base_filename): version = 1 while True: new_filename = f”{base_filename}_{version}.csv” full_path = os.path.join(base_path, new_filename) if not os.path.exists(full_path): return full_path version += 1

def main(): # Get the active document doc = c4d.documents.GetActiveDocument() if doc is None: c4d.gui.MessageDialog(“No active document found.”) return

# Find the object named 'Export'
export_object = find_export_object(doc.GetFirstObject())
if export_object is None:
    c4d.gui.MessageDialog("Object named 'Export' not found in the scene.")
    return

# Specify the CSV file directory
base_path = r'C:\Users\Chris\OneDrive\Desktop\Test'
base_filename = 'file'

# Manually set the frames per second (FPS)
fps = 12

# Determine the start and end frames
start_frame = int(doc.GetMinTime().GetFrame(fps))
end_frame = int(doc.GetMaxTime().GetFrame(fps))

for frame in range(start_frame, end_frame + 1):
    doc.SetTime(c4d.BaseTime(frame, fps))
    c4d.EventAdd()

    # Get the deformed state of the object
    deformed_object = c4d.utils.SendModelingCommand(
        command=c4d.MCOMMAND_CURRENTSTATETOOBJECT,
        list=[export_object],
        doc=doc
    )[0]

    if deformed_object is not None:
        # Get the points of the spline
        points = deformed_object.GetAllPoints()

        # Get the next available filename
        csv_filename = get_next_filename(base_path, base_filename)

        # Append the data to the CSV file for this frame
        export_to_csv(csv_filename, frame, points)

        # Delete the temporary object after use
        temp_doc = c4d.documents.BaseDocument()
        temp_doc.InsertObject(deformed_object)
        c4d.documents.KillDocument(temp_doc)

print("Export completed.")

Execute the main function

if name == “main”: main()

Your script is well-structured and performs the task of exporting spline points to a CSV file. However, I noticed that your script creates a new CSV file for every frame, which contradicts your requirement of having all data in one file. To fix this, you should modify the main function so that the CSV filename is determined only once before entering the frame loop, and then use this same file for all frame exports.

Here is the updated code with the necessary modifications:

import c4d
import csv
import os

def find_export_object(root):
    # Existing code remains the same

def export_to_csv(csv_filename, frame, points):
    # Existing code remains the same

def get_next_filename(base_path, base_filename):
    # Existing code remains the same

def main():
    # Existing code remains the same up to specifying the CSV file directory

    # Get the next available filename before the frame loop
    csv_filename = get_next_filename(base_path, base_filename)

    # Determine the start and end frames
    start_frame = int(doc.GetMinTime().GetFrame(fps))
    end_frame = int(doc.GetMaxTime().GetFrame(fps))

    for frame in range(start_frame, end_frame + 1):
        # Existing frame loop code with one modification:
        # Replace the line inside the loop that gets the next filename with the already determined 'csv_filename'

            # Append the data to the CSV file for this frame
            export_to_csv(csv_filename, frame, points)

            # Existing code for deleting the temporary object

    print("Export completed.")

# Existing code for executing the main function

This adjustment ensures that the same CSV file is used for appending data across all frames, resulting in a single file containing all the coordinates for each point for each frame.

The error you’re encountering, IndentationError: expected an indented block, indicates a problem with the indentation in your Python script. Python relies on indentation to define the structure of code blocks, such as functions or loops. The error message suggests that there’s an issue with the indentation after the function definition for find_export_object.

Let’s correct the indentation issue in your script. Here’s the revised version:

import c4d
import csv
import os

def find_export_object(root):
    # Recursively search for the object named 'Export' in the hierarchy
    if root is not None:
        if root.GetName() == 'Export':
            return root
        for child in root.GetChildren():
            found_object = find_export_object(child)
            if found_object is not None:
                return found_object
    return None

def export_to_csv(csv_filename, frame, points):
    try:
        # Open the CSV file in append mode
        with open(csv_filename, 'a', newline='') as csvfile:
            csvwriter = csv.writer(csvfile)
            # Loop through each point and write its coordinates
            for index, point in enumerate(points):
                x = point.x
                y = point.y
                z = point.z
                csvwriter.writerow([frame, index, x, y, z])
        print(f'Frame {frame} data appended to {csv_filename}')
    except Exception as e:
        print(f'Error: {e}')

def get_next_filename(base_path, base_filename):
    version = 1
    while True:
        new_filename = f"{base_filename}_{version}.csv"
        full_path = os.path.join(base_path, new_filename)
        if not os.path.exists(full_path):
            return full_path
        version += 1

def main():
    # Get the active document
    doc = c4d.documents.GetActiveDocument()
    if doc is None:
        c4d.gui.MessageDialog("No active document found.")
        return

    # Find the object named 'Export'
    export_object = find_export_object(doc.GetFirstObject())
    if export_object is None:
        c4d.gui.MessageDialog("Object named 'Export' not found in the scene.")
        return

    # Specify the CSV file directory
    base_path = r'C:\Users\Chris\OneDrive\Desktop\Test'
    base_filename = 'file'

    # Manually set the frames per second (FPS)
    fps = 12

    # Get the next available filename before the frame loop
    csv_filename = get_next_filename(base_path, base_filename)

    # Determine the start and end frames
    start_frame = int(doc.GetMinTime().GetFrame(fps))
    end_frame = int(doc.GetMaxTime().GetFrame(fps))

    for frame in range(start_frame, end_frame + 1):
        doc.SetTime(c4d.BaseTime(frame, fps))
        c4d.EventAdd()

        # Get the deformed state of the object
        deformed_object = c4d.utils.SendModelingCommand(
            command=c4d.MCOMMAND_CURRENTSTATETOOBJECT,
            list=[export_object],
            doc=doc
        )[0]

        if deformed_object is not None:
            # Get the points of the spline
            points = deformed_object.GetAllPoints()

            # Append the data to the CSV file for this frame
            export_to_csv(csv_filename, frame, points)

            # Delete the temporary object after use
            temp_doc = c4d.documents.BaseDocument()
            temp_doc.InsertObject(deformed_object)
            c4d.documents.KillDocument(temp_doc)

    print("Export completed.")

# Execute the main function
if __name__ == "__main__":
    main()

Make sure that each level of indentation in Python is consistent, typically using 4 spaces per indentation level. The error should be resolved with the provided code.

To include column headings in your CSV file, you can modify the export_to_csv function. The modification involves checking if the file is newly created and, if so, writing the column headings before appending the data for each frame.

Here’s the updated export_to_csv function with this change:

def export_to_csv(csv_filename, frame, points):
    try:
        # Open the CSV file in append mode
        with open(csv_filename, 'a', newline='') as csvfile:
            csvwriter = csv.writer(csvfile)

            # Check if the file is newly created and write the column headings
            if os.stat(csv_filename).st_size == 0:
                csvwriter.writerow(['Frame', 'Point Index', 'X', 'Y', 'Z'])

            # Loop through each point and write its coordinates
            for index, point in enumerate(points):
                x = point.x
                y = point.y
                z = point.z
                csvwriter.writerow([frame, index, x, y, z])
        print(f'Frame {frame} data appended to {csv_filename}')
    except Exception as e:
        print(f'Error: {e}')

This function now checks if the file size is zero (i.e., it’s a new file) and writes the headings ['Frame', 'Point Index', 'X', 'Y', 'Z'] before appending the data. The rest of the script remains the same.

Ensure that this function replaces the existing export_to_csv function in your script. This way, the first time data is written to the CSV file, it will start with these column headings, followed by the data for each frame.

Sure, I’ll integrate the updated export_to_csv function with the column headings into your previous code. Here’s the revised script:

import c4d
import csv
import os

def find_export_object(root):
    # Recursively search for the object named 'Export' in the hierarchy
    if root is not None:
        if root.GetName() == 'Export':
            return root
        for child in root.GetChildren():
            found_object = find_export_object(child)
            if found_object is not None:
                return found_object
    return None

def export_to_csv(csv_filename, frame, points):
    try:
        # Open the CSV file in append mode
        with open(csv_filename, 'a', newline='') as csvfile:
            csvwriter = csv.writer(csvfile)

            # Check if the file is newly created and write the column headings
            if os.stat(csv_filename).st_size == 0:
                csvwriter.writerow(['Frame', 'Point Index', 'X', 'Y', 'Z'])

            # Loop through each point and write its coordinates
            for index, point in enumerate(points):
                x = point.x
                y = point.y
                z = point.z
                csvwriter.writerow([frame, index, x, y, z])
        print(f'Frame {frame} data appended to {csv_filename}')
    except Exception as e:
        print(f'Error: {e}')

def get_next_filename(base_path, base_filename):
    version = 1
    while True:
        new_filename = f"{base_filename}_{version}.csv"
        full_path = os.path.join(base_path, new_filename)
        if not os.path.exists(full_path):
            return full_path
        version += 1

def main():
    # Get the active document
    doc = c4d.documents.GetActiveDocument()
    if doc is None:
        c4d.gui.MessageDialog("No active document found.")
        return

    # Find the object named 'Export'
    export_object = find_export_object(doc.GetFirstObject())
    if export_object is None:
        c4d.gui.MessageDialog("Object named 'Export' not found in the scene.")
        return

    # Specify the CSV file directory
    base_path = r'C:\Users\Chris\OneDrive\Desktop\Test'
    base_filename = 'file'

    # Manually set the frames per second (FPS)
    fps = 12

    # Get the next available filename before the frame loop
    csv_filename = get_next_filename(base_path, base_filename)

    # Determine the start and end frames
    start_frame = int(doc.GetMinTime().GetFrame(fps))
    end_frame = int(doc.GetMaxTime().GetFrame(fps))

    for frame in range(start_frame, end_frame + 1):
        doc.SetTime(c4d.BaseTime(frame, fps))
        c4d.EventAdd()

        # Get the deformed state of the object
        deformed_object = c4d.utils.SendModelingCommand(
            command=c4d.MCOMMAND_CURRENTSTATETOOBJECT,
            list=[export_object],
            doc=doc
        )[0]

        if deformed_object is not None:
            # Get the points of the spline
            points = deformed_object.GetAllPoints()

            # Append the data to the CSV file for this frame
            export_to_csv(csv_filename, frame, points)

            # Delete the temporary object after use
            temp_doc = c4d.documents.BaseDocument()
            temp_doc.InsertObject(deformed_object)
            c4d.documents.KillDocument(temp_doc)

    print("Export completed.")

# Execute the main function
if __name__ == "__main__":
    main()

This script now includes the updated export_to_csv function that adds column headings to the CSV file the first time it writes data. This will ensure that each CSV file generated starts with the headings ‘Frame’, ‘Point Index’, ‘X’, ‘Y’, ‘Z’, followed by the corresponding data for each frame.

Sure, I can modify the export_to_csv function so that it only writes the coordinates (X, Y, Z) of each point to the CSV file, without including the frame number and point index. Here’s your updated script with these changes:

import c4d
import csv
import os

def find_export_object(root):
    # Recursively search for the object named 'Export' in the hierarchy
    if root is not None:
        if root.GetName() == 'Export':
            return root
        for child in root.GetChildren():
            found_object = find_export_object(child)
            if found_object is not None:
                return found_object
    return None

def export_to_csv(csv_filename, points):
    try:
        # Open the CSV file in append mode
        with open(csv_filename, 'a', newline='') as csvfile:
            csvwriter = csv.writer(csvfile)

            # Check if the file is newly created and write the column headings
            if os.stat(csv_filename).st_size == 0:
                csvwriter.writerow(['X', 'Y', 'Z'])

            # Loop through each point and write its coordinates
            for point in points:
                x = point.x
                y = point.y
                z = point.z
                csvwriter.writerow([x, y, z])
        print(f'Data appended to {csv_filename}')
    except Exception as e:
        print(f'Error: {e}')

def get_next_filename(base_path, base_filename):
    version = 1
    while True:
        new_filename = f"{base_filename}_{version}.csv"
        full_path = os.path.join(base_path, new_filename)
        if not os.path.exists(full_path):
            return full_path
        version += 1

def main():
    # Get the active document
    doc = c4d.documents.GetActiveDocument()
    if doc is None:
        c4d.gui.MessageDialog("No active document found.")
        return

    # Find the object named 'Export'
    export_object = find_export_object(doc.GetFirstObject())
    if export_object is None:
        c4d.gui.MessageDialog("Object named 'Export' not found in the scene.")
        return

    # Specify the CSV file directory
    base_path = r'C:\Users\Chris\OneDrive\Desktop\Test'
    base_filename = 'file'

    # Manually set the frames per second (FPS)
    fps = 12

    # Get the next available filename before the frame loop
    csv_filename = get_next_filename(base_path, base_filename)

    # Determine the start and end frames
    start_frame = int(doc.GetMinTime().GetFrame(fps))
    end_frame = int(doc.GetMaxTime().GetFrame(fps))

    for frame in range(start_frame, end_frame + 1):
        doc.SetTime(c4d.BaseTime(frame, fps))
        c4d.EventAdd()

        # Get the deformed state of the object
        deformed_object = c4d.utils.SendModelingCommand(
            command=c4d.MCOMMAND_CURRENTSTATETOOBJECT,
            list=[export_object],
            doc=doc
        )[0]

        if deformed_object is not None:
            # Get the points of the spline
            points = deformed_object.GetAllPoints()

            # Append the data to the CSV file for this frame
            export_to_csv(csv_filename, points)

            # Delete the temporary object after use
            temp_doc = c4d.documents.BaseDocument()
            temp_doc.InsertObject(deformed_object)
            c4d.documents.KillDocument(temp_doc)

    print("Export completed.")

# Execute the main function
if __name__ == "__main__":
    main()

This version of the script will only save the X, Y, and Z coordinates of each point to the CSV file, and it won’t include the frame number or point index. The column headings will be ‘X’, ‘Y’, ‘Z’ only.

Certainly! I’ll remove the column headings from the export_to_csv function. Here’s the updated script:

import c4d
import csv
import os

def find_export_object(root):
    # Recursively search for the object named 'Export' in the hierarchy
    if root is not None:
        if root.GetName() == 'Export':
            return root
        for child in root.GetChildren():
            found_object = find_export_object(child)
            if found_object is not None:
                return found_object
    return None

def export_to_csv(csv_filename, points):
    try:
        # Open the CSV file in append mode
        with open(csv_filename, 'a', newline='') as csvfile:
            csvwriter = csv.writer(csvfile)

            # Loop through each point and write its coordinates
            for point in points:
                x = point.x
                y = point.y
                z = point.z
                csvwriter.writerow([x, y, z])
        print(f'Data appended to {csv_filename}')
    except Exception as e:
        print(f'Error: {e}')

def get_next_filename(base_path, base_filename):
    version = 1
    while True:
        new_filename = f"{base_filename}_{version}.csv"
        full_path = os.path.join(base_path, new_filename)
        if not os.path.exists(full_path):
            return full_path
        version += 1

def main():
    # Get the active document
    doc = c4d.documents.GetActiveDocument()
    if doc is None:
        c4d.gui.MessageDialog("No active document found.")
        return

    # Find the object named 'Export'
    export_object = find_export_object(doc.GetFirstObject())
    if export_object is None:
        c4d.gui.MessageDialog("Object named 'Export' not found in the scene.")
        return

    # Specify the CSV file directory
    base_path = r'C:\Users\Chris\OneDrive\Desktop\Test'
    base_filename = 'file'

    # Manually set the frames per second (FPS)
    fps = 12

    # Get the next available filename before the frame loop
    csv_filename = get_next_filename(base_path, base_filename)

    # Determine the start and end frames
    start_frame = int(doc.GetMinTime().GetFrame(fps))
    end_frame = int(doc.GetMaxTime().GetFrame(fps))

    for frame in range(start_frame, end_frame + 1):
        doc.SetTime(c4d.BaseTime(frame, fps))
        c4d.EventAdd()

        # Get the deformed state of the object
        deformed_object = c4d.utils.SendModelingCommand(
            command=c4d.MCOMMAND_CURRENTSTATETOOBJECT,
            list=[export_object],
            doc=doc
        )[0]

        if deformed_object is not None:
            # Get the points of the spline
            points = deformed_object.GetAllPoints()

            # Append the data to the CSV file for this frame
            export_to_csv(csv_filename, points)

            # Delete the temporary object after use
            temp_doc = c4d.documents.BaseDocument()
            temp_doc.InsertObject(deformed_object)
            c4d.documents.KillDocument(temp_doc)

    print("Export completed.")

# Execute the main function
if __name__ == "__main__":
    main()

With this version of the script, the CSV file will directly start with the coordinates data for each point, without any column headings.

To modify the script so that it only runs for a single frame, you can adjust the frame range in the main function. If you want to specify a particular frame to export the data for, you can set both start_frame and end_frame to that frame number. Here’s the updated script to run for only one frame:

import c4d
import csv
import os

def find_export_object(root):
    # Existing function code

def export_to_csv(csv_filename, points):
    # Existing function code

def get_next_filename(base_path, base_filename):
    # Existing function code

def main():
    # Get the active document
    doc = c4d.documents.GetActiveDocument()
    if doc is None:
        c4d.gui.MessageDialog("No active document found.")
        return

    # Find the object named 'Export'
    export_object = find_export_object(doc.GetFirstObject())
    if export_object is None:
        c4d.gui.MessageDialog("Object named 'Export' not found in the scene.")
        return

    # Specify the CSV file directory
    base_path = r'C:\Users\Chris\OneDrive\Desktop\Test'
    base_filename = 'file'

    # Manually set the frames per second (FPS)
    fps = 12

    # Set the specific frame you want to export
    specific_frame = 10  # Change this to the frame number you want to export

    # Set both start and end frames to the specific frame
    start_frame = specific_frame
    end_frame = specific_frame

    for frame in range(start_frame, end_frame + 1):
        doc.SetTime(c4d.BaseTime(frame, fps))
        c4d.EventAdd()

        # Existing code for processing the frame

    print("Export completed.")

# Existing code to execute the main function

In this script, you should replace specific_frame = 10 with the frame number you wish to export. This will set both start_frame and end_frame to this specific frame, causing the script to run for that frame only.

The IndentationError indicates that the Python interpreter expects an indented block after the def find_export_object(root): function definition, but it’s not finding one. This usually occurs when there’s a mismatch in indentation levels or missing code. Let’s correct the indentation in your script:

Here’s the corrected script:

import c4d
import csv
import os

def find_export_object(root):
    # Recursively search for the object named 'Export' in the hierarchy
    if root is not None:
        if root.GetName() == 'Export':
            return root
        for child in root.GetChildren():
            found_object = find_export_object(child)
            if found_object is not None:
                return found_object
    return None

def export_to_csv(csv_filename, points):
    try:
        # Open the CSV file in append mode
        with open(csv_filename, 'a', newline='') as csvfile:
            csvwriter = csv.writer(csvfile)

            # Loop through each point and write its coordinates
            for point in points:
                x = point.x
                y = point.y
                z = point.z
                csvwriter.writerow([x, y, z])
        print(f'Data appended to {csv_filename}')
    except Exception as e:
        print(f'Error: {e}')

def get_next_filename(base_path, base_filename):
    # Your existing code here...

def main():
    # Your existing code here...

# Execute the main function
if __name__ == "__main__":
    main()

Please make sure that all the function definitions and their respective contents are properly indented. In Python, it’s crucial to maintain consistent indentation, typically with 4 spaces for each level of indentation. The corrected script should resolve the indentation error.

It seems the IndentationError is still present, likely due to a missing or incorrect indentation in the get_next_filename function. Let’s correct this by ensuring proper indentation for the entire script. Each function and the code inside it should be consistently indented.

Here’s the corrected script:

import c4d
import csv
import os

def find_export_object(root):
    # Recursively search for the object named 'Export' in the hierarchy
    if root is not None:
        if root.GetName() == 'Export':
            return root
        for child in root.GetChildren():
            found_object = find_export_object(child)
            if found_object is not None:
                return found_object
    return None

def export_to_csv(csv_filename, points):
    try:
        # Open the CSV file in append mode
        with open(csv_filename, 'a', newline='') as csvfile:
            csvwriter = csv.writer(csvfile)

            # Loop through each point and write its coordinates
            for point in points:
                x = point.x
                y = point.y
                z = point.z
                csvwriter.writerow([x, y, z])
        print(f'Data appended to {csv_filename}')
    except Exception as e:
        print(f'Error: {e}')

def get_next_filename(base_path, base_filename):
    version = 1
    while True:
        new_filename = f"{base_filename}_{version}.csv"
        full_path = os.path.join(base_path, new_filename)
        if not os.path.exists(full_path):
            return full_path
        version += 1

def main():
    # Get the active document
    doc = c4d.documents.GetActiveDocument()
    if doc is None:
        c4d.gui.MessageDialog("No active document found.")
        return

    # Find the object named 'Export'
    export_object = find_export_object(doc.GetFirstObject())
    if export_object is None:
        c4d.gui.MessageDialog("Object named 'Export' not found in the scene.")
        return

    # Specify the CSV file directory
    base_path = r'C:\Users\Chris\OneDrive\Desktop\Test'
    base_filename = 'file'

    # Manually set the frames per second (FPS)
    fps = 12

    # Get the next available filename before the frame loop
    csv_filename = get_next_filename(base_path, base_filename)

    # Determine the start and end frames
    start_frame = int(doc.GetMinTime().GetFrame(fps))
    end_frame = int(doc.GetMaxTime().GetFrame(fps))

    for frame in range(start_frame, end_frame + 1):
        doc.SetTime(c4d.BaseTime(frame, fps))
        c4d.EventAdd()

        # Get the deformed state of the object
        deformed_object = c4d.utils.SendModelingCommand(
            command=c4d.MCOMMAND_CURRENTSTATETOOBJECT,
            list=[export_object],
            doc=doc
        )[0]

        if deformed_object is not None:
            # Get the points of the spline
            points = deformed_object.GetAllPoints()

            # Append the data to the CSV file for this frame
            export_to_csv(csv_filename, points)

            # Delete the temporary object after use
            temp_doc = c4d.documents.BaseDocument()
            temp_doc.InsertObject(deformed_object)
            c4d.documents.KillDocument(temp_doc)

    print("Export completed.")

# Execute the main function
if __name__ == "__main__":
    main()

Please ensure this corrected script replaces your previous one. Python is sensitive to indentation, and it’s crucial that each block of code (like the contents of a function) is indented consistently. This script should now be free of indentation errors.

If your script is reporting that it cannot find the object named “Export” even though it exists in your Cinema 4D scene, there are a few potential issues to consider:

Case Sensitivity: Python is case-sensitive. Ensure that the name of the object in your Cinema 4D scene exactly matches ‘Export’ in terms of case. For instance, ‘export’, ‘EXPORT’, or ‘Export’ are all different from Python’s perspective.
Scene Structure: Ensure that the object named ‘Export’ is actually in the scene and not inside a collapsed object or in a state where it might not be detected by the script.
Object Type: Make sure that the object named ‘Export’ is the correct type of object that your script is designed to work with (e.g., a spline).

To diagnose the issue, you might want to add some diagnostic print statements to your find_export_object function. This can help you understand whether the function is searching through all objects in your scene as expected.

Here’s a modified version of your find_export_object function with added print statements:

def find_export_object(root):
    print("Searching in:", root.GetName() if root else "None")  # Diagnostic print
    if root is not None:
        if root.GetName() == 'Export':
            print("Found 'Export'")  # Diagnostic print
            return root
        for child in root.GetChildren():
            print("Checking child:", child.GetName())  # Diagnostic print
            found_object = find_export_object(child)
            if found_object is not None:
                return found_object
    return None

These additional print statements will output the names of the objects being checked, which can help you determine if the script is searching through the correct part of the scene. Once you identify the issue, you can remove these diagnostic prints.

Remember to run this modified script in your Cinema 4D environment where the scene is loaded, and observe the console output for any clues as to why the ‘Export’ object is not being found.

Sure, I will incorporate the modified find_export_object function with diagnostic print statements into your existing script. Here’s the updated version:

import c4d
import csv
import os

def find_export_object(root):
    print("Searching in:", root.GetName() if root else "None")  # Diagnostic print
    if root is not None:
        if root.GetName() == 'Export':
            print("Found 'Export'")  # Diagnostic print
            return root
        for child in root.GetChildren():
            print("Checking child:", child.GetName())  # Diagnostic print
            found_object = find_export_object(child)
            if found_object is not None:
                return found_object
    return None

def export_to_csv(csv_filename, points):
    # Existing function code

def get_next_filename(base_path, base_filename):
    # Existing function code

def main():
    # Existing function code

# Existing code to execute the main function

This updated script includes the diagnostic print statements in the find_export_object function. These statements will help you trace how the function navigates through the objects in your Cinema 4D scene, and they will confirm when the script finds an object named “Export”.

Run this script in your Cinema 4D environment, and observe the console output. It should provide more insight into why the ‘Export’ object might not be getting detected, allowing you to troubleshoot more effectively.