Hi,

thanks for the kind words both from Maxon and the community. I am looking forward to my upcoming adventures with the SDK Team and Cinema community.

Cheers,
Ferdinand

Hi,

as @Cairyn said the problem is unreachable code. I also just saw now that you did assign the same ID to all your buttons in your CreateLayout(). Ressource and dialog element IDs should be unique. I would generally recommend to define your dialogs using a resource, but here is an example on how to do it in code.

BUTTON_BASE_ID = 1000
BUTTON_NAMES = ["Button1", "Button2", "Button3", "Button4", "Button5"]
BUTTON_DATA = {BUTTON_BASE_ID + i: name for i, name in enumerate(BUTTON_NAMES)}

class MyDialog(gui.GeDialog):

    def CreateLayout(self):
        """
        """
        self.GroupBegin(id=1013, flags=c4d.BFH_SCALEFIT, cols=5, rows=4)
        for element_id, element_name in BUTTON_DATA.items():
            self.AddButton(element_id, c4d.BFV_MASK, initw=100, 
                           name=element_name)
        self.GroupEnd()
        return True

    def Command(self, id, msg):
        """
        """
        if id == BUTTON_BASE_ID:
            print "First button has been clicked"
        elif id == BUTTON_BASE_ID + 1:
            print "Second button has been clicked"
        # ...
        if id in BUTTON_DATA.keys(): # or just if id in BUTTON_DATA
            self.Close()
        return True

Hi,

that your script is not working has not anything to do with pseudo decimals, but the fact that you are treating numbers as strings (which is generally a bad idea) in a not very careful manner. When you truncate the string representation of a number which is represented in scientific notation (with an exponent), then you also truncate that exponent and therefor change the value of the number.

To truncate a float you can either take the floor of my_float * 10 ** digits and then divide by 10 ** digits again or use the keyword round.

data = [0.03659665587738824,
        0.00018878623163019122,
        1.1076812650509394e-03,
        1.3882258325566638e-06]

for n in data:
    rounded = round(n, 4)
    floored = int(n * 10000) / 10000
    print(n, rounded, floored)

0.03659665587738824 0.0366 0.0365
0.00018878623163019122 0.0002 0.0001
0.0011076812650509394 0.0011 0.0011
1.3882258325566637e-06 0.0 0.0
[Finished in 0.1s]

Cheers
zipit

Hi,

sorry for all the confusion. You have to pass actual instances of objects. The following code does what you want (and this time I actually tried it myself ;)).

import c4d

def main():
    """
    """
    bc = doc.GetAllTextures(ar=doc.GetMaterials())
    for cid, value in bc:
        print cid, value

if __name__=='__main__':
   main()

Cheers,
zipit

Hi,

the nature of your problem remains a bit unclear to me. You talk about polygonal data and beveling edges, which I would interpret as the question for bevelling in a network of curves, .e.g. a polygonal topology, but you show the image of a curve and also your code operates in a plane. I assume you want interpret your mesh as a series of cross-sections/curves?

That aside, beveling (either curves or curves in surfaces, i.e. edges) is an application of interpolation and can therefor implemented in various forms, here are some approaches:

1. Piecing in arc segments. This what you are basically trying to do from the looks of your code. You normally would properly define a series of transforms (i.e. "matrices" in Cinema) to transform a base vector and by that construct the vertices making up the arc segment. This solution is not very suited for a data of intersecting curve networks, i.e. surfaces, it works better in something like a 2D Vector app.

2. Than there are multiple ways to construct a smooth curve over a series points. The easiest one are Chaikin's Curves which also have spawned a whole group of algorithms all following more or less the same one fourth three fourth idea and some of them can also be applied to meshes.

3. The next obvious candidates would be quadratic or cubic polynomials/curves. They can the can also be viewed as a combination of linear interpolations. This is called De Casteljau's algorithm. To get from multiple curves segments to splines, you just piece them together (there are multiple ways to do this). But in you case of beveling you probably will only need a single curve. Depending on how deep you venture into this topic this reaches from splines and curves (.e.g. a B-Spline or a Bezier spline) to surfaces (e.g. a NURBS surface).

4. The last one, and that is the one Cinema probably uses for its edge tool is just Subdivision Surfaces. There are also multiple algorithms of varying complexity, but classical Catmull-Clark SDS have very nice properties (producing only quads for example) and are very easy to implement. The problem here is how to restrict the subdivision part of the algorithm so that you only generate new edges along the edge loop and not perpendicular to it and then come up with the correct modified weights for the smoothing.

Its all a bit vague, but your question is very broad, so I thought this might help.

edit: Forgot this, but should have put this first - Implementing a bevel tool is not trivial. Covering the default case is not that hard, but covering all the corner cases is, especially when you want to maintain secondary mesh attributes like texture coordinates. I would not go for reinventing the wheel here. Is there a reason why you do not want to use Cinema's edge bevel? Does it not work with SendModellingCommand?

Cheers,
zipit

Hi,

you use GetActiveDocument() in a NodeData environment. You cannot do this, since nodes are also executed when their document is not the active document (while rendering for example - documents get cloned for rendering).

Cheers
zipit

Hoi,

@blastframe said in Moving a Point Along an Arc by Distance from another Point:

• In your code comment you mention spherical interpolation between the arc segment. Is that the same as the quadratic bezier interpolation from the example you provided (code below)? I think that's also called slerp?

Yeah, slerp is a synonym for spherical linear interpolation. While linear interpolation, a.k.a. lerp, gives you points on the line segment spanned by its two input vectors, a spherical linear interpolation gives you points on the arc segment spanned between the unit vectors of the two input vectors. Cinema does not have a slerp for vectors for some reason, only one for quaternions. The whole interpolation and interpolation naming situation in Cinema's classic API is a huge mess IMHO. So you would have to write your own slerp. And slerp is not directly related to splines, only in the sense that you will need it when you want to linearly place points on that spline, as you then have to do the arc-length parametrization of that spline for which you will need slerp.

• How do I get the points to stop at the limits of the arc? In this case, it would seem to be limiting the angle to 0 and math.pi, but what if the start & end angles are different?

Basically the same way you did it in your code. The computed angle is an angle in radians. So to limit it to let's say [0°, 180°] you would have to clamp it to [0 rad,π rad]. There is also the problem that angles work the other way around in relation to the circle functions sine and cosine and your example. They "start on the right side" of the unit circle and then go counter clockwise. Which is why my code flips things around. Getting back to "your setup" should just a matter of inverting the angle, i.e. -theta instead of theta, and then adding π, i.e. 180°.

• If I'm not to use c4d.Vector.GetDistance, how would you recommend I get the geodesic norm? I found modules online like geopy, but I'd rather do it with standard Python.

Its the same thing in green. You get the Euclidean norm, a.k.a the "length" of your vectors, implying the radius of the circle they are sitting on. Then you can compute the angle spanned between them with the dot product. Finally you put this into the relation shown above, solve for the arc length and you are done. And to be clear, Geodesic norm is just a fancy name for saying the distance between two points on a sphere, while the Euclidean norm is the distance in a plane.

Cheers,
zipit

Hi,

you have to invoke AddUserArea and then attach an instance of your implemented type to it. Something like this:

my_user_area = MyUserAreaType()
self.AddUserArea(1000,*other_arguments)
self.AttachUserArea(my_user_area, 1000)

I have attached an example which does some things you are trying to do (rows of things, highlighting stuff, etc.). The gadget is meant to display a list of boolean values and the code is over five years old. I had a rather funny idea of what good Python should look like then and my attempts of documentation were also rather questionable. I just wrapped the gadget into a quick example dialog you could run as a script. I did not maintain the code, so there might be newer and better ways to do things now.

Also a warning: GUI stuff is usually a lot of work and very little reward IMHO.

Cheers
zipit

import c4d
import math
import random

from c4d import gui

# Pattern Gadget
IDC_SELECTLOOP_CELLSIZE = [32, 32]
IDC_SELECTLOOP_GADGET_MINW = 400
IDC_SELECTLOOP_GADGET_MINH = 32

class ExampleDialog(gui.GeDialog):
    """
    """
    def CreateLayout(self):
        """
        """

        self.Pattern = c4d.BaseContainer()
        for i in range(10):
            self.Pattern[i] = random.choice([True, False])
        self.PatternSize = len(self.Pattern)

        self.gadget = Patterngadget(host=self)
        self.AddUserArea(1000, c4d.BFH_FIT, 400, 32)
        self.AttachUserArea(self.gadget, 1000)
        return True

class Patterngadget(gui.GeUserArea):
    """
    A gui gadget to modify and display boolean patterns.
    """

    def __init__(self, host):
        """
        :param host: The hosting BaseToolData instance
        """
        self.Host = host
        self.BorderWidth = None
        self.CellPerColumn = None
        self.CellWidht = IDC_SELECTLOOP_CELLSIZE[0]
        self.CellHeight = IDC_SELECTLOOP_CELLSIZE[1]
        self.Columns = None
        self.Height = None
        self.Width = None
        self.MinHeight = IDC_SELECTLOOP_GADGET_MINH
        self.MinWidht = IDC_SELECTLOOP_GADGET_MINW
        self.MouseX = None
        self.MouseY = None

    """------------------------------------------------------------------------
        Overridden methods
        --------------------------------------------------------------------"""

    def Init(self):
        """
        Init the gadget.
        :return : Bool
        """
        self._get_colors()
        return True

    def GetMinSize(self):
        """
        Resize the gadget
        :return : int, int
        """
        return int(self.MinWidht), int(self.MinHeight)

    def Sized(self, w, h):
        """
        Get the gadgets height and width
        """
        self.Height, self.Width = int(h), int(w)
        self._fit_gadget()

    def Message(self, msg, result):
        """
        Fetch and store mouse over events
        :return : bool
        """
        if msg.GetId() == c4d.BFM_GETCURSORINFO:
            base = self.Local2Screen()
            if base:
                self.MouseX = msg.GetLong(c4d.BFM_DRAG_SCREENX) - base['x']
                self.MouseY = msg.GetLong(c4d.BFM_DRAG_SCREENY) - base['y']
                self.Redraw()
                self.SetTimer(1000)
        return gui.GeUserArea.Message(self, msg, result)

    def InputEvent(self, msg):
        """
        Fetch and store mouse clicks
        :return : bool
        """
        if not isinstance(msg, c4d.BaseContainer):
            return True
        if msg.GetLong(c4d.BFM_INPUT_DEVICE) == c4d.BFM_INPUT_MOUSE:
            if msg.GetLong(c4d.BFM_INPUT_CHANNEL) == c4d.BFM_INPUT_MOUSELEFT:
                base = self.Local2Global()
                if base:
                    x = msg.GetLong(c4d.BFM_INPUT_X) - base['x']
                    y = msg.GetLong(c4d.BFM_INPUT_Y) - base['y']
                    pid = self._get_id(x, y)
                    if pid <= self.Host.PatternSize:
                        self.Host.Pattern[pid] = not self.Host.Pattern[pid]
                        self.Redraw()
        return True

    def Timer(self, msg):
        """
        Timer loop to catch OnMouseExit
        """
        base = self.Local2Global()
        bc = c4d.BaseContainer()
        res = gui.GetInputState(c4d.BFM_INPUT_MOUSE,
                                c4d.BFM_INPUT_MOUSELEFT, bc)
        mx = bc.GetLong(c4d.BFM_INPUT_X) - base['x']
        my = bc.GetLong(c4d.BFM_INPUT_Y) - base['y']
        if res:
            if not (mx >= 0 and mx <= self.Width and
                    my >= 0 and my <= self.Height):
                self.SetTimer(0)
                self.Redraw()

    def DrawMsg(self, x1, y1, x2, y2, msg):
        """
        Draws the gadget
        """
        # double buffering
        self.OffScreenOn(x1, y1, x2, y2)
        # background & border
        self.DrawSetPen(self.ColBackground)
        self.DrawRectangle(x1, y1, x2, y2)
        if self.BorderWidth:
            self.DrawBorder(c4d.BORDER_THIN_IN, x1, y1,
                            self.BorderWidth + 2, y2 - 1)
        # draw pattern
        for pid, state in self.Host.Pattern:
            x, y = self._get_rect(pid)
            self._draw_cell(x, y, state, self._is_focus(x, y))

    """------------------------------------------------------------------------
        Public methods
        --------------------------------------------------------------------"""

    def Update(self, cid=None):
        """
        Update the gadget.
        :param cid: A pattern id to toggle.
        """
        if cid and cid < self.Host.PatternSize:
            self.Host.Pattern[cid] = not self.Host.Pattern[cid]
        self._fit_gadget()
        self.Redraw()

    """------------------------------------------------------------------------
        Private methods
        --------------------------------------------------------------------"""

    def _get_colors(self, force=False):
        """
        Set the drawing colors.
        :return : Bool
        """
        self.ColScale = 1.0 / 255.0
        if self.IsEnabled() or force:
            self.ColBackground = self._get_color_vector(c4d.COLOR_BG)
            self.ColCellActive = c4d.GetViewColor(
                c4d.VIEWCOLOR_ACTIVEPOINT) * 0.9
            self.ColCellFocus = self._get_color_vector(c4d.COLOR_BGFOCUS)
            self.ColCellInactive = self._get_color_vector(c4d.COLOR_BGEDIT)
            self.ColEdgeDark = self._get_color_vector(c4d.COLOR_EDGEDK)
            self.ColEdgeLight = self._get_color_vector(c4d.COLOR_EDGELT)
        else:
            self.ColBackground = self._get_color_vector(c4d.COLOR_BG)
            self.ColCellActive = self._get_color_vector(c4d.COLOR_BG)
            self.ColCellFocus = self._get_color_vector(c4d.COLOR_BG)
            self.ColCellInactive = self._get_color_vector(c4d.COLOR_BG)
            self.ColEdgeDark = self._get_color_vector(c4d.COLOR_EDGEDK)
            self.ColEdgeLight = self._get_color_vector(c4d.COLOR_EDGELT)
        return True

    def _get_cell_pen(self, state, _is_focus):
        """
        Get the color for cell depending on its state.
        :param state   : The state
        :param _is_focus : If the cell is hoovered.
        :return        : c4d.Vector()
        """
        if state:
            pen = self.ColCellActive
        else:
            pen = self.ColCellInactive
        if self.IsEnabled() and _is_focus:
            return (pen + c4d.Vector(2)) * 1/3
        else:
            return pen

    def _draw_cell(self, x, y, state, _is_focus):
        """
        Draws a gadget cell.
        :param x:       local x
        :param y:       local y
        :param state:   On/Off
        :param _is_focus: MouseOver state
        """
        # left and top bright border
        self.DrawSetPen(self.ColEdgeLight)
        self.DrawLine(x, y, x + self.CellWidht, y)
        self.DrawLine(x, y, x, y + self.CellHeight)
        # bottom and right dark border
        self.DrawSetPen(self.ColEdgeDark)
        self.DrawLine(x, y + self.CellHeight - 1, x +
                      self.CellWidht - 1, y + self.CellHeight - 1)
        self.DrawLine(x + self.CellWidht - 1, y, x +
                      self.CellWidht - 1, y + self.CellHeight - 1)
        # cell content
        self.DrawSetPen(self._get_cell_pen(state, _is_focus))
        self.DrawRectangle(x + 1, y + 1, x + self.CellWidht -
                           2, y + self.CellHeight - 2)

    def _get_rect(self, pid, offset=1):
        """
        Get the drawing rect for an array id.
        :param pid    : the pattern id
        :param offset : the pixel border offset
        :return       : int, int
        """
        pid = int(pid)
        col = pid / self.CellPerColumn
        head = pid % self.CellPerColumn
        return self.CellWidht * head + offset, self.CellHeight * col + offset

    def _get_id(self, x, y):
        """
        Get the array id for a coord within the gadget.
        :param x : local x
        :param y : local y
        :return  : int
        """
        col = (y - 1) / self.CellHeight
        head = (x - 1) / self.CellWidht
        return col * self.CellPerColumn + head

    def _is_focus(self, x, y):
        """
        Test if the cell coords are under the cursor.
        :param x : local x
        :param y : local y
        :return  : bool
        """
        if (self.MouseX >= x and self.MouseX <= x + self.CellWidht and
                self.MouseY >= y and self.MouseY <= y + self.CellHeight):
            self.MouseX = c4d.NOTOK
            self.MouseY = c4d.NOTOK
            return True
        else:
            return False

    def _fit_gadget(self):
        """
        Fit the gadget size to the the array
        """
        oldHeight = self.MinHeight
        self.CellPerColumn = int((self.Width - 2) / self.CellWidht)
        self.Columns = math.ceil(
            self.Host.PatternSize / self.CellPerColumn) + 1
        self.MinHeight = int(IDC_SELECTLOOP_GADGET_MINH * self.Columns) + 3
        self.MinWidht = int(IDC_SELECTLOOP_GADGET_MINW)
        self.BorderWidth = self.CellWidht * self.CellPerColumn
        if oldHeight != self.MinHeight:
            self.LayoutChanged()

    def _get_color_vector(self, cid):
        """
        Get a color vector from a color ID.
        :param cid : The color ID
        :return    : c4d.Vector()
        """
        dic = self.GetColorRGB(cid)
        if dic:
            return c4d.Vector(float(dic['r']) * self.ColScale,
                              float(dic['g']) * self.ColScale,
                              float(dic['b']) * self.ColScale)
        else:
            return c4d.Vector()

if __name__ == "__main__":
    dlg = ExampleDialog()
    dlg.Open(c4d.DLG_TYPE_ASYNC, defaultw=400, defaulth=400)

Hello @shetal,

thank you for reaching out to us. The reformulation of your question and the conformance with the forum guidelines on tagging is also much appreciated.

About your question: As stated in the forum guidelines, we cannot provide full solutions for questions, but provide answers for specific questions. Which is why I will not show here any example code, the first step would have to be made by you. I will instead roughly line out the purpose of and workflow around VideoPostData, which I assume is what you are looking for anyway.

VideoPostData is derived from NodeData, the base class to implement a node for a classic API scene graph. Node means here 'something that lives inside a document and is an addressable entity', examples for such nodes are materials, shaders, objects, tags, ..., and as such 'video post' node. As mentioned in its class description, VideoPostData is a versatile plugin interface which can be used to intervene a rendering process in multiple ways. The most tangible place for VideoPostData in the app is the render settings where video post plugins can be added as effects for a rendering process as shown below with the built-in water mark video post node.

VideoPostData is an effect, meaning that you cannot use it to invoke a rendering process and on its own it also cannot forcibly add itself to a rendering and must be included manually with the RenderData, the render settings of a rendering. However, a user could make a render setting which includes such watermark effect part of his or her default render settings. One could also implement another plugin interface, SceneHookData, to automatically add such effect to every active document. We would not encourage that though, as this could be confusing or infuriating for users. Finally, such VideoPostData plugin would be visible by default like all NodeData plugins, i.e., it would appear as something in menus that the user can add and interact with. To prevent this if desired, one would have to register the plugin with the flag PLUGINFLAG_HIDE suppress it from popping up in the 'Effect ...' button menu. I cannot tell you with certainty if it is possible to hide programmatically added effect nodes from the users view in the effect list of a render settings. There are some flags which can be used to hide instances of nodes, but I would have to test myself if this also applies in this list, it is more likely that this will not be possible.

To implement a VideoPostData plugin interface, one can override multiple methods and take different approaches, the most commonly used one is to override VideoPostData::Execute(Link) which will be called multiple times for each rendered frame. The method follows a flag/message logic which is commonly used in Cinema 4D's classic API, where one gets passed in a flag which signalizes in which context the method is being called. Here the context is at which state of the rendering this call is being made, and the chain is:

• VIDEOPOSTCALL::FRAMESEQUENCE - Series of images starts.
• VIDEOPOSTCALL::FRAME - Image render starts.
• VIDEOPOSTCALL::SUBFRAME - Sub-frame starts.
• VIDEOPOSTCALL::RENDER - Render precalculation.
• VIDEOPOSTCALL::INNER - Render precalculation.
• VIDEOPOSTCALL::INNER - Immediately after rendering.
• VIDEOPOSTCALL::RENDER - Immediately after shader cleanup.
• VIDEOPOSTCALL::SUBFRAME - Sub-frame rendering done.
• VIDEOPOSTCALL::FRAME - Frame rendering done.
• VIDEOPOSTCALL::FRAMESEQUENCE - Complete rendering process finished.

These flags are accompanied by information if the flags denotes the opening or closing of that 'step' in the rendering process. A developer often then restricts its plugin functionality to a certain flag. I.e., in your case you only want to execute some code when the closing VIDEOPOSTCALL::FRAME is being passed, i.e., after a single frame and all its sub-frames have been rendered. Execute() also passes in a pointer to a VideoPostStruct(Link) which carries information about the ongoing rendering. One of its fields is render, a pointer to a Render(Link). This data structure represents a rendering with multiple buffers and provides the method GetBuffer() which returns a pointer to VPBuffer buffer. In your case you would want to retrieve the RGBA buffer for the rendering by requesting the VPBUFFER_RGBA buffer (Link) with GetBuffer().

This buffer is then finally the pixel buffer, the bitmap data you want to modify. The buffer is being read and written in a line wise fashion with VPBuffer::GetLine() and ::SetLine(). Here you would have to superimpose your watermark information onto the frame. I would do this in a shader like fashion, i.e., write a function which I can query for a texture coordinate for every pixel/fragment in every line and it will then return an RBGA value which I could then combine with the RGBA information which is in the buffer at that coordinate. The details on that depend on what you want to do, e.g.,

• Should the watermark be tiled across the frame or just live in a 'corner'?
• Should it contain alpha information?
• Can the user influence it, or is it just a png file on disk?
• etc...

and the answers to that are mostly algorithmic and not directly connected to our API which limits the amount of support we can provide for them. If this all sounds very confusing to you, it might be helpful to look at our video post examples I did post in the previous thread, e.g., vpreconstructimage.cpp, as this will probably make things less daunting.

If you decide that you do not want to take this route for technical or complexity reasons, you could write a SceneHookData plugin which listens via NodeData::Message for MSG_MULTI_RENDERNOTIFICATION(Link), a message family which is being sent in the context of a rendering. There you would have to evaluate the start field in the RenderNotificationData(Link) accompanying the message, to determine if the call is for the start or end of a rendering. Then you could grab the rendering output file(s) on disk with the help of the render settings from disk and 'manually' superimpose your watermark information. This will come with the drawback that you might have to deal with compressed video files like mpeg or Avi and all the image formats. Some complexity in that can be hidden away with our BaseBitmap type I did mention in my last posting, but not all of it. There is also the fact that you might run into problems when this plugin runs on a render server, where you cannot easily obtain write or even read access to files of the render output.

I hope this give you some desired guidance,
Ferdinand

Hello @holgerbiebrach,

please excuse the wait. So, this is possible in Python and quite easy to do. This new behavior is just the old dialog folding which has been reworked a little bit. I have provided a simple example at the end of the posting. There is one problem regarding title bars which is sort of an obstacle for plugin developers which want to distribute their plugins, it is explained in the example below.

I hope this helps and cheers,
Ferdinand

The result:

The code:

"""Example for a command plugin with a foldable dialog as provided with the
Asset Browser or Coordinate Manger in Cinema 4D R25.

The core of this is just the old GeDialog folding mechanic which has been
changed slightly with R25 as it will now also hide the title bar of a folded
dialog, i.e., the dialog will be hidden completely.

The structure shown here mimics relatively closely what the Coordinate Manger
does. There is however one caveat: Even our internal implementations do not
hide the title bar of a dialog when unfolded. Instead, this is done via 
layouts, i.e., by clicking onto the ≡ icon of the dialog and unchecking the
"Show Window Title" option and then saving such layout. If you would want
to provide a plugin which exactly mimics one of the folding managers, you
would have to either ask your users to take these steps or provide a layout.

Which is not ideal, but I currently do not see a sane way to hide the title
bar of a dialog. What you could do, is open the dialog as an async popup which 
would hide the title bar. But that would also remove the ability to dock the 
dialog. You could then invoke `GeDialog.AddGadegt(c4d.DIALOG_PIN, SOME_ID)`to 
manually add a pin back to your dialog, so that you can dock it. But that is 
not how it is done internally by us, as we simply rely on layouts for that.
"""

import c4d


class ExampleDialog (c4d.gui.GeDialog):
    """Example dialog that does nothing.

    The dialog itself has nothing to do with the implementation of the
    folding.
    """
    ID_GADGETS_START = 1000
    ID_GADGET_GROUP = 0
    ID_GADGET_LABEL = 1
    ID_GADGET_TEXT = 2

    GADGET_STRIDE = 10
    GADEGT_COUNT = 5

    def CreateLayout(self) -> bool:
        """Creates a some dummy gadgets.
        """
        self.SetTitle("ExampleDialog")
        flags = c4d.BFH_SCALEFIT

        for i in range(self.GADEGT_COUNT):
            gid = self.ID_GADGETS_START + i * self.GADGET_STRIDE
            name = f"Item {i}"

            self.GroupBegin(gid + self.ID_GADGET_GROUP, flags, cols=2)
            self.GroupBorderSpace(5, 5, 5, 5)
            self.GroupSpace(2, 2)
            self.AddStaticText(gid + self.ID_GADGET_LABEL, flags, name=name)
            self.AddEditText(gid + self.ID_GADGET_TEXT, flags)
            self.GroupEnd()
        return True


class FoldingManagerCommand (c4d.plugins.CommandData):
    """Provides the implementation for a command with a fordable dialog.
    """
    ID_PLUGIN = 1058525
    REF_DIALOG = None

    @property
    def Dialog(self) -> ExampleDialog:
        """Returns a class bound ExampleDialog instance.
        """
        if FoldingManagerCommand.REF_DIALOG is None:
            FoldingManagerCommand.REF_DIALOG = ExampleDialog()

        return FoldingManagerCommand.REF_DIALOG

    def Execute(self, doc: c4d.documents.BaseDocument) -> bool:
        """Folds or unfolds the dialog.

        The core of the folding logic as employed by the Asset Browser
        or the Coordinate manager in R25.
        """
        # Get the class bound dialog reference.
        dlg = self.Dialog
        # Fold the dialog, i.e., hide it if it is open and unfolded. In C++
        # you would also want to test for the dialog being visible with
        # GeDialog::IsVisible, but we cannot do that in Python.
        if dlg.IsOpen() and not dlg.GetFolding():
            dlg.SetFolding(True)
        # Open or unfold the dialog. The trick here is that calling
        # GeDialog::Open will also unfold the dialog.
        else:
            dlg.Open(c4d.DLG_TYPE_ASYNC, FoldingManagerCommand.ID_PLUGIN)

        return True

    def RestoreLayout(self, secret: any) -> bool:
        """Restores the dialog on layout changes.
        """
        return self.Dialog.Restore(FoldingManagerCommand.ID_PLUGIN, secret)

    def GetState(self, doc: c4d.documents.BaseDocument) -> int:
        """Sets the command icon state of the plugin.

        This is not required, but makes it a bit nicer, as it will indicate
        in the command icon when the dialog is folded and when not.
        """
        dlg = self.Dialog
        result = c4d.CMD_ENABLED
        if dlg.IsOpen() and not dlg.GetFolding():
            result |= c4d.CMD_VALUE

        return result


def RegisterFoldingManagerCommand() -> bool:
    """Registers the example.
    """
    return c4d.plugins.RegisterCommandPlugin(
        id=FoldingManagerCommand.ID_PLUGIN,
        str="FoldingManagerCommand",
        info=c4d.PLUGINFLAG_SMALLNODE,
        icon=None,
        help="FoldingManagerCommand",
        dat=FoldingManagerCommand())


if __name__ == '__main__':
    if not RegisterFoldingManagerCommand():
        raise RuntimeError(
            f"Failed to register {FoldingManagerCommand} plugin.")

Hello @bureaudesprojets,

welcome to the Plugin Café and thank you for reaching out to us. That looks like a fun project you have there.

However, there are a few problems with your code.

You redefine your null on each step of the loop, causing only the last iteration to be returned. It is:

if ((x // 26)-1 == -1):
   null = c4d.BaseObject(c4d.Onull)
   ...
   texte.InsertUnder(null)
else:
   null = c4d.BaseObject(c4d.Onull)
   ...
   texte.InsertUnder(null)

But it should be:

null = c4d.BaseObject(c4d.Onull)
for x in range( number):
    if ((x // 26)-1 == -1):
        ...
        texte.InsertUnder(null)
    else:
       ...
        texte.InsertUnder(null)

This was what caused your major problem, but there were also other problems with how you set the distance between the elements with texte[c4d.ID_BASEOBJECT_REL_POSITION,c4d.VECTOR_Z] = x* distance, which was outside of the loop, and I also did not understand the whole "aeronautical numerations" thing in your code.

Find below an example of how I would do it.

Cheers,
Ferdinand

The result:

The file:
abcd.c4d

The code:

"""Simple example for building caches for a Python Generator object.
"""

import c4d
import itertools

# The upper case letters from their ASCII range.
ALPHABET = tuple(chr (i) for i in range(65, 91))


def GetNumerationList(a: int, b: int) -> list[str]:
    """Returns a list of numerations following your scheme from index #a
    to #b.
    """
    # I have no clue what aeronautical numerations are, but I guess
    # you just want A-Z, AA-AZ, BA-BZ, ..., ZA-ZZ, AAA - AAZ, and so on.
    # I do not really see how your code was supposed to do that. I did
    # provide below a simple version using itertools.

    assert(a < b)

    # Build the full array, we could also be more elegant here, and only
    # build what we need, but that would be up to you. I create here quite
    # a lot of entries to avoid index errors. range(1, 4) means we create
    # everything from A to ZZZ, i.e., 26 + 26² + 26³ ~ 18,000 items. Python's
    # iteration is slow, and you should optimize this.
    result = []
    for i in range(1, 4):
        result += ("".join(item)
                   for item in itertools.product(ALPHABET, repeat=i))

    # And return the slice we have been asked for.
    return result[a:b]


def main():
    """Executed by Cinema 4D to build the cache of the Python Generator.
    """
    # Instantiate a null object to parent the "numerations" to.
    null = c4d.BaseObject(c4d.Onull)
    if not isinstance(null, c4d.BaseObject):
        raise MemoryError()

    # Get the user data.
    a = op[c4d.ID_USERDATA, 1] # The starting index.
    b = op[c4d.ID_USERDATA, 2] # The end index.
    distance = op[c4d.ID_USERDATA, 3] # The distance between elements.

    # Iterate over all numerations between the index #a and #b.
    for i, item in enumerate(GetNumerationList(a, b)):
        # Instantiate a text object.
        node = c4d.BaseObject(1019268)
        if not isinstance(node, c4d.BaseObject):
            raise MemoryError("Could not allocate object.")

        # Set the text to the yielded numeration item.
        node[c4d.PRIM_TEXT_TEXT] = item
        # Set the distance on the x-axis in the local space of the parent, 
        # the null object.
        node.SetMl(c4d.Matrix(off=c4d.Vector(i * distance, 0, 0)))
        # Parent the text object to the null object.
        node.InsertUnder(null)

    # Return the cache.
    return null

Hello @aimidi,

please excuse, I overlooked the C++ tag you did assign to your posting. R21, the version you tagged this posting as, is also out of scope of support. The code examples I provided below have been written for R25. There were substantial changes to the C++ Python API with R23, you might not be able to translate that example to R21. The branch info approach should work in R21.

The short answer is, "no, there is no C++ API for Redshift at the moment". You can however use the Python API from C++ or use BranchInfo to access the Xpresso nodes attached to a Redshift material. The Python approach has the advantage that you can make use of the whole Python Redshift API, but the disadvantage that it is a bit involved. The branch info approach is easier, but it will only solve your problem at hand, getting the underlying graph, and will not give you access to the other functionalities of the Redshift Python API (there are not many other features in the Python API).

Find below an example demonstrating both approaches.

Cheers,
Ferdinand

The result:

The code:

// For https://plugincafe.maxon.net/topic/13752

#include "c4d_basedocument.h"
#include "c4d_basematerial.h"
#include "c4d_general.h"
#include "c4d_graphview.h"

#include "lib_py.h"
#include "maxon/cpython.h"
#include "maxon/cpython_c4d.h"
#include "maxon/cpython3_raw.h"
#include "maxon/errortypes.h"
#include "maxon/vm.h"

// The type id of Redshift materials.
const maxon::Int32 g_redshift_material_id = 1036224;

/// Attempts to retrieve the Redshift GvNodeMaster of #material with Python.
/// 
/// @param material The material to get the Redshift GvNodeMaster for.
/// @param pythonCode The Python code that is used to retrieve it.
/// @return The Redshift GvNodeMaster for #material.
/// ------------------------------------------------------------------------------------------------ 
static maxon::Result<GvNodeMaster*> CallRedshiftPythonLayer(
  BaseMaterial* material, const maxon::String& pythonCode)
{
  iferr_scope;

  // Bail when #material is null or not a Redshift material.
  if (!material || (material->GetType() != g_redshift_material_id))
    return maxon::IllegalArgumentError(
      MAXON_SOURCE_LOCATION, "Passed material is not a Redshift material."_s);

  // Initialize a scope with the Python 3 virtual machine for #pythonCode.
  const maxon::VirtualMachineRef& vm = MAXON_CPYTHON3VM();
  const maxon::VirtualMachineScopeRef scope = vm.CreateScope() iferr_return;
  scope.Init("Python"_s, pythonCode, maxon::ERRORHANDLING::PRINT, nullptr) iferr_return;

  // We could setup here the modules attributes doc and op that are commonly used in Cinema 4D 
  // Python scripts by adding them to the scope. But that is not really necessary in the example 
  // since we just call one function which does not require any module attributes.

  // Set the __name__ attribute of the module so that the execution context guard ifnamemain works.
  // Also not necessary in a technical sense, since we do not make use of it.
  scope.Add("__name__"_s, maxon::Data("__main__"_s)) iferr_return;

  // When the script does modify the active document, you must stop all threads before executing it.
  // Here not necessary, since the example code does not modify anything.
  StopAllThreads();

  // Execute the module context of the script, i.e., carry out imports and module level expressions,
  // as for example an ifnamemain execution guard.
  scope.Execute() iferr_return;

  // Now we are going to call the specific function GetNodeMaster() in the script.

  // Make the passed material accessible as an argument for the python function GetNodeMaster() 
  // by casting it into its binding type that handles the C++/Python type binding.
  maxon::specialtype::BaseMaterial* materialSpeical = (
    reinterpret_cast<maxon::specialtype::BaseMaterial*>(material));

  // Create a data structure for the arguments of GetNodeMaster(), containing the material binding.
  maxon::Data materialArgument = maxon::Data(materialSpeical);
  maxon::BaseArray<maxon::Data*> arguments;
  arguments.Append(&materialArgument) iferr_return;

  // Setup the return type. We are using here BaseList2D for the return type, or more specifically 
  // its special binding type, since there is no dedicated binding type for GvNodeMaster. But 
  // GvNodeMaster is of type BaseList2D and we will later attempt to cast the return value back to 
  // GvNodeMaster.
  maxon::BlockArray<maxon::Data> helperStack;
  const maxon::DataType& returnType = maxon::GetDataType<maxon::specialtype::BaseList2D*>();

  // Call GetNodeMaster() in the scope and interpret its return value(s).
  maxon::Data* res = scope.PrivateInvoke(
    "GetNodeMaster"_s, helperStack, returnType, &arguments.ToBlock()) iferr_return;

  // The function execution did fail.
  if (!res)
    return maxon::UnexpectedError(MAXON_SOURCE_LOCATION, "Function execution did fail."_s);

  // The function in Python does not conform to the expected return type of BaseList2D.
  maxon::specialtype::BaseList2D* returnValue = res->Get<maxon::specialtype::BaseList2D*>().GetValue();
  if (returnValue == nullptr)
    return maxon::UnexpectedError(
      MAXON_SOURCE_LOCATION, "Function does not conform to its return value signature."_s);

  // The C++/Python binding type return value cast back into its native C++ form.
  BaseList2D* result = reinterpret_cast<BaseList2D*>(returnValue);

  // Finally cast it into what we are after, a GvNodeMaster.
  GvNodeMaster* nodeMaster = static_cast<GvNodeMaster*>(result);

  return nodeMaster;
}

/// Attempts to retrieve the Redshift node graph of #material with branching information.
/// 
/// An alternative and less complex solution than CallRedshiftPythonLayer() which uses branch info
/// to get hold of the graph. This is easier but other than with the Python approach it will give
/// you not access to all the things the Redshift Python API can do.
/// 
/// @param material The material to get the Redshift graph for.
/// @return The Redshift graph for #material.
/// ------------------------------------------------------------------------------------------------ 
maxon::Result<GvNode*> GetRedshiftNodeBranch(BaseMaterial* material)
{
  iferr_scope;

  // Bail when #material is null or not a Redshift material.
  if (!material || (material->GetType() != g_redshift_material_id))
    return maxon::IllegalArgumentError(
      MAXON_SOURCE_LOCATION, "Passed material is not a Redshift material."_s);

  // Setup an array for all branches of #material. Usually nodes do not have more than ten 
  // branches, e.g., a BaseObject might have a tags and tracks branch, and one or two internally 
  // used branches. So, setting maxBranchCount to 64 is very generous. 
  const maxon::Int32 maxBranchCount = 64;
  BranchInfo branches[maxBranchCount];

  // Get all branches for #material.
  maxon::Int32 count = material->GetBranchInfo(branches, maxBranchCount, GETBRANCHINFO::NONE);

  // Search for a "Node" branch, which is the branch containing the Redshift graph.
  BranchInfo* nodeBranch = nullptr;
  for (maxon::Int32 i = 0; i < count; i++)
  {
    if (branches[i].name.Compare("Node"_s) == maxon::COMPARERESULT::EQUAL)
    {
      nodeBranch = &branches[i];
    }
  }

  if (!nodeBranch)
    return maxon::UnexpectedError(
      MAXON_SOURCE_LOCATION, "The passed material does not contain a Redshift 'Node' branch."_s);

  GeListHead* head = nodeBranch->head;
  if ((!head) || (!head->GetFirst()))
    return maxon::UnexpectedError(MAXON_SOURCE_LOCATION, "Malformed or empty branch info."_s);

  // Get the first node in the list head, this is equivalent to nodeMaster->GetRoot(). We cannot
  // access the node master itself with this approach, but all the nodes in it.
  GvNode* node = static_cast<GvNode*>(head->GetFirst());
  return node;
}

/// Prints #node and all its descendants as a tree to the console.
/// 
/// @param node The graph node to print.
/// @param level (optional) The indentation level.
/// ------------------------------------------------------------------------------------------------
static void PrintNodes(GvNode* node, const maxon::Int level = 0)
{
  if (!node)
    return;

  maxon::String indentation = ""_s;
  for (maxon::Int i = 0; i < level; i++)
    indentation += "\t"_s;

  while (node)
  {
    maxon::Int location = reinterpret_cast<maxon::Int>(node);
    ApplicationOutput("@ @ at [email protected]{x}", indentation, node->GetTitle(), location);
    PrintNodes(node->GetDown(), level + 1);
    node = node->GetNext();
  }
}

/// Runs the two examples. 
static maxon::Result<void> pc13752(BaseDocument* doc)
{
  iferr_scope_handler
  {
    ApplicationOutput("@: @", err.GetClass().GetId(), err.GetMessage());
    return err;
  };

  // The Python code we are going to run with CallRedshiftPythonLayer. 
  const maxon::String pythonCode = (
    "import c4d\n"_s +
    "import redshift\n\n"_s +
    "def GetNodeMaster(\n"_s +
    "    material: c4d.BaseMaterial) -> c4d.modules.graphview.GvNodeMaster:\n"_s +
    "    '''Attempts to return the Redshift GvNodeMaster for #material.\n"_s +
    "    '''\n"_s +
    "    if material.GetType() != redshift.Mrsmaterial:\n"_s +
    "        raise ArgumentError(f'Unexpected type with {material = }.')\n\n"_s +
    "    master = redshift.GetRSMaterialNodeMaster(material)\n"_s +
    "    if master is None:\n\n"_s +
    "        raise RuntimeError(f'Could not access node master for {material}.')\n\n"_s +
    "    return master\n\n\n"_s);

  // Get the active material for which we will attempt to get the RS node master for.
  BaseMaterial* activeMaterial = doc->GetActiveMaterial();
  if (!activeMaterial)
    return maxon::IllegalStateError(MAXON_SOURCE_LOCATION, "No material selected"_s);

  // Run the example using Python to get hold of the nodes in the material.
  ApplicationOutput("\nAccess with Python layer:");
  GvNodeMaster* nodeMaster = CallRedshiftPythonLayer(activeMaterial, pythonCode) iferr_return;
  if (!nodeMaster)
    return maxon::UnexpectedError(MAXON_SOURCE_LOCATION, "CallRedshiftPythonLayer() failed."_s);
  PrintNodes(nodeMaster->GetRoot());

  // Run the example using branching information to get hold of the nodes in the material.
  ApplicationOutput("\nAccess with branching information:");
  GvNode* nodeRoot = GetRedshiftNodeBranch(activeMaterial) iferr_return;
  if (!nodeRoot)
    return maxon::UnexpectedError(MAXON_SOURCE_LOCATION, "GetRedshiftNodeBranch() failed."_s);
  PrintNodes(nodeRoot);

  return maxon::OK;
}

Hello @rastan_cgi,

Thank you for reaching out to us. This forum is targeted at software development with the Cinema 4D & Cineware SDK. Xpresso or Scene Nodes are not part of the scope of the forum and the support Maxon does deliver here.

However, you already did post in the correct forum for asking an off-topic question, the General Talk forum. The community is welcome to discuss here topics that are adjacent to the Cinema 4D & Cineware SDKs, as for example Xpresso. But the SDK-Team cannot offer any support for these questions. If you seek an official answer from Maxon, you should contact user support.

With that being said: Xpresso setups cannot automatically be converted into a Python or C++ plugin. You can provide a scene with a null object and your setup, but these workflows are not within the scope of the SDK-Team. When you seek help with reimplementing your Xpresso setup as a plugin, for example as a Python plugin, then we will need more information on what the Xpresso setup does. We can then tell you where you can find learning resources related to your goals, but you will have to write the code yourself.

Cheers,
Ferdinand

Hello @HerminioLehner,

Thank you for reaching out to us. This is a forum dedicated to software development for Maxon Cinema 4D. It is unfortunately not the place to discuss media consumption in general or 3D movies in particular. You are going to be more successful with your question on www.blu-ray.com.

I have closed this thread due to the reasons lined out above.

Cheers,
Ferdinand

Hello @aimidi,

Thank you for reaching out to us. You can access the node master of a Redshift material with redshift.GetRSMaterialNodeMaster(material: c4d.BaseMaterial). Find below a simple script which accesses the Xpresso graph of a Redshift material. I did orignally post the code here.

Cheers,
Ferdinand

The code:

"""Run this in the script manger with a Redshift material selected.
"""

import c4d

def main():
    """
    """
    # Try to import the Redshift module.
    try:
        import redshift
    except:
        raise RuntimeError("Could not import Redshift.")
    
    # Get the active material.
    material = doc.GetActiveMaterial()
    # Bail if it is not a redshift material.
    if material.GetType() != redshift.Mrsmaterial:
        raise TypeError("Selected material is not a Redshift material.")

    # Get the graph view node master of the material.
    master = redshift.GetRSMaterialNodeMaster(material)
    if master is None:
        raise RuntimeError("Could not access material node master.")

    # From here on out its is basically smooth sailing, and just standard 
    # graph view stuff.
    
    # Get the root node.
    root = master.GetRoot()
    # The shader graph stuff is here.
    node = root.GetDown()

    # Iterate over the nodes in the graph.
    while node:
        # When the node is selected and a Redshift Shader:
        if (node.GetBit(c4d.BIT_ACTIVE) is True and
            node.GetTypeName() == "Redshift Shader"):
            # Get the diffuse color
            diffuse = node[c4d.REDSHIFT_SHADER_MATERIAL_DIFFUSE_COLOR]
            print (diffuse)
        node = node.GetNext()
   

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

Hello @wen,

Thank you for reaching out to us. You got it almost right, but you must access the actual BaseVideoPost attached to the RenderData instance, since there can be multiple render data instances with different values, so the BasePlugin cannot hold these values.

The underlying "trick" is here that some things that are render settings are expressed directly in the render data and some by video post nodes. Non-removeable entries like "Output" or "Save" are represented in the render data directly, the rest is represented by video post nodes. You can find out more tangibly with the console as demonstrated by the screen grab below.

At the end of the posting, you can find some example code for your exact use case.

Cheers,
Ferdinand

The output:

Found <c4d.documents.BaseVideoPost object called Redshift/Redshift with ID 1036219 at 1699066826048> for 'redshiftRenderEngineId = 1036219'.
Old value for color space: ACEScg
New value for color space: ACES2065-1

The code:

"""Demonstrates how to access Redshift render engine render settings attached
to render data.
"""

import c4d

def main():
    """Entry point.
    """
    # doc in predefined in script manger scripts, so this would not be 
    # necessary, but since you did call GetActiveDocument() I copied this
    # here.
    doc = c4d.documents.GetActiveDocument()
    if not isinstance(doc, c4d.documents.BaseDocument):
        raise RuntimeError("Could not access active document.")

    renderData = doc.GetActiveRenderData()

    # The elements in the render settings are video post plugins. Some of
    # the common entries, e.g., Output/Save are mapped automatically to the
    # render data, for everything that is optional, we must access the 
    # corresponding BaseVideoPost. Your idea with FindPlugin was not bad, but
    # that will only give you the BasePlugin and not the actual video post
    # instance associated with the concrete render data instance.

    # We could also get the Redshift id like you did with RDATA_RENDERENGINE,
    # but this assumes that the Redshift is indeed the active render engine.
    # So, for me it is a bit more comfy to hard-code it.
    redshiftRenderEngineId = 1036219

    # Iterate over the video post to find one matching the render engine.
    videoPost = renderData.GetFirstVideoPost()
    while (videoPost):
        if videoPost.CheckType(redshiftRenderEngineId):
            break
        videoPost = videoPost.GetNext()

    if not isinstance(videoPost, c4d.documents.BaseVideoPost):
        raise RuntimeError(
            f"Could not access video post for '{redshiftRenderEngineId = }'")

    print (f"Found {videoPost} for '{redshiftRenderEngineId = }'.")

    # This is now normal parameter access, man that is a long symbol :)
    csId = c4d.REDSHIFT_RENDERER_COLOR_MANAGEMENT_OCIO_RENDERING_COLORSPACE
    print (f"Old value for color space: {videoPost[csId]}")
    videoPost[csId] = "ACES2065-1"
    print (f"New value for color space: {videoPost[csId]}")

    c4d.EventAdd()


if __name__ == '__main__':
    main()

Hi @del,

did not really have the time yesterday, and this is slightly out of scope of support, but below you can find a bit more graceful approach to quantizing the values in case you are interested.

import math

def quantize(v: float, binSize: float = .1, tolerance: float = 1E-8) -> float:
    """Quantizes #v to a multiple of #binSize with a distance of #tolerance.
    """
    vq = float(v) / float(binSize)
    vqmin, vqmax = math.floor(vq) * binSize, math.ceil(vq) * binSize
    if (abs(vqmin - v) < tolerance):
        return vqmin
    elif (abs(vqmax - v) < tolerance):
        return vqmax
    return v


def main():
    """
    """
    # Quantize some values.

    # Will quantize to 0 because the next multiple of .1 to v is 0.0 and
    # the distance from v to that multiple is less than the tolerance.
    print (f"{quantize(0.000001, binSize = .1, tolerance=1E-5) = }")
    # Same call as the prior, just a different v, will snap to .2
    print (f"{quantize(0.200001, binSize = .1, tolerance=1E-5) = }")
    # A value almost touching .75, this will quantize to 0, .25, .5, .75 and
    # 1.0 with a tolerance of 1E-5.
    print (f"{quantize(0.749999999, binSize = .25, tolerance=1E-5) = }")

    # Quantize to either 0 or 1. I picked here a low tolerance so that that 
    # things are easier to read.

    # Wont' t be touched because (1 - .51234) and abs(0 - .51234) are much 
    # larger than the tolerance. Other than with simple rounding we can
    # preserve precision with the values which are not quantized.
    print (f"{quantize(0.51234, binSize = 1., tolerance=1E-2) = }")

    # Will snap to 0.
    print (f"{quantize(0.00002, binSize = 1., tolerance=1E-2) = }")
    # Will snap to 1.
    print (f"{quantize(0.99999, binSize = 1., tolerance=1E-2) = }")

if __name__ == "__main__":
    main()

quantize(0.000001, binSize = .1, tolerance=1E-5) = 0.0
quantize(0.200001, binSize = .1, tolerance=1E-5) = 0.2
quantize(0.749999999, binSize = .25, tolerance=1E-5) = 0.75
quantize(0.51234, binSize = 1., tolerance=1E-2) = 0.51234
quantize(0.00002, binSize = 1., tolerance=1E-2) = 0.0
quantize(0.99999, binSize = 1., tolerance=1E-2) = 1.0

@del said in Python uvTag.GetSlow(poly) data not matching what's in Structure Manager:

Is there a way to change the tags for this this thread as it's not a bug report. I thought it was but it turns out it's not.

You would have to edit your own first posting in this thread and then remove the tag. I took the liberty of doing it for you here and thanks for bringing it up!

Cheers,
Ferdiand

Hello @del,

so, I had a look at your data, and I cannot see any UVW vertex component values there which are 1 in the UI, but when accessed in Python are -1.1102230246251565e-16, i.e., almost 0. There are however a few values which are -1.1102230246251565e-16 which are shown as 0 in the UI and when printing out a c4d.Vector instance. Because vectors round their value when printed. Internally they will always work with the true values and when one wants to print out the true values, one must access the components individually.

# A vector where all three components are very close to zero.
v = c4d.Vector(1E-10)
# Printing out the vector will show the rounded components.
print (f"{v = }")
# Accessing them directly will provide the true values.
print (f"{v.x = }, {v.y = }, {v.z = }")

v = Vector(0, 0, 0)
v.x = 1e-10, v.y = 1e-10, v.z = 1e-10

So, your data is fine, it is just that the UVW data was either created by an artist who rightfully did not care if some values are 0 or 'almost zero', or that the data was created at lower precision and then converted at some point, which lead to these rounding errors.

Below you can find a script which prints out all the UVW data for a selected object and then quantizes the data with a given precision, running QuantizeUvwTag from my script will persistently fix an Uvw tag in the context of very small values and also quantize other values. You would have to implement yourself what you want to be fixed and what not, this is a purely cosmetic issue after all.

Cheers,
Ferdinand

An excerpt from the script output for your file:

Uvw-Data:
uvw polygon 0: {'a': Vector(0.25, 0.152, 0), 'b': Vector(0.433, 0.152, 0), 'c': Vector(0.25, 0.174, 0), 'd': Vector(0, 0, 0)}
    0: a(0)=0.25
    0: a(1)=0.15186521410942078
    0: a(2)=0.0
    0: b(0)=0.4333333373069763
    0: b(1)=0.15186521410942078
    0: b(2)=0.0
    0: c(0)=0.25
    0: c(1)=0.17397046089172363
    0: c(2)=0.0
    0: d(0)=0.0
    0: d(1)=0.0
    0: d(2)=0.0
...
uvw polygon 8: {'a': Vector(0.433, 0, 0), 'b': Vector(0.433, 0.111, 0), 'c': Vector(0.25, 0.111, 0), 'd': Vector(0.25, 0, 0)}
    8: a(0)=0.4333333373069763
    8: a(1)=-1.1102230246251565e-16
    8: a(2)=0.0
    8: b(0)=0.4333333373069763
    8: b(1)=0.11077965795993805
    8: b(2)=0.0
    8: c(0)=0.25
    8: c(1)=0.11081257462501526
    8: c(2)=0.0
    8: d(0)=0.25
    8: d(1)=-1.1102230246251565e-16
    8: d(2)=0.0
uvw polygon 9: {'a': Vector(0.433, 0.174, 0), 'b': Vector(0.433, 0.152, 0), 'c': Vector(0.477, 0.152, 0), 'd': Vector(0.25, 0, 0)}
    9: a(0)=0.4333333373069763
    9: a(1)=0.17397046089172363
    9: a(2)=0.0
    9: b(0)=0.4333333373069763
    9: b(1)=0.15186521410942078
    9: b(2)=0.0
    9: c(0)=0.476666659116745
    9: c(1)=0.15186521410942078
    9: c(2)=0.0
    9: d(0)=0.25
    9: d(1)=-1.1102230246251565e-16
    9: d(2)=0.0
...


Quantized Uvw-Data:
uvw polygon 0: {'a': Vector(0.25, 0.152, 0), 'b': Vector(0.433, 0.152, 0), 'c': Vector(0.25, 0.174, 0), 'd': Vector(0, 0, 0)}
    0: a(0)=0.25
    0: a(1)=0.15186521410942078
    0: a(2)=0.0
    0: b(0)=0.4333333373069763
    0: b(1)=0.15186521410942078
    0: b(2)=0.0
    0: c(0)=0.25
    0: c(1)=0.17397046089172363
    0: c(2)=0.0
    0: d(0)=0.0
    0: d(1)=0.0
    0: d(2)=0.0
...
uvw polygon 8: {'a': Vector(0.433, 0, 0), 'b': Vector(0.433, 0.111, 0), 'c': Vector(0.25, 0.111, 0), 'd': Vector(0.25, 0, 0)}
    8: a(0)=0.4333333373069763
    8: a(1)=-0.0
    8: a(2)=0.0
    8: b(0)=0.4333333373069763
    8: b(1)=0.11077965795993805
    8: b(2)=0.0
    8: c(0)=0.25
    8: c(1)=0.11081257462501526
    8: c(2)=0.0
    8: d(0)=0.25
    8: d(1)=-0.0
    8: d(2)=0.0
uvw polygon 9: {'a': Vector(0.433, 0.174, 0), 'b': Vector(0.433, 0.152, 0), 'c': Vector(0.477, 0.152, 0), 'd': Vector(0.25, 0, 0)}
    9: a(0)=0.4333333373069763
    9: a(1)=0.17397046089172363
    9: a(2)=0.0
    9: b(0)=0.4333333373069763
    9: b(1)=0.15186521410942078
    9: b(2)=0.0
    9: c(0)=0.476666659116745
    9: c(1)=0.15186521410942078
    9: c(2)=0.0
    9: d(0)=0.25
    9: d(1)=-0.0
    9: d(2)=0.0
...

The script:

"""Showcases how to quantize data in a UvwTag.
"""

import c4d

def InspectUvwTag(tag: c4d.UVWTag):
    """Prints out the uvw data for the passed UVWTag.
    
    Args:
        tag: The tag to inspect.
    """
    if not isinstance(tag, c4d.UVWTag):
        raise TypeError(f"Unexpected argument type: {tag = }")

    countGenerator = range(tag.GetDataCount())
    for i, uvwPolygon in ((i, tag.GetSlow(i)) for i in countGenerator):
        print (f"uvw polygon {i}: {uvwPolygon}")
        for vertexName, vertex in uvwPolygon.items():
            for componentName, component in enumerate((vertex.x, 
                                                       vertex.y, 
                                                       vertex.z)):
                print (f"\t{i}: {vertexName}({componentName})={component}")

def QuantizeUvwTag(tag: c4d.UVWTag, digits: int = 12):
    """Quantizes the uvw data in #tag with a stride of #digits.
    
    Args:
        tag: The tag to modify.
        digits (optional): The number of digits of precision, defaults 
        to 12.
    """
    if not isinstance(tag, c4d.UVWTag):
        raise TypeError(f"Unexpected argument type: {tag = }")

    countGenerator = range(tag.GetDataCount())
    for i, uvwPolygon in ((i, tag.GetSlow(i)) for i in countGenerator):
        quantizedUvwPolygon = {}
        for key, vertex in uvwPolygon.items():
            # I am only modifying the precision of the values here, I am
            # not clamping them. Which will lead to values of -0.0 to be
            # written. Modify this to your requirements, this is a very
            # cosmetic task after all. -1.1e-16 is when push comes to shove
            # the same as 0.0 in the context of UVW data. So this quantization
            #  is not really required, unless you want 'nice' data.
            quantizedUvwPolygon[key] = c4d.Vector(round(vertex.x, digits), 
                                                  round(vertex.y, digits),
                                                  round(vertex.z, digits))
        tag.SetSlow(i, 
            quantizedUvwPolygon["a"], 
            quantizedUvwPolygon["b"], 
            quantizedUvwPolygon["c"],
            quantizedUvwPolygon["d"])


def main():
    """Entry point.
    """
    if op is None:
        raise RuntimeError("Please select an object.")

    tag = op.GetTag(c4d.Tuvw)
    if tag is None:
        raise AttributeError(f"Selected object {op} has no uvw tag.")

    # Inspect the tag. This will only print out different results than the
    # second call of InspectUvwTag() the first time the script is being run,
    # because after that the tag will already have been quantized.
    print ("Uvw-Data:")
    InspectUvwTag(tag)
    # Quantize its data.
    QuantizeUvwTag(tag)
    # And inspect it again.
    print ("\n\nQuantized Uvw-Data:")
    InspectUvwTag(tag)


if __name__=='__main__':
    main()

Hello @roman,

I have forked this topic since this a new question. Please refer to the Forum Guidelines for details on forum procedures.

The error message AttributeError: 'NoneType' object has no attribute 'GetAllPoints'. likely stems from you having no object selected when trying to run the script you posted. This is because the script simply assumes that op is populated, i.e., some kind of BaseObject, and even further it assumes that it is not only a BaseObject but also a PointObject. Both assumptions can prove false, as the user can have no selection, then op is None, or a selection which is not a PointObject, e.g., some parametric object.

Your code will also not work for what you wanted to do regarding the last thread, as this new code only applies to a singular object. Your code is also a bit complicated for my taste, it could be done more cleanly like this:

# Get the origin of the bounding box of the object, i.e., where
# the axis should be.
origin = node.GetMp()

# The global matrix of the object.
mg = node.GetMg()

# The delta between where the axis is and where it should be
delta = c4d.Matrix(off=origin)

# Move all points by the inverse of that delta.
node.SetAllPoints([(p * ~delta) for p in node.GetAllPoints()])

# Set the new node position
node.SetMg(mg * delta)

I have provided an example solution in the context of your last topic. The major insight here is that you have to do things then in two steps. First you go over all selcted objects to set their layers and try to move their axis. And after that you can calaculate the position of the null. Please also note that:

1. Moving the axis of an object can be quite the can of worms when you start touching orientation or scale, as you then also have to update tangent tags, normal tags and other data.
2. The provided code is an example and might still contain bugs you must fix yourself. We cannot provide full solutions.

Cheers,
Ferdinand

The result:

The test scene:
test_scene.c4d

The code:

import c4d

def main():
    """
    """
    # Start an undo stack item.
    doc.StartUndo()

    # Add a new top-level layer
    newLayer = c4d.documents.LayerObject()
    layerRoot = doc.GetLayerObjectRoot()
    newLayer.InsertUnder(layerRoot)
    doc.AddUndo(c4d.UNDOTYPE_NEWOBJ, newLayer)

    # Let the user name the new layer
    newName = c4d.gui.RenameDialog(newLayer.GetName())
    newLayer[c4d.ID_BASELIST_NAME] = newName

    # Get the selected objects.
    selectedObjects = doc.GetActiveObjects(c4d.GETACTIVEOBJECTFLAGS_NONE)

    # Iterate over the selected objects to change their layer and the layer
    # of the attached materials and optionally center their axis.
    for node in selectedObjects:
        # Attempt to center the axis for editable objects.
        if isinstance(node, c4d.PointObject):
            # Get the origin of the bounding box of the object, i.e., where
            # the axis should be.
            origin = node.GetMp()

            # The global matrix of the object.
            mg = node.GetMg()

            # The delta between where the axis is and where it should be
            delta = c4d.Matrix(off=origin)

            # Move all points by the inverse that delta.
            doc.AddUndo(c4d.UNDOTYPE_CHANGE, node)
            node.SetAllPoints([(p * ~delta) for p in node.GetAllPoints()])

            # Move the object by that delta.
            node.SetMg(mg * delta)

        # Set the layer of the current node.
        doc.AddUndo(c4d.UNDOTYPE_CHANGE, node)
        node[c4d.ID_LAYER_LINK] = newLayer

        # Get all materials attached with material tags to the node.
        isTex = lambda node: node.IsInstanceOf(c4d.Ttexture)
        for material in [t.GetMaterial() for t in node.GetTags() if isTex(t)]:
            doc.AddUndo(c4d.UNDOTYPE_CHANGE, material)
            material[c4d.ID_LAYER_LINK] = newLayer

    # Compute the mean global offset for all objects in the selection.
    meanOffset = (sum((n.GetMg().off for n in selectedObjects)) * 
                  (1. / len(selectedObjects)))

    # Create a null object at that offset to parent the selected objects to.
    newLayerNull = c4d.BaseObject(c4d.Onull)
    newLayerNull[c4d.ID_LAYER_LINK] = newLayer
    newLayerNull[c4d.ID_BASELIST_NAME] = newName
    newLayerNull.SetMg(c4d.Matrix(off=meanOffset))
    doc.InsertObject(newLayerNull)
    doc.AddUndo(c4d.UNDOTYPE_NEWOBJ, newLayerNull)

    # Loop again over all selected objects to parent them to the new null
    # object.
    for node in selectedObjects:

        # Get the global matrix of the node and then remove it from the scene.
        mg = node.GetMg()
        doc.AddUndo(c4d.UNDOTYPE_CHANGE, node)
        node.Remove()

        # Attach the node to its new parent and set its global matrix to the 
        # stored value.
        node.InsertUnder(newLayerNull)
        node.SetMg(mg)

    # Close the undo item and push an update event to Cinema 4D.
    doc.EndUndo()
    c4d.EventAdd()

if __name__ == '__main__':
    main()