Vortex Studio SDK - Python 2 Scripting

import VxSim
 
s = VxSim.Scene.create()

m = VxSim.Matrix44() 
r = len(m) # r = 4
c = len(m[0]) # c = 4

# The input is an int
extension.getInput['Int'].value = 8
 
# The output is a VxVector3, extract x from VxVector3
x = extension.getOutput['Vector3'].value.x
 
# The Parameter is an Field<Assembly>
extension.getParameter['Assembly'].value.addPart(part)

# Getting the HingeInterface from a ConstraintInterface
hinge = VxSim.HingeInterface(constraint.getExtension())  #constraint is a ConstraintInterface of an hinge.

from VxSim import *
...
# Create and setup the application
...
# using create function from the Part class
part= Part.create() # part type is PartInterface
part.setName(partName)

# update partDef
box = Box.create() # box type is BoxInterface
 
# Part.addCollisionGeometry accepts BoxInterfaces
part.addCollisionGeometry(box) #part.addCollisionGeometry accepts CollisionGeometryInterface as well as all <cg>Interface objects
 
# Contrary to c++, python VxApplication.add() accepts VxExtension rather than Interfaces. Use getExtension() on the interface object to get it
application.add(part.getExtension())

...
# Working with CGs
# Part.getCollisionGeometries() returns an array of CollisionGeometryInterface, getting the proper cg type require a conversion
cg_0 = part.getCollisionGeometries()[0]
 
# To use the cg_0 as a Box, convert to a BoxInterface with getCollisionGeometryInterface using the VxExtension of the CollisionGeometryInterface
box = CollisionGeometry.getCollisionGeometryInterface( cg_0 ) # Since cgs_0 is a box, getCollisionGeometryInterface() returns a BoxInterface
 
# This is equivalent of doing
# box = BoxInterface( cg_0.getExtension() ) 

# get the output transform from a PartInterface object
output_transform = part.outputWorldTransform.value
 
# get position and orientation of the part as VxSim.VxVector3
position = VxSim.getTranslation(output_transform.value)
orientation = VxSim.getRotation(output_transform.value)
 
# move the part
# set the input local transform
new_position = VxSim.VxVector3(1,1,1)
part.setLocalTransform( VxSim.translateTo(output_transform.value, new_position) ) # prefer using setLocalTransform over Field inputLocalTransform.value

# Scale, Rotation and Translation Matrix Constructor
m = VxSim.createScale(x,y,z) # Create a scale matrix.
m = VxSim.createScale(scale) # Create a scale matrix from VxVector3.
m = VxSim.createRotation(rx, ry, rz) # Creates a rotation matrix. rx, ry and rz are Euler angles given in radian, using the default Euler order
m = VxSim.createRotation(axis, angle) # Creates a rotation matrix from an axis (VxVector3) and angle (radian).
m = VxSim.createRotation(quat) # Creates a rotation matrix from a quaternion
m = VxSim.createRotationFromOuterProduct(v, w) # Creates a rotation matrix from the outer product of two 3 dimensions vectors.
m = VxSim.createTranslation(tx, ty, tz) # Creates a translation matrix.
m = VxSim.createTranslation(translation) # Creates a translation matrix from VxVector3.

# Creates a transform matrix with a position sets to the eye and oriented to the center. 
# The first component of the matrix is the forward vector, the second one is the side vector and the third is the up.
m = VxSim.createObjectLookAt(eye, center, up)
 
# The first component of the matrix is the side-way vector, the second one is the up vector and the third is pointing backward to the center.
m = VxSim.createCameraLookAt(eye, center, up)

# Creates an orthographic projection matrix.
m = VxSim.createOrthographic(left, right, bottom, top, zNear, zFar)
 
# Creates a non-regular projection frustum.
m = VxSim.createFrustum(left, right, bottom, top, zNear, zFar)
 
# Creates a regular perspective projection frustum.
m = VxSim.createPerspective(double fovy, double aspectRatio, double zNear, double zFar)

# Extraction helpers
s = VxSim.getScale(m) # Get Scale VxVector3 from Matrix44
r = VxSim.getRotation(m) # Get Rotation VxVector3 from Matrix44
t = VxSim.getTranslation(m) # Get Translation VxVector3 from Matrix44

# Checks whether this matrix includes a perspective projection.
b = VxSim.isPerspectiveProjection(m)

# Affine Matrix operation
mt = VxSim.translateTo(m, translation) # Sets translation VxVector3 on m
mr = VxSim.rotateTo(m, rotation) # Sets rotation VxVector3 on m
ms = VxSim.scaleTo(m, scale) # Sets scale VxVector3 on m
m = VxSim.compose(scale, rotation, translation, flip) #C reates a matrix by composition with a VxVector3 scaling, then a VxVector3 rotation and a VxVector3 translation.
scale, rotation, translation, flip = VxSim.decompose(m) # Decomposes the affine matrix m into a scale, rotation and translation matrix. Rotation are given in the range [-pi, pi] for x, [-pi/2, pi/2] for y, [-pi, pi] for z.

from VxSim import *
application = VxApplication()
serializer = ApplicationConfigSerializer()
 
serializer.load('myconfig.vxc')

# Extract the ApplicationConfig
config = serializer.getApplicationConfig()
 
# Apply it
config.apply(application)
...
# Load Content
...
# Run the application
... 

...
application = VxApplication()
...
# Setup the application
...
# Get the file manager to load content
fileManager = application.getSimulationFileManager()

# Load the file, the object returned is the root object, in this case, a scene. The Reference should be kept to inspect the content during the simulation
# The object loaded is already added to the application
scene = SceneInterface( fileManager.loadObject("myScene.vxscene") )
if (scene.valid()):
	# Work with scene
	...
	# run application
	...
	# Done with content
	fileManager.unloadObject("myScene.vxscene")
	...
	# Load new content and continue...

...
# Create and setup the application
...
#Load content
# loadObject returns a VxObject type, it needs to be converted to a SceneInterface (C++ equivalent of VxSmartInterface<Scene>)
scene = SceneInterface( fileManager.loadObject("myScene.vxscene") )
if scene.valid():
	# Browse to my hinge
    # scene.getMechanisms returns an array of MechanismInterface, no conversion needed
    mechanism = scene.getMechanisms()[0]
	# mechanism.getExtensions returns an array of IExtensionInterface
	iextension = mechanism.getExtensions ()[0]
	connectionContainer = ConnectionContainerInterface(iextension .getExtension())
 
    # mechanism.getAssemblies returns an array of AssemblyInterface, no conversion needed    
	assembly = mechanism.getAssemblies()[0]
    # assembly.getConstraints() returns an array of ConstraintInterface, getting the proper constraint type require a conversion
    constraint = assembly.getConstraints[0]
     
    # To use the constraint as a hinge, create the HingeInterface using the VxObject of the ContraintInterface
    hinge = ConstraintInterface.getConstraintInterface(constraint) #since contraint is an Hinge, getConstraintInterface() returns an HingeInterface
	# this is the equivalent of doing
	# hinge = HingeInterface(constraint.getExtension())
 

...
# Create and setup the application
...
#Load content
...
# Set the input Velocity, with is a Field<VxVector3>, property value is a VxVector3
part.inputLinearVelocity.value = VxSim.VxVector3(1,1,1)

# Updates the application's modules
application.update()

# Get the mechanism position from an custom extension with a field<Mechanism>, using getParameter since the Interface is not available in python
# property value is a MechanismInterface
mechanism = myCustomExtension.getParameter('Mechanism').value
mechPos = VxSim.getTranslation( mechanism.outputWorldTranform.value )
...
 

        # init key frame
        application.update()
        keyFrameList = application.getContext().getKeyFrameManager().createKeyFrameList("KeyFrameList", False)
        application.update()
        key_frames_array = keyFrameList.getKeyFrames()
        # len(key_frames_array) should be 0

        # first key frame
        frameId1 = keyFrameList.saveKeyFrame()
        waitForNbKeyFrames(1, application, keyFrameList)
        key_frames_array = keyFrameList.getKeyFrames()
        # len(key_frames_array) should be 1
        # key_frames_array[0] should not be None

        # wait a bit, do something...
        counter = 0
        while(self.application.update() and counter < 60):
            counter += 1

        # restore first key frame       
        keyFrameList.restore(key_frames_array[0])
        self.application.update()

def waitForNbKeyFrames(expectedNbKeyFrames, application, keyFrameList):
    maxNbIter = 100
    nbIter = 0
    while len(keyFrameList.getKeyFrames()) != expectedNbKeyFrames and nbIter < maxNbIter:
        if not application.update():
            break
        ++nbIter

# loading a definition
serializer = VxObjectSerializer()
serializer.load(fileName)
partDef = PartInterface(serializer.getObject()) #getObject() returns a VxObject so the PartInterface must be created

...
#Modify the definition
...
#saving a definition
serializer = VxObjectSerializer(partDef)
serializer.save(fileName)
 

# Clone the part since I need a part with a box CG, but lighter
partDefClone = partDef.clone()
partDefClone.parameterMassPropertiesContainer.mass.value = lighter
 
# Instantiate a definition
partInstance = partDef.instantiate()

# add it to a previously created assembly
assembly.addPart(partInstance)

# move the instance
partInstance.setLocalTransform(transform) #Instance data
partInstance.inputControlType.value = Part.kControlDynamic #Instance Data

...
# Modify partDef by changing the mass and adding a sphere in place of a box
partDef .parameterMassPropertiesContainer.mass.value = heavier # Definition data
partDef .removeCollisionGeometry(box)
sphere = Sphere.create()
partDef .addCollisionGeometry(sphere)
...
# Sync to get the definition data
partInstance.sync()
# After the sync, part instance mass is heavier, have a sphere in its CG

# create a box
box = VxSim.Box.create()
 
# Set the box dimensions (x,y,z) to (1 meters, 2 meters, 3 meters)
box.parameterDimension.value = VxSim.VxVector3(1.0,2.0,3.0)

# create a part
part = VxSim.Part.create()
# set the mass
part.parameterMassPropertiesContainer.mass.value = 1.0
 # Adding a CG
part.addCollisionGeometry(box)

# create an assembly
assembly = VxSim.Assembly.create()

# create an instance from the part definition
partInstance = part.instantiate()   

# Sets Position and Control type
partInstance.setLocalTransform( VxSim.createTranslation(1.0,2.0,3.0) )
partInstance.inputControlType.value = VxSim.Part.kControlDynamic
 
#Add the part instance to the assembly
assembly.addPart(partInstance)

# create an hinge
hinge = VxSim.Hinge.create()
 
# set the attachment parts
hinge.inputAttachment1.part.value = part1
hinge.inputAttachment1.part.value = part2
 
# set the attachment positions
hinge.inputAttachment1.position.value = VxSim.VxVector3(1.0,0.0,0.0)
hinge.inputAttachment2.position.value = VxSim.VxVector3(1.0,0.0,0.0)
 
# set the attachment primary axis
hinge.inputAttachment1.primaryAxis = primaryAxis
hinge.inputAttachment2.primaryAxis = primaryAxis
 
# Add the hinge to the assembly
assembly.addConstraint(hinge)

# create a first attachment point
attPt1 = VxSim.AttachmentPoint.create()
attPt1.parameterParentPart.value = partInstance1
assembly.addAttachmentPoint(attPt1)

# create a second attachment point and add it 
attPt2 = VxSim.AttachmentPoint.create()
attPt2.parameterParentPart.value = partInstance2
assembly.addAttachmentPoint(attPt2)

# create an attachment using both attachment points
attachment = VxSim.Attachment.create()
attachment.setAttachmentPoints(attPt1, attPt2)

# add the attachment to the assembly
assembly.addAttachment(attachment)
 
# attach 
attachment.inputAttach = True

# create a mechanism
mechanism = VxSim.Mechanism.create()
 
# create an instance from the assembly definition
assemblyInstance = assembly.instantiate()    

# Position
assemblyInstance.setLocalTransform( VxSim.createTranslation(1.0,2.0,3.0) )

# Add the assembly instance to the mechanism
mechanism.addAssembly(assemblyInstance)

scene = VxSim.Scene.create()

# create an instance from the mechanism definition
mechanismInstance = mechanism.instantiate()

# Position
mechanismInstance.setLocalTransform( VxSim.createTranslation(1.0,2.0,3.0) )

# Add the mechanism instance to the scene
scene.addMechanism(mechanismInstance)

# Create the VHL extension
vhlInterface = VxSim.VxVHLInterface.create()

# Add a hinge control field as input of VHL. Make sure to use the correct hinge extension (i.e. from the assembly instance)
vhlInterface.addInput('Input Value', hingeFromAssemblyInstance.inputAngularCoordinate.control)        

# Add the VHL extension to the mechanism
mechanism.addExtension(vhlInterface.getExtension()) 

# Create the connection container extension
connectionContainer = VxSim.ConnectionContainerExtension.create()

# Add a connection between two fields : my custom extension output and a part input control
# Types have to be compatible for the connection creation to succeed
connectionIndex = connectionContainer.create(myCustomExt.getOutput('CustomOutput'), part.inputControlType)

# Add the connection container to the mechanism
mechanism.addExtension(connectionContainer.getExtension())

# Create the python scripting extension
pythonExt = VxSim.VxExtensionFactory.create(VxSim.VxSimPythonDynamicsICD.kFactoryKey)

# Add the scripting file as parameter - the script can also be added as a string
pythonExt.getParameter(VxSim.VxSimPythonDynamicsICD.kScriptFile)value = '/mypythonscript.py'

# Add a parameter of type Part and set its reference
pythonExt.addParameter('ParamPart', VxSim.Types.Type_Part)
pythonExt.getParameter('ParamPart').value = part

# Add an input of type boolean and set its value
pythonExt.addInput('Switch', VxSim.Types.Type_Bool)
pythonExt.getInput('Switch').value = False

# Add an output of type integer and set its value
Vx::VxID kOutputControl("Control Mode")
pythonExt.addOutput('Control Mode', VxSim.Types.Type_Int)
pythonExt.getOutput('Control Mode').value = 0

# Add the connection container to the mechanism
mechanism.addExtension(pythonExt)

...
# Add 4 extensions to mechanism
myExtension1 = VxSim.VxExtensionFactory.create(MyFactoryKey)
myExtension2 = VxSim.VxExtensionFactory.create(MyFactoryKey)
myExtension3 = VxSim.VxExtensionFactory.create(MyFactoryKey)
myExtension4 = VxSim.VxExtensionFactory.create(MyFactoryKey)
 
# Sets default value
myExtension1.parameterA.value = 1
myExtension1.parameterB.value = 2
myExtension1.parameterC.value = 3

myExtension2.parameterA.value = 4
myExtension2.parameterB.value = 5
myExtension2.parameterC.value = 6

myExtension3.parameterA.value = 7
myExtension3.parameterB.value = 8
myExtension3.parameterC.value = 9

myExtension4.parameterA.value = 10
myExtension4.parameterB.value = 11
myExtension4.parameterC.value = 12

mechanism.addExtension(myExtension1)
mechanism.addExtension(myExtension2)
mechanism.addExtension(myExtension3)
mechanism.addExtension(myExtension4)
...
# Create a configuration
configuration = VxSim.Configuration.create()
configuration.setName('Configuration1')
mechanism.addExtension(configuration.getExtension())
 
# Configuration will modify Extension 1, remove extension 2 and add extension 4
configuration.addReference(myExtension1, VxSim.kModify)
configuration.addReference(myExtension2, VxSim.kRemoveOnActivation)
configuration.addReference(myExtension4, VxSim.kAddOnActivation) # Because the flag is AddOnActivation, myExtension4 is immediately removed from the content. It still exist with mechanism but no module will received it.
 
# Start edition.
if(configuration.canActivate()[0]): # just to make sure there is no conflict, canActivate has 2 return values, the first being True are False, the second being the conflicts
{
	configuration.inputActivate.value = True # Activation will remove myExtension2 and add myExtension4.
    mApplication.update() # activation requires an application update
 
	if(configuration.outputActivated.value):
	{
		# Edit the extension 1 and 4
		myExtension1.parameterA.value = -1
		myExtension1.parameterC.value = -10
 
		myExtension4.parameterB.value = 42
		
        # Done editing
		mConfiguration.inputActivate.value = False
		mApplication.update() # deactivation requires an application update
	}
	else:
	{
		# Handles errors
		errors = mConfiguration.getRuntimeErrors()
	}
}
   
... # Continue edition
 
# Create a scene
scene = VxSim.Scene.create()
# instantiate a mechanism
mechInstance = mechanism.instantiate()
 
# myExtension1 is in the content, parameterA value is 1, parameterB is 2 and parameterC is 3
# myExtension2 is in the content, parameterA value is 4, parameterB is 5 and parameterC is 6
# myExtension3 is in the content, parameterA value is 7, parameterB is 8 and parameterC is 9
# myExtension4 is NOT in the content
scene.addMechanism(mechInstance)
 
# Activate the mechanism configuration in the scene
confInstance = VxSim.ConfigurationInstance( mechInstance.getObject().findExtensionByName('configuration1', False) )
confInstance.inputActivate.value = True
mApplication.update() # requires an application update
 
# myExtension1 is in the content, parameterA value is 11, parameterB is 2 and parameterC is -10
# myExtension2 is NOT in the content
# myExtension3 is in the content, parameterA value is 7, parameterB is 8 and parameterC is 9
# myExtension4 is in the content, parameterA value is 10, parameterB is 42 and parameterC is 12

set VXTK=%~dp0..\
set PATH=%VXTK%\bin;%VXTK%\plugins;%VXTK%\bin\osgPlugins-3.2.0;%PATH%
set OSG_FILE_PATH=%VXTK%\resources\images;%VXTK%\resources\shaders
set PYTHONPATH=%VXTK%\bin;%PYTHONPATH%

import os
import unittest

from VxSim import *
from vxatp import * 

class TestMethods(unittest.TestCase):

  directory = os.path.dirname(os.path.realpath(__file__))
 
  def test_upper(self):
     self.assertEqual('foo'.upper(), 'FOO')

  def test_isupper(self):
     self.assertTrue('FOO'.isupper())
     self.assertFalse('Foo'.isupper())

  def test_loading(self):
     # create a VxApplication while applying a setup file contained in the test directory 
     application = VxATPConfig.createApplication(self, setup='%s/config.vxc' % self.directory)

     # load content and verify it has been correctly loaded
     file = '%s/MyAsset.vxscene' % self.directory
     object = application.getSimulationFileManager().loadObject(file)
     self.assertIsNotNone(object)

if __name__ == '__main__':
    vxatp_run_thisfile('my_vxatp_output_directory')

import os
import unittest

from VxSim import *
from vxatp import * 

class TestMutipleDiff(unittest.TestCase):

  directory = os.path.dirname(os.path.realpath(__file__))
 
  @VxATPUtils.parametrized([['diff_one', 3, 5, -2], ['diff_two', 13, 8, 6], ['diff_three', 13, 8, 5]])
  def test_diff(self, test_name, a, b, expected):
     self.assertTrue(a-b == expected, '%d-%d does not match expected value %d.' % (a,b,expected))

if __name__ == '__main__':
    vxatp_run_thisfile('.\\results\\')

vxatp_run_onetest.bat my_test.py

vxatp_launcher.py -p my_test_directory -o my_output_directory_for_results_and_logs

vxatp_launcher.py -p my_test_directory -o my_output_directory_for_results_and_logs -r

vxatp_launcher.py -p my_test_directory -o my_output_directory_for_results_and_logs -i -r

vxatp_launcher.py -p my_test_directory -o my_output_directory_for_results_and_logs -g -r

vxatp_set_env.bat

vxatp_run_onetest.bat my_test.py

vxatp_run_tests.bat test_directory output_directory

vxatp_run_tests_interactive.bat test_directory output_directory

vxatp_run_tests_interactive.bat test_directory output_directory

hook = self.parameters.Hook.value
pulley = self.parameters.Pulley.value
diff = getTranslation(hook.outputWorldTransform.value) - getTranslation(pulley.outputWorldTransform.value)
distance = math.sqrt(diff.x ** 2 + diff.y ** 2 + diff.z ** 2

attachment_point1 = self.parameters.AttachmentPoint_A.value
attached_part1 = attachment_point1.parameterParentPart.value

attachment_point2 = self.parameters.AttachmentPoint_B.value
attached_part2 = attachment_point2.parameterParentPart.value

attachment = self.parameters.Attachment.value
attachment.setAttachmentPoints(attachment_point1, attachment_point2)
attachment.inputAttach = True

drum = self.parameters.Drum.value

# accessing drum as a Hinge
drum_c = drum.inputAngularCoordinate  # Equivalent to drum.inputCoordinates[0]
drum_c.lock.position.value = 0
drum_c.control.value = Constraint.kControlLocked 

from VxSim import *

def on_add_to_universe(self, universe):
	self.inputs.Connect.value = False

def on_remove_from_universe(self, universe):
	self.inputs.Connect.value = False

def pre_step(self):
	self.outputs.Attach.value = self.inputs.Connect.value

from VxSim import *
import math


filteredHydraulic = 0.0


def on_add_to_universe(self, universe):
    global filteredHydraulic
    filteredHydraulic = 0.0
    Hydraulic = self.parameters.Hydraulic.value.inputLinearCoordinate
    Hydraulic.control.value = Constraint.kControlLocked
def post_step(self):
    global filteredHydraulic
    Throttle = self.inputs.Throttle.value
    Direction = self.inputs.Direction.value
    filteredHydraulic = lowPassFilter( filteredHydraulic, Direction, 0.001 )
    Hydraulic = self.parameters.Hydraulic.value.inputLinearCoordinate
    BoomOut = self.parameters.Boom.value.outputAngularCoordinate
    Hydraulic.lock.velocity.value = filteredHydraulic * Throttle
    self.outputs.Boom_Angle.value = -math.degrees( BoomOut.currentStatePosition.value )
def lowPassFilter( inputSignal, outputSignal, timeConstant ):
    deltaTime = getSimulationTimeStep()
    value = ( (deltaTime * inputSignal) + (timeConstant * outputSignal) ) / (deltaTime + timeConstant )
    return value
    
def on_state_save( self, data ):
    global filteredHydraulic
    
    # Save the filter internal state
    data['filteredHydraulic'] = filteredHydraulic
def on_state_restore( self, data ):
    global filteredHydraulic
    
    # Restore the filter internal state
    if data['filteredHydraulic']:
        filteredHydraulic = data['filteredHydraulic']
    else:
        filteredHydraulic = 0.0

from VxSim import *

def pre_step(self):
	shoulder_rot = self.inputs.Shoulder_Rotation_Signal.value
	shoulder_piv = self.inputs.Shoulder_Pivot_Signal.value
	elbow1_piv = self.inputs.Elbow_1_Pivot_Signal.value
	elbow2_piv = self.inputs.Elbow_2_Pivot_Signal.value 

	basearm = self.parameters.Base_Arm.value
	basearm_c = basearm.inputAngularCoordinate
	basearm_c.motor.desiredVelocity.value = shoulder_rot * -2. / 10. 

	arm01 = self.getParameter("Arm 01").value
	arm01_c = arm01.inputAngularCoordinate
	arm01_c.motor.desiredVelocity.value = shoulder_piv * 1. / 10. 

	arm02 = self.getParameter("Arm 02").value
	arm02_c = arm02.inputAngularCoordinate
	arm02_c.motor.desiredVelocity.value = elbow1_piv * -2. / 10. 

	arm03 = self.getParameter("Arm 03").value
	arm03_c = arm03.inputAngularCoordinate
	arm03_c.motor.desiredVelocity.value = elbow2_piv * 2. / 10.

from VxSim import *
 
# create a VxDynamics::Part
part = Part.create()
# This is the equivalent of doing
extension = VxExtensionFactory.create(PartICD.kFactoryKey)
part = PartInterface(extension)
 
part->addCollisionGeometry(cg) # using it has an interface

# mechanism.getExtensions returns an array of IExtensionInterface
iextension_0 = mechanism.getExtensions ()[0]
connectionContainer = ConnectionContainerInterface(iextension_0.getExtension())

import VxSim
  
application = VxSim.VxApplication() # VxApplication is not a Smart Interface. Just call the constructor
part = VxSim.Part.create()
# Contrary to c++, python VxApplication.add() accepts VxExtension rather than Smart Interface. Use getExtension() on the interface object 
application.add(part.getExtension())
 
# addExtension on a VxDynamics::Mechanism was modified to accept VxExtension
connectionContainer = ConnectionContainer.create()
mechanism.addExtension( connectionContainer.getExtension() )