I tried to implement the multi-clip reward described in the DeepMimic paper. In this pull request you will find:

• loading of multiple clips and multiple kinematic characters
• downsampling (using random sampling) and upsampling (using SLERP) of clips in case of multiple clips with different duration
• selection of the maximum reward among all the clips, as described in the paper
• train and run files to use as arguments
• motions file to try the training and evaluation
• a script to visualize the train and test return from output/agent0_log.txt

I chose create new files as I am not 100% sure about the implementation. At the moment, I managed to train the character with multiple walking clips, but it limps. However, if a single clip is provided, it works exactly as the current version of train_humanoid3d_walk.txt and all the others single clip instances.

I am putting this out there so that someone else can try it out as well. The only significant difference is that in the configuration file, instead of indicating a file containing the motion data, you can indicate the folder containing the motion data.

NOTE: I am sure this has been asked before but I have not found a completely clear explanation on closed issues.

I find it very confusing that it is seemingly impossible to cleanly install pybullet as a conda/conda-forge package. Here's what I find confusing:

1. conda-forge has a bullet package and installing it actually installs pybullet
2. regardless of that, it's been mentioned often that "bullet is not the same as pybullet" (eg here), and while they are not the same, the package installs pybullet, so, I don't understand the clarification.
3. after having installed conda install bullet, running pip install pybullet overrides the installation instead of finding it as already satisfied requirement (which is what happens with mostly every other package out there).

Finally, the conda-forge package has not been updated in about 10 months, while the pip has had very frequent updates in the same period. Normally, conda-forge bot automatically takes care of creating a PR when a new release is detected, so it's not clear to me what this doesn't happen in this case.

I saw the greatly expanded gym examples the selection looks nice! I checked the pybullet docs and I tried running them, but the path doesn't seem to work as-is, and it seems spaces is missing.

I saw the announcement about pybullet in the 2.84 prerelease, and I went to tinker with it, but I noticed that it doesn't install libpybullet.so. It would be nice to install it like the other libraries I think. I'm not sure how other packages would find it though.

tl;dr Check summary comments below

Hello!

I created a basic example of walkers that get a random Neural network initialization that enables them to walk (or not). The walker's body parts all have sensors, which get linked to the joint motors of each walker by randomized connection weights, which leads to non-random movement behavior. My next ideas would be to implement an optimization strategy like evolution (hence the folder name evolution) to find a fit walker. Alternatively, I could look into OpenGym-like Deep Reinforcement learning to make it work with Tensor flow. Any suggestions? I just wanted to publish early to have a basis for discussion before I go too far into the details of either one.

...latest tf model from the roboschool model zoo. All my examples try to connect to an already running ExampleBrowser and run headless if no browser is open (if somebody just wants the recording or the scores etc.).

For some reason, the model zoo version of reacher does not perform well at all. I will look into it again and otherwise just pull-request it here too since the env as such looks ok. If you want me to integrate the other gym envs you have into the same structure, just tell me. I can propose some structure for the gym stuff in general. Furthermore, I will soon pull-request my training pipeline so that people can also train stuff with the Example Browser.

Adds a multithreading demo to the example browser which uses either OpenMP, Intel TBB or Microsoft PPL to provide task scheduling. (issue #126) Demo allows task scheduler API to be changed on the fly. On my quad-core machine the bullet part of the demo (ignoring rendering, etc) runs about 3 times faster with threading enabled than in single-threaded mode.

Also makes Dvbt rayTest threadsafe (issue #254, #258) Discussion (here)[http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?f=9&t=10232]

Areas that run in parallel:

narrowphase (dispatchAllPairs) discreteDynamicsWorld solve islands (each island is a separate task) discreteDynamicsWorld predictUnconstraintMotion discreteDynamicsWorld createPredictiveContacts discreteDynamicsWorld integrateTransforms

There were some significant changes to how the btSimulationIslandManager works, so that islands could be dispatched in parallel to different solvers. Based on an earlier (pull request)[https://github.com/bulletphysics/bullet3/pull/303]. This version has been collapsed into fewer commits and many dead ends were stripped out. All of the previous patch's changes in the sequential impulse constraint solver were dropped, it is simpler and more effective to run islands of constraints in parallel.

Two tools would be extremely helpful for pybullet:

1. A way to add arbitrary poses/coordinate systems with optional visualization, like an unlimited version of CoodinateSystemDemo.
2. A useful companion would be a way to get arbitrary transforms between any two objects, including what is loaded from files like URDF.

Is there a transform object with a vector + quaternion or are position and orientation always stored separately at the moment?

Here is my first pass at an API, which will need some refinement:

import pybullet as p

# create/modify a pose object
id = p.setPoseObject(transform,
                     itemUniqueId=None # create by default
                     relativeToId=WorldFrameId, 
                     parentFrameId=WorldFrameId, 
                     ballOpacity=1, 
                     triadOpacity=1, 
                     name="PoseObject####",
                     color="yellow")

# move any object to an arbitrary position relative to an arbitrary frame
success = setTransform(itemUniqueId, 
                       transform, 
                       relativeToId=WorldFrameId)

# change the frame within which the specified frame moves
success = setParentFrame(itemUniqueId, parentUniqueId)

# get the id of the parent frame
parentId = getParent(itemUniqueId)

# get the transform between two arbitrary objects
transform = getTransform(itemUniqueId, relativeToId=WorldFrameId)

# get separate v,q (maybe not necessary if the transform above is [v,q]
v, q = getTransformVectorQuaternion(itemUniqueId, relativeToId=WorldFrameId)

It would be important that any frame moves along with its parent, for example if you were setting a tool point on a gripper, the frame should move with the gripper. If the world frame is the parent, it should remain static.

Why is this important? It will be extremely useful for debugging, defining goals and visualizing them, etc.

Overview

This issue was found on godot engine, while I was checking what was happening here: https://github.com/godotengine/godot/issues/17960

I've noticed that when my kinematic body was using a sphere shape, sometimes the engine was returning me a positive depth result even if the shape is penetrated.

Details

To check the collision between kinematic body with sphere shape and trimesh shape I'm using this algorithm: https://github.com/godotengine/godot/blob/master/modules/bullet/space_bullet.cpp#L1100-L1136

and here the manifold result class to collect the data: https://github.com/godotengine/godot/blob/master/modules/bullet/godot_result_callbacks.cpp#L258-L268

Problem

As you can see from the addContactPoint function from the ManifoldResult callback (link above) I've this like of code:

if (m_penetration_distance > depth) { // Has penetration?

That check if there was penetration, since the depth is negative if penetration happens m_penetration_distance value is more than depth value (initially m_penetration_distance is 0).

Even if the shape is penetrated for some reason the depth is positive. This start happening after a bit while I'm moving the kinematic body on certain area of this trimesh shape, and more important thing is that if I change the kinematic shape from sphere to capsule this problem never happens.

Run the project:

Compile godot engine from master branch and open this project: https://github.com/godotengine/godot/files/1874984/godot-desert-physics_collision_error.zip

Move the camera using W-A-S-D and arrows of keyboards, move the kinematic body using T-F-G-H

Images

In this images the kinematic body is stuck The blue line is the normal of contact point

Screenshot from the above

Screenshot from the below to assert that there's penetration

Screenshot from the above more close

What I need:

I'm implementing bullet wrapper for Godot and I need to implement a custom shape "ray". This shape is basically a ray that push the body in the opposite direction where it points.

What I does:

Here a video difference from the Godot shape to the shape that I already implemented: https://www.youtube.com/watch?v=Ff0qlG55t_E&feature=youtu.be

As you can see the shape can receive lateral forces.

This is how I've implemented it: Header: https://github.com/AndreaCatania/godot/blob/59ac2999ea4af77cc36c65c9da904616d9eb832b/modules/bullet/btRayShape.h CPP: https://github.com/AndreaCatania/godot/blob/59ac2999ea4af77cc36c65c9da904616d9eb832b/modules/bullet/btRayShape.cpp

As you can see I've extended the convex shape to implement the RayShape, and this allowed me to easily implement it, but its behaviour is not what I need.

I need that the shape respond to the direction of ray only and for doing this I think that I need to create all algorithms to find the collisions in the narrowphase against all shapes.

My question:

Since do and maintain it could be not so easy, There's a way to customize the shape response in an easier way (in order to clamp forces to ray direction)?

Related godot issue: https://github.com/godotengine/godot/issues/12156

I am trying to add the joint limits to the pybullet.getJointInfo(...), but it still segfaults when I load a URDF (discussed here #959 ). I am working on it. All help welcome.

Running import pybullet_examples.deformable_torus leads to starting a pybullet GUI window with a torus, and then a crash with the following message:

b3Printf: b3Warning[examples/SharedMemory/../Importers/ImportURDFDemo/UrdfFindMeshFile.h,102]:

b3Printf: : cannot find 'torus.vtk' in any directory in urdf path

Nodes:  0
Links:  0
Faces:  0
Tetras: 0
b3Printf: b3Warning[examples/Importers/ImportURDFDemo/UrdfFindMeshFile.h,102]:

b3Printf: /usr/local/lib/python3.8/dist-packages/pybullet_data/torus_deform.urdf:12: cannot find 'torus.vtk' in any directory in urdf path

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/lib/python3.8/dist-packages/pybullet_examples/deformable_torus.py", line 22, in <module>
    bunny2 = p.loadURDF("torus_deform.urdf", [0,1,0.2], flags=p.URDF_USE_SELF_COLLISION)
pybullet.error: Cannot load URDF file.

Note that commenting out the lines in the source file associated with torus.vtk, torus_deform.urdf, and bunny2 eliminates the crashing issue but this likely changes the desired behavior of the example

For addressing situations like Issue #4386.

I am working on a fix in removeGraphicsInstance behaviour but I think I should modify OpenGL buffers also for not producing breaking changes, I can commit the solution I have until now and have some feedback from @erwincoumans

I want to load deformable object in PyBullet with function "loadSoftBody". I know that PyBullet offers example object file "torus.obj" and "torus.vtk". It works well. However, when I try to generate .vtk file by myself from .obj with the following steps, PyBullet crashes down:

1. open .obj file in Blender in Windows and export .stl file
2. generate .msh file in TetWild (https://github.com/Yixin-Hu/TetWild) in Ubuntu with command in terminal: $ ./TetWild --input torus.stl --output torus.msh
3. open .msh file in Gmsh in Windows and export .vtk file
4. run the following Python script:

import pybullet as p
from time import sleep
import pybullet_data

physicsClient = p.connect(p.GUI)

p.setAdditionalSearchPath(pybullet_data.getDataPath())

p.resetSimulation(p.RESET_USE_DEFORMABLE_WORLD)
p.setGravity(0, 0, -10)

planeId = p.loadURDF("plane.urdf", [0,0,0])

# original .vtk file ------- success
# softBodyId1 = p.loadSoftBody("original files/torus.vtk", basePosition = [0,0,5])
# generated .vtk file ------- fail
softBodyId2 = p.loadSoftBody("generated files/torus.vtk", basePosition = [0,0,5])

p.setRealTimeSimulation(0)

while p.isConnected():
p.stepSimulation()

Then PyBullet crashes down.

pybullet build time: May 20 2022 19:44:17
startThreads creating 1 threads.
starting thread 0
started thread 0
argc=2
argv[0] = --unused
argv[1] = --start_demo_name=Physics Server
ExampleBrowserThreadFunc started
X11 functions dynamically loaded using dlopen/dlsym OK!
X11 functions dynamically loaded using dlopen/dlsym OK!
Creating context
Created GL 3.3 context
Direct GLX rendering context obtained
Making context current
GL_VENDOR=VMware, Inc.
GL_RENDERER=SVGA3D; build: RELEASE; LLVM;
GL_VERSION=4.1 (Core Profile) Mesa 21.2.6
GL_SHADING_LANGUAGE_VERSION=4.10
pthread_getconcurrency()=0
Version = 4.1 (Core Profile) Mesa 21.2.6
Vendor = VMware, Inc.
Renderer = SVGA3D; build: RELEASE; LLVM;
b3Printf: Selected demo: Physics Server
startThreads creating 1 threads.
starting thread 0
started thread 0
MotionThreadFunc thread started
ven = VMware, Inc.
ven = VMware, Inc.
Segmentation fault (core dumped)

All the files are attached in the files.zip Folder "original files" are files provided by PyBullet git repository. Folder "generated files" are files generated by myself. I search for the solution online and issue #2726 but still cannot solve this problem.

When using objects that have composite collision objects (e.g. created via vhacd), then the simulation after save/restoreState is not deterministic anymore.

To reproduce this error, I simply used the existing TestPybulletSaveRestoreMethods and replaced cube_small.urdf with duck_vhacd.urdf.

import unittest
import pybullet as p
import math, time
import difflib, sys

from utils import allclose, dot


class TestPybulletSaveRestoreMethods(unittest.TestCase):

  def setupWorld(self):
    numObjects = 50

    maximalCoordinates = False

    p.resetSimulation()
    p.setPhysicsEngineParameter(deterministicOverlappingPairs=1)
    p.loadURDF("planeMesh.urdf", useMaximalCoordinates=maximalCoordinates)
    kukaId = p.loadURDF("kuka_iiwa/model_free_base.urdf", [0, 0, 10],
                        useMaximalCoordinates=maximalCoordinates)
    for i in range(p.getNumJoints(kukaId)):
      p.setJointMotorControl2(kukaId, i, p.POSITION_CONTROL, force=0)
    for i in range(numObjects):
      cube = p.loadURDF("duck_vhacd.urdf", [0, i * 0.02, (i + 1) * 0.2])
      #p.changeDynamics(cube,-1,mass=100)
    p.stepSimulation()
    p.setGravity(0, 0, -10)

  def dumpStateToFile(self, file):
    for i in range(p.getNumBodies()):
      pos, orn = p.getBasePositionAndOrientation(i)
      linVel, angVel = p.getBaseVelocity(i)
      txtPos = "pos=" + str(pos) + "\n"
      txtOrn = "orn=" + str(orn) + "\n"
      txtLinVel = "linVel" + str(linVel) + "\n"
      txtAngVel = "angVel" + str(angVel) + "\n"
      file.write(txtPos)
      file.write(txtOrn)
      file.write(txtLinVel)
      file.write(txtAngVel)

  def compareFiles(self, file1, file2):
    diff = difflib.unified_diff(
        file1.readlines(),
        file2.readlines(),
        fromfile='saveFile.txt',
        tofile='restoreFile.txt',
    )
    numDifferences = 0
    for line in diff:
      numDifferences = numDifferences + 1
      sys.stdout.write(line)
    self.assertEqual(numDifferences, 0)

  def testSaveRestoreState(self):
    numSteps = 500
    numSteps2 = 30

    verbose = 0
    self.setupWorld()

    for i in range(numSteps):
      p.stepSimulation()
    p.saveBullet("state.bullet")
    if verbose:
      p.setInternalSimFlags(1)
    p.stepSimulation()
    if verbose:
      p.setInternalSimFlags(0)
      print("contact points=")
      for q in p.getContactPoints():
        print(q)

    for i in range(numSteps2):
      p.stepSimulation()

    file = open("saveFile.txt", "w")
    self.dumpStateToFile(file)
    file.close()

    #################################
    self.setupWorld()

    #both restore from file or from in-memory state should work
    p.restoreState(fileName="state.bullet")
    stateId = p.saveState()

    if verbose:
      p.setInternalSimFlags(1)
    p.stepSimulation()
    if verbose:
      p.setInternalSimFlags(0)
      print("contact points restored=")
      for q in p.getContactPoints():
        print(q)
    for i in range(numSteps2):
      p.stepSimulation()

    file = open("restoreFile.txt", "w")
    self.dumpStateToFile(file)
    file.close()

    p.restoreState(stateId)
    if verbose:
      p.setInternalSimFlags(1)
    p.stepSimulation()
    if verbose:
      p.setInternalSimFlags(0)
      print("contact points restored=")
      for q in p.getContactPoints():
        print(q)
    for i in range(numSteps2):
      p.stepSimulation()

    file = open("restoreFile2.txt", "w")
    self.dumpStateToFile(file)
    file.close()

    file1 = open("saveFile.txt", "r")
    file2 = open("restoreFile.txt", "r")
    self.compareFiles(file1, file2)
    file1.close()
    file2.close()

    file1 = open("saveFile.txt", "r")
    file2 = open("restoreFile2.txt", "r")
    self.compareFiles(file1, file2)
    file1.close()
    file2.close()


#while (p.getConnectionInfo()["isConnected"]):
#	time.sleep(1)

if __name__ == '__main__':
  p.connect(p.DIRECT)
  unittest.main()

The bug exists for both cases: restoring from file or from in-memory state. I used pybullet 3.2.5 for testing.

What I am doing: I am repeating the following cycle: (1) load an object from a URDF file, (2) interact with it with a robot, (3) then delete it. Problem: After iteration number 125 (after creating and removing the object 125 times), the object visual is not shown. However, I can see the collision shape by pressing w, and I can interact with the object with the cursor. No problem if: There is no problem if I load the URDF once and reset its position. Expectation: The visual of the object would not be affected by the number of load/removal times. Recording of the mentioned effect: https://youtu.be/4bPfYZ6zjK8 Sample code:

import os
import time

import pybullet as p
import pybullet_data

p.connect(p.GUI)
p.configureDebugVisualizer(p.COV_ENABLE_GUI, 0)
p.resetDebugVisualizerCamera(1.5, 0, -40, [0.55, -0.35, 0.2])


robot = p.loadURDF(os.path.join(pybullet_data.getDataPath(), "franka_panda/panda.urdf"), useFixedBase=True)
table = p.loadURDF(os.path.join(pybullet_data.getDataPath(), "plane_transparent.urdf"))

it = 0
while True:
    it += 1
    p.resetJointState(robot, 0, 0)
    p.resetJointState(robot, 1, 0.307)
    p.resetJointState(robot, 2, 0)
    p.resetJointState(robot, 3, -2.7)
    p.resetJointState(robot, 4, 0)
    p.resetJointState(robot, 5, 3)
    p.resetJointState(robot, 6, -2.356)
    p.resetJointState(robot, 9, 0.01)
    p.resetJointState(robot, 10, 0.01)

    obj = p.loadURDF(os.path.join(pybullet_data.getDataPath(), "soccerball.urdf"), [0.6, 0., 0.05], globalScaling=0.1)
    # p.stepSimulation()

    joints = p.calculateInverseKinematics(robot, 11, [0.4, 0., 0.05])
    for _ in range(50):
        p.setJointMotorControlArray(robot, [0, 1, 2, 3, 4, 5, 6], p.POSITION_CONTROL, targetPositions=joints[:-2])
        p.stepSimulation()
        if it > 120:
            time.sleep(1/240)
    joints = p.calculateInverseKinematics(robot, 11, [0.6, 0., 0.05])
    for _ in range(50):
        p.setJointMotorControlArray(robot, [0, 1, 2, 3, 4, 5, 6], p.POSITION_CONTROL, targetPositions=joints[:-2])
        p.stepSimulation()
        if it > 120:
            time.sleep(1/240)
    p.removeBody(obj)
    print(it)

I tried to run this simple code in vscode terminal and the pop up example browser shutdowns immediately. I don't know what is causing this to happen. I looked around and didn't see similar problem I was wondering if anyone can help. The code runs perfectly in anaconda environment. But I cannot run in the terminal - here's the proof that it shutdowns immediately:

import pybullet as p

p.connect(p.GUI)
p.setPhysicsEngineParameter(enableFileCaching=0)
plane_shape = p.createCollisionShape(p.GEOM_PLANE)
floor = p.createMultiBody(plane_shape,plane_shape)
box_shape = p.createCollisionShape(p.GEOM_BOX, halfExtents = [1, 1, 1])
box_object1 = p.createMultiBody(box_shape,box_shape)
box_object2 = p.createMultiBody(box_shape,box_shape)
p.setGravity(0,0,-10)

Here's what the console shows:

pybullet build time: Dec 22 2022 20:13:02 starting thread 0 started testThreads thread 0 with threadHandle 0000000000000484 argc=2 argv[0] = --unused argv[1] = --start_demo_name=Physics Server ExampleBrowserThreadFunc started Version = 4.6.0 NVIDIA 527.56 Vendor = NVIDIA Corporation Renderer = NVIDIA GeForce GTX 1080/PCIe/SSE2 b3Printf: Selected demo: Physics Server starting thread 0 started MotionThreads thread 0 with threadHandle 00000000000006F8 MotionThreadFunc thread started numActiveThreads = 0 stopping threads Thread with taskId 0 with handle 00000000000006F8 exiting Thread TERMINATED finished numActiveThreads = 0 btShutDownExampleBrowser stopping threads Thread with taskId 0 with handle 0000000000000484 exiting Thread TERMINATED