Hi mfersaoui, thanks for reaching out us.

With regard to your issue I've a few notes:

• the Adaptive interpolation is by definition strictly dependent on the shape of the spline with regard to the tessellation of the curve: the curve will be tessellated more where the curvature is larger and this generates evidently non-uniform segments distribution - check here for further notes -;
• standing on the code presented the in_range variable is always 1.0 which makes this

if (CompareFloatTolerant(inrange, 0.0)) value = 0.0;
	else value = (value - min_input) / inrange;

pretty useless.

I would recommend, assuming that the adaptive strategy is the one you want to keep to consider ( sorry for the python code, but porting should be trivial)

        # swap the max/min values of the slider
        val = op[c4d.ID_USERDATA, 1]
        # set the interpolation method
        interp = 3
        # allocate the spline
        spline = c4d.SplineObject(4, c4d.SPLINETYPE_BSPLINE)
        # set interpolation method
        spline[c4d.SPLINEOBJECT_INTERPOLATION] = interp
        # switch according to interpolation method
        if interp == 2: # uniform
            # set the max number of segs
            maxSegs = 100
            spline[c4d.SPLINEOBJECT_SUB] = int(maxSegs * val)
        if interp == 3: # adaptive
            # get the rad representation of the slider's value
            radVal = c4d.utils.DegToRad(90 * (1.0 - val))
            # set the adaptive angle value
            spline[c4d.SPLINEOBJECT_ANGLE] = radVal
        # set the points
        point = spline.SetAllPoints((c4d.Vector(0,0,0),c4d.Vector(0,0,900),c4d.Vector(0,900,900), c4d.Vector(0,900,0)))
        # return the spline
        return spline

If instead you'd like to linearly increase the subdivision, I warmly recommend to switch to the uniform method and you'll see that a linear behavior is established

Best, R

Hi cmpxchg8b and thanks for reaching out us.

With regard to your issue, it's explicitly discouraged, as written in the C++ API documentation, to store BaseObject pointers and to use them for further operations especially when object creation/deletion and undo processes steps takes place.

It's instead recommended using the BaseLinkwhich provides a convenient and reliable way to refer to BaseList2D elements in a scene.

BaseLink principles and use are well explained here.

Finally, the code below doesn't show the segmentation fault you've mentioned.

maxon::Result<void> Check(BaseDocument *doc)
{
	// check for passed parameter
	if (!doc)
		return maxon::IllegalArgumentError(MAXON_SOURCE_LOCATION);
	
	// get the active BaseObject
	BaseObject* obj = doc->GetActiveObject();
	if (!obj)
		return maxon::OK;
	
	// print the object's name
	DiagnosticOutput ("Object [@]", maxon::String(obj->GetName()));
	
	// allocate a BaseLink
	BaseLink *link = BaseLink::Alloc();
	if (!link)
		return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
	
	// connect to the object
	link->SetLink(obj);
	
	// access the BaseObject referred by the link
	BaseObject* const linkedObj = static_cast<BaseObject*>(link->GetLink(doc));
	
	// print the referred object's name
	DiagnosticOutput ("Linked Object [@]", maxon::String(linkedObj->GetName()));
	
	// assert returned names are equal
	DebugAssert(obj->GetName() == linkedObj->GetName());
	
	return maxon::OK;
}

Looking forward further feedback, give best.
Riccardo

Hi Ilad, thanks for reaching out us.

With regard to your request, I warmly recommend to have a look at Materials and Shaders Overview where the basic of Cinema 4D materials and shading handling are discussed. Consider that even if the documentation refers to C++ the described concepts can be applied to Python as well.

Briefly the solution to your request is:

def main():
    # get first object
    cubeA = doc.GetActiveObject()
    if cubeA is None: 
       return
   
    # get second object
    cubeB = op.GetNext()
    if cubeB is None:
        cubeB = op.GetPred()
    
    #get first material
    matA = doc.GetActiveMaterial()
    if matA is None: 
        return
    
    # get second material
    matB = matA.GetNext()
    if matB is None:
        matB = matA.GetPred()
    
    # create the texture tags for A and B
    ttagA = c4d.TextureTag()
    ttagB = c4d.TextureTag()
    
    # assign the swapped materials to the texture tags
    ttagA.SetMaterial(matB)
    ttagB.SetMaterial(matA)
    
    # insert the tags to the corresponding objects
    cubeA.InsertTag(ttagA)
    cubeB.InsertTag(ttagB)
    
    # queue an event
    c4d.EventAdd()

Last but not least, it's recommended for future threads to use the appropriate category and mark it as "Ask as a question" upon creation.

Best, Riccardo

Can you create user interfaces with Python or do you somehow build the tool interface with user data?

Yes you can! Cinema 4D Python API comes with a complete set of classes to deliver full-fledged UI to your scripts or plugins. Please start looking at the examples in the Python Github repository to get an idea on Python API potentials.

If I wanted this camera rig to be setup via a button would I have to create the xpresso interface or would this be done another way?

Depending on the final purposes, skipping the Xpresso graph in favor of a Python-based logic could be preferred if the logic is supposed not to be changed by development-agnostic guys. The initial idea of Xpresso was exactly of providing a convenient and easy-to-use interface to implement programmatic behaviors or models without writing a single line of code.

Also, is it best to learn Python basics before jumping into C4D plugin development? If so what are the best starting points?

Definitively it is! I warmly recommend going through a first dive in Python, get comfortable with those concepts representing its development foundation and then move to the Cinema 4D Python API. This will help you to better understand the examples.

Best, Riccardo

Hi woodstar, thanks for reaching out us.

With regard to your issue, the problem is that you're addressing an invalid object when you call `op.GetObject(). This is typically the case when you've a Python Tag attached to an object and by using that statement you're able to retrieve the parent object of the Python Tag.
In your case instead it's enough to write something like:

...
def message(msgId, msgData):
    if msgId == c4d.MSG_DESCRIPTION_COMMAND:
        if msgData['id'] == c4d.DescID(c4d.DescLevel(c4d.ID_USERDATA), c4d.DescLevel(9)):
            op[c4d.ID_USERDATA,8] = 36
            print "36mm"
        elif msgData['id'] == c4d.DescID(c4d.DescLevel(c4d.ID_USERDATA), c4d.DescLevel(13)):
            op[c4d.ID_USERDATA,8] = 50
            print "50mm"
        elif msgData['id'] == c4d.DescID(c4d.DescLevel(c4d.ID_USERDATA), c4d.DescLevel(15)):
            op[c4d.ID_USERDATA,8] = 80
            print "80mm"
    return True
...

That said, considering the usual scope of a Python Generator which actually is to "generate" geometry and the one pertaining to a Python Tag which instead is to react programmatically to certain user interactions (like pressing a button) I suggest to reconsider your solution, eventually getting rid of the Xpresso network, and embedd the whole functionality in a simpler scripting tag.

Best, Riccardo

Hi joe_curwen, thanks for reaching out us.

With regard to your question, can you please elaborate more? It's not completely clear what you're attempting to achieve and we can't be of any support with more information.

Are you thinking to use a generic geometry as a some sort of 'live selectio' tool to select all the points (of other scene entities) that are intersected by this "selecting" geometry? Or what?

Best, Riccardo

Hi iLad, thanks for reaching out us.

With regard to your question, beside sponsoring @mp5gosu's answers, I also recommend to look at:

• Matrix Fundamentals: a few basic information on matrices and geometry are provided
• c4d.Matrix: the section describing the matrix class implementation in Cinema 4D
• c4d.PointObject: the section describing the PointObject implementation (the class responsible for handling the vertex data of a generic object)

Wrapping all the above information together, you might end up with something like:

import c4d
from c4d import gui
#Welcome to the world of Python


def main():
    # check about op existance
    if op == None:
        return

    #check about op being derived from a PointObject
    if op.IsInstanceOf(c4d.Opoint) == False:
        return
    
    # set the offset of the axis
    offset = c4d.Vector(100,0,0)
    
    # move object
    m = op.GetMg()
    m.off = m.off + offset
    op.SetMg(m)
    
    # transform points
    padr = op.GetAllPoints()
    
    for i, point in enumerate(padr):
        point = point - offset
        op.SetPoint(i,point)
        
    op.Message(c4d.MSG_UPDATE)

if __name__=='__main__':
    main()
    c4d.EventAdd()

Note that the above example works properly only if you're supposed to make on offset of the axis and not if you're attempting to change axis orientation: in this latter case you've to compute the inverse transformation matrix and use this to reposition the object in space upon vertexes repositioning.

Best, Riccardo

@rsodre : looks like it.

Hi Ilad, I've overlooked one thing here: my notes above are useful if you're running the code as a script in the Script Manager but if you're using a Python generator then you've to return an object in your code that contains all the different cubes and, in this case, the EventAdd() can be skipped.

Something like this should work:

import c4d

def create_object(x):
    position = c4d.Vector(x, 0, 0)
    a = c4d.BaseObject(c4d.Ocube)
    a.SetAbsPos(position)
    return a

def main():
    mynull = c4d.BaseObject(c4d.Onull)
    for i in range(1,2000,400):
        create_object(i).InsertUnder(mynull)
        
    return mynull

Best, Riccardo

Hi ilad, thanks for reaching out us and welcome to our community

With regard to your issue, there are two main things to note:

1. the create_object function returns a BaseObject that should be inserted in the active BaseDocument in order to let Cinema make good use of it. The method to look for is BaseDocument::InsertObject();
2. upon inserting the objects in the scene an EventAdd() should be called in order to inform Cinema that the scene has changed and the events queue needs to be processed.

Something like the code below should work.

import c4d 

def create_object(x):
    position = c4d.Vector(x, 0, 0)
    a = c4d.BaseObject(c4d.Ocube)
    a.SetAbsPos(position)
    return a

def main():
    for i in range(1,2000,400):
        doc.InsertObject(create_object(i))
        
    c4d.EventAdd()

That said I also recommend you for the future to:

• use the appropriate category for posting questions making good use of the Read Before Posting ;
• use the tagging system in order to improve our knowledge-base;
• use the Question & Answer functionality when posting questions.

Keep enjoying your discovery of Cinema 4D Python API and feel free to get back with further questions

Riccardo