Thank you Manuel! :)

I appreciate it!

Andre

Hi Manuel,

Apologies for this, as due to current circumstances I'm inundated in solving other issues.
Can we revisit this please?

Thank you in advance and apologies!

Andre

Hi @r_gigante,

Thanks for letting me know!

Andre

Hi @m_magalhaes,

Apologies! Pyblish is called from a script inside Cinema and the script above runs after Pyblish opening and going through each stage.

Hope this helps!

Cheers!

Andre

Hi all,

Our studio added an awesome publishing plugin to our pipeline called Pyblish and I'm currently developing sense checks to work with it.

One of the requests is to extract a .aec file, ready to be imported to After Effects.
Unfortunately, when extracting the objects transformations values Cinema crashes and looking at the bug report it shows the following. Let me know if you need full report, please.
CRITICAL: Stop: Current take is nullptr document data could be corrupted [takemanager.cpp(505)]

To understand what I've done here's the latest full code:
This is working in the Pyblish context and I understand if there are a few parts that may not easy to understand without knowing the tool.

I commented on the lines which I think are causing the crashing.

"""
Extract .aec file into a server path
"""

import os
import pyblish.api as api
import c4d
from c4d import utils

DOC = c4d.documents.GetActiveDocument()
DOC_NAME = DOC.GetDocumentName().split('.')[0]
DOC_PATH = DOC.GetDocumentPath()


def aec_file(data):
    full_doc_name = DOC.GetDocumentName()

    doc_name = os.path.splitext(full_doc_name)
    abs_path = DOC.GetDocumentPath()
    file_path = '{0}/05_Animations/04_AE'.format(os.path.dirname(os.path.dirname(abs_path)))

    if os.path.exists(file_path):

        txt_file_path = os.path.join(file_path, 'AEC', '{}.aec'.format(doc_name[0]))
        with open(txt_file_path, 'w') as txt_file:

            for line in data:
                txt_file.write(''.join(line))

    return file_path


class ExtractAEC(api.InstancePlugin):
    """
    Extract .aec file into server path
    """

    order = api.ExtractorOrder
    families = ["animation.assets"]
    label = "AEC"

    def process(self, instance):

        if instance.data["name"] == "Cameras":

            # Start data file
            global extract_data
            extract_data = ['CINEMA 4D COMPOSITION\n\n']
            bp_render = DOC.GetFirstRenderData()

            root_layer = DOC.GetLayerObjectRoot()
            global layer
            layer = c4d.documents.LayerObject()
            layer.SetName('Temp_Layer')
            layer.InsertUnder(root_layer)

            cam_lst = [cam[0] for cam in instance.data["cameras"]]

            #  We create a layer and solo the object under it to improve performance.
            layer_data = layer.GetLayerData(DOC)
            layer_data['solo'] = True
            layer.SetLayerData(DOC, layer_data)
            DOC.ChangeNBit(c4d.NBIT_SOLO_LAYER, c4d.NBITCONTROL_SET)

            res_x = bp_render[c4d.RDATA_XRES_VIRTUAL]
            res_y = bp_render[c4d.RDATA_YRES_VIRTUAL]

            extract_data.extend(['RESOLUTION {0} {1}\n'.format(int(res_x), int(res_y))])

            # Time frames
            global full_start_frame
            full_start_frame = cam_lst[0][c4d.ID_USERDATA, 3]
            global full_end_frame
            full_end_frame = cam_lst[-1][c4d.ID_USERDATA, 4]
            time_range = full_end_frame + 1
            global fps
            fps = bp_render[c4d.RDATA_FRAMERATE]

            if bp_render[c4d.RDATA_FIELD] == 0:
                field = 'NONE'

            elif bp_render[c4d.RDATA_FIELD] == 1:
                field = 'EVEN'

            else:
                field = 'ODD'

            aspect = bp_render[c4d.RDATA_PIXELASPECT]

            extract_data.extend(['FROM {0}\n'
                                 'TO {1}\n'
                                 'RANGE {2}\n'
                                 'FPS {3}\n'
                                 'FIELDS {4}\n'
                                 'ASPECT {5}\n'
                                 'VERSION 7\n\n'.format(full_start_frame,
                                                        full_end_frame,
                                                        time_range,
                                                        fps,
                                                        field,
                                                        aspect)])

            # Composition
            extract_data.extend(['COMPOSITION NRM ON "{0}"\n'
                                 '{1}\n'
                                 '\tSTEREONUM -1\n'
                                 '{2}\n\n'.format(DOC_NAME, '{', '}')])

            # Cameras
            for cam in cam_lst:

                cam_layer = cam.GetLayerObject(DOC)
                cam.SetLayerObject(layer)

                start_frame = cam[c4d.ID_USERDATA, 3]
                end_frame = cam[c4d.ID_USERDATA, 4]
                focal = utils.RadToDeg(cam[c4d.CAMERAOBJECT_FOV])

                extract_data.extend(['CAMERA "{0}"\n'
                                     '{1}\n'
                                     '\tSHOWFROM {2}\n'
                                     '\tSHOWTO {3}\n'.format(cam.GetName().split(' ')[0],
                                                             '{',
                                                             start_frame,
                                                             end_frame)])

                for key in range(start_frame, end_frame + 1):

                    # Is this correct?
                    DOC.SetTime(c4d.BaseTime(key, float(fps)))
                    DOC.ExecutePasses(None, True, False, False, 0)
                    c4d.EventAdd(c4d.EVENT_ANIMATE)

                    pos = cam.GetAbsPos()
                    rot = cam.GetAbsRot()

                    # This is where it usually crashes. Not sure if anything to do with converting Radians to Degrees.
                    extract_data.extend(['\tKEY {0} '
                                         '{1:.3f} {2:.3f} {3:.3f} '
                                         '{4:.3f} {5:.3f} {6:.3f} '
                                         '{7} 100 0\n'.format(key,
                                                              pos.x, pos.y, pos.z,
                                                              utils.RadToDeg(rot.x),
                                                              utils.RadToDeg(rot.y),
                                                              utils.RadToDeg(rot.z),
                                                              focal)])

                cam.SetLayerObject(cam_layer)
                extract_data.extend('}\n\n')

        # Trackers
        if instance.data["name"] == "External Comp Tags":
            trackers = instance.data["compTags"]

            for tracker in trackers:

                tracker_layer = tracker.GetLayerObject(DOC)
                tracker.SetLayerObject(layer)

                extract_data.extend(['NULL2 "{0}"\n'
                                     '{1}\n'
                                     '\tNULLTYPE 1\n'
                                     '\tSIZEX 100\n'
                                     '\tSIZEY 100\n'
                                     '\tANCHOR 3\n'
                                     '\tORIENTATION 1\n'
                                     '\tCOLOR 1 0 0\n'
                                     '\tSHOWFROM {2}\n'
                                     '\tSHOWTO {3}\n'.format(tracker.GetName(),
                                                             '{',
                                                             full_start_frame,
                                                             full_end_frame)])

                for key in range(full_start_frame, full_end_frame + 1):

                    # Is this correct?
                    DOC.SetTime(c4d.BaseTime(key, float(fps)))
                    DOC.ExecutePasses(None, True, True, True, 0)
                    c4d.EventAdd(c4d.EVENT_ANIMATE)

                    pos = tracker.GetMg().off
                    rot_xyz = c4d.utils.MatrixToHPB(tracker.GetMg(), c4d.ROTATIONORDER_XYZGLOBAL)
                    rot_hpb = c4d.utils.MatrixToHPB(tracker.GetMg(), c4d.ROTATIONORDER_HPB)

                    # # This is where it usually crashes. Not sure if anything to do with converting Radians to Degrees.
                    extract_data.extend(['\tKEY {0} '
                                         '{1:.3f} {2:.3f} {3:.3f} '
                                         '{4:.3f} {5:.3f} {6:.3f} '
                                         '{7:.3f} {8:.3f} {9:.3f}\n'.format(key,
                                                                            pos.x, pos.y, pos.z,
                                                                            utils.RadToDeg(rot_xyz.x),
                                                                            utils.RadToDeg(rot_xyz.y),
                                                                            utils.RadToDeg(rot_xyz.z),
                                                                            utils.RadToDeg(rot_hpb.x),
                                                                            utils.RadToDeg(rot_hpb.y),
                                                                            utils.RadToDeg(rot_hpb.z))])

                tracker.SetLayerObject(tracker_layer)
                extract_data.extend('}\n\n')

            # Markers
            first_marker = c4d.documents.GetFirstMarker(DOC)
            markers = []

            # If a marker exists add it to the markers list
            if first_marker is not None:
                while first_marker is not None:
                    markers.append(first_marker)
                    first_marker = first_marker.GetNext()

            for marker in markers:
                extract_data.extend(['MARKER  "{0}" {1}\n'.format(marker.GetName(),
                                                                  marker[c4d.TLMARKER_TIME].GetFrame(24))])

            DOC.ChangeNBit(c4d.NBIT_SOLO_LAYER, c4d.NBITCONTROL_CLEAR)
            layer.Remove()

            path_file = aec_file(extract_data)

            self.log.info("AEC extracted to {}".format(path_file))

If there is other solutions for exporting a .aec file with python I would like to know as well, please!

Let me know if you need more information!

Thank you all in advance!

Andre

Hi @r_gigante,

Any luck with this? It's no rush at all for us, just curious if you have an update

Cheers!

Andre

Also as an update!
I've been talking with a couple of artists here and after a few simple tests using the Delete Duplicate Materials in Cinema R19 and R21, does not work as well.

Is this a common issue?

Thanks!

Hi @r_gigante

I must be really stupid here, but can't have the result you are saying with this function.
A simple test of having 2 supposedly duplicate materials and still returns False.

import c4d

def main():

    mat_lst = doc.GetMaterials()
    result = mat_lst[0].Compare(mat_lst[1])
    print(result)

if __name__ == '__main__':
    main()

I must be missing something very obvious and I can't figure it out.

Thanks for your help!

Hi @r_gigante,

Thank you very much for pointing stuff out!

first reading your initial question: was hard to understand what you meant with regard to "duplicated" materials and how you were defining the equality among twos. Standing on the solution you presented, basically two materials are identical only and only if the values of all their parameters are equal

Apologies for this! Should have been more specific with my description.

second the get_data function expects two arguments, whilst, in your code, only one is given to both calls in the main.

This has now been updated! Thanks for pointing it out.

Finally, as pointed out by @PluginStudent, BaseMaterial::Compare() actually does exactly what you're trying to achieve, and any material implementing MaterialData can be checked via this method belonging to the BaseMaterial class to which they inherit from (independently from the rendering engine they belong and assuming they following up with the best practice of storing data in BaseContainers)
The Compare actually does:

• compares BaseChannels
• compares BaseContainers
• compares Ckeys found in CCurves belonging to CTrack.

Only when these three checks give all positive results, the two materials are considered identical

Great! Thank you for your explanation! Did not know if that would be the case since my tests were not coming with the results. So will give it another go!

Thanks again!

Hi all,

So I after a bit of tinkering and based on what @Cairyn explained, this is the outcome.
Please do let me know if I can improve on something.

My only doubt is regarding the PyCObject types and what to do with it. In the code below I'm just ignoring it as I can't do anything with it anyway in a Python data context (I think!) and it doesn't seem to create any unusal cases when comparing the materials values.

import c4d


def get_data(data, lst):
    """
    Get the parameters from the materials container and return a list.
    """

    for i in range(len(data) - 1):
        index = data.GetIndexId(i)
        try:
            if isinstance(data[index], (c4d.BaseShader, c4d.BaseTime)):
                sub_data = data[index].GetDataInstance()
                get_data(sub_data, lst)
            else:
                if type(data[index]).__name__ == 'PyCObject':
                    continue
                lst.append(data[index])
        except AttributeError:
            continue

    return lst


def compare_data(lst_a, lst_b):
    """
    Compare the data between lists a and b. If data is the same, than material is a duplicate.
    """

    zipped = zip(lst_a, lst_b)

    for params in zipped:
        if params[0] != params[1]:
            return False

    return True

def main():

    mat_lst = doc.GetMaterials()
    duplicate_materials = []

    for a, mat_a in enumerate(mat_lst):
        data_a = get_data(mat_a, [])

        for b, mat_b in enumerate(mat_lst):
            if a != b:

                data_b = get_data(mat_b, [])
                data_difference = compare_data(data_a, data_b)

                if data_difference:
                    duplicate_materials.append(mat_b)


    assert not duplicate_materials, "You have {0} materials duplicated! " \
                                    "See list below:\n\n{1}".format(len(duplicate_materials),
                                                                    ", ".join(mat.GetName() for mat in duplicate_materials))
                                                                    
if __name__ == '__main__':

    main() 

Hope this helps anyone else!

Cheers!