SOLVED Flat UV Projection in Python

I'm creating a polygon object in an ObjectData plugin. I would like to layout its UVs with Flat projection (similar to BodyPaint's Flat Projection button). I found this post with code taken from this post on the forum. This seems to be what I need, but it's old and I ran into some issues with methods unavailable to the Python API. Here is my port of the code to Python:

import c4d,math

#This code creates the equivalent to the flat mapping button in the BP UV options

#Define a value macro to be used several times later on

def TrimDecimal(num, digits):
    n = None
    n = num * math.pow(10.0, digits)
    n = math.copysign(1, n) * abs(math.floor(n + 0.5))
    return n / math.pow(10.0, digits)

def FrontalMapUVs(op, mg):
    if op is None:
        return false

    numFaces = op.GetPolygonCount()
    numVerts = op.GetPointCount()
    pVerts = op.GetPointW() #GetPointW doesn't exist in the Python API
    pPolys = op.GetPolygonW()

    pUVTag = op.MakeVariableTag(c4d.Tuvw, numFaces)
    if pUVTag is None:
        return false

    pUVHndl = pUVTag.GetDataAddressW() #GetDataAddressW doesn't exist in the Python API
    if pUVHndl is None:
        return false

    lenxinv, lenyinv, lenzinv = None, None, None

    vMin = c4d.Vector(100000.0)
    vMax = c4d.Vector(-100000.0)

    for ndx in range(numVerts):
        pt = pVerts[ndx] * mg #pVerts won't work because GetPointW doesn't exist
        if pt.x < vMin.x: vMin.x = pt.x
        if pt.x > vMax.x: vMax.x = pt.x
        if pt.y < vMin.y: vMin.y = pt.y
        if pt.y > vMax.y: vMax.y = pt.y
        if pt.z < vMin.z: vMin.z = pt.z
        if pt.z > vMax.z: vMax.z = pt.z

    mapSize = c4d.Vector(abs(vMax.x - vMin.x),abs(vMax.y - vMin.y),abs(vMax.z - vMin.z))
    mapCenter = c4d.Vector(vMin.x+(mapSize.x*0.5),vMin.y+(mapSize.y*0.5),vMin.z+(mapSize.z*0.5))

    if mapSize.x != 0.0:
        lenxinv = 1.0 / mapSize.x
        lenxinv = 0.0

    if mapSize.y != 0.0:
        lenyinv = 1.0 / mapSize.y
        lenyinv = 0.0

    if mapSize.z != 0.0:
        lenzinv = 1.0 / mapSize.z
        lenzinv = 0.0

    # Walk the list of polygons and map the UVs
    for ndx in range(numFaces):
        Not sure what to do here as UVWStruct & UVWTag.Get do not exist in the Python API
        uvw = c4d.UVWStruct()
        pUVTag.Get(pUVHndl, ndx, uvw)

        pt_a = (pVerts[pPolys[ndx].a] - mapCenter) +
        pt_b = (pVerts[pPolys[ndx].b] - mapCenter) +
        pt_c = (pVerts[pPolys[ndx].c] - mapCenter) +
        pt_d = (pVerts[pPolys[ndx].d] - mapCenter) +

        uvw.a.x = TrimDecimal((pt_a.x*lenxinv)+0.5, SIGDIG)
        uvw.a.y = TrimDecimal((-pt_a.y*lenyinv)+0.5, SIGDIG)

        uvw.b.x = TrimDecimal((pt_b.x*lenxinv)+0.5, SIGDIG)
        uvw.b.y = TrimDecimal((-pt_b.y*lenyinv)+0.5, SIGDIG)

        uvw.c.x = TrimDecimal((pt_c.x*lenxinv)+0.5, SIGDIG)
        uvw.c.y = TrimDecimal((-pt_c.y*lenyinv)+0.5, SIGDIG)

        uvw.d.x = TrimDecimal((pt_d.x*lenxinv)+0.5, SIGDIG)
        uvw.d.y = TrimDecimal((-pt_d.y*lenyinv)+0.5, SIGDIG)

        commented out because of UVWStruct missing above
        #pUVTag.Set(pUVHndl, ndx, uvw)

    return true

if __name__=='__main__':
    FrontalMapUVs(op,op.GetMg()) #I'm sending the selected object's global matrix, but I'm not sure if it's correct to do.

I noted some of the issues in the code's comments, but to sum up, I couldn't get it to work because these were missing in Python:

I also didn't know which Global Matrix I should send to the FrontalMapUVs function. I'd assume it was op, but it seems strange for that to be a parameter if it's already accepting op.

If there are no Python equivalents to these missing C++ methods, is there another way to do Flat UV Projection in Python with an ObjectData plugin?

Thank you!


your code looks a bit overly complicated and c-ish. There might very well be a reason for all the gymnastics that code does, but at least I am not able to see that reason. Here is how I would do it in Python.


"""Simple example for generating uvw data.

import c4d

# To implement other projections, you have just to implement another
# projection function ...

def planar_projection(frame, points):
    """Projects points into the XY plane.

        frame (c4d.Matrix): The projection frame.
        points (list[c4d.Vector]): The points to project.
        list[c4d.Vector]:The projected points.
    points = [p * frame for p in points]
    return [c4d.Vector(p.x, p.y, 0) for p in points]

def remap_to_texcoords(points):
    """Remaps a list of points to the common uv half range.

    The function assumes the x and y coordinates of the points to be the
    relevant coordinates and the points are being remapped based on the XY
    bounding rectangle.

        points (list[c4d.Vector]): The points to remap.

        list[c4d.Vector]:The remapped points.
    # Get the texture coordinates bounding rectangle.
    xmin, xmax = float("inf"), float("-inf")
    ymin, ymax = float("inf"), float("-inf")
    for p in points:
        xmin = p.x if p.x < xmin else xmin
        xmax = p.x if p.x > xmax else xmax
        ymin = p.y if p.y < ymin else ymin
        ymax = p.y if p.y > ymax else ymax

    # Remap the points from object coordinates to texture coordinates
    # in the common uv half range.
    points = [c4d.Vector(c4d.utils.RangeMap(p.x, xmin, xmax, 0., 1., True),
                         c4d.utils.RangeMap(p.y, ymin, ymax, 0., 1., True),
                         0) for p in points]
    return points

def create_uvw_tag(node, frame, f):
    """Creates an uvw tag for an object, a frame and a projection.

        node (c4d.PolygonObject): The node.
        frame (c4d.Matrix): The texture projection frame.
        f (callable): The projection function.
        c4d.UVWTag: The uvw tag.
    # Project the points of the node.
    points = f(frame, node.GetAllPoints())
    # Convert these points to texture space.
    uv_points = remap_to_texcoords(points)
    # Create the actual tag
    polygons = node.GetAllPolygons()
    uvw_tag = c4d.UVWTag(len(polygons))
    # We just go over all polygons and with that index our projected and
    # remapped points into the uvw tag.
    for i, cpoly in enumerate(polygons):
        a, b = uv_points[cpoly.a], uv_points[cpoly.b]
        c, d = uv_points[cpoly.c], uv_points[cpoly.d]
        uvw_tag.SetSlow(i, a, b, c, d)
    return uvw_tag

def main():
    if not isinstance(op, c4d.PolygonObject):
        msg = "Please select a polygon object."
        raise TypeError(msg)

    tag = create_uvw_tag(op, c4d.Matrix(), f=planar_projection)

if __name__ == "__main__":

Thank you very much @zipit ! That works great.