Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
[CINEMA 4D: Python Helpers Class] The Helpers class is collection of reusable methods from cgsociety, the Plugin Café and from my own scripts. #cinema4d #c4d #python #class #helpers #computergraphics #cg
class Helpers(object):
"""Contains various helper methods."""
def __init__(self, arg):
super(Helpers, self).__init__()
@staticmethod
def readConfig(filepath=None):
"""
Read settings from a configuration file.
Returns None if config file at filepath doesn't exist.
Returns the config object on success.
"""
result = None
if filepath is None:
filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), "res/", "config.ini")
if os.path.exists(filepath):
config = ConfigParser.ConfigParser()
config.read(filepath)
result = config
return result
@staticmethod
def saveConfig(config, filepath=None):
"""
Save settings to a configuration file.
If filepath is None, it will be assumed to point to res/config.ini.
Returns True if successful, False otherwise.
"""
result = False
if filepath is None:
filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), "res/", "config.ini")
try:
with open(filepath, 'wb') as configfile:
config.write(configfile)
result = True
except Exception, e:
print "*** Caught Exception: %r ***" % e
return result
@staticmethod
def initConfig(defaults, filepath=None):
"""
Initialize configuration file by writing the defaults.
Returns True if config file was created,
False if config file already exists or otherwise.
"""
result = False
if filepath is None:
filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), "res/", "config.ini")
if not os.path.exists(filepath):
config = ConfigParser.ConfigParser(defaults)
result = Helpers.saveConfig(config, filepath)
return result
@staticmethod
def vDeg(v, ishpb=False):
"""Convert each component of vector v to degrees"""
if v is None:
raise ValueError("v can't be None")
if not isinstance(v, c4d.Vector):
raise TypeError("Expected vector, got %s" % type(v))
if ishpb:
res = c4d.Vector(0,0,0)
res.x = Deg(v.x)
res.y = Deg(v.y)
res.z = Deg(v.z)
if res.x >= 180:
res.x -= 360
if res.y >= 180:
res.y -= 360
if res.z >= 180:
res.z -= 360
return res
else:
return c4d.Vector(Deg(v.x), Deg(v.y), Deg(v.z))
@staticmethod
def vRad(v, ishpb=False):
"""Convert each component of vector v to radians"""
if v is None:
raise ValueError("v can't be None")
if not isinstance(v, c4d.Vector):
raise TypeError("Expected vector, got %s" % type(v))
if ishpb:
if v.x >= 180:
v.x -= 360
if v.y >= 180:
v.y -= 360
if v.z >= 180:
v.z -= 360
return c4d.Vector(Rad(v.x), Rad(v.y), Rad(v.z))
@staticmethod
def vAvg(lst):
"""Calculate the average of a list of vectors"""
if lst is None:
raise ValueError("List lst can't be None")
if not isinstance(lst, list):
raise TypeError("Expected list of vectors, got %s" % type(lst))
lstlen = len(lst)
res = c4d.Vector(0,0,0)
if lstlen == 0: return res
for l in lst:
res.x += l.x
res.y += l.y
res.z += l.z
res.x = res.x / float(lstlen)
res.y = res.y / float(lstlen)
res.z = res.z / float(lstlen)
return res
@staticmethod
def select(op):
if not op.GetBit(c4d.BIT_ACTIVE):
op.ToggleBit(c4d.BIT_ACTIVE)
return op.GetBit(c4d.BIT_ACTIVE)
@staticmethod
def selectAdd(op):
"""
Same as select(op) but uses a slightly different mechanism.
See also BaseDocument.SetSelection(sel, mode).
"""
doc = op.GetDocument()
doc.SetActiveObject(op, c4d.SELECTION_ADD)
@staticmethod
def selectGroupMembers(grp):
doc = documents.GetActiveDocument()
for obj in grp:
# add each group member to the selection
# so we can group them in the object manager
#doc.AddUndo(UNDO_BITS, obj)
doc.SetActiveObject(obj, c4d.SELECTION_ADD)
@staticmethod
def selectObjects(objs):
for op in objs:
Helpers.select(op)
@staticmethod
def deselectAll(inObjMngr=False):
"""
Not the same as BaseSelect.DeselectAll().
inObjMngr bool if True, run the deselect command from Object Manager,
else the general one for editor viewport
"""
if inObjMngr is True:
c4d.CallCommand(100004767) # deselect all (Object Manager)
else:
c4d.CallCommand(12113) # deselect all
@staticmethod
def groupObjects(objs, name="Group"):
"""
CallCommand based grouping of objects from a list.
Generally unreliable, because selection state matters.
Use insertUnderNull for better effect.
"""
Helpers.deselectAll(True)
result = None
if objs is None:
return result
if not isinstance(objs, list):
objs = [objs]
else:
return result
for o in objs:
Helpers.select(o)
if DEBUG: print "creating group %s" % name
c4d.CallCommand(100004772) # group objects
doc = documents.GetActiveDocument()
grp = doc.GetActiveObject()
grp.SetName(name)
result = grp
return result
@staticmethod
def groupSelected(name="Group"):
"""
CallCommand based grouping of selected objects.
Generally unreliable, because selection state matters.
Use insertUnderNull for better effect.
"""
result = None
if DEBUG: print "creating group %s" % name
c4d.CallCommand(100004772) # group objects
doc = documents.GetActiveDocument()
grp = doc.GetActiveObject()
grp.SetName(name)
result = grp
return result
@staticmethod
def recurseBranch(obj):
child = obj.GetDown()
while child:
child = child.GetNext()
return Helpers.recurseBranch(child)
@staticmethod
def getNextObject(op, stopobj=None):
if op == None: return None
if op.GetDown(): return op.GetDown()
if stopobj is None:
while not op.GetNext() and op.GetUp():
op = op.GetUp()
else:
while (not op.GetNext() and
op.GetUp() and
op.GetUp() != stopobj):
op = op.GetUp()
return op.GetNext()
@staticmethod
def getActiveObjects(doc):
"""
Same as BaseDocument.GetSelection(), where GetSelection also selects tags and materials.
"""
lst = list()
op = doc.GetFirstObject()
while op:
if op.GetBit(c4d.BIT_ACTIVE) == True:
lst.append(op)
op = Helpers.getNextObject(op)
return lst
@staticmethod
def findObject(name):
"""Find object with name 'name'"""
if name is None: return None
if not isinstance(name, basestring):
raise TypeError("Expected string, got %s" % type(name))
doc = documents.GetActiveDocument()
if not doc: return None
result = None
op = doc.GetFirstObject()
if not op: return None
curname = op.GetName()
if curname == name: return op
op = Helpers.getNextObject(op)
while op:
curname = op.GetName()
if curname == name:
return op
else:
op = Helpers.getNextObject(op)
return result
@staticmethod
def findObjects(name):
"""Find objects with name 'name'"""
if name is None: return None
if not isinstance(name, basestring):
raise TypeError("Expected string, got %s" % type(name))
doc = documents.GetActiveDocument()
if not doc: return None
result = []
op = doc.GetFirstObject()
if not op: return result
while op:
curname = op.GetName()
if curname == name:
result.append(op)
op = Helpers.getNextObject(op)
return result
@staticmethod
def createObject(typ, name, undo=True):
obj = None
try:
doc = documents.GetActiveDocument()
if doc is None: return None
obj = c4d.BaseObject(typ)
obj.SetName(name)
c4d.StopAllThreads()
doc.InsertObject(obj)
if undo is True:
doc.AddUndo(c4d.UNDOTYPE_NEW, obj)
c4d.EventAdd()
except Exception, e:
print "*** Caught Exception: %r ***" % e
return obj
@staticmethod
def insertUnderNull(objs, grp=None, name="Group", copy=False):
"""
Inserts objects under a group (null) object, optionally creating the group.
objs BaseObject can be a single object or a list of objects
grp BaseObject the group to place the objects under
(if None a new null object will be created)
name str name for the new group
copy bool copy the objects if True
Returns the modyfied/created group on success, None on failure.
"""
if grp is None:
grp = Helpers.createObject(c4d.Onull, name)
if copy == True:
objs = [i.GetClone() for i in objs]
if DEBUG: print "inserting objs into group '%s'" % grp.GetName()
if isinstance(objs, list):
for obj in objs:
obj.Remove()
obj.InsertUnder(grp)
else:
objs.Remove()
objs.InsertUnder(grp)
c4d.EventAdd()
return grp
@staticmethod
def togglePolySelection(op):
result = False
totalpolys = op.GetPolygonCount()
psel = op.GetPolygonS()
while psel.HostAlive() == 1:
for poly in xrange(totalpolys):
psel.Toggle(poly)
result = True
break
return result
@staticmethod
def selectAllPolys(op):
result = False
totalpolys = op.GetPolygonCount()
psel = op.GetPolygonS()
while psel.HostAlive() == 1:
for poly in xrange(totalpolys):
psel.Select(poly)
result = True
break
return result
@staticmethod
def polyToList(p):
if not isinstance(p,c4d.CPolygon):
raise TypeError, "CPolygon expected"
if p.c == p.d: return [p.a,p.b,p.c]
return [p.a,p.b,p.c,p.d]
@staticmethod
def listToPoly(l):
if not isinstance(l, list):
raise TypeError, "list or dict expected"
ln = len(l)
if ln < 3:
raise IndexError, "lst must have at least 3 indieces"
elif ln == 3:
return c4d.CPolygon(l[0],l[1],l[2])
else:
return c4d.CPolygon(l[0],l[1],l[2],l[3])
@staticmethod
def calcPolyNormal(p, op):
"""
Calculate the orientation of face normal by using Newell's method.
See calcVertexNormal for an example of usage within the calling context.
"""
if not p: raise ValueError("p can't be None")
if not isinstance(p, c4d.CPolygon):
raise TypeError("Expected CPolygon, got %s" % type(p))
N = c4d.Vector(0,0,0)
lst = Helpers.polyToList(p)
llen = len(lst)
#print "lst = %r" % lst
allp = op.GetAllPoints()
for i in range(llen):
x = i
n = ((i+1) % llen)
#print x, n
vtx = allp[lst[x]]
vtn = allp[lst[n]]
#print "vtx%d = %r (%s)" % (x, vtx, type(vtx))
#print "vtn%d = %r (%s)" % (n, vtn, type(vtn))
N.x += (vtx.y - vtn.y) * (vtx.z + vtn.z)
N.y += (vtx.z - vtn.z) * (vtx.x + vtn.x)
N.z += (vtx.x - vtn.x) * (vtx.y + vtn.y)
return N.GetNormalized()
@staticmethod
def calcVertexNormal(v, idx, op):
"""
Calculate the vertex normal by averaging surrounding face normals.
Usually called from a construct like the following:
for i, point in enumerate(op.GetAllPoints()):
vn = calcVertexNormal(point, i, op):
"""
if not v: raise ValueError("v can't be None")
if not isinstance(v, c4d.Vector):
raise TypeError("Expected Vector, got %s" % type(v))
N = c4d.Vector(0,0,0)
nb = Neighbor()
nb.Init(op)
pntpolys = nb.GetPointPolys(idx)
polys = []
normals = []
allp = op.GetAllPolygons()
for poly in pntpolys:
x = poly
poly = allp[poly]
#print "poly %d = %r (%s)" % (x, poly, type(poly))
polys.append(poly)
normal = Helpers.calcPolyNormal(poly, op)
normals.append(normal)
ln = len(normals)
if ln == 0: return N # beware of div by zero
for n in normals:
N += n
N = c4d.Vector(N.x/ln, N.y/ln, N.z/ln)
return N.GetNormalized()
@staticmethod
def calcThreePointNormal(v1, v2, v3):
"""
Calculate the surface normal of a three point plane.
Doesn't take orientation of neighboring polygons into account.
"""
try:
d1 = - v1 + v3
d2 = - v2 + v3
result = d1.Cross(d2).GetNormalized()
except Exception, e:
raise ValueError("Surface normal calculation failed. The error message was: %r" % e)
return result
@staticmethod
def getGlobalPosition(obj):
return obj.GetMg().off
@staticmethod
def getGlobalRotation(obj):
return MatrixToHPB(obj.GetMg())
@staticmethod
def getGlobalScale(obj):
m = obj.GetMg()
return c4d.Vector(m.v1.GetLength(),
m.v2.GetLength(),
m.v3.GetLength())
@staticmethod
def setGlobalPosition(obj, pos):
m = obj.GetMg()
m.off = pos
obj.SetMg(m)
@staticmethod
def setGlobalRotation(obj, rot):
"""
Please remember, CINEMA 4D handles rotation in radians.
Example for H=10, P=20, B=30:
import c4d
from c4d import utils
#...
hpb = c4d.Vector(utils.Rad(10), utils.Rad(20), utils.Rad(30))
SetGlobalRotation(obj, hpb) #object's rotation is 10, 20, 30
"""
m = obj.GetMg()
pos = m.off
scale = c4d.Vector( m.v1.GetLength(),
m.v2.GetLength(),
m.v3.GetLength())
m = HPBToMatrix(rot)
m.off = pos
m.v1 = m.v1.GetNormalized() * scale.x
m.v2 = m.v2.GetNormalized() * scale.y
m.v3 = m.v3.GetNormalized() * scale.z
obj.SetMg(m)
@staticmethod
def setGlobalScale(obj, scale):
m = obj.GetMg()
m.v1 = m.v1.GetNormalized() * scale.x
m.v2 = m.v2.GetNormalized() * scale.y
m.v3 = m.v3.GetNormalized() * scale.z
obj.SetMg(m)
@staticmethod
def setAxisRotation(op, rot, local=False):
"""
Set the rotation of the object axis (i.e. keeping points in place).
obj object
rot vector
Courtesy of Scott Ayers, source:
http://www.plugincafe.com/forum/forum_posts.asp?TID=5663&PID=23480#23480
"""
if op is None: return False
if not isinstance(rot, c4d.Vector):
raise TypeError("expected c4d.Vector, got %s" % type(rot))
currot = op.GetRelRot()
if VectorEqual(currot, rot): return
op.SetRelRot(rot)
if local is True:
mat = op.GetMl()
else:
mat = op.GetMg()
inv = ~mat
points = op.GetAllPoints()
for i in range(len(points)):
points[i] = points[i] * inv
op.SetAllPoints(points)
op.Message(c4d.MSG_UPDATE)
c4d.EventAdd()
@staticmethod
def centerObjectAxis(obj):
# check object type
if obj is None or not isinstance(obj, c4d.PointObject):
return True
maxpoints = obj.GetPointCount()
if maxpoints == 0:
return False
# get center of gravity of object vertices in parent's coordinates
cg = c4d.Vector(0,0,0)
scale = 1.0 / maxpoints
for c in xrange(0, maxpoints):
cg += (obj.GetPoint(c) * scale)
ml = obj.GetMl()
cg = ml * cg # GetMulP
# get inverse of matrix of object and the translation vector to new position
inv = ml.__invert__()
trans = inv * (cg - obj.GetRelPos()) # GetMulV
# move object to new position and compensate vertex positions
obj.SetRelPos(cg)
for c in xrange(0, maxpoints):
obj.SetPoint(c, obj.GetPoint(c) - trans)
obj.Message(c4d.MSG_UPDATE)
# compensate positions of child objects
child = obj.GetDown()
while child:
child = child.GetNext()
child.SetRelPos(child.GetRelPos() - trans)
return True
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment