@m_magalhaes

This morning: uff more learning and work.
This Afternoon lets try this code ... mind blown ... thank you !

I'll mark this as solved hence I think ist a good way to close a thread with a working prototype for others to learn.

Thank You again, @zipit & @m_magalhaes
mogh

No stupid me,
overlocked this ... thanks for the hint Frank.

Dear Developers,

I found this handy builtin

https://developers.maxon.net/docs/Cinema4DPythonSDK/html/modules/c4d/Matrix/index.html#Matrix.eq

but It always reports false. What am I missing?
thanks in advance.

parent = obj.GetUp()
print (parent.GetMg())
print (obj.GetMg())
print ( obj.GetMg().__eq__(parent.GetMg()) )

Matrix(v1: (1, 0, 0); v2: (0, 1, 0); v3: (0, 0, 1); off: (-33.9, -49.3, 152.75))
Matrix(v1: (1, 0, 0); v2: (0, 1, 0); v3: (0, 0, 1); off: (-33.9, -49.3, 152.75))
False

Dear Developers,

I have a python script which saves the unsaved (untiteled) active document to a *_imported.c4d file which works fine, but Cinema still has the original "Untiteled" Filename active how can I activate the successfully saved file in Cinema 4D and discard the "untiteled"

thanks in advance.

here is my save method:

    def savedoc(self, doc):
        c4d.StatusSetText ('Saving Document.')

        path = self.folderpath
        if doc.GetDocumentPath():
            path = doc.GetDocumentPath()

        name = doc.GetDocumentName()    
        # an unsaved doc has no extension we have to check
        if name[-4:] == ".c4d":            
            newname = name # the user has his own document we dont change the name
        else:
            newname = name + "_imported.c4d" # the user has no document we give a little context
            
            # c4d does not update to _imported.c4d doc.
            #doc.SetName(newname)            
            #c4d.documents.SetActiveDocument(doc) 
            
        filename = os.path.join(path, newname)
        
        print ("Saving file to: ",  filename)        
        c4d.documents.SaveDocument( doc, filename,                                     c4d.SAVEDOCUMENTFLAGS_DONTADDTORECENTLIST | c4d.SAVEDOCUMENTFLAGS_DIALOGSALLOWED, format=c4d.FORMAT_C4DEXPORT)

Seems to work ... fingers crossed...

you managed to implement the normal tag handling faster ! my script that cleans up CAD data went down from 60 seconds to 25 seconds !!!!

        11153152 function calls in 25.692 seconds

   Ordered by: cumulative time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.547    0.547   25.692   25.692 03 optimize Objects.py:354(main)
      889    1.696    0.002   21.027    0.024 03 optimize Objects.py:205(TransferAxisTo)
      889    0.016    0.000   10.535    0.012 03 optimize Objects.py:159(WriteNormalTag)
      889    0.005    0.000    6.767    0.008 03 optimize Objects.py:127(ReadNormalTag)
      889    6.750    0.008    6.750    0.008 03 optimize Objects.py:154(<listcomp>)
      889    6.137    0.007    6.137    0.007 03 optimize Objects.py:189(<listcomp>)
        1    0.000    0.000    3.051    3.051 03 optimize Objects.py:290(optimizepolyobject)
        1    3.051    3.051    3.051    3.051 {built-in method c4d.utils.SendModelingCommand}
      889    1.763    0.002    2.956    0.003 03 optimize Objects.py:186(<listcomp>)
      889    1.679    0.002    1.679    0.002 03 optimize Objects.py:237(<listcomp>)
      889    1.413    0.002    1.413    0.002 {method 'fromlist' of 'array.array' objects}
 11038804    1.193    0.000    1.193    0.000 {method 'GetNormalized' of 'c4d.Vector' objects}
      889    0.004    0.000    0.813    0.001 03 optimize Objects.py:245(removesinglenull)
      890    0.808    0.001    0.808    0.001 {built-in method c4d.CallCommand}
     1876    0.237    0.000    0.237    0.000 {method 'GetAllPoints' of 'c4d.PointObject' objects}
      889    0.157    0.000    0.157    0.000 03 optimize Objects.py:227(<listcomp>)
     1778    0.082    0.000    0.082    0.000 {method 'AddUndo' of 'c4d.documents.BaseDocument' objects}
     3763    0.006    0.000    0.047    0.000 03 optimize Objects.py:81(statusbar)
     3763    0.028    0.000    0.028    0.000 {built-in method c4d.StatusSetBar}
     8045    0.007    0.000    0.026    0.000 03 optimize Objects.py:38(GetNextObject)
      889    0.017    0.000    0.017    0.000 {method 'SetAllPoints' of 'c4d.PointObject' objects}
       21    0.017    0.001    0.017    0.001 {built-in method c4d.StatusSetText}
        2    0.002    0.001    0.016    0.008 03 optimize Objects.py:61(get_all_poly_objects)
        2    0.001    0.000    0.011    0.005 03 optimize Objects.py:52(get_all_objects)
    13109    0.011    0.000    0.011    0.000 {method 'GetUp' of 'c4d.GeListNode' objects}
      889    0.011    0.000    0.011    0.000 {method 'tobytes' of 'array.array' objects}
      889    0.010    0.000    0.010    0.000 {method 'frombytes' of 'array.array' objects}
    13696    0.008    0.000    0.008    0.000 {method 'GetNext' of 'c4d.GeListNode' objects}
    11327    0.005    0.000    0.005    0.000 {method 'GetDown' of 'c4d.GeListNode' objects}
      994    0.002    0.000    0.004    0.000 03 optimize Objects.py:90(rename)
     1938    0.004    0.000    0.004    0.000 {method 'GetChildren' of 'c4d.GeListNode' objects}
      889    0.004    0.000    0.004    0.000 {method 'Message' of 'c4d.C4DAtom' objects}
        1    0.000    0.000    0.004    0.004 03 optimize Objects.py:71(get_all_null_objects)
        2    0.003    0.002    0.003    0.002 {built-in method c4d.StatusSetSpin}
      889    0.002    0.000    0.002    0.000 {method 'SetMg' of 'c4d.BaseObject' objects}
     8575    0.002    0.000    0.002    0.000 {method 'CheckType' of 'c4d.C4DAtom' objects}
     1778    0.002    0.000    0.002    0.000 {method 'GetMg' of 'c4d.BaseObject' objects}
      889    0.001    0.000    0.001    0.000 {method 'GetTag' of 'c4d.BaseObject' objects}
      889    0.001    0.000    0.001    0.000 {method 'DelBit' of 'c4d.BaseList2D' objects}
     1038    0.001    0.000    0.001    0.000 {method 'Remove' of 'c4d.GeListNode' objects}
     4611    0.001    0.000    0.001    0.000 {built-in method builtins.len}
     3976    0.001    0.000    0.001    0.000 {method 'split' of 'str' objects}
      994    0.001    0.000    0.001    0.000 {method 'SetName' of 'c4d.BaseList2D' objects}
     4550    0.001    0.000    0.001    0.000 {built-in method builtins.isinstance}
      889    0.001    0.000    0.001    0.000 {method 'GetLowlevelDataAddressR' of 'c4d.VariableTag' objects}
      994    0.001    0.000    0.001    0.000 {method 'GetName' of 'c4d.BaseList2D' objects}
      889    0.001    0.000    0.001    0.000 {method 'GetLowlevelDataAddressW' of 'c4d.VariableTag' objects}
      889    0.001    0.000    0.001    0.000 {method 'GetDataCount' of 'c4d.VariableTag' objects}
     6844    0.001    0.000    0.001    0.000 {method 'append' of 'list' objects}
      889    0.000    0.000    0.000    0.000 {method 'SetBit' of 'c4d.BaseList2D' objects}
        8    0.000    0.000    0.000    0.000 {built-in method builtins.print}
       24    0.000    0.000    0.000    0.000 __init__.py:65(write)
        1    0.000    0.000    0.000    0.000 {built-in method c4d.StatusClear}
       24    0.000    0.000    0.000    0.000 __init__.py:46(MAXON_SOURCE_LOCATION)
       24    0.000    0.000    0.000    0.000 {built-in method _maxon_core.GetCurrentTraceback}
      994    0.000    0.000    0.000    0.000 {method 'replace' of 'str' objects}
       24    0.000    0.000    0.000    0.000 {built-in method _maxon_output.stdout_write}
        1    0.000    0.000    0.000    0.000 03 optimize Objects.py:261(savetorun)
        1    0.000    0.000    0.000    0.000 03 optimize Objects.py:31(gime_time)
        1    0.000    0.000    0.000    0.000 {method 'GetFirstObject' of 'c4d.documents.BaseDocument' objects}
        1    0.000    0.000    0.000    0.000 {built-in method c4d.EventAdd}
        1    0.000    0.000    0.000    0.000 {built-in method c4d.documents.GetActiveDocument}
        2    0.000    0.000    0.000    0.000 {built-in method c4d.GeGetTimer}
        2    0.000    0.000    0.000    0.000 {built-in method builtins.divmod}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

as I understand my problem in my thinking was not rotating the orentation seperatly ....

mgOrientationDelta = c4d.Matrix(v1=mgDelta.v1, v2=mgDelta.v2, v3=mgDelta.v3)

Should I / we mark your last code as solution as its working better and is easier to understand ?!?

anyway thank you again and I am sorry to have caused any trouble ...
kind regards ....

Thank you ferdinand for your personal time ...
will check the Code in the office tomorrow ...

kind regards
mogh

Its getting stranger and I am still unclear whats happening ...
I changed the precedence of the

normals = [ (~transform).MulV(n) for n in read_normal_tag(tag) ]

Tested in
R20 - fail -> Normals flip ...
R23 - first test good moving to another parent Null second execution -> Normals flip .. iratic behavior depending on null location ?
R24 - first test good moving to another parent Null second execution ->Normals flip .. iratic behavior depending on null location ?
R25 - first test good moving to another parent Null second execution -> Normals flip .. iratic behavior depending on null location ?

kind regards

Hi again,

@ferdinand sorry to pester you ....

I recorded my outcome and it seems it does not make a difference if the normals are multiplied by the invers object matrix or the object matrix.

c4d_normal_tag_centeraxis.mp4
The lighting in the video should not change if I center the axis to the parent.

...
btw if anybody is curious R20 Version needs besides some .stringformat()

        #data.frombytes(buffer)
        data.fromstring(buffer) # python 2.7

        #data = data.tobytes()
        data = data.tostring() # python 2.7

kind regards

That's strange for me inverting the Matrix (using your posted script) does not fix the nut it flips still !
Why do we have different outcomes ? (R23 atm, R25 in the office not tested yet)

normal_examplev2.c4d

Thanks for the quick answer,

@ferdinand said in CAD Normal Tag flipped after Polyon merge (join) and axis repositioning - how realign?:

I think you have your axis inverted.

This was the first fix I tried, it seems to fix the nut, but not all parts, especially when they are tilted on all axis.
I guess I have to find better examples to get to the bottom of this.

kind regards
mogh

Hi Ferdinand,

sadly i have to resurect this topic hence I still have problem with the normals when the AXIS changes.

I boiled down a script which moves the axis of selected polygon object to the parent (which is a common task in deply nested cad data )

anyway the axis is not a problem but I still have wrong shading because the normals are not transformed corectly ...

I attached a simple exaple file where a nut is orientaded off axis and results in wrong normals when executed the script.

thanks in advance

normal_example.c4d

import c4d, array
#from c4d import Vector as V
#https://plugincafe.maxon.net/topic/13004/cad-normal-tag-flipped-after-polyon-merge-join-and-axis-repositioning-how-realign/6

#new Task:
#Corrects points and normals on a point object after placing the polygon axis to the same as the parent 

def adjust_point_node(node, transform):
    """Corrects points and normals on a point object after running the join
    command in the scenario specific to PC13004.

    Args:
        node (c4d.PointObject): The PointObject to transform.
        transform (c4d.Matrix): The transform to apply.

    Raises:
        TypeError: When either `node` or `transform` are not of expected type.
    """
    def read_normal_tag(tag):
        """`Reads a `c4d.NormalTag` to a list of c4d.Vector.

        Args:
            tag (c4d.NormalTag): The tag to read the normals from.

        Returns:
            list[c4d.Vector]: The red in normals. There are polygon_count * 4 
             normals, i.e. each vertex has a normal for each polygon it is
             attached to. The normals are stored in polygon groups.

        Raises:
            RuntimeError: When the memory of the tag cannot be red.
            TypeError: When `tag` is not a `c4d.NormalTag`.
        """
        if not (isinstance(tag, c4d.BaseTag) and tag.CheckType(c4d.Tnormal)):
            msg = f"Expected normal tag, received: {tag}."
            raise TypeError(tag)

        buffer = tag.GetLowlevelDataAddressR()
        if buffer is None:
            msg = "Failed to retrieve memory buffer for VariableTag."
            raise RuntimeError(msg)

        data = array.array('h')
        data.frombytes(buffer)
        # Convert the int16 representation of the normals to c4d.Vector.
        return [c4d.Vector(data[i-3] / 32000.0,
                           data[i-2] / 32000.0,
                           data[i-1] / 32000.0)
                for i in range(3, len(data) + 3, 3)]

    def write_normal_tag(tag, normals, do_normalize=True):
        """`Writes a list of c4d.Vector to a `c4d.NormalTag`.

        Args:
            tag (c4d.NormalTag): The tag to write the normals to.
            normals (list[c4d.Vector]): The normals to write.
            do_normalize (bool, optional): If to normalize the normals.
             Default to `True`.

        Note:
            Does not ensure that `normals` is only composed of c4d.Vector.

        Raises:
            IndexError: When `normals` does not match the size of `tag`.
            RuntimeError: When the memory of the tag cannot be red.
            TypeError: When `tag` is not a `c4d.NormalTag`.
        """
        if not (isinstance(tag, c4d.BaseTag) and tag.CheckType(c4d.Tnormal)):
            msg = f"Expected normal tag, received: {tag}."
            raise TypeError(tag)

        buffer = tag.GetLowlevelDataAddressW()
        if buffer is None:
            msg = "Failed to retrieve memory buffer for VariableTag."
            raise RuntimeError(msg)

        if do_normalize:
            normals = [n.GetNormalized() for n in normals]

        # Convert c4d.Vector normals to integer representation.
        raw_normals = [int(component * 32000.0)
                       for n in normals for component in (n.x, n.y, n.z)]

        # Catch input data of invalid length.
        count = tag.GetDataCount()
        if count * 12 != len(raw_normals):
            msg = (f"Invalid data size. Expected length of {count}. "
                   f"Received: {len(raw_normals)}")
            raise IndexError(msg)

        # Write the data back.
        data = array.array('h')
        data.fromlist(raw_normals)
        data = data.tobytes()
        buffer[:len(data)] = data

    # --- Start of outer function --------------------------------------------
    if (not isinstance(node, c4d.PointObject) or
            not isinstance(transform, c4d.Matrix)):
        msg = f"Illegal argument types: {type(node)}{type(transform)}"
        raise TypeError(msg)

    # Transform the points of the node.
    #points = [p * ~transform for p in node.GetAllPoints()]
    
    # This works the polygon object stays in place now
    
    mat = op.GetMg()
    points = op.GetAllPoints()
    for i,p in enumerate(points):
        points[i] = ~transform * mat * p #Note that the multiplication sequence needs to be read from the right to the left.
        
    node.SetAllPoints(points)
    node.Message(c4d.MSG_UPDATE)
    
    # these where my desperate efforts to fix it 
    #------------------------------------------------------------------------    
    node.SetMg(transform)
    nodelocalmatrix = node.GetMl()    
    nodematrix = node.GetMg()
    
    # Transform its baked normals.
    tag = node.GetTag(c4d.Tnormal)
    if isinstance(tag, c4d.NormalTag):
        # We just have to apply the same transform here (without the 
        # translation).
        
        # original Code
        #normals = [~transform.MulV(n) for n in read_normal_tag(tag)] 
        
        # my tests
        normals = [~transform.MulV(n) for n in read_normal_tag(tag)]
        
        write_normal_tag(tag, normals)
    else:
        msg = f"Could not find normal data to adjust for: {node}."
        print(f"Warning - {msg}")

def main():
    c4d.CallCommand(13957)  # Konsole löschen
    if op is None or not op.CheckType(c4d.Opoint):
        return False

    doc.StartUndo()
    doc.AddUndo(c4d.UNDOTYPE_CHANGE, op)

    targetMat = op.GetUp().GetMg()
    
    adjust_point_node(op, targetMat)
    
    op.Message(c4d.MSG_UPDATE)
    c4d.EventAdd()
    doc.EndUndo()
    
if __name__=='__main__':
    main()