def update(self, object):
"""Adjusts the node's _subTreeItemIds list so that it matches an input object list.
TreeItemId s will be deleted or inserted into _subTreeItemIds based on its current content and
that of the input object list."""
count = self._member.getCount(object)
for i in range(count):
inObject = self._member.getObject(object,i)
try:
outObject = self.getObject(i)
areSameObject = PyUtils.sameObject(inObject, outObject)
except IndexError:
outObject = None
areSameObject = False
if not areSameObject:
# Need to delete or insert
# First, check how many objects we should delete
delete = 1
try:
while not PyUtils.sameObject( inObject, self.getObject(i+delete) ) :
delete += 1
except IndexError:
delete = 0
if delete > 0 :
# Delete the specified objects
self.removeChildren(i,i+delete)
else :
# Insert the specified object
self.insertChild(i, inObject)
# Delete any remaining objects
self.removeChildren(count)
def createBox( size=(1,1,1), position=(0,0,0), colour=(0.6,0.6,0.6) ):
"""
Creates the mesh for a box having the specified size and a specified position.
The size should be a 3-tuple (xSize, ySize, zSize).
The position should be a 3-tuple.
Colour should be a 3-tuple (R,G,B) or a 4-tuple (R,G,B,A)
"""
size = PyUtils.toVector3d(size)
position = PyUtils.toPoint3d(position)
vertices = []
delta = MathLib.Vector3d()
for repeat in range(3):
for x in (-0.5,0.5) :
delta.x = size.x * x
for y in (-0.5,0.5) :
delta.y = size.y * y
for z in (-0.5,0.5) :
delta.z = size.z * z
vertices.append( position + delta )
faces = [(0,1,3,2),(5,4,6,7), # YZ Faces
(9,13,15,11),(12,8,10,14), # XY Faces
(18,19,23,22),(17,16,20,21)] # XZ Faces
return create( vertices, faces, colour )
def create(self):
"""Creates the instant character based on the available description. Attach a reasonable controller, if available."""
app = wx.GetApp()
try:
wrappedController = PyUtils.wrapCopy( app.getController(0) )
except IndexError:
wrappedController = None
try:
character = app.getCharacter(0)
previousMass = character.getMass()
except IndexError:
previousMass = None
app.deleteAllObjects()
PyUtils.load( "RigidBodies.FlatGround" )
character = self._characterDescription.createCharacter()
character.computeMass()
app.addCharacter(character)
if wrappedController is not None:
controller = wrappedController.createAndFillObject(None, character)
if previousMass is not None:
massRatio = character.getMass() / previousMass
controller.scaleGains( massRatio )
app.addController(controller)
controller.setStance( Core.LEFT_STANCE )
self.connectController()
return character
def update(self, data = None):
"""Called whenever the curve list is updated. Make sure the curve editor list match the application curve list."""
count = self._appCurveList.getCount()
for i in range(count):
inCurve = self._appCurveList.get(i)
inTrajectory1d = inCurve.getTrajectory1d()
try:
outTrajectory1d = self.getTrajectory(i)
areSameObject = PyUtils.sameObject(inTrajectory1d, outTrajectory1d)
except IndexError:
outTrajectory1d = None
areSameObject = False
if not areSameObject:
# Need to delete or insert
# First, check how many curves we should delete
delete = 1
try:
while not PyUtils.sameObject( inTrajectory1d, self.getTrajectory(i+delete) ) :
delete += 1
except IndexError:
delete = 0
if delete > 0 :
# Delete the specified controllers
self._removeCurveEditors(i,i+delete)
else :
# Insert the specified controller
self._insertCurveEditor(i, inCurve)
# Delete any remaining controllers
self._removeCurveEditors(count)
self.getParent().layout()
def update(self, data = None):
"""Called whenever the tree is updated."""
try:
tree = self._infoTree
rootItem = tree.GetRootItem()
nodeData = tree.GetItemPyData( rootItem )
snapshot = nodeData.getObject().getCurrentSnapshot()
except AttributeError: return
if self._activeTreeItemId != None :
currentSnapshot = tree.GetItemPyData( self._activeTreeItemId )
if PyUtils.sameObject(currentSnapshot, snapshot) : return
tree.SetItemBold( self._activeTreeItemId, False )
# Look for the new item
activeList = [tree.GetFirstChild(rootItem)[0]]
while len(activeList) > 0 :
treeItemId = activeList.pop()
if not treeItemId.IsOk(): continue
object = tree.GetItemPyData( treeItemId ).getObject()
if PyUtils.sameObject(snapshot, object) :
self._activeTreeItemId = treeItemId
tree.SetItemBold( treeItemId, True )
return
activeList.append( tree.GetFirstChild(treeItemId)[0] )
activeList.append( tree.GetNextSibling(treeItemId) )
def load(self):
assert not self._loaded, "Cannot load scenario twice!"
self._loaded = True
# Create the rigid bodies for the main staircase
orientation = PyUtils.angleAxisToQuaternion( (self._angle,(0,1,0)) )
size = MathLib.Vector3d( self._staircaseWidth, self._riserHeight, self._threadDepth )
pos = PyUtils.toPoint3d( self._position ) + MathLib.Vector3d( 0, -self._riserHeight/2.0, 0 )
delta = MathLib.Vector3d(size)
delta.x = 0
delta = orientation.rotate( delta )
for i in range(self._stepCount):
box = PyUtils.RigidBody.createBox( size, pos = pos + delta * (i+1), locked = True, orientation=orientation )
Physics.world().addRigidBody(box)
# Create the rigid bodies for both ramps
rampHeights = ( self._leftRampHeight, self._rightRampHeight )
deltaRamp = MathLib.Vector3d(self._staircaseWidth/2.0,0,0)
deltaRamp = orientation.rotate( deltaRamp )
deltaRamps = (deltaRamp, deltaRamp * -1)
for deltaRamp, rampHeight in zip( deltaRamps, rampHeights ):
if rampHeight is None: continue
deltaRamp.y = rampHeight/2.0
box = PyUtils.RigidBody.createBox( (0.02,rampHeight,0.02), pos = pos + deltaRamp + delta , locked = True, orientation=orientation )
Physics.world().addRigidBody(box)
box = PyUtils.RigidBody.createBox( (0.02,rampHeight,0.02), pos = pos + deltaRamp + (delta * self._stepCount) , locked = True, orientation=orientation )
Physics.world().addRigidBody(box)
deltaRamp.y = rampHeight
rampOrientation = orientation * PyUtils.angleAxisToQuaternion( (math.atan2(self._riserHeight, self._threadDepth), (-1,0,0)) )
rampLen = self._stepCount * math.sqrt( self._riserHeight*self._riserHeight + self._threadDepth*self._threadDepth )
box = PyUtils.RigidBody.createBox( (0.04,0.02,rampLen), pos = pos + deltaRamp + (delta * ((self._stepCount+1) * 0.5)) , locked = True, orientation=rampOrientation )
Physics.world().addRigidBody(box)
def saveController(self, event = None):
"""Save the currently selected controller"""
controller = self._getSelectedController()
if controller is None : return
saveNumber = self._saveNumber
if PyUtils.sameObject( self._lastSave[0], controller ) :
if self._lastSave[2] is not None :
saveNumber = self._lastSave[2]
controllerName = controller.getName()
dialogTitle = "Save %s Controller" % controllerName
fileName = "%s_%d.py" % (controllerName, saveNumber)
dialog = wx.FileDialog(self, dialogTitle, self._dirName, fileName, "*.py", wx.SAVE | wx.OVERWRITE_PROMPT )
dialog.CenterOnScreen()
if dialog.ShowModal() == wx.ID_OK:
if saveNumber != self._saveNumber:
self._lastSave = (None, None, None)
else:
self._lastSave = (controller, self._saveNumber, None)
self._saveNumber += 1
fileName=dialog.GetFilename()
self._dirName=dialog.GetDirectory()
pathName = os.path.join(self._dirName,fileName)
file = open(pathName,'w')
file.write( "from App.Proxys import *\n\ndata = %s" % PyUtils.fancify( PyUtils.serialize(controller)) )
file.close()
dialog.Destroy()
def _addIndirectVar(self, varName, initialValue):
"""Add an indirect variable with the given name, as well as its getter and setter."""
if isinstance(initialValue, _Symmetric) :
self.__setattr__( PyUtils.getterName(varName), lambda side: self.getIndirectVarSymmetric(varName, side) )
else:
self.__setattr__( PyUtils.getterName(varName), lambda: self.getIndirectVar(varName) )
self._indirectVarsAreValid = None
self.__setattr__(varName, initialValue)
def DownloadPDBs(PDB_list_file):
PDB_list = open(os.getcwd()+'/'+PDB_list_file,'r').readlines()
for i in range(len(PDB_list)):
PDBid = PDB_list[i].strip()
PyUtils.create_folder(os.getcwd()+"/"+PDBid)
os.chdir(PDBid)
cmd = ["~/../scripts/pdbUtil/getPdb.pl"+" -id "+PDBid]
subprocess.call(cmd,shell=True)
os.chdir("..")
def _addNativeVar(self, varName, initialValue):
"""Add a variable with he given name, as well as its getter and setter."""
if isinstance(initialValue, _Symmetric) :
self.__setattr__( PyUtils.getterName(varName), lambda side: self.getNativeVarSymmetric(varName, side) )
self.__setattr__( PyUtils.setterName(varName), lambda side, value: self.setNativeVarSymmetric(varName, side, value) )
else :
self.__setattr__( PyUtils.getterName(varName), lambda: self.getNativeVar(varName) )
self.__setattr__( PyUtils.setterName(varName), lambda value: self.setNativeVar(varName, value) )
self.__setattr__( varName, initialValue )
def __init__(self, rec, lig, cov, cov_index, HG, tart=False):
self.tart = bool(tart)
self.rec = rec
self.lig = lig
self.folder = os.path.dirname(os.path.abspath(rec)) + "/"
self.fixed_rec = self.folder + "rec.pdb"
self.fixed_lig = self.folder + "xtal-lig.pdb"
self.cov = cov
self.cov_index = cov_index
self.hg = HG
PyUtils.initPythonVs()
def __init__(self, rec, lig, cov, cov_index, HG):
self.rec = rec
self.lig = lig
#self.folder = os.getcwd() + "/"
self.folder = os.path.dirname(os.path.abspath(rec)) + "/"
self.fixed_rec = self.folder + "rec.pdb"
self.fixed_lig = self.folder + "xtal-lig.pdb"
self.cov = cov
self.cov_index = cov_index
self.hg = HG
PyUtils.initPythonVs()
def _createCylinder(proxy, axis, basePos, tipPos, radius, colour, moiScale, withMesh):
"""
Private function.
Use createCylinder() or createArticulatedCylinder() instead.
"""
if axis != 0 and axis != 1 and axis != 2:
raise ValueError("Axis must be 0 for x, 1 for y or 2 for z.")
# Mesh and cdps will be set manually
proxy.meshes = None
proxy.cdps = None
# Compute box moi
moi = [0, 0, 0]
height = math.fabs(tipPos - basePos)
for i in range(3):
if i == axis:
moi[i] = proxy.mass * radius * radius / 2.0
else:
moi[i] = proxy.mass * (3 * radius * radius + height * height) / 12.0
### HACK!
moi[i] = max(moi[i], 0.01)
proxy.moi = PyUtils.toVector3d(moi) * moiScale
cylinder = proxy.createAndFillObject()
basePoint = [0, 0, 0]
tipPoint = [0, 0, 0]
basePoint[axis] = basePos
tipPoint[axis] = tipPos
basePoint3d = PyUtils.toPoint3d(basePoint)
tipPoint3d = PyUtils.toPoint3d(tipPoint)
baseToTipVector3d = Vector3d(basePoint3d, tipPoint3d)
if baseToTipVector3d.isZeroVector():
raise ValueError("Invalid points for cylinder: base and tip are equal!")
baseToTipUnitVector3d = baseToTipVector3d.unit()
if height <= radius * 2.0:
cdp = Physics.SphereCDP()
cdp.setCenter(basePoint3d + baseToTipVector3d * 0.5)
cdp.setRadius(height / 2.0)
else:
cdp = Physics.CapsuleCDP()
cdp.setPoint1(basePoint3d + baseToTipUnitVector3d * radius)
cdp.setPoint2(tipPoint3d + baseToTipUnitVector3d * -radius)
cdp.setRadius(radius)
cylinder.addCollisionDetectionPrimitive(cdp)
if withMesh:
mesh = Mesh.createCylinder(basePoint, tipPoint, radius, colour)
cylinder.addMesh(mesh)
return cylinder
def __init__(self, folder_name, compound, library = False):
self.folder = os.getcwd() + "/"
self.name = self.folder + folder_name + "/"
#self.compound = os.path.abspath(compound)[5:]
self.compound = compound
self.library = library
PyUtils.create_folder(self.name)
self.copyIndock()
self.softlink()
os.chdir(self.name)
self.dock_command = Paths.DOCKBASE + "docking/DOCK/src/i386/dock64"
self.DOCK()
def poses2pdb(self):
PyUtils.create_folder('recs')
os.chdir('poses')
for k in range(1, len(os.listdir(os.getcwd())) + 1):
i = str(k) + '.mol2'
surface = PYMOLUtils.get_surface_area(i)
with open(i, 'r') as f_mol:
for line in f_mol:
if 'SMILES' in line:
smile_line = line.split()[2]
if 'heavy atom count' in line:
heavy_atoms = int(line.split()[-1])
break
if surface < 200 or surface / heavy_atoms < 14.5:
self.counters.append(0)
continue
if '[N+](=O)[O-]' in smile_line or smile_line.count('N') + smile_line.count('O') + smile_line.count('n') + smile_line.count('o') > 4:
self.counters.append(0)
continue
pdb_pose = '../recs/' + i[:-4] + 'pdb'
subprocess.call(['convert.py', i, pdb_pose])
hetatm = []
with open(pdb_pose, 'r') as f_pdb:
for line in f_pdb:
if 'HETATM' in line:
hetatm.append(line[:23] + ' -1' + line[26:])
rec_pose = '../recs/rec_' + i[:-4] + 'pdb'
with open(rec_pose, 'w') as f_rec:
for line in hetatm:
f_rec.write(line)
for line in self.rec_lines:
f_rec.write(line)
sub_command = []
for res_l in self.res_list:
sub_command.append('-seed_residue')
sub_command.append(str(res_l))
subprocess.call(['python', Paths.SCRIPTS + 'HBonanza.py', '-trajectory_filename', rec_pose, '-hydrogen_bond_distance_cutoff', '3.0', '-hydrogen_bond_angle_cutoff', '30', '-seed_residue', '-1'] + sub_command + ['-just_immediate_connections', 'true'], stdout=open(os.devnull, 'w'))
os.remove(rec_pose + '.average_hbonds')
os.remove(rec_pose + '.frame_by_frame_hbonds.csv')
if os.path.isfile(rec_pose + '.hbond_averages_in_occupancy_column.pdb'):
os.remove(rec_pose + '.hbond_averages_in_occupancy_column.pdb')
counter = self.countHbonds(rec_pose + '.HBonds')
else:
counter = 0
self.counters.append(counter)
os.remove(rec_pose)
os.chdir('../')
shutil.rmtree('recs')
shutil.rmtree('poses')
def _addCurves(self, treeItemId, nameStack):
"""PRIVATE. Recursively add curves under this treeItemId."""
from App.Proxys import Member
app = wx.GetApp()
controller = self._getSelectedController()
phiPtr = controller.getPhiPtr()
nodeData = self._tree.GetItemPyData( treeItemId )
if nodeData is None : return
try:
# Assume the tree node contains an object
object = nodeData.getObject()
except AttributeError:
object = None
if object is not None:
proxyObject = PyUtils.wrap(object, recursive = False)
for i in range( proxyObject.getMemberCount() ):
value, member = proxyObject.getValueAndInfo(i)
if value is None: continue
if isinstance( member, Member.Trajectory1d ):
name = " : ".join(nameStack[1:])
if member.name != "baseTrajectory" :
name += " : " + member.fancyName
app.addCurve( name, value, phiPtr )
# Recurse on the child nodes
currTreeItemId, cookie = self._tree.GetFirstChild( treeItemId )
while currTreeItemId.IsOk():
newNameStack = nameStack[:]
newNameStack.append( self._tree.GetItemText(currTreeItemId) )
self._addCurves( currTreeItemId, newNameStack )
currTreeItemId, cookie = self._tree.GetNextChild( treeItemId, cookie )
def __init__(self, memberName, object, tree, treeItemId, container = None, index = None):
"""Subclasses must calls this constructor.
Pass a string giving the member name for this node (member should be either App.Proxys.Member.Object or App.Proxys.Member.ObjectList.
Pass the object to observe, the member information for this object (from App.Proxys.Member).
Also pass the tree and the treeItemId where this object is found.
In container, pass the object that contains this node (in an HAS_A or HAS_MANY relationship)
In index, pass the index of this node within its container (in an HAS_MANY relationship)
"""
super( NodeData, self ).__init__()
self._memberName = memberName
self._object = object
self._tree = tree
self._treeItemId = treeItemId
self._container = container
self._index = index
if object is None :
self._proxyClass = None
iconIndex = getIconIndex( '../data/ui/noneIcon.png' )
else:
object.addObserver( self )
self._proxyClass = PyUtils.getProxyClass(object)
iconIndex = getIconIndex( self._proxyClass.getIcon() )
self._tree.SetItemImage( self._treeItemId, iconIndex )
self._subMemberNodes = []
if self._proxyClass is not None :
for subMember in self._proxyClass.getObjectMembers():
self._subMemberNodes.append( _createSubMemberNode(subMember, self._tree, self._treeItemId, object) )
tree.SetItemPyData( treeItemId, self )
# Initial update
self.update()
def _createEllipsoid(proxy, radius, colour, moiScale, withMesh):
"""
Private function.
Use createEllipsoid() or createArticulatedEllipsoid() instead.
"""
# Mesh and cdps will be set manually
proxy.meshes = None
proxy.cdps = None
# Compute box moi
moi = [0, 0, 0]
for i in range(3):
j = (i + 1) % 3
k = (i + 2) % 3
moi[i] = proxy.mass * (radius[j] * radius[j] + radius[k] * radius[k]) / 5.0
proxy.moi = PyUtils.toVector3d(moi) * moiScale
ellipsoid = proxy.createAndFillObject()
cdp = Physics.SphereCDP()
cdp.setCenter(Point3d(0, 0, 0))
cdp.setRadius(min(radius))
ellipsoid.addCollisionDetectionPrimitive(cdp)
if withMesh:
mesh = Mesh.createEllipsoid((0, 0, 0), radius, colour)
ellipsoid.addMesh(mesh)
return ellipsoid
def add(self, object):
"""Adds an object to the list, notify observers."""
if PyUtils.sameObjectInList(object, self._objects) :
raise KeyError ('Cannot add the same object twice to application.')
self._objects.append( object )
self.notifyObservers()
return object
def saveCharacterState(self, event = None):
"""Saves the selected character state"""
controller = self._getSelectedController()
if controller is None : return
app = wx.GetApp()
character = controller.getCharacter()
saveNumber = self._saveNumber
if PyUtils.sameObject( self._lastSave[0], controller ) :
if self._lastSave[1] is not None :
saveNumber = self._lastSave[1]
controllerName = controller.getName()
dialogTitle = "Save Character State for %s" % controllerName
fileName = "%sState_%d.rs" % (controllerName, saveNumber)
dialog = wx.FileDialog(self, dialogTitle, self._dirName, fileName, "*.rs", wx.SAVE | wx.OVERWRITE_PROMPT )
dialog.CenterOnScreen()
if dialog.ShowModal() == wx.ID_OK:
if saveNumber != self._saveNumber:
self._lastSave = (None, None, None)
else:
self._lastSave = (controller, None, self._saveNumber)
self._saveNumber += 1
fileName=dialog.GetFilename()
self._dirName=dialog.GetDirectory()
pathName = os.path.join(self._dirName,fileName)
stateArray = Core.ReducedCharacterStateArray()
if controller.getStance() == Core.RIGHT_STANCE:
character.getReverseStanceState(stateArray)
else:
character.getState(stateArray)
character.saveReducedStateToFile( str(pathName), stateArray )
dialog.Destroy()
def create( vertices, faces, colour=(0.6,0.6,0.6) ):
"""
Creates a mesh having the specified vertices and faces.
Vertices should be a list of 3-tuples of float or Point3d (positions).
Faces should be a list of tuples of indices.
Colour should be a 3-tuple (R,G,B) or a 4-tuple (R,G,B,A)
"""
mesh = GLUtils.GLMesh()
for vertex in vertices:
mesh.addVertex( PyUtils.toPoint3d(vertex) )
for face in faces:
poly = GLUtils.GLIndexedPoly()
for index in face:
poly.addVertexIndex( index )
mesh.addPoly(poly)
try:
mesh.setColour( *colour )
except TypeError:
mesh.setColour( *(colour + (1,)) )
mesh.computeNormals()
return mesh
def update(self, object):
"""Updates the node so that it contains the specified object."""
subObject = self._member.getObject(object)
try:
currentObject = self.getObject()
if PyUtils.sameObject(currentObject, subObject) : return
except AttributeError: pass
nodeData = NodeData( self._member.name, subObject, self._tree, self._treeItemId, self._container )
def __init__(self, type, name, default, editable = False, fancyName = None, isObject = False ):
self.name = name
self.default = default
self.editable = editable
self.isObject = isObject
self.type = type
self.fancyName = fancyName
if fancyName == None:
self.fancyName = PyUtils.unCamelCase(name)
def attachObject(self, object):
self.deleteObserver()
self._object = object
try:
self._proxy = PyUtils.wrap( object, recursive = False )
except AttributeError:
self._proxy = None
try: object.addObserver(self)
except AttributeError: pass
self.createControls()
def setValueAndUpdateObject(self, memberName, value, object, container = None):
"""
Sets the specified value of the specified member and updates the object.
As a container, specify the object (not proxy object) to which this object is attached with an HAS_A or HAS_MANY relationship.
"""
info = self._memberDict[memberName]
newValue = info.interpret(value)
if PyUtils.safeEqual( newValue, self.__getattribute__(memberName) ) : return
self.__setattr__(memberName, newValue)
info.set(object, newValue, container )
def addCharacter(self, character):
"""Adds a character to the application and the world"""
import Physics
if PyUtils.sameObjectInList(character, self._characters) :
raise KeyError ('Cannot add the same character twice to application.')
Physics.world().addArticulatedFigure( character )
self._characters.append( character )
if self._followedCharacter is None :
self._followedCharacter = character
self._cameraFollowCharacter = True
self._cameraObservable.notifyObservers()
self._characterObservable.notifyObservers()
def createCylinder( basePoint=(0,-1,0), tipPoint=(0,1,0), radius = 1.0, colour=(0.6,0.6,0.6), samples = 20 ):
"""
Creates the mesh for a cylinder between the two specified points.
Colour should be a 3-tuple (R,G,B) or a 4-tuple (R,G,B,A)
"""
basePoint = PyUtils.toPoint3d(basePoint)
tipPoint = PyUtils.toPoint3d(tipPoint)
baseToTipVector = Vector3d(basePoint,tipPoint)
if baseToTipVector.isZeroVector() :
raise ValueError( 'Invalid points for cylinder: base and tip are equal!' )
baseToTipUnitVector = baseToTipVector.unit()
xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,0,1) )
if xUnitVector.length() < 0.5 :
xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,-1,0) )
xUnitVector.toUnit()
yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(-1,0,0) )
if yUnitVector.length() < 0.5 :
yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,1,0) )
yUnitVector.toUnit()
vertices = []
for i in range(samples):
theta = i * 2 * math.pi / float(samples)
vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )
for i in range(samples):
theta = i * 2 * math.pi / float(samples)
vertices.append( tipPoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )
for i in range(samples):
theta = i * 2 * math.pi / float(samples)
vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )
vertices.append( tipPoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )
faces = [ range(0,samples), range(samples,2*samples) ]
for i in range(0,2*samples,2) :
base = 2*samples
size = 2*samples
faces.append( (base+i, base+i+1, base+(i+3)%size, base+(i+2)%size ) )
return create( vertices, faces, colour )
def __repr__(self) :
"""
Creates a representation of this proxy object. This can be evaluated provided the following includes:
from App.Proxys.All import *
"""
outMembers = []
for member in self._members:
value = self.__getattribute__(member.name)
if self._verbose and PyUtils.safeEqual(value, member.default) : continue
outMember = repr( member.format(value) )
if self._verbose: outMember = member.name + " = " + outMember
outMembers.append( outMember )
return type(self).__name__ + "(" + ','.join(outMembers) + ")"
def _createBox(proxy, size, colour, moiScale, withMesh):
"""
Private function.
Use createBox() or createArticulatedBox() instead.
"""
# Mesh and cdps will be set manually
proxy.meshes = None
proxy.cdps = None
# Compute box moi
size = PyUtils.toVector3d(size)
proxy.moi = (
MathLib.Vector3d(
size.y * size.y + size.z * size.z, size.x * size.x + size.z * size.z, size.x * size.x + size.y * size.y
)
* 1.0
/ 12.0
* proxy.mass
* moiScale
)
box = proxy.createAndFillObject()
cdp = Physics.BoxCDP()
halfSize = PyUtils.toVector3d(size) * 0.5
cdp.setPoint1(MathLib.Point3d(halfSize * -1))
cdp.setPoint2(MathLib.Point3d(halfSize))
box.addCollisionDetectionPrimitive(cdp)
if withMesh:
mesh = Mesh.createBox(size=size, colour=colour)
box.addMesh(mesh)
return box
def toList(m):
'''
Convert a PyMEL Matrix or [4][4] list into a flat 16-element list
'''
if isinstance(m, pm.datatypes.Matrix):
m = [m.a00, m.a01, m.a02, m.a03,
m.a10, m.a11, m.a12, m.a13,
m.a20, m.a21, m.a22, m.a23,
m.a30, m.a31, m.a32, m.a33]
elif PyUtils.isIterable(m[0]):
m = [m[0][0], m[0][1], m[0][2], m[0][3],
m[1][0], m[1][1], m[1][2], m[1][3],
m[2][0], m[2][1], m[2][2], m[2][3],
m[3][0], m[3][1], m[3][2], m[3][3]]
return m
def __init__(self):
"""Creates a new model for a character description, including the required UI."""
app = wx.GetApp()
glCanvas = app.getGLCanvas()
self._container = glCanvas.addGLUITool(GLUtils.GLUIContainer)
self._container.setVisible(False)
self._optionsObservable = PyUtils.Observable()
self._sizer = GLUtils.GLUIBoxSizer(GLUtils.GLUI_HORIZONTAL)
self._container.setSizer(self._sizer)
self.reset()
self._toolSet = ToolSet(app.getToolPanel(), self)
def __init__(self, nbEditors = 5):
self._nbEditors = nbEditors
app = wx.GetApp()
app.addControllerObserver(self)
app = wx.GetApp()
glCanvas = app.getGLCanvas()
self._container = glCanvas.addGLUITool( GLUtils.GLUIContainer )
self._sizer = GLUtils.GLUIBoxSizer(GLUtils.GLUI_HORIZONTAL)
self._container.setSizer(self._sizer)
self._optionsObservable = PyUtils.Observable()
self._create()
self._toolSet = ToolSet(app.getToolPanel(), self)
def createEllipsoid( position=(0,0,0), radius=(1,1,1), colour=(0.6,0.6,0.6), samplesY = 20, samplesXZ = 20, exponentBottom = 2, exponentTop = 2, exponentSide = 2 ):
"""
Creates the mesh for an ellipsoid having the specified position and radius
Colour should be a 3-tuple (R,G,B) or a 4-tuple (R,G,B,A)
"""
if exponentBottom < 2.0 or exponentTop < 2.0 or exponentSide < 2.0 :
raise ValueError( 'Exponents for ellipsoid must all be under 2.0!' )
position = PyUtils.toPoint3d(position)
vertices = []
for i in range(1,samplesY):
thetaI = i*math.pi/float(samplesY)
if i < samplesY / 2 :
n = exponentTop
else:
n = exponentBottom
cos = math.cos(thetaI)
y = cos * radius[1]
scaleXZ = math.pow( 1-math.pow(math.fabs(cos),n), 1.0/float(n) )
for j in range(0,samplesXZ):
thetaJ = j*2.0*math.pi/float(samplesXZ)
n = exponentSide
cos = math.cos(thetaJ)
x = cos * scaleXZ * radius[0]
z = math.pow( 1-math.pow(math.fabs(cos),n), 1.0/float(n) ) * math.copysign(1, math.sin(thetaJ)) * scaleXZ * radius[2]
vertices.append( position + Vector3d(x,y,z) )
vertices.append( position + Vector3d(0,radius[1],0) )
vertices.append( position + Vector3d(0,-radius[1],0) )
faces = []
for i in range(0,(samplesY-2)*samplesXZ,samplesXZ) :
for j in range(0,samplesXZ) :
faces.append( (i+j, i+(j+1)%samplesXZ, i+samplesXZ+(j+1)%samplesXZ, i+samplesXZ+j) )
for i in range(0,samplesXZ) :
base = (samplesY-2)*samplesXZ
faces.append( ((i+1)%samplesXZ, i, (samplesY-1)*samplesXZ) )
faces.append( (base+i, base+(i+1)%samplesXZ, (samplesY-1)*samplesXZ+1) )
return create( vertices, faces, colour )
def __init__(self,
memberName,
object,
tree,
treeItemId,
container=None,
index=None):
"""Subclasses must calls this constructor.
Pass a string giving the member name for this node (member should be either App.Proxys.Member.Object or App.Proxys.Member.ObjectList.
Pass the object to observe, the member information for this object (from App.Proxys.Member).
Also pass the tree and the treeItemId where this object is found.
In container, pass the object that contains this node (in an HAS_A or HAS_MANY relationship)
In index, pass the index of this node within its container (in an HAS_MANY relationship)
"""
super(NodeData, self).__init__()
self._memberName = memberName
self._object = object
self._tree = tree
self._treeItemId = treeItemId
self._container = container
self._index = index
if object is None:
self._proxyClass = None
iconIndex = getIconIndex('../data/ui/noneIcon.png')
else:
object.addObserver(self)
self._proxyClass = PyUtils.getProxyClass(object)
iconIndex = getIconIndex(self._proxyClass.getIcon())
self._tree.SetItemImage(self._treeItemId, iconIndex)
self._subMemberNodes = []
if self._proxyClass is not None:
for subMember in self._proxyClass.getObjectMembers():
self._subMemberNodes.append(
_createSubMemberNode(subMember, self._tree,
self._treeItemId, object))
tree.SetItemPyData(treeItemId, self)
# Initial update
self.update()
def __init__(self, parentBranch):
"""Takes a shot of a world, add it to the specified branch."""
super(Snapshot, self).__init__()
self._time = time.localtime()
# Save the world
world = Physics.world()
self._worldState = Utils.DynamicArrayDouble()
world.getState(self._worldState)
# Save the controllers
app = wx.GetApp()
self._controllers = []
for i in range(app.getControllerCount()):
controller = app.getController(i)
controllerState = Core.SimBiControllerState()
controller.getControllerState(controllerState)
self._controllers.append(
(controllerState, PyUtils.wrapCopy(controller)))
self._parentBranch = parentBranch
self._childBranches = []
self._activeIndex = -1
''' Created on 2009-11-26 @author: beaudoin ''' import PyUtils import Core, wx import Controllers PyUtils.load( "RigidBodies.FiniteFlatGround" ) PyUtils.loadMany( "RigidBodies.DodgeBall", 5 ) character = PyUtils.load( "Characters.BipV3" ) character.loadReducedStateFromFile( "Data/Characters/BipV3/Controllers/WalkingState.rs" ); character.computeMass(); #controller = PyUtils.load( "Characters.BipV3.Controllers.StylizedWalking", character ) controller = PyUtils.load( "Characters.BipV3.Controllers.EditableWalking", character ) controller.setStance( Core.LEFT_STANCE ); app = wx.GetApp() worldOracle = app.getWorldOracle() behaviour = Core.TurnController(character, controller, worldOracle) behaviour.initializeDefaultParameters() controller.setBehaviour(behaviour) behaviour.requestHeading(0); behaviour.conTransitionPlan();
def runDirSingle(self, dirname, command):
PyUtils.create_folder(dirname[:-1])
curr = os.getcwd()
os.chdir(dirname[:-1])
self.runSingle(command)
os.chdir(curr)
def get(self, object):
result = []
for i in range(self.getCount(object)):
result.append(PyUtils.wrap(self.getObject(object, i)))
return result
def set(self, object, valueProxyList, container=None):
if valueProxyList is None: return
PyUtils.callOnObjectOrListAndEnumerate(
valueProxyList,
lambda i, valueProxy: self._set(object, i, valueProxy, container))
def __init__(self,
appTitle="Simbicon Application",
fps=30.0,
dt=1 / 2000.0,
glCanvasSize=wx.DefaultSize,
size=wx.DefaultSize,
redirect=False,
filename=None,
useBestVisual=False,
clearSigInt=True,
showConsole=True):
"""
appTitle is the window title
fps is the desired number of frames per seconds
dt is the desired simulation timestep
:see: wx.BasicApp.__init__`
"""
wx.App.__init__(self, redirect, filename, useBestVisual, clearSigInt)
# No annoying error logging window
wx.Log.SetActiveTarget(wx.LogStderr())
import UI
# Setup the main window style
style = wx.DEFAULT_FRAME_STYLE
if size == wx.DefaultSize:
size = wx.GetDisplaySize()
size.height *= 0.75
size.width *= 0.75
if glCanvasSize == wx.DefaultSize:
style |= wx.MAXIMIZE
# Setup the environment for the python interactive console
consoleEnvironment = {"wx": wx, "Physics": Physics, "Utils": Utils}
exec "from MathLib import *\n" + \
"app = wx.GetApp()\n" + \
"from PyUtils import load" in consoleEnvironment, consoleEnvironment
# Create the main window
self._frame = UI.MainWindow(None,
-1,
appTitle,
size=size,
style=style,
fps=fps,
glCanvasSize=glCanvasSize,
showConsole=showConsole,
consoleEnvironment=consoleEnvironment)
# Define GL callbacks
self._glCanvas = self._frame.getGLCanvas()
self._glCanvas.addDrawCallback(self.draw)
self._glCanvas.addPostDrawCallback(self.postDraw)
self._glCanvas.addOncePerFrameCallback(self.advanceAnimation)
self._glCanvas.setDrawAxes(False)
self._glCanvas.setPrintLoad(True)
self._glCanvas.setCameraTargetFunction(self.cameraTargetFunction)
self._glCanvas.setDrawGround(False)
# Get the tool panel
self._toolPanel = self._frame.getToolPanel()
# Show the application
self._frame.Show()
# Set-up starting state
self._dt = dt
self._drawShadows = True
self._simulationSecondsPerSecond = 1 # 1 = real time, 2 = twice real time, 1/2 = half real time
self._animationRunning = False
self._cameraFollowCharacter = False
self._drawCollisionVolumes = False
self._followedCharacter = None # Pointer to focused character
self._captureScreenShots = False
self._printStepReport = True
self._screenShotNumber = 0
self._worldOracle = Core.WorldOracle()
self._worldOracle.initializeWorld(Physics.world())
self._kinematicMotion = False
# Set-up starting list of characters and controllers
self._characters = []
# Define the observables
self._controllerList = ObservableList()
self._characterObservable = PyUtils.Observable()
self._animationObservable = PyUtils.Observable()
self._cameraObservable = PyUtils.Observable()
self._optionsObservable = PyUtils.Observable()
self._COMObservable = PyUtils.Observable()
self._curveList = ObservableList()
self._snapshotTree = SnapshotBranch()
self._showAbstractView = False
self._showAbstractViewSkeleton = False
self._showBodyFrame = False
self._showCDPrimitives = False
self._showColors = False
self._showFrictionParticles = False
self._showJoints = False
self._showMesh = True
self._showMinBDGSphere = False
self._showCenterOfMass = True
self._COMErrorScale = 0.01
params = [
3.75162180e-04, 1.70361201e+00, -7.30441228e-01, -6.22795336e-01,
3.05330848e-01
]
fps = 100
# params = [0, 0, 0, 0, 0]
# fps = 100.0
# model_order = (50, 50)
# params = [0.00019815056771797725, 1.9687785869242351, -0.9709165752219967, -0.565841931234043, 0.3226849680645409]
self._armaX = ArmaProcess(params[0], params[1:3], params[3:5], fps)
self._armaY = ArmaProcess(params[0], params[1:3], params[3:5], fps)
self._armaZ = ArmaProcess(params[0], params[1:3], params[3:5], fps)
def poses2pdb(self):
PyUtils.create_folder('recs')
os.chdir('poses')
for k in range(1, len(os.listdir(os.getcwd())) + 1):
i = str(k) + '.mol2'
surface = PYMOLUtils.get_surface_area(i)
with open(i, 'r') as f_mol:
for line in f_mol:
if 'SMILES' in line:
smile_line = line.split()[2]
if 'heavy atom count' in line:
heavy_atoms = int(line.split()[-1])
break
#if surface < 200 or surface / heavy_atoms < 14.5:
# self.counters.append(0)
# continue
#if '[N+](=O)[O-]' in smile_line or smile_line.count('N') + smile_line.count('O') + smile_line.count('n') + smile_line.count('o') > 4:
# self.counters.append(0)
# continue
#Remove comment to filter for phosphates
#if 'P' in smile_line:
# self.counters.append(0)
# continue
pdb_pose = '../recs/' + i[:-4] + 'pdb'
subprocess.call(
['python', Paths.SCRIPTS + 'ChemChem/convert.py', i, pdb_pose])
hetatm = []
with open(pdb_pose, 'r') as f_pdb:
for line in f_pdb:
#if 'HETATM' in line:
if 'ATOM' in line:
hetatm.append(line[:23] + ' -1' + line[26:])
rec_pose = '../recs/rec_' + i[:-4] + 'pdb'
with open(rec_pose, 'w') as f_rec:
for line in hetatm:
f_rec.write(line)
for line in self.rec_lines:
f_rec.write(line)
sub_command = []
for res_l in self.res_list:
sub_command.append('-seed_residue')
sub_command.append(str(res_l))
subprocess.call([
'python', Paths.SCRIPTS + 'HBonanza.py',
'-trajectory_filename', rec_pose,
'-hydrogen_bond_distance_cutoff', '3.0',
'-hydrogen_bond_angle_cutoff', '30', '-seed_residue', '-1'
] + sub_command + ['-just_immediate_connections', 'true'],
stdout=open(os.devnull, 'w'))
os.remove(rec_pose + '.average_hbonds')
os.remove(rec_pose + '.frame_by_frame_hbonds.csv')
if os.path.isfile(rec_pose +
'.hbond_averages_in_occupancy_column.pdb'):
os.remove(rec_pose + '.hbond_averages_in_occupancy_column.pdb')
counter = self.countHbonds(rec_pose + '.HBonds')
else:
counter = 0
self.counters.append(counter)
os.remove(rec_pose)
os.chdir('../')
#shutil.rmtree('recs')
shutil.rmtree('poses')
def format(self, value):
return PyUtils.angleAxisFromQuaternion(value)
def __init__(self,
appTitle="Simbicon Application",
fps=30.0,
dt=1 / 2000.0,
glCanvasSize=wx.DefaultSize,
size=wx.DefaultSize,
redirect=False,
filename=None,
useBestVisual=False,
clearSigInt=True,
showConsole=True):
"""
appTitle is the window title
fps is the desired number of frames per seconds
dt is the desired simulation timestep
:see: wx.BasicApp.__init__`
"""
wx.App.__init__(self, redirect, filename, useBestVisual, clearSigInt)
# No annoying error logging window
wx.Log.SetActiveTarget(wx.LogStderr())
import UI
# Setup the main window style
style = wx.DEFAULT_FRAME_STYLE
if size == wx.DefaultSize:
size = wx.GetDisplaySize()
size.height *= 0.75
size.width *= 0.75
if glCanvasSize == wx.DefaultSize:
style |= wx.MAXIMIZE
# Setup the environment for the python interactive console
consoleEnvironment = {"wx": wx, "Physics": Physics, "Utils": Utils}
exec "from MathLib import *\n" + \
"app = wx.GetApp()\n" + \
"from PyUtils import load" in consoleEnvironment, consoleEnvironment
# Create the main window
self._frame = UI.MainWindow(None,
-1,
appTitle,
size=size,
style=style,
fps=fps,
glCanvasSize=glCanvasSize,
showConsole=showConsole,
consoleEnvironment=consoleEnvironment)
# Define GL callbacks
self._glCanvas = self._frame.getGLCanvas()
self._glCanvas.addDrawCallback(self.draw)
self._glCanvas.addPostDrawCallback(self.postDraw)
self._glCanvas.addOncePerFrameCallback(self.advanceAnimation)
self._glCanvas.setDrawAxes(False)
self._glCanvas.setPrintLoad(True)
self._glCanvas.setCameraTargetFunction(self.cameraTargetFunction)
# Get the tool panel
self._toolPanel = self._frame.getToolPanel()
# Show the application
self._frame.Show()
# Set-up starting state
self._dt = dt
self._drawShadows = True
self._simulationSecondsPerSecond = 1 # 1 = real time, 2 = twice real time, 1/2 = half real time
self._animationRunning = False
self._cameraFollowCharacter = False
self._drawCollisionVolumes = False
self._followedCharacter = None # Pointer to focused character
self._captureScreenShots = False
self._printStepReport = True
self._screenShotNumber = 0
self._worldOracle = Core.WorldOracle()
self._worldOracle.initializeWorld(Physics.world())
self._kinematicMotion = False
# Set-up starting list of characters and controllers
self._characters = []
# Define the observables
self._controllerList = ObservableList()
self._characterObservable = PyUtils.Observable()
self._animationObservable = PyUtils.Observable()
self._cameraObservable = PyUtils.Observable()
self._optionsObservable = PyUtils.Observable()
self._curveList = ObservableList()
self._snapshotTree = SnapshotBranch()
''' Created on 2009-08-28 @author: beaudoin ''' import PyUtils import Core, wx File = "Jumping" #File = "Running" #File = "SideRunning" #File = "JumpWalk" #File = "Walking" #File = "Turning" #PyUtils.load( "RigidBodies.FlatGround" ) PyUtils.load( "RigidBodies.FiniteFlatGround" ) PyUtils.loadMany( "RigidBodies.DodgeBall", 5 ) character = PyUtils.load( "Characters.Bip" ) character.loadReducedStateFromFile( "Data/Characters/Bip/Controllers/%sState.rs" % File ); controller = PyUtils.load( "Characters.Bip.Controllers.%s" % File, character ) controller.setStance( Core.LEFT_STANCE );
#from Data.Frameworks import DefaultFramework
#from Data.Frameworks import DanceFramework
#from Data.Frameworks import WalkFramework
#####################
## BEGIN Custom for Instant Character
character = instantChar.create()
#controller = PyUtils.load( "Characters.BipV3.Controllers.CartoonySneak", character )
#controller = PyUtils.load( "Characters.BipV3.Controllers.ZeroWalk", character )
#controller = PyUtils.load( "Characters.BipV3.Controllers.VeryFastWalk_5-43_0-4", character )
#controller = PyUtils.load( "Characters.BipV3.Controllers.jog_8-76_0-33", character )
#controller = PyUtils.load( "Characters.BipV3.Controllers.run_21-57_0-38_0-10", character )
#controller = PyUtils.load( "Characters.BipV3.Controllers.FastWalk_3-7_0-53", character )
controller = PyUtils.load("Characters.BipV3.Controllers.EditableWalking",
character)
#controller = PyUtils.load( "Temp.Cartoony", character )
#controller = PyUtils.load( "Temp.TipToe", character )
controller.setStance(Core.LEFT_STANCE)
instantChar.connectController(False)
#character.loadReducedStateFromFile( "Data/Characters/BipV3/Controllers/runState.rs" )
keyframeEditor = KeyframeEditor.Model()
## END
#####################
######################
## BEGIN DUMMY STUFF
def interpret(self, value):
value = self.basicInterpret(value)
if isinstance(value, MathLib.Point3d): return value
else: return PyUtils.toPoint3d(value)
def format(self, value):
return PyUtils.fromVector3d(value)
'''
Created on 2009-11-26
@author: beaudoin
'''
import PyUtils
import Core, wx
import Controllers
PyUtils.load("RigidBodies.FiniteFlatGround")
PyUtils.loadMany("RigidBodies.DodgeBall", 5)
character = PyUtils.load("Characters.BipV3")
character.computeMass()
controller = Controllers.DanceController(character)
controller.loadFromFile("../data/controllers/bipV3/fWalk_4.sbc")
#controller.loadFromFile("../data/controllers/bipV3/fWalk_3.sbc")
Core.cvar.SimGlobals_stanceKnee = 0.00
Core.cvar.SimGlobals_rootSagittal = 0.3
Core.cvar.SimGlobals_stepHeight = 0.25
Core.cvar.SimGlobals_duckWalk = 0.2
Core.cvar.SimGlobals_VDelSagittal = 2.0
Core.cvar.SimGlobals_stepTime = 0.2
#Core.cvar.SimGlobals_upperBodyTwist = 0.2
controller.initialSetup()
def runDirSingle(self, dirname, command):
PyUtils.create_folder(dirname[:-1])
os.chdir(dirname[:-1])
self.runSingle(command)
os.chdir('../')
def interpret(self, value):
value = self.basicInterpret(value)
if isinstance(value, MathLib.Trajectory1d): return value
else: return PyUtils.toTrajectory1d(value)
''' Created on 2009-11-23 @author: beaudoin ''' import PyUtils PyUtils.load( "RigidBodies.FiniteFlatGround" )
def format(self, value):
return PyUtils.fromTrajectory1d(value)
glCanvas = app.getGLCanvas()
glCanvas.addGLUITool(UI.GLUITools.CurveEditorCollection)
#from Data.Frameworks import DefaultFramework
#from Data.Frameworks import DanceFramework
#from Data.Frameworks import WalkFramework
#####################
## BEGIN Custom for Instant Character
character = instantChar.create()
#controller = PyUtils.load( "Characters.BipV3.Controllers.CartoonySneak", character )
#controller = PyUtils.load( "Characters.BipV3.Controllers.ZeroWalk", character )
# This shows off the balance controller well
controller = PyUtils.load("Characters.BipV3.Controllers.jerome2", character)
#controller = PyUtils.load( "Characters.BipV3.Controllers.emps", character )
#controller = PyUtils.load( "Characters.BipV3.Controllers.run_21-57_0-38_0-10", character )
#controller = PyUtils.load( "Characters.BipV3.Controllers.FastWalk_3-7_0-53", character )
#controller = PyUtils.load( "Characters.BipV3.Controllers.EditableWalking", character )
#controller = PyUtils.load( "Temp.Cartoony", character )
#controller = PyUtils.load( "Temp.TipToe", character )
controller.setStance(Core.LEFT_STANCE)
instantChar.connectController(False)
#character.loadReducedStateFromFile( "Data/Characters/BipV3/Controllers/runState.rs" )
keyframeEditor = KeyframeEditor.Model()
## END
def get(self, object):
return PyUtils.wrap(self.getObject(object))
def format(self, value):
return PyUtils.fromPoint3d(value)
def _create(self):
"""Creates the basic model class for the simple keyframe editor. Characters are always forced to left stance."""
app = wx.GetApp()
try:
self._controller = app.getController(0)
except IndexError:
return
self._character = self._controller.getCharacter()
handlesSide = []
handlesFront = []
self._handles = []
handlesSide.append( self._addHandle( 'SWING_Shoulder', 2, 'SWING_Elbow', minValue = -3.14, maxValue = 3.14 ) )
handlesSide.append( self._addHandle( 'STANCE_Shoulder', 2, 'STANCE_Elbow', minValue = -3.14, maxValue = 3.14 ) )
handlesSide.append( self._addHandle( 'SWING_Elbow', 0, reverseOppositeJoint = True, minValue = -2.8, maxValue = 0 ) )
handlesSide.append( self._addHandle( 'STANCE_Elbow', 0, type = 'reverseCircular', reverseOppositeJoint = True,minValue = 0, maxValue = 2.8 ) )
handlesSide.append( self._addHandle( 'SWING_Ankle', 0, 'SWING_ToeJoint' ) )
handlesSide.append( self._addHandle( 'STANCE_Ankle', 0, 'STANCE_ToeJoint' ) )
handlesSide.append( self._addHandle( 'pelvis_lowerback', 2, 'lowerback_torso', minValue = -1.2, maxValue = 1.2 ) )
handlesSide.append( self._addHandle( 'lowerback_torso', 2, 'torso_head', minValue = -1.2, maxValue = 1.2 ) )
handlesSide.append( self._addHandle( 'torso_head', 2, minValue = -1.2, maxValue = 1.2 ) )
handlesFront.append( self._addHandle( 'SWING_Shoulder', 1, 'SWING_Elbow', type = 'reverseCircular', reverseOppositeJoint = True, minValue = -2, maxValue = 2 ) )
handlesFront.append( self._addHandle( 'STANCE_Shoulder', 1, 'STANCE_Elbow', type = 'reverseCircular', reverseOppositeJoint = True, minValue = -2, maxValue = 2 ) )
handlesFront.append( self._addHandle( 'SWING_Shoulder', 0, type = 'reversePerpendicular', minValue = -3.3, maxValue = 3.3 ) )
handlesFront.append( self._addHandle( 'STANCE_Shoulder', 0, type = 'perpendicular', minValue = -3.3, maxValue = 3.3 ) )
handlesFront.append( self._addHandle( 'pelvis_lowerback', 1, 'lowerback_torso', reverseOppositeJoint = True, minValue = -1.2, maxValue = 1.2 ) )
handlesFront.append( self._addHandle( 'lowerback_torso', 1, 'torso_head', reverseOppositeJoint = True, minValue = -1.2, maxValue = 1.2 ) )
handlesFront.append( self._addHandle( 'torso_head', 1, reverseOppositeJoint = True, minValue = -1.2, maxValue = 1.2 ) )
stanceKneeHandle = Handle( self._controller, 'STANCE_Knee', 0, minValue = 0.1, maxValue = 2.2 )
self._handles.append( stanceKneeHandle )
swingFootHandleSagittal = BaseHandle( self._controller.getSwingFootTrajectoryDeltaSagittal() )
swingFootHandleCoronal = BaseHandle( self._controller.getSwingFootTrajectoryDeltaCoronal() )
swingFootHandleHeight = BaseHandle( self._controller.getSwingFootTrajectoryDeltaHeight() )
self._handles.append( swingFootHandleSagittal )
self._handles.append( swingFootHandleCoronal )
self._handles.append( swingFootHandleHeight )
self._editors = []
self._times = [ i / float(self._nbEditors-1) for i in range(self._nbEditors) ]
for handle in self._handles:
handle.forceKeyframesAt([0,1],self._times)
for handle in self._handles:
handle.enforceSymmetry()
stanceFootToSwingFootTrajectory = Trajectory3dv()
stanceFootToSwingFootTrajectory.addKnot(0,Vector3d(-0.2,0,-0.4))
stanceFootToSwingFootTrajectory.addKnot(0.5,Vector3d(-0.2,0.125,0))
stanceFootToSwingFootTrajectory.addKnot(1,Vector3d(-0.2,0,0.4))
glCanvasSize = wx.GetApp().getGLCanvas().GetSize()
minWidth = glCanvasSize.x / self._nbEditors - 50
minHeight = glCanvasSize.y / 2
for i, time in enumerate(self._times) :
posableCharacter = PosableCharacter(PyUtils.copy(self._character), self._controller)
if i == 0 or i == self._nbEditors-1:
checkBoxVisible = False
else :
checkBoxVisible = True
editor = EditorWindow( self._container,
posableCharacter = posableCharacter,
handlesSide = handlesSide,
handlesFront = handlesFront,
stanceKneeHandle = stanceKneeHandle,
swingFootHandleSagittal = swingFootHandleSagittal,
swingFootHandleCoronal = swingFootHandleCoronal,
swingFootHandleHeight = swingFootHandleHeight,
time = time,
controller = self._controller,
stanceFootToSwingFootTrajectory = stanceFootToSwingFootTrajectory,
minWidth = minWidth, minHeight = minHeight,
checkBoxVisible = checkBoxVisible )
functor = SetKeyframeVisibilityFunctor(self,i)
editor.addCheckBoxCallback( functor.execute )
self._sizer.add(editor, 0, GLUtils.GLUI_EXPAND )
self._editors.append(editor)
self._container.getParent().layout()
def interpret(self, value):
value = self.basicInterpret(value)
if isinstance(value, MathLib.Quaternion): return value
else: return PyUtils.angleAxisToQuaternion(value)
def softlink(self):
files = "dockfiles"
PyUtils.create_softlink(self.folder + files, self.name + files)