
Caméra synthétique 35
Erwin Coumans , Yunfei Bai , 2017/2018
Visitez les forums .
Bonjour PyBullet World 3
Demandes de renseignements sur la détection des collisions 39
chargeURDF, chargeSDF, chargementMJCF 7
sauverÉtat, sauverBullet, restaurer état 9
Dynamique inverse, cinématique 44
Renforcement de la formation Gym Envs 47
Environnements et données 47
Contrôle d'un robot 17
Base, articulations, liens 17
Debug GUI, Lignes, Texte, Paramètres 55
getNumBodies, getBodyInfo, getsBodyUniqueId, removeBody 26
créerConstraint, supprimerConstrainte, changerConstrain 26
Construire et installer PyBullet 60
Soutien, conseils, citation 63

PyBullet est un module de simulation physique facile à utiliser pour la robotique, les jeux, les effets visuels et l'apprentissage automatique. Avec PyBullet, vous pouvez charger des corps articulés à partir d'URDF, SDF, MJCF et d'autres formats de fichiers. PyBullet fournit la simulation de dynamique avant, le calcul de dynamique inverse, la cinématique avant et inverse, le détection des collisions et les requêtes d'intersection de rayon. Le SDK de physique Bullet comprend des exemples robotiques PyBullet tels qu'un quadribus Minitaur simulé, humanoïdes fonctionnant avec l'inférence TensorFlow et les bras KUKA saisissant des objets.



Outre la simulation physique, il existe des liaisons au rendu avec un récepteur CPU (TinyRenderer) et une visualisation OpenGL et le support pour les casques de réalité virtuelle tels que HTC Vive et Oculus Rift. PyBullet a également des fonctionnalités pour effectuer des requêtes de détection de collision (points les plus proches, paires recoupantes, test d'intersection de rayon etc) et ajouter le rendu de débogage (lignes de débogue et texte). PyBullet a une plateforme intégrée de support client-serveur pour la mémoire partagée, UDP et le réseau TCP. Vous pouvez donc exécuter PyBullet sur Linux en vous connectant à un serveur VR Windows. PyBullet enveloppe le nouveau Bullet C-API , conçu pour être indépendant du moteur physique sous-jacent et rendre le moteur, de sorte que nous pouvons facilement migrer vers les versions plus récentes de Bullet, ou utiliser un autre moteur physique ou rendu moteur. Par défaut, PyBullet utilise l'API Bullet 2.x sur le processeur. Nous allons exposer Bullet 3.x en cours d'exécution sur GPU en utilisant OpenCL aussi bien. Il existe également une API C++ similaire à PyBullet, voir b3RobotSimulatorClientAPI . PyBullet peut être facilement utilisé avec TensorFlow et des cadres tels que OpenAI Gym. Les chercheurs de Google Brain [ 1 , 2 , 3 ], X , Stanford AI Lab et OpenAI utilisent PyBullet/Bullete C-API. L'installation de PyBullet est aussi simple que (sudo) pip install PyBullet (Python 2.x), pip3 installe Pybullet. Cela exposera le module PyBullet ainsi que les environnements PyBullet envs Gym.

Voici un script d'introduction de PyBullet que nous discutons étape par étape:
importation pybullet comme temps d'importation importation pylullet data physiqueClient = p.connect(p.GUI)#or p.DIRECT pour la version non graphique p.setRecherche additionnellePath(pybullet data.getDataPath(1) #facultatively p.SetGravity(0,0,-10) planId = p.loadURDF("plane.urdf") cubeStartPos = [0,1] cubeStarTOrientation = p,getQuaternionFromEuler([0,20)] boîteId= p.chargeURLF("r2d2.ourdf",cubeStartPOSs, cubeStarttOritation) pour i dans l'intervalle (10000): p.stepSimulation() time.sleep(1./240.) cubePos, cubOrn = p:getBasePositionAndOrientation(boxId) print(cubes,cubeOrn) p.disconnect()
Après avoir importé le module PyBullet, la première chose à faire est de se connecter à la simulation physique. PyBullet est conçu autour d'une API pilotée par un client-serveur, avec des commandes d'envoi de clients et un serveur physique qui retourne l'état. PyBullet possède des serveurs de physique intégrés : DIRECT et GUI. Les connexions GUI et DIRECT exécuteront la simulation physique et le rendu dans le même processus que PyBullet. Notez qu'en mode DIRECT vous ne pouvez pas accéder aux fonctionnalités matérielles OpenGL et VR, comme décrit dans les chapitres "Réalité Virtuelle" et "Debug GUI, Lines, Text, Parameters". Le mode DIRECT permet le rendu d'images en utilisant le logiciel intégré de rendus via l'API 'getCameraImage'. Cela peut être utile pour exécuter des simulations dans le cloud sur les serveurs sans GPU. Vous pouvez fournir vos propres fichiers de données, ou vous pouvez utiliser le paquet PyBullet data qui est livré avec PyBullet. Pour cela, importez pybullet data et enregistrez le répertoire en utilisant pybollet.setAdditionalSearchPath([email protected](1). getConnectionInfo
Vu une physiqueClientId retournera la liste [isConnected, connectionMéthod]


Diagramme avec différentes options de client physique (bleu) et serveur physique (vert). Vert foncé
La connexion DIRECT envoie les commandes directement au moteur physique, sans utiliser de couche de transport et aucune fenêtre de visualisation graphique, et renvoie directement l'état après exécution de la commande. La connexion GUI créera une nouvelle interface utilisateur graphique (GUI) avec rendu 3D OpenGL, dans le même espace de processus que PyBullet. Sous Linux et Windows, cette interface graphique fonctionne dans un thread séparé, tandis que sur OSX elle tourne dans le même thread en raison des limitations du système d'exploitation. Sur Mac OSX, vous pouvez voir une roue tournante dans la fenêtre OpenGL, jusqu'à ce que vous lancez une commande 'stepSimulation' ou autre PyBullet. Les commandes et les messages d'état sont envoyés entre le client PyBullet et le serveur de simulation physique GUI en utilisant un tampon mémoire ordinaire. Il est également possible de se connecter à un serveur physique dans un processus différent sur la même machine ou sur une machine distante en utilisant SHARED MEMORY, UDP ou TCP réseau. Consultez la section sur Mémoire partagée, UDP et TCP pour plus de détails. Contrairement à presque toutes les autres méthodes, cette méthode n'analyse pas les arguments de mots clés, en raison de la compatibilité arrière.

Les arguments de connexion sont :
connect retourne un identifiant client physique ou -1 si ce n'est pas connecté. L'identifiant client de physique est un argument optionnel pour la plupart des autres commandes PyBullet. Si vous ne le fournissez pas, il supposera que le client de physique id = 0. Vous pouvez vous connecter à plusieurs serveurs de physique différents, sauf pour l'interface graphique. Par exemple: Pybullet.coNect(pybullet.DIRECT) Pybullet.connect(pybullet.GUI, options ─-opengl2") Pybullet.connect(pybullet.SHARED MEMORY,1234) Pybullet.coNect(pybullet.UDP,"192.168.0.1") Pybullet.connect(pybullet.UDP,"localhost", 1234) Pybullet.connect(pybullet.TCP,"localhost", 6667) se connectent en utilisant la mémoire partagée
Il y a quelques serveurs de physique qui permettent la connexion à mémoire partagée : l'App SharedMemoryPhysics, App ShardMemaryPhysic GUI et le navigateur Bullet Example ont un exemple sous Experimental/Physical Server qui permet la connexion de mémoire partagée. Cela vous permettra d'exécuter la simulation physique et le rendu dans un processus séparé.

Vous pouvez également vous connecter sur la mémoire partagée à l'App SharedMemoryPhysics VR, l'application Virtual Reality avec support pour les écrans montés à la tête et les contrôleurs suivis de 6 dof tels que HTC Vive et Oculus Rift avec des contrôleurs tactiles. Puisque le Valve OpenVR SDK ne fonctionne correctement que sous Windows, l'App SharedMemoryPhysics VR peut être construit uniquement sous Windows en utilisant premake (de préférence) ou cmake. se connecter en utilisant le réseau UDP ou TCP
Pour le réseau UDP, il existe un App PhysicsServerUDP qui écoute un certain port UDP. Il utilise la bibliothèque en ligne open source pour un réseau UDP fiable. Cela vous permet d'exécuter la simulation physique et le rendu sur une machine séparée. Pour TCP PyBullet utilise la bibliothèque de clsocket. Cela peut être utile lorsque vous utilisez un tunnel SSH d'une machine derrière un pare-feu à une simulation robot. Par exemple, vous pouvez exécuter une pile de contrôle ou l'apprentissage automatique en utilisant PyBullet sur Linux, tout en exécutant le serveur physique sur Windows dans la réalité virtuelle en utilisant HTC Vive ou Rift. Une application UDP supplémentaire est l'application App PhysicsServerSharedMemoryBridgeUDP qui sert de pont vers un serveur physique existant : vous pouvez vous connecter sur UDP à ce pont, et le pont se connecte à un serveur Physique en utilisant une mémoire partagée : le pont passe des messages entre client et serveur. De la même façon, il existe une version TCP (remplacez UDP par TCP). Remarque : pour le moment, le client et le serveur doivent être soit 32bits soit 64bits ! Déconnecter
Vous pouvez vous déconnecter d'un serveur physique en utilisant le client de physique Id retourné par l'appel connect (si non négatif). Un serveur physique 'DIRECT' ou 'GUI' s'arrêtera. Un serveur de physique séparé (hors processus) continuera à fonctionner. Voir aussi 'resetSimulation' pour supprimer tous les articles. Paramètres de déconnexion:
physique optionnelleClientId int si vous vous connectez à plusieurs serveurs de physique, vous pouvez choisir lequel.
Par défaut, il n'y a pas de force gravitationnelle activée.setGravitévous permet de définir la force gravitationnelle par défaut pour tous les objets. Les paramètres d'entrée setGravity sont : (aucune valeur de retour)
force de gravité requise X flotteur sur l'axe mondial des X

La chargeURDF enverra une commande au serveur physique pour charger un modèle de physique à partir d'un fichier universel de description du robot (URLF). Le fichier URDF est utilisé par le projet ROS (Robot Operating System) pour décrire les robots et autres objets, il a été créé par la WillowGarage et l'Open Source Robotics Foundation (OSRF). De nombreux robots ont des fichiers URDF publics, vous pouvez trouver une description et un tutoriel ici:http://wiki.ros.org/urdf/Tutoriels Remarque importante : la plupart des articulations (glisseur, revolute, continu) ont des moteurs activés par défaut qui empêchent le mouvement libre. C'est similaire à un joint robot avec une commande harmonique très haute friction. Vous devez définir le mode de commande du moteur et les paramètres de la cible en utilisant pybullet.setJointMotorControl2. Consultez l'API setJointMotorControl2 pour plus d'informations. Avertissement : par défaut, PyBullet cache certains fichiers pour accélérer le chargement. Vous pouvez désactiver le cache de fichier en utilisant setPhysicsEngineParamètre(enableFileCaching=0). Les arguments de loadURDF sont:

loadURDF retourne un identifiant unique du corps, une valeur entière non négative. Si le fichier URDF ne peut pas être chargé, ce nombre entier sera négatif et non un identifiant unique du corps valide. chargeSDF, chargeMJCF
Vous pouvez également charger des objets à partir d'autres formats de fichiers, tels que .bullet, .sdf et .mjcf. Ces formats de fichiers supportent plusieurs objets, donc la valeur de retour est une liste d'ids uniques d'objets. Le format SDF est expliqué en détail àhttp://sdformat.org La commande loadSDF n'extrait que quelques parties essentielles du SDF liées aux modèles robotisés et à la géométrie, et ignore de nombreux éléments liés aux caméras, aux lumières, etc. La commande loadMJCF effectue l'importation de base des fichiers MuJoCo MJCF xml, utilisés dans OpenAI Gym. Voir aussi la note importante sous loadURDF relative aux réglages par défaut du moteur joint, et assurez-vous d'utiliser setJointMotorControl2.
loadBullet, loadSDF et loadMJCF retourneront un tableau d'identifiants uniques pour l'objet:
objetUniqueIds liste de int
la liste inclut l'identifiant unique de chaque objet chargé.

Vous pouvez créer un instantané approximatif du monde actuel sous forme de fichier PyBullet Python, stocké sur le serveur. saveWorld peut être utile comme fonction d'édition de base, la configuration du robot, les angles de joint, les positions des objets et l'environnement par exemple en VR. Plus tard, vous pouvez charger le fichier PyBullet Python pour recréer le monde. L'instantané python contient des commandes loadURDF ainsi que l'initialisation d'angles de joint et de transformations d'objets. Notez que tous les paramètres ne sont pas stockés dans le fichier mondial. Les arguments d'entrée sont les suivants:
Lorsque vous avez besoin de simulation déterministe après avoir rétabli un état précédemment sauvegardé, toutes les informations importantes sur l'état, y compris les points de contact, doivent être stockées. La commande saveWorld ne suffit pas à cela. Vous pouvez utiliser la commande restaurState pour restaurer à partir d'un instantané pris en utilisant saveState (in-memory) ou saveBullet (sur disque). La commande saveState prend seulement un clientServerId optionnel en entrée et retourne l'identifiant d'état. La commande saveBullet enregistrera l'état dans un fichier .bullet sur le disque. Les arguments d'entrée de la commande returnState sont :
Soit le nom du fichier ou l'identifiant d'état doit être valide. Notez que restaurer l'état réinitialisera les positions et les angles d'articulation des objets à l'État sauvegardé, ainsi que la restauration des informations de point de contact. Vous devez vous assurer que les objets et les contraintes sont configurés avant d'appeler restoreState. Voir l'exemple saveRestoreState.py.

Bien que la façon recommandée et plus facile de créer des choses dans le monde soit d'utiliser les fonctions de chargement (loadURDF/SDF/MJCF/Bullet), vous pouvez également créer des formes de collision et visuelles programmatiques et les utiliser pour créer un corps multi-en utilisant createMultiBody. Voir l'exemple createMultiBodyLinks.py et créerVisualShape.py dans le SDK de physique Bullet. Les paramètres d'entrée pour createCollisionShape sont
La valeur de retour est un id unique non négatif pour la forme de collision ou -1 si l'appel a échoué. créerVisualShape
Vous pouvez créer une forme visuelle de manière similaire à la création d'une forme de collision, avec quelques arguments supplémentaires pour contrôler l'apparence visuelle, comme la couleur diffuse et spéculaire. Lorsque vous utilisez le type GEOM MESH, vous pouvez pointer vers un fichier Wavefront OBJ et le visuel

forme analysera certains paramètres du fichier matériel (.mtl) et chargera une texture. Notez que les grandes textures (au-dessus de 1024x1024 pixels) peuvent ralentir le chargement et la performance d'exécution. Voir exemples/pybullet/exemples/addPlanarReflexion.py et créerVisualShape.py

Les paramètres d'entrée sont:

La valeur de retour est un id unique non négatif pour la forme visuelle ou -1 si l'appel a échoué.
Bien que la façon la plus facile de créer des choses dans le monde soit d'utiliser les fonctions de chargement (loadURDF/SDF/MJCF/Bullet), vous pouvez créer un corps multi en utilisant createMultiBody. Voir l'exemple createMultiBodyLinks.py dans le SDK de physique Bullet. Les paramètres de createMultiBody sont très similaires aux paramètres URDF et SDF. Vous pouvez créer un corps multi avec une seule base sans liens articulaires/enfants ou vous pouvez créer une structure multi-corps avec des liens articulation/enfant. Si vous fournissez des liens, assurez-vous que la taille de chaque liste est identique (len( linkMasses) == len(linkCollisionShapeIndices) etc.). Les paramètres d'entrée pour createMultiBody sont:

lien optionnelListe des indices de forme visuelle de la liste int de l'identifiant unique de forme visuel pour chaque lien
lien optionnelListe des positions de la liste vec3 des postes de liens locaux, par rapport au parent
lien optionnelListe des orientations de la liste vec4 d'orientations locales, w.r.t. parent
lien optionnelInertialFramePositions liste de vec3 liste des pos d'armature locale inertielle. dans le cadre de liaison
lien optionnelFrameInertielleListe d'orientation de la liste vec4 des ornes locales à cadre inertiel. dans le cadre de liaison
lien optionnelListe des indices de Parent d'int Lien index du lien parent ou 0 pour la base.
lien optionnelJointTypes liste d'inte liste de types de joints, un pour chaque lien. Pour le moment, seuls MIXTE REVOLUTE, MIXT-PRISMATIQUE et MIXTÉ FIXÉ sont pris en charge.
lien optionnelListe de l'axe d'articulation vec3 dans le cadre local
utilisation optionnelleMaximalCoordonne int expérimental, mieux vaut laisser 0/false.
physique optionnelleClientId int Si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
La valeur de retour de createMultiBody est un id unique non négatif ou -1 pour l'échec. Exemple : cuid = pybullet.createCollisionShape(pybullet,GEOM BOX, halfExtents = [1, 1, 1]) masse= 0 #boîte statique pybollet. createMultiBody(mass,cuid) Voir aussi create MultiBodyLinks.py, createObstacleCourse.py et createVisualShape.py dans le dossier Bullet/examples/pybullets/exemples.
stepSimulation effectuera toutes les actions en une seule étape de simulation dynamique avant, comme la détection des collisions, la résolution des contraintes et l'intégration. stepSimulation arguments d'entrée sont optionnels:
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
stepSimulation n'a pas de valeurs de retour. Voir aussi setRealTimeSimulation pour laisser automatiquement le serveur physique exécuter la simulation dynamique avant basée sur son horloge en temps réel.

Par défaut, le serveur physique n'interviendra pas dans la simulation, à moins d'envoyer explicitement une commande « stepSimulation ». De cette façon, vous pouvez maintenir le déterminisme de contrôle de la simulation. Il est possible de faire tourner la simulation en temps réel en laissant le serveur physique effectuer automatiquement un pas en avant selon sa montre-temps (RTC) à l'aide de la commande setRealTimeSimulation. Si vous activez la simulation en temps réel, vous n'avez pas besoin d'appeler 'stepSimulation'. Notez que setRealTimeSimulation n'a aucun effet en mode DIRECT : en mode direct, le serveur physique et le client arrivent dans le même thread et vous déclenchez chaque commande. En mode GUI et en mode Réalité Virtuelle, et en TCP/UDP, le serveur physique fonctionne dans un thread séparé du client (PyBullet), et setRealTimeSimulation permet au thread de physicsserver d'ajouter des appels supplémentaires à stepSimulation. Les paramètres d'entrée sont:
requis activerRealTimeSimulation int 0 pour désactiver la simulation en temps réel, 1 pour permettre
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
getBasePositionAndOrientation rapporte la position et l'orientation actuelles de la base (ou du lien racine) du corps dans les coordonnées mondiales cartésiennes. L'orientation est un quaternion au format [x,y,z,w]. Les paramètres d'entrée getBasePositionAndOrientation sont:
objet requisUniqueId int objet unique id, comme renvoyé de chargeURDF.
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
getBasePositionAndOrientation retourne la liste de position de 3 flotteurs et l'orientation comme liste de 4 flotteurs dans [x,y,z,w] ordre. Utilisez getEulerFromQuaternion pour convertir le quaternions en Euler si nécessaire. Voir aussi resetBasePositionAndOrientation pour réinitialiser la position et l'orientation de l'objet.

Ceci complète le premier script PyBullet. La balle est livrée avec plusieurs fichiers URDF dans le dossier Bullet/data.
Vous pouvez réinitialiser la position et l'orientation de la base (racine) de chaque objet. Il est préférable de le faire seulement au début, et non pas lors d'une simulation en cours d'exécution, puisque la commande va surcharger l'effet de toute simulation physique. La vitesse linéaire et angulaire est réglée à zéro. Vous pouvez utiliser resetBaseVelocity pour se réinitialiser à une vitesse linéaire et/ou angulaire non nulle. Les arguments d'entrée pour réinitialiserBasePositionAndOrientation sont:
objet requisUniqueId int objet unique id, comme renvoyé de chargeURDF.
reinitialisez la base de l'objet à la position spécifiée dans les coordonnées mondiales [X,Y,Z]
requis ornObj vec4 réinitialiser la base de l'objet à l'orientation spécifiée comme quaternion spatial mondial [X,Y,Z,W]
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
Il n'y a pas d'arguments de retour.
La position des objets peut être exprimée en coordonnées cartésiennes de l'espace mondial [x,y,z]. L'orientation (ou la rotation) des objets peut être exprimée par les quaternions [x,y,z,w], les angles d'euler [yaw, pitch, roll] ou les matrices 3x3. PyBullet fournit quelques fonctions d'aide à convertir entre quaternions, angles d'euler et matrices 3x3. En plus, il y a certaines fonctions à multiplier et inverser les transformations. GetQuaternionDeEuler et GetEulerDeQuaternion
L'API PyBullet utilise des quaternions pour représenter les orientations. Comme les quaternaires ne sont pas très intuitifs pour les gens, il y a deux API à convertir entre les quaternions et les angles d'Euler. Les arguments d'entrée getQuaternionFromEuler sont :
Les angles X,Y,Z Euler sont en radians, accumulant 3 rotations exprimant le roulis autour du X, pitch autour de Y et lacet autour de l'axe Z.
physique optionnelleClientId int inutilisé, ajouté pour la cohérence de l'API.
getQuaternionFromEuler retourne un quaternions, liste vec4 de 4 valeurs flottantes [X,Y,Z,W].

Les arguments d'entrée getEulerFromQuaternion sont :
physique optionnelleClientId int inutilisé, ajouté pour la cohérence de l'API.
getMatrixFromQuaternion est une API utilitaire pour créer une matrice 3x3 à partir d'un quaternions. L'entrée est un quaternion et affiche une liste de 9 flotteurs, représentant la matrice. multiplieTransforms, invertTransform
PyBullet fournit quelques fonctions d'aide pour multiplier et inversement les transformations. Cela peut être utile pour transformer les coordonnées d'un système à l'autre. Les paramètres d'entrée de MultipleTransforms sont:
position requiseA vec3, liste de 3 flotteurs
orientation requiseA vec4, liste de 4 flotteurs quaternion [x,y,z,w]
position requiseB vec3, liste de 3 flotteurs
orientation B vec4, liste de 4 flotteurs quaternion [x, y, z, w]
physique optionnelleClientId int inutilisé, ajouté pour la cohérence de l'API.
La valeur de retour est une liste de position (vec3) et d'orientation (veC4, quaternion x,y,x,w). Les paramètres d'entrée et de sortie d'invertTransform sont :
position requise vec3, liste de 3 flotteurs
orientation requise vec4, liste de 4 flotteurs quaternion [x,y,z,w]
La sortie de invertTransform est une position (vec3) et orientation (veC4, quaternion x,y,x,w).

Vous pouvez demander la version de l'API en format année-mois-0-jour. Vous ne pouvez vous connecter entre le client/serveur de physique d'une même version API, avec le même nombre de bits (32-bit / 64bit). Il y a un paramètre optionnel inutilisé physiqueClientId, ajouté pour la cohérence de l'API.
physique optionnelleClientId int inutilisé, ajouté pour la cohérence de l'API.
Dans l'introduction, nous avons déjà montré comment initialiser PyBullet et charger certains objets. Si vous remplacez le nom du fichier dans la commande loadURDF par "r2d2.urdf", vous pouvez simuler un robot R2D2 à partir du tutoriel ROS. Contrôleons ce robot R2D2 pour se déplacer, regarder autour et contrôler la pince. Pour cela, nous devons savoir comment accéder à ses moteurs de joint.

Un robot simulé décrit dans un fichier URDF possède une base et, en option, des liens reliés par des joints. Chaque joint relie un lien parent à un lien enfant. À la racine de la hiérarchie il y a un seul parent root que nous appelons base. La base peut être soit entièrement fixe, 0 degrés de liberté, ou totalement libre, avec 6 degrés de libertés. Comme chaque lien est relié à un parent avec une seule jointure, le nombre de joints est égal au nombre de liens. Les liens réguliers ont des indices de lien dans la plage [0..getNumJoints()] Comme la base n'est pas un «lien» régulier, nous utilisons la convention de -1 comme son lien

Indice. Nous utilisons la convention selon laquelle les cadres de joint sont exprimés par rapport au centre parent du cadre inertiel en masse, qui est aligné avec l'axe principal d'inertie.
Après avoir chargé un robot, vous pouvez interroger le nombre de joints en utilisant l'API getNumJoints. Pour le r2d2.urdf, cela devrait retourner 15. getNumJoints paramètres d'entrée:
requis bodyUniqueId int l'identifiant unique du corps, comme retourné par chargeURDF etc.
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
Pour chaque joint, nous pouvons interroger certaines informations, telles que son nom et type. paramètres d'entrée getJointInfo
requis bodyUniqueId int l'identifiant unique du corps, comme retourné par chargeURDF etc.
jointIndex requis un indice dans la plage [0 .. GetNumJoints(bodyUniqueId))
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
getJointInfo retourne une liste d'informations:
jointIndex int le même index que le paramètre d'entrée
jointName chaîne le nom de l'articulation, comme spécifié dans le fichier URDF (ou SDF etc)
jointType int type de l'articulation, cela implique également le nombre de variables de position et vitesse. JOINT REVOLUTE, JOINT PRISMATIC, JOINT-SPHÉRIQUE, JOINT PLANAR, JOINT/FIXED. Pour plus de détails, voir la section sur Base, Joint et Liens.
qIndex int le premier indice de position dans les variables d'état positionnel pour cet organisme
uIndex int le premier indice de vitesse dans les variables d'état de vitesse pour ce corps
jointDamping flotter la valeur d'amortissement de l'articulation, comme spécifié dans le fichier URDF
jointFriction flotte la valeur de frottement, comme spécifié dans le fichier URDF
articulationLowerLimit flotteur Limite inférieure positionnelle pour les articulations coulissantes et révoltées (hanche).
jointUpperLimit flotteur Limite supérieure positionnelle pour les articulations coulissantes et révoltées. Valeurs ignorées au cas où supérieur
drapeaux Int réservé

limite
jointMaxForce flotteur Force maximale spécifiée dans URDF (éventuellement d'autres formats de fichiers) Notez que cette valeur n'est pas utilisée automatiquement. Vous pouvez utiliser maxForce dans 'setJointMotorControl2'.
jointMaxVelocity float Vitesse maximale spécifiée en URDF. Notez que la vitesse maximale n'est pas utilisée pour les commandes de commande moteur réelles à l'heure actuelle.
linkName chaîne le nom du lien, comme spécifié dans le fichier URDF (ou SDF etc.)
axe de jointAxe vec3 dans le cadre local (ignoré pour Joint FIXED)
position de l'articulation du cadreFramePos vec3 dans le cadre parent
orientation de l'articulation dans le cadre parent
index parentIndex int lien parent, -1 pour la base
Remarque:setJointMotorControl est obsolète et remplacé par setMeput2 API. (Ou encore mieux utiliser setJointMotorControlArray). Nous pouvons contrôler un robot en réglant le mode de commande souhaité pour un ou plusieurs moteurs articulés. Pendant la phase Simulation, le moteur physique simulera les moteurs pour atteindre la valeur cible donnée qui peut être atteinte dans les forces motrices maximales et autres contraintes. Chaque joint revolute et prismatique est motorisé par défaut. Il existe 3 modes de commande moteur différents : contrôle de position, régulation de vitesse et contrôle du couple. Vous pouvez désactiver efficacement le moteur en utilisant une force de 0. Vous devez désactiver le moteur pour utiliser un contrôle direct du couple. Par exemple:
maxForce = 0 mode = p.VELOCITY CONTROL p.setJointMotorControl2(objUid, jointIndex, controlMode=mode, force=maxForce) Si vous voulez une roue pour maintenir une vitesse constante, avec une force maximale, vous pouvez utiliser:
maxForce = 500 p.setJointMotorControl2(bodyUniqueId=objUid,
jointIndex=0, controlMode=p.VELOCITY CONTROL, cibleVélocité = cibleVel, force = maxForce)

Les arguments d'entrée à définirJointMotorControl2 sont:
bodyUniqueId int corps unique id comme retourné de chargeURDF etc.
index de liaison jointIndex int requis dans la plage [0..getNumJoints(bodyUniqueId) (notez que l'index du lien == indice de connexion)
Contrôle requisMode int POSITION CONTROL (qui est en fait CONTROL MODE POSITION VELOCITY PD), VELOCITY CONtroL, TORQUE CONTROL
cible optionnellePosition flotteur dans POSITION CONTROL la valeur de cible est la position cible de l'articulation
cible optionnelleVélocity flotteur dans VELOCITY CONTROL et POSITION CONtroL la cibleVélocité est la vitesse souhaitée de l'articulation, voir note d'implémentation ci-dessous. Notez que la vitesse cibleVélocity n'est pas la vitesse maximale de l'articulation. Dans POSITION CONTROL/CONTROl MODE POSITION VELOC ITÉ PD, la vitesse cible finale est calculée en utilisant : kp*(erp* (désiréPosition-currentPostion)/dt)+currentVelocity+kd *(m désiredVeolocity - courantVelovity) .
flotteur de force optionnel en POSITION CONTROL et VELOCITY CONtroL c'est la force maximale utilisée pour atteindre la valeur cible. Dans TORQUE CONTROL, c'est la force/torque à appliquer chaque étape de simulation.
position optionnelleGain flotteur Voir la note de mise en œuvre ci-dessous
Vitesse optionnelleRatter de gain Voir la note d'implémentation ci-dessous
maxVélocity flotteur en POSITION CONTROL, ce qui limite la vitesse à un maximum
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
méthode de mise en œuvre composant contrainte erreur à minimiser
POSITION CONTROL contrainte vitesse et la position contrainte
erreur = position gain*(désired position-a ctual position)+vitalité gaen*(de sired velocity-actual velocité)
VELOCITY CONTROL contrainte pure vitesse contrainte erreur = la vitesse souhaitée - actual velocity
TORQUE CONTROL force extérieure

Il est généralement préférable de commencer par VELOCITY CONTROL ou POSITION CONtroL. Il est beaucoup plus difficile de faire TORQUE CONTROL (contrôle de la force) car simuler les forces correctes repose sur des paramètres de fichiers URDF/SDF très précis et l'identification du système (masses correctes, inerties, centre de masse, frottement d'articulation etc.). setJointMotorControlArray
Au lieu de faire des appels individuels pour chaque joint, vous pouvez passer des tableaux pour toutes les entrées afin de réduire considérablement les frais généraux d'appel. setJointMotorControlArray prend les mêmes paramètres que setMeputMotor, sauf en remplaçant les entiers par des listes d'entiers. Les arguments d'entrée à définirJointMotorControlArray sont:
bodyUniqueId int corps unique id comme retourné de chargeURDF etc.
liste obligatoire des indices de l'indice d'int dans la plage [0..getNumJointes(bodyUniqueId) (notez que l'index du lien == index de l ́articulation)
commande requiseMode int POSITION CONTROL, VELOCITY CONtroL, TORQUE CONTROL
cible optionnelle Liste de positions du flotteur dans POSITION CONTROL la valeur cible est la position cible de l'articulation
cible optionnelleListe des vitesses de flotteur dans VELOCITY CONTROL et POSITION CONtroL la valeur cible est la vitesse cible de l'articulation, voir note d'implémentation ci-dessous.
liste optionnelle des forces de flotteur dans POSITION CONTROL et VELOCITY CONtroL c'est la force maximale utilisée pour atteindre la valeur cible. Dans TORQUE CONTROL, c'est la force/torque à appliquer chaque étape de simulation.
position optionnelleListe des écarts de flotteur Voir la note d'implémentation ci-dessous
float liste de vitesse de flotteur optionnelle Voir la note d'implémentation ci-dessous
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
Voir project3/exemples/pybullet/tensorflow/humanoid running.py pour un exemple d'utilisation de setJointMotorControlArray.
Nous pouvons interroger plusieurs variables d'état de l'articulation en utilisant getJointState, telles que la position de l ́articulation, la vitesse, les forces de réaction articulaire et le couple moteur joint.

bodyUniqueId int corps unique id tel que retourné par chargeURDF etc
index de liaison jointIndex int requis dans la plage [0..getNumJoints(bodyUniqueId)]
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
jointPlace de position La valeur de la position de cette jointure.
articulationVélocity flotteur La valeur de vitesse de cette jointure.
jointReactionForces liste de 6 flotteurs Ce sont les forces de réaction articulaire, si un capteur de couple est activé pour cette jointure c'est [Fx, Fy, Fz, Mx, My, Mz]. Sans capteur de couple, il est [0,00,00,00].
appliqueJointMotorTorque flotteur C'est le couple moteur appliqué lors de la dernière étapeSimulation. Notez que cela ne s'applique qu'en VELOCITY CONTROL et POSITION CONtroL. Si vous utilisez TORQUE CONTROL, le couple de moteur appliqué est exactement ce que vous fournissez, donc il n'est pas nécessaire de le déclarer séparément.
getJointStates est la version tableau de getJentState. Au lieu de passer dans un seul indice articulaire, vous passez dans une liste d'indices articulaires. Réinitialisation de l'État conjoint
Vous pouvez réinitialiser l'état de la jointure. Il est préférable de le faire seulement au début, sans lancer la simulation: resetJointState remplace toute simulation physique. Notez que nous ne supportons que les joints motorisés 1-DOF pour le moment, les joints coulissants ou les joints révoltés.
bodyUniqueId int corps unique id tel que retourné par chargeURDF etc
l'indice d'articulation jointIndex int requis dans la plage [0..getNumJoints(bodyUniqueId)]
cible obligatoireValeur flottante la position de l'articulation (angle en radians ou en position)
cible optionnelleVélocity flotte la vitesse de l'articulation (vitesse angulaire ou linéaire)
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
Vous pouvez activer ou désactiver un capteur de force/torque dans chaque joint. Une fois activé, si vous effectuez une simulation étape, le 'getJointState' signalera les forces de réaction interarmées dans les degrés fixes de
paramètres d'entrée getJointState · sortie getRejointState

liberté: un joint fixe mesurera les forces/torques interarmées 6DOF. Un capteur de force/torque d'articulation révolté/de charnière mesurera les forces de réaction 5DOF sur tous les axes, à l'exception de l'axe des charnières. La force appliquée par un moteur articulaire est disponible dans le JointMotorTorque appliqué de getJointState. Les arguments d'entrée pour activerJointForceTorqueSensor sont:
bodyUniqueId int corps unique id tel que retourné par chargeURDF etc
l'indice d'articulation jointIndex int requis dans la plage [0..getNumJoints(bodyUniqueId)]
option enableSensor int 1/True pour activer, 0/False pour désactiver le capteur de force/torque
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
Vous pouvez également demander la position et l'orientation du monde cartésien pour le centre de masse de chaque lien en utilisant getLinkState. Il rapportera également le cadre local d'inertie du centre de masse au cadre URDF pour faciliter le calcul du cadre graphique/visualisation. paramètres d'entrée getLinkState
bodyUniqueId int corps unique id tel que retourné par chargeURDF etc
lien obligatoireIndex index int link
calcul optionnelLinkVelocity int Si défini à 1, la vitesse mondiale cartésienne sera calculée et retournée.
calculé en optionForwardKinematics int si elle est réglée à 1 (ou vrai), la position / orientation du monde cartésien sera recalculée en utilisant la cinématique avant.
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
linkWorldPosition vec3, liste de 3 flotteurs Position cartésienne du centre de masse
linkWorldOrientation vec4, liste de 4 flotteurs Orientation cartésienne du centre de masse, en quaternion [x,y,z,w]
localInertialFramePosition vec3, liste de 3 flotteurs position locale offset du cadre inertiel (centre de masse) exprimé dans le cadre de liaison URDF
localInertialFrameOrientation vec4, liste de 4 flotteurs orientation locale (quaternion [x,y,z,w]) offset du cadre inertiel exprimé en cadre de liaison URDF.
getLinkState valeurs de retour

worldLinkFramePosition vec3, liste de 3 flotteurs position mondiale du cadre de liaison URDF
worldLinkFrameOrientation vec4, liste de 4 flotteurs orientation mondiale du cadre de liaison URDF
worldLinkLinearVelocity vec3, liste de 3 flotteurs Vitesse mondiale cartésienne. Seulement retourné si calculLinkVelocity non-zéro.
worldLinkAngularVelocity vec3, liste de 3 flotteurs Vitesse du monde cartésien. Seulement retourné si calculLinkVelocity non-zéro.
La relation entre le cadre de liaison URDF et le centre du cadre de masse (tous deux dans l'espace mondial) est : urdfLinkFrame = comLinkFrAME * localInertialFrame.inverse(). Pour plus d'informations sur le lien et le cadre inertiel, consultez le tutoriel ROS URDF .

Exemple de scripts (pourrait être obsolète, vérifier le dossier réel Bullet/exemples/pybullet/exemple.)
exemples/pybullet/tensorflow/humanoid runnin g.py
charger un humanoïde et utiliser un réseau neuronal formé pour contrôler le fonctionnement en utilisant TensorFlow, entraîné par OpenAI
exemples/pybullet/gym/pybollet envs/bullet / min itaur.py et minitaur gym en v.py
Environnement minimal pour OpenAI GYM et TensorFlow Vous pouvez également utiliser python -m pybullet envs.examples.minitaur gym enV exemple après avoir installé pybolet pour voir le Minitaur en action.
exemple/pybullet/examples/quadruped.py charge un quadruplé à partir du fichier URDF, étape la simulation, contrôle les moteurs pour une simple démarche de saut basée sur des ondes sinusoïdales.Logera également l'état à fichiers en utilisant p.startStateLogging. Voir vidéo .
exemples/quadruped playback.py Créez un quadrupède (Minitaur), lisez le fichier journal et définissez les positions comme cibles de contrôle moteur.
exemple/pybullet/examples/testrender.py charge un fichier URDF et rend une image, obtient les pixels (RGB, profondeur, masque de segmentation) et affiche l'image en utilisant MatPlotLib.
exemples/pybullet/examples/testrender np.py Similaire à testrender.py, mais accélère le transfert de pixel en utilisant des tableaux NumPy. Comprend également des repères/timings simples.

exemples/pybullet/examples/saveWorld.py Sauvegardez l'état (position, orientation) des objets dans un script pybullet Python. Ceci est principalement utile pour configurer une scène en VR et enregistrer l'état initial. Tout l'état n'est pas sériarisé.
exemples/pybullet/exemples/invers kinematic s.py
Afficher comment utiliser la commande calculerInverseKinematics, créant une horloge Kuka ARM
exemples/pybullet/exemples/rollPitchYaw.py Afficher comment utiliser les widgets GUI slider
exemples/pybullet/exemples/contrainte.py Créer une contrainte entre les liens.
exemples/pybullet/examples/vrhand.py Contrôlez une main à l'aide d'un gant VR, suivi par un contrôleur VR. Voir vidéo .
Vous avez accès à la vitesse linéaire et angulaire de la base d'un corps en utilisant getBaseVelocity. Les paramètres d'entrée sont:
requis bodyUniqueId int corps unique id, comme retourné des méthodes de charge*.
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
Cela renvoie une liste de deux valeurs vector3 (3 flotteurs dans une liste) représentant la vitesse linéaire [x,y,z] et la vitesse angulaire [wx,wy,wz] dans les coordonnées de l'espace mondial cartésien. Vous pouvez réinitialiser la vitesse linéaire et/ou angulaire de la base d'un corps en utilisant resetBaseVelocity. Les paramètres d'entrée sont:
objet requisUniqueId int corps id unique, comme renvoyé des méthodes de charge*.
option linéaireVelocity vec3, liste de 3 flotteurs vitesse linéaire [x,y,z] dans les coordonnées du monde cartésien.
optionnel angulaireVelocity vec3, liste de 3 flottes vitesse angulaire [wx,wy,wz] dans les coordonnées du monde cartésien.
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
Vous pouvez appliquer une force ou un couple à un corps en utilisant applyExternalForce et implémentezExternaleTorque. Notez que cette méthode ne fonctionnera qu'en marchant explicitement sur la simulation en utilisant stepSimulation, c'est-à-dire : setRealTimeSimulation(0). Après chaque étape de simulation, les forces extérieures sont dégagées à zéro. Si vous utilisez « setRealTimeSimulation(1), applyExternalForce/Torque aura un comportement non défini (soit 0, 1 ou plusieurs applications force/torque).

Les paramètres d'entrée sont:
objet requisUniqueId int objet unique id tel que retourné par les méthodes de chargement.
linkIndex index int lien ou -1 pour la base.
forceObj vec3, liste de 3 flotteurs force/vecteur de couple à appliquer [x,y,z]. Voir les drapeaux pour le système de coordonnées.
posObj vec3, liste de 3 flotteurs sur la liaison où la force est appliquée. Seulement pour appliquerExternalForce. Voir les drapeaux pour le système de coordonnées.
flags requis int Spécifiez le système de coordonnées de force/position: soit WORLD FRAME pour les coordonnées du monde cartésien, soit LINK FRame pour les points de liaison locale.
getNumBodies retournera le nombre total de corps dans le serveur physique. Si vous avez utilisé 'getNumBodies', vous pouvez interroger les ids uniques du corps en utilisant 'getBodyUniqueId'. Notez que toutes les API retournent déjà des ids uniques du corps, donc vous n'avez généralement jamais besoin d'utiliser getBodyUniqueId si vous gardez une trace de ceux-ci. getBodyInfo retournera le nom de base, tel qu'il est extrait des URDF, SDF, MJCF ou autre
fichier. removeBody va enlever un corps par son id unique de corps (de chargeURDF, loadSDF etc).
URDF, SDF et MJCF spécifient les corps articulés comme des structures arborescentes sans boucles. Le 'createConstraint' vous permet de connecter des liens spécifiques de corps pour fermer ces boucles. Voir Bullet/exemples/pybullet/exemple/quadruped.py comment connecter les jambes d'un lien de boucle fermée quadrupède à 5 barres. De plus, vous pouvez créer des contraintes arbitraires entre les objets et entre un objet et une image mondiale spécifique. Voir Bullet/exemples/pybullet/exemple/contrainte.py pour un exemple. Il peut également être utilisé pour contrôler le mouvement des objets de physique, entraînés par des cadres animés, comme un contrôleur VR. Il est préférable d'utiliser des contraintes, au lieu de régler la position ou la vitesse directement à cette fin, car ces contraintes sont résolues avec d'autres contraintes dynamiques. createConstraint a les paramètres d'entrée suivants:
physique optionnelleClientId int

parent requisBodyUniqueId int corps parent unique id
parentLienIndex index index parent lien (ou -1 pour la base)
enfant requisBodyUniqueId int corps d'enfant unique id, ou -1 pour aucun corps (préciser un cadre enfant non dynamique dans les coordonnées du monde)
enfantLinkIndex int index lien d'enfant requis, ou -1 pour la base
articulationAxe vec3 obligatoire, liste de 3 flotteurs axe d'articulation, dans le cadre de liaison enfant
parentFramePosition vec3, liste de 3 flotteurs position du cadre articulaire par rapport au centre parent du cadre massique.
enfantFramePosition vec3, liste de 3 flotteurs position du cadre articulaire par rapport à un centre d'enfant donné de monture (ou origine mondiale si aucun enfant n'a été spécifié)
parentéFrameOrientation vec4, liste de 4 flotte l'orientation du cadre articulaire par rapport au centre parent du cadre de coordonnées masse
en option ChildFrameOrientation vec4, liste de 4 flotte l'orientation du cadre articulaire par rapport au centre enfant du cadre de coordonnées de masse (ou cadre d'origine mondiale si aucun enfant n'a été spécifié)
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
createConstraint retournera un id unique entier, qui peut être utilisé pour modifier ou supprimer la contrainte. Voir exemples/pybullet/examples/mimicJointConstraint.py pour un exemple de MIXTE GEAR et exemples/pyrbullet /example/minitaur.pypour un MIXte POINT2POINT et exemples /pybullets/exemples/contrainte.py. changementConstraint
changeConstraint vous permet de modifier les paramètres d'une contrainte existante. Les paramètres d'entrée sont:
utilisateur requisConstraintUniqueId int unique id retourné par createConstrainte
joint optionnel ChildPivot vec3, liste de 3 flotteurs mis à jour pivot enfant, voir 'createConstraint'
articulation optionnelleChildFrameOrientation vec4, liste de 4 flotteurs mise à jour orientation du cadre enfant comme quaternion
maxForce flotteur force maximale que la contrainte peut appliquer

physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
Voir aussi Bullet/exemples/pybullet/exemple/contrainte.py removeConstraint supprimera une contrainte, donnée par son id unique. Ses paramètres d'entrée sont les suivants:
user requisConstraintUniqueId int unique id tel que retourné par createConstraint
option physiqueClientId int unique id tel que retourné par 'connect'
Vous pouvez demander le nombre total de contraintes, créé en utilisant 'createConstraint'. Le paramètre optionnel est la physique intClientId. GetConstraintUniqueId
getConstraintUniqueId prendra un index série dans la plage 0..getNumConstraintes, et rapporte l'identifiant unique de contrainte. Notez que les identifiants uniques de contrainte peuvent ne pas être contigus, car vous pouvez supprimer les contraintes. L'entrée est l'index série entier et éventuellement un physicsClientId.
Vous pouvez demander l'info de contrainte donner un identifiant unique de la contrainte. Les paramètres d'entrée sont:
contrainte requiseUniqueId int unique id tel que retourné par createConstraint
option physiqueClientId int unique id tel que retourné par 'connect'
La liste des sorties est :
parentBodyUniqueId int Voir createConstraint
parentJointIndex int Voir createConstraint
enfantBodyUniqueId int Voir createConstraint
ChildLinkIndex int Voir createConstraint
contrainteType int Voir createConstraint

jointAxis vec3, liste de 3 flotteurs Voir createConstraint
jointPivotInParent vec3, liste de 3 flotteurs Voir createConstraint
jointPivotInChild vec3, liste de 3 flotteurs Voir createConstraint
jointFrameOrientationParent vec4, liste de 4 flotteurs Voir createConstraint
articulaireOrientationEnfant vec4, liste de 4 flotteurs Voir createConstraint
maxAppliedForce float Voir createConstraint
Donnez un identifiant unique de contrainte, vous pouvez demander les forces de contrainte appliquées dans la dernière étape de simulation. L'entrée est un id unique de contrainte et la sortie est un vecteur de forces de contraintes, sa dimension est les degrés de liberté qui sont affectés par la contrainte (une contrainte fixe affecte 6 DoF par exemple).
Vous pouvez obtenir des informations sur la masse, le centre de masse, les frottements et d'autres propriétés de la base et des liens. Les paramètres d'entrée pour getDynamicsInfo sont :
requis bodyUniqueId int objet unique id, comme retourné par loadURDF etc.
lien obligatoireIndex index int link (joint) ou -1 pour la base.
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
Les renseignements sur la déclaration sont limités, nous en exposerons plus lorsque nous en aurons besoin :
masse double en kg
coefficient de double frottement latéral
vec3, liste de 3 flotteurs diagonale d'inertie locale. Notez que les liaisons et la base sont centrées autour du centre de masse et alignées avec les axes principaux d'inertie.
position locale de la structure d'inertie en coordonnées locales du cadre articulaire
orientation locale du cadre inertiel dans les coordonnées locales du cadre de joint
restitution double coefficient de la restitution
diagonale d'inertie locale

frottement en rotation coefficient de friction orthogonal à contact normal
frottement de rotation coefficient de friction double tournant autour du contact normal
amortissement du contact double -1 si non disponible. amortissement des contraintes de contact.
rigidité de contact double -1 si elle n'est pas disponible. rigidité des contraintes de contact.
Vous pouvez modifier les propriétés telles que la masse, le frottement et les coefficients de restitution en utilisant changeDynamics. Les paramètres d'entrée sont:
requis bodyUniqueId int objet unique id, comme retourné par loadURDF etc.
linkIndex index int lien ou -1 pour la base
double variation de masse optionnelle de la masse du lien (ou base pour linkIndex -1)
friction latérale optionnelle en double sens (linéaire) de contact
rotation optionnelleFriction double friction torsion autour du contact normal
roulement facultatifFriction double torsion de frottement orthogonal au contact normal
restitution facultative double bonification du contact. Gardez-le un peu moins de 1.
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
amortissement linéaire optionnel double amortisseur linéaire du lien (0,04 par défaut)
amortissement angulaire optionnel double angle de la liaison (0,04 par défaut)
contact optionnelSuppression double rigidité des contraintes de contact, utilisé avec le dampage contact.
contact optionnelDampage double amortissement des contraintes de contact pour ce corps/lien. Utilisé avec contactStiffness. Cela remplace la valeur si elle était spécifiée dans le fichier URDF de la section contact.
friction optionnelleAnchor int active ou désactive une ancre de frottement: correction positionnelle du frottement (désactivée par défaut, sauf si définie dans la section contact URDF)
éléments diagonaux locaux d'inertieDiagnoal vec3 en option de la tenseur à inertie. Notez que la base et les liaisons sont centrées autour du centre de masse et alignées avec les axes principaux d'inertie, il n'y a donc pas d'éléments hors-diagone dans l'inertie

tensor.
Vous pouvez définir le temps de la physique moteur qui est utilisé lors de l'appel 'stepSimulation'. Il est préférable d'appeler cette méthode seulement au début d'une simulation. Ne changez pas cette étape régulièrement. setTimeStep peut également être réalisé en utilisant la nouvelle API de setPhysicsEngineParamètre. Les paramètres d'entrée sont:
temps requisStep flotter Chaque fois que vous appelez 'stepSimulation', le timeStep va procéder avec 'timeStep'.
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
Vous pouvez définir les paramètres du moteur physique en utilisant l'API setPhysicsEngineParameter. Les paramètres d'entrée suivants sont exposés:
FixedTimeStep flotter physique moteur temps pas en fraction de secondes, chaque fois que vous appelez 'stepSimulation'. Même chose que 'setTimeStep'
numSolverItérations int optionnelles Choisissez le nombre d'itérations de résolveur de contrainte.
utilisation optionnelleSplitImpulse int Fonction avancée, seulement lorsque vous utilisez des coordonnées maximales : fractionner la résolution de contrainte positionnelle et la résolution en deux étapes pour éviter d'énormes forces de récupération de pénétration.
splitImpulsionPénétrationSeuil de flotteur associé à 'useSplitImpulse': si la pénétration pour une contrainte particulière de contact est inférieure à ce seuil spécifié, aucune impulsion fractionnée ne se produira pour ce contact.
numSubSteps int. optionnel Subdivisez l'étape de simulation physique plus loin par 'numSubSt Steps'. Cela permettra d'échanger les performances sur la précision.
collision optionnelleFilterMode int Utilisez 0 pour le filtre de collision par défaut : (groupe A&maskB) ET (groupe B&maska). Utilisez 1 pour passer au filtre OU collision (groupe)

contact optionnelDécoupageFlotteur de seuil Les points de contact dont la distance dépasse ce seuil ne sont pas traités par le résolveur LCP. De plus, les AABB sont prolongés de ce nombre. Par défaut à 0.02 dans Bullet 2.x.
maxNumCmdPer1ms int Expérimental: ajouter 1ms dort si le nombre de commandes exécutées dépasse ce seuil.
optionable activationFileCaching int Set to 0 pour désactiver la mise en cache de fichier, comme le chargement du fichier .obj wavefront
restitution facultativeVélocitySeuil flottant Si la vitesse relative est inférieure à ce seuil, la restitution sera zéro.
paramètre optionnel de réduction des erreurs de contrainte de flotteur (sans contact, sans friction)
option contactERP flotter le paramètre de réduction des erreurs de contact
paramètre de réduction des erreurs de frottement du flotteur (lorsque les ancrages de friction positionnels sont activés)
option enableConeFriction int Set to 0 pour désactiver le frottement implicite du cône et utiliser l'approximation pyramidale (le cône est par défaut)
option deterministic OverlappingPairs int Set to 1 for activate and 0 to disable tri of recoupement pair (valorisation de la compatibilité vers l'arrière).
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
setDefaultContactERP est une API pour définir le paramètre de contact par défaut. Il sera roulé dans l'API setPhysicsEngineParameter. getPhysicsEngineParamètres
Vous pouvez interroger certains paramètres actuels du moteur de physique en utilisant la commande getPhysicsEngineParameters, en utilisant l'option 'physicsClientId'. Cela retournera les tuples nommés de paramètres.
ResetSimulation va supprimer tous les objets du monde et réinitialiser le monde aux conditions initiales. Il faut un paramètre optionnel : l'Id client physique (au cas où vous avez créé plusieurs connexions de serveur physique).
A&maskB) OU (Groupe B&maska)

L'état de l'enregistrement vous permet de consigner l'état d'une simulation, comme l' état d'un ou plusieurs objets après chaque étape de la simulation (après chaque appel à steepSimulation ou automatiquement après chaque phase de simulation lorsque définiRealTimeSimlation est activé). Cela vous permet d'enregistrer les trajectoires des objets. Il est également possible de consigner l'état commun des corps, tels que la position et l'orientation de base, les positions conjointes (angles) et les forces motrices interarmées. Tous les fichiers de journaux générés par startStateLogging peuvent être lus en utilisant des scripts C++ ou Python. Voir quadruped playback.py et kuka with cube play back.py pour les scripts Python lisant les fichiers journaux. Vous pouvez utiliser des exemples de puce3/s/Utils/RobotLogingUtil.cpp/h pour lire les fichiers journaux en C++. Pour l'enregistrement vidéo MP4, vous pouvez utiliser l'option de journalisation ÉTAT LOGGING VIDEO MP4 . Nous prévoyons mettre en œuvre divers autres types de logage, y compris la logging de l'état des contrôleurs VR. Comme cas particulier, nous avons mis en œuvre l'enregistrement du robot Minitaur. Le fichier journal de la simulation PyBullet est identique au vrai fichier journal quadribudé Minitaur. Voir Bullet/exemples/pybullet/exemple/logMinitaur.py pour un exemple. Important : les différents enregistreurs incluent leur propre horodatage interne qui commence à zéro lorsqu'il est créé. Cela signifie que vous devez démarrer tous les enregistreurs en même temps, pour être synchronisé. Vous devez vous assurer que la simulation ne fonctionne pas en mode temps réel, tout en commençant les enregistreurs: utilisez pybullet.setRealTimeSimulation(0) avant de créer les enregistreur.
logingType int requis Il existe différents types de logging implémenté. ÉTAT LOGGING MINITAUR: Cela nécessitera de charger le quadrupède/quadrupède.urdf et l'identifiant unique objet du quadrubède. Il enregistre l'horodatage, le roulis/pitch/yaw IMU, 8 positions de moteur des jambes (q0-q7), 8 couples de moteurs des jambes (20-u7), la vitesse avant du torse et le mode (inutilisés dans la simulation). ÉTAT LOGGING GENERIC ROBOT: Ceci enregistrera un journal des données de tous les objets ou de ceux sélectionnés (si objetUniqueIds est fourni). ÉTAT LOGGING VIDEO MP4 : cela ouvrira un fichier MP4 et commencera à diffuser les pixels du visualisateur 3D OpenGL dans le fichier en utilisant une pipe ffmpeg. Il faudra installer ffmpeg. Vous pouvez également utiliser avconv (par défaut sur Ubuntu), il suffit de créer un lien symbolique pour que ffmpeg pointe vers avconvi. Sur Windows, ffmpeg a quelques problèmes qui causent la déchirure / artefacts de couleur dans certains cas. STATE LOGGING CONTACT POINTS STATE LOGGING VR CONTROLLERS.

ÉTAT LOGGING PROFIL TIMINGS Ceci va vider un fichier de timing au format JSON qui peut être ouvert en utilisant Google Chrome à propos de la LOAD.
fileName chaîne obligatoire nom de fichier (chemin absolu ou relatif) pour stocker les données du fichier journal.
objet optionnelUniqueIds liste d'int Si laissé vide, le logger peut enregistrer chaque objet, sinon le logger ne fait que consigner les objets dans la liste des objetsUnique.
maxLogDof int Nombre maximal de degrés de liberté de l'assemblage (à l'exclusion des dofs de base). Cela s'applique à ÉTAT LOGGING GENERIC ROBOT DATA. La valeur par défaut est 12. Si un robot dépasse le nombre de dofs, il ne sera pas du tout enregistré.
bodyUniqueIdA int s'applique à ETAT LOGGING CONTACT POINTS. Si fourni, seulement les points de contact du journal impliquant bodyUniqueIdA.
bodyUniqueIdB int s'applique à ETAT LOGGING CONTACT POINTS. Si fourni, seulement les points de contact du journal impliquant bodyUniqueIdB.
lien optionnelIndexA int S'applique à ÉTAT LOGGING CONTACT POINTS. Si fourni, seulement les points de contact log impliquant linkIndexA pour bodyUniqueIdA.
lien optionnelIndexB int S'applique à ÉTAT LOGGING CONTACT POINTS. Si fourni, seulement les points de contact log impliquant linkIndexB pour bodyUniqueIdA.
En option, le périphériqueTypeFilter int deviceTypeFelter vous permet de sélectionner les périphériques VR à enregistrer : VR DEVICE CONTROLLER, VR DEVIGE HMD ,VR DEViCE GENERIC TRACKER ou toute combinaison d'entre eux. S'applique aux ÉTAT LOGGING VR CONTROLLERS. Les valeurs par défaut sont VR DEVICE CONTROLLER.
logFlags int (à venir PyBullet 1.3.1). ÉTAT LOG JOINT TORQUES, pour loger les couples d'articulation dus aux moteurs de joint.
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
La commande retournera une valeur non négative de logUniqueId, qui peut être utilisée avec stopStateLogging. Todo: documenter les données enregistrées pour chaque type de logarithme. Pour l'instant, utilisez les utilitaires de lecture des journaux pour le découvrir ou consultez le code source C++ du script dropLog.py ou de la session Python. ArrêterStateLogging
Vous pouvez arrêter un enregistreur en utilisant son code d'enregistrementUnique. soumettreProfileTiming
facultatif

PyBullet et Bullet ont instrumenté de nombreuses fonctions afin que vous puissiez voir où le temps est passé. Vous pouvez supprimer ces chronométrages de profil dans un fichier, qui peut être consulté avec Google Chrome dans la fenêtre about://tracing en utilisant la fonction LOAD. Dans l'interface graphique, vous pouvez appuyer sur 'p' pour démarrer/arrêter le dump profil. Dans certains cas, vous pouvez utiliser les dates de votre code client. Vous pouvez soumettre des horaires de profil en utilisant PyBullet. Voici un exemple de sortie :
PyBullet possède à la fois un visualisateur GPU OpenGL intégré et un rendu CPU intégré basé sur TinyRenderer. Cela rend très facile de rendre les images d'une position arbitraire de la caméra. La caméra synthétique est spécifiée par deux matrices 4 à 4 : la matrice de vue et la matrice des projections. Comme ceux-ci ne sont pas très intuitifs, il existe des méthodes d'aide pour calculer la matrice de vision et de projection à partir de paramètres compréhensibles.
Les paramètres d'entrée de calculViewMatrix sont:
caméra requiseEyePosition vec3, liste de 3 flotteurs position oeil dans les coordonnées du monde cartésien
caméra requiseTargetPosition vec3, liste de 3 flotteurs position du point cible (focus), dans les coordonnées mondiales cartésiennes
caméra requiseUpVector vec3, liste de 3 flottes vers le haut vecteur de la caméra, dans les coordonnées du monde cartésien
physique optionnelleClientId int inutilisé, ajouté pour la cohérence API
Sortie est la matrice de vue 4x4, stockée sous forme d'une liste de 16 flotteurs. CalculerViewMatrixFromYawPitchRoll
Les paramètres d'entrée sont:
caméra requiseTargetListe de position des 3 flotteurs point focal cible dans les coordonnées du monde cartésien
distance requise de flotteur distance entre l'oeil et le point d'orientation
l'angle de lacet nécessaire en degrés gauche/droit autour de l'axe supérieur.
pitch float tang en degrés haut/bas.

rouleau de flotteur requis en degrés autour du vecteur avant
requis jusqu'AxisIndex int soit 1 pour Y ou 2 pour l'axe Z vers le haut.
physique optionnelleClientId int inutilisé, ajouté pour la cohérence de l'API.
Sortie est la matrice de vue 4x4, stockée sous forme d'une liste de 16 flotteurs.
Les paramètres d'entrée sont:
coordonnées de flotteur gauche (canvas)
coordonnée droite de flotteur requise (canvas)
coordonnées de fond flotteur (canvas)
Coordonnées requises de l'écran supérieur flottant (canvas)
Requis près du flotteur à proximité de la distance plane
distance de flottement lointain requise
physique optionnelleClientId int inutilisé, ajouté pour la cohérence de l'API.
La sortie est la matrice de projection 4x4, stockée comme une liste de 16 flotteurs. calculProjectionMatrixFOV
Cette commande retournera également une matrice de projection 4x4, en utilisant différents paramètres. Vous pouvez consulter la documentation OpenGL pour connaître le sens des paramètres. Les paramètres d'entrée sont:
champ de vision obligatoire fov flotteur
rapport d'aspect de flotteur requis
requis près deVal flotter près du plan
distance requise du plan de flotteur lointain de farVal
physique optionnelleClientId int inutilisé, ajouté pour la cohérence de l'API.
L'API getCameraImage retournera une image RGB, un tampon de profondeur et un masque de segmentation avec des ids uniques du corps d'objets visibles pour chaque pixel. Notez que PyBullet peut être compilé en utilisant l'option numpy : utiliser nompy améliorera les performances de copie de la caméra

pixels de C à Python. Note : l'ancienne API de renduImage est obsolète et remplacée par getCameraImage. getCameraParamètres d'entrée image:
résolution d'image horizontale en pixels
résolution verticale d'image en pixels
vue optionnelleMatrix 16 flotte 4x4 matrice de vue, voir calculViewMatriX*
projection optionnelleMatrix 16 flotteurs 4x4 matrice de projection, voir calculProduction*
en option direction lumière Direction vec3, liste de 3 flotteurs direction lumière
en option lightColor vec3, liste de 3 flotteurs directionnels couleur lumière dans [RED,GREEN,BLUE] dans la plage 0.1
lumière optionnelleDistance de flotteur de la lumière le long de la lampe normaliséeDirection
1 int d'ombre optionnel pour ombres, 0 pour pas d'ombrage
Feux optionnelsAmbientCoeff Coeff coefficient ambiant de lumière flottante
Feux de flotteurDiffuseCoeff coefficient diffuse
Feux facultatifsSpecularCoeff flottant coefficient de lumière spéculaire
Le rendu optionnel int ER BULLET HARDWARE OPENG ou ER TINY RENDERER. Notez que le mode DIRECT n'a pas d'OpenGL, donc il nécessite ER TINY RENDERER.
drapeaux optionnels int ER SEGMENTATION MASK OBJECT AND L INKINDEX, voir ci-dessous dans la description de segmentationMaskBuffer et le code exemple.
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
getCameraImage retourne une liste de paramètres :
résolution d'image largeur int largeur en pixels (horizontale)
hauteur int résolution d'image en pixels (vertical)
rgbPixels liste de [char RED,char GREEN,char BLUE, liste des couleurs de pixels dans le format R,G,B,A

Char ALPHA] [0..width*hauteur] dans la plage [0,255] pour chaque couleur
profondeur Liste des pixels du tampon de profondeur [0..width*hauteur]
segmentationMasqueBuffer liste d'int [0..width*hight] Disponible uniquement lorsque vous utilisez ER TINY RENDERER. Pour chaque pixels, l'identifiant unique de l'objet visible. Si ER SEGMENTATION MASK OBJ ECT AND LINKINDEX est utilisé, la segmentationMaskBuffer combine l'identifiant unique de l'objet et l'index des liens comme suit : valeur = objetUniqueId + (linkIndex+1)
Vous pouvez accéder à des informations de forme visuelle en utilisant getVisualShapeData. Vous pouvez utiliser ceci pour articuler votre propre méthode de rendu avec la simulation PyBullet, et synchroniser le monde se transforme manuellement après chaque étape de simulation. Les paramètres d'entrée sont:
objet requisUniqueId int objet unique id, tel que retourné par une méthode de chargement.
option physiqueClientId int id client de physique comme retourné par 'connect'
La sortie est une liste de données de forme visuelle, chaque forme visuelle se présente dans le format suivant:
objetUniqueId int objet unique id, même que l'entrée
linkIndex index int lien ou -1 pour la base
spectromètreType int géométrie visuelle (TBD)
dimensions vec3, liste des 3 flotteurs dimensions (taille, échelle locale) de la géométrie
mahAssetFileName chaîne, liste des caractères chemin vers le triangle mesh, s'il y a lieu. Généralement par rapport à l'emplacement du fichier URDF, SDF ou MJCF, mais pourrait être absolu.

localVueFrame position vec3, liste de 3 flotteurs position du cadre visuel local, par rapport au cadre lien/joint
localVisualFrame orientation vec4, liste de 4 flotteurs orientation du cadre visuel local par rapport au cadre lien/joint
rgbaColor vec4, liste de 4 flotteurs couleur URDF (le cas échéant) en rouge/vert/bleu/alpha
La simulation physique utilise le centre de masse comme référence pour les transformations du monde cartésien, dans getBasePositionAndOrientation et dans getsLinkState. Si vous implémentez votre propre rendu, vous devez transformer la transformation visuelle locale en espace mondial, en utilisant le centre de transformation du monde de masse et (inverse) le cadre localInertial. Vous pouvez accéder au localInertialFrame en utilisant l'API getLinkState.
Vous pouvez utiliser changeVisualShape pour changer la texture d'une forme. Cette texture n'affectera actuellement que le logiciel de rendu (voir getCameraImage), et non la fenêtre de visualisation OpenGL (encore).
objet requisUniqueId int objet unique id, tel que renvoyé par la méthode de chargement.
index jointIndex int lien requis
forme optionnelleIndex int Expérimental pour usage interne, recommandé ignorer la formeIndex ou laisser-la -1. L'intention était de vous laisser choisir un index de forme spécifique à modifier, car URDF (et SDF etc.) peut avoir plus d'une forme visuelle par lien. Cette formeIndex correspond à la liste des commandes retournées par getVisualShapeData.
texture optionnelleUniqueId int texture unique id, comme retourné par la méthode 'loadTexture'
rgbaColor vec4, liste de 4 flotteurs
composants de couleur pour RED, GREEN, BLUE et ALPHA, chacun dans la gamme [0,1]. Alpha doit être 0 (invisible) ou 1 (visible) en ce moment (pas encore de transparance).
Les composants de couleur spéculaire en option, RED, GREEN et BLUE, peuvent être de 0 à un grand nombre (>100).
requis physiqueClientId int ident client de physique tel que retourné par 'connect'
Chargez une texture à partir du fichier et retournez un identifiant unique de texture non négative si le chargement réussit. Ce code unique peut être utilisé avec changeVisualShape.

Vous pouvez demander les informations de point de contact qui existaient lors du dernier 'stepSimulation'. Pour obtenir les points de contact, vous pouvez utiliser l'API «getContactPoints». Notez que les 'getContactPoints' ne recalculeront pas les informations sur les points de contact.
Cette requête retournera tous les identifiants uniques d'objets qui ont un chevauchement de lier la boîte alignée par axe avec une zone délimitée par axes donnés. Notez que la requête est conservatrice et peut renvoyer des objets supplémentaires qui n'ont pas de chevauchement AABB réel. Cela se produit parce que les structures d'accélération ont un certain heuristique qui agrandit un peu les AABBs (la marge supplémentaire et extrudé le long du vecteur de vitesse). Les paramètres d'entrée getOverlapingObjects sont:
aabbMin vec3, liste de 3 flotteurs coordonnées minimales du abb
aabbMax vec3, liste de 3 flotteurs coordonnées maximales du abb
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
Vous pouvez interroger la zone de délimitation alignée par axe (dans l'espace mondial) avec un id unique d'objet et éventuellement un index de lien. (lorsqu'on ne passe pas l'index des liens, ou qu'on utilise -1, on obtient le AABB de la base). Les paramètres d'entrée sont:
requis bodyUniqueId int objet unique id tel que retourné par les méthodes de création.
lien optionnelIndex index int link dans la plage [0..getNumJoints(..)]
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.

La structure de retour est une liste de vec3, aabbMin (x,y,z) et aabbaMax (x.y,Z) dans les coordonnées spatiales mondiales. Voir aussi l'exemple getAABB.py.
L'API getContactPoints retourne les points de contact calculés lors du dernier appel à stepSimulation. Ses paramètres d'entrée sont les suivants:
bodyA int ne signale que les points de contact qui impliquent l'organisme A
bodyB int ne signale que les points de contact qui impliquent l'organisme B
lien optionnelIndexA int Ne rapportez que les points de contact qui impliquent linkIndexa du corpsA
lien optionnelIndexB int Ne rapportez que les points de contact qui impliquent linkIndex B du corpsB
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
getContactPoints retournera une liste de points de contact. Chaque point de contact a les champs suivants:
bodyUniqueIdA int corps unique id du corps A
bodyUniqueIdB int corps unique id du corps B
linkIndexA index int lien du corps A, -1 pour la base
linkIndexB int lien index du corps B, -1 pour la base
positionOnA vec3, liste de 3 flotteurs position de contact sur A, dans les coordonnées du monde cartésien
positionOnB vec3, liste de 3 flotteurs position de contact sur B, dans les coordonnées du monde cartésien
contactNormalOnB vec3, liste de 3 flotteurs contact normal sur B, pointant vers A
contactDistance de contact du flotteur, positive pour la séparation, négative pour la pénétration
Force normaleForce flotteur force normale appliquée au cours de la dernière 'étapeSimulation'
contactDrapeau int réservé

Il est également possible de calculer les points les plus proches, indépendamment de stepSimulation. Cela vous permet également de calculer les points les plus proches des objets avec une distance arbitraire de séparation. Dans cette requête, il n'y aura pas de forces normales signalées. getFermerstPoints paramètres d'entrée:
bodyA int objet unique pour le premier objet (A)
bodyB int objet unique requis pour le second objet (B)
distance requise flotter Si la distance entre les objets dépasse cette distance maximale, aucun point ne peut être retourné.
lien optionnelIndexA index int link pour objet A (-1 pour base)
lien optionnelIndexB index int link pour l'objet B (-1 pour la base)
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
getFermerstPoints retourne une liste de points les plus proches dans le même format que getContactPoints (mais normalForce est toujours zéro dans ce cas)
Vous pouvez effectuer une seule projection de rayon pour trouver les informations d'intersection du premier objet touché. Les paramètres d'entrée de rayTest sont:
rayDePosition vec3, liste de 3 flotteurs début du rayon dans les coordonnées mondiales
required rayToPosition vec3, liste de 3 flotteurs en bout du rayon dans les coordonnées mondiales
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
La requête raytest retournera les informations suivantes en cas d'intersection :
objetUniqueId int objet unique id de l'objet frappé
linkIndex int index de lien de l'objet frappé, ou -1 si aucun/parent.
fraction de frappe flottante fraction de collision le long du rayon dans la plage [0,1] le long de la ray.
position de frappe vec3, liste des 3 flotteurs position de collision dans les coordonnées mondiales cartésiennes
frappe Vec3 normal, liste de 3 flotteurs frappés normale dans les coordonnées du monde cartésien

Ceci est similaire au rayTest, mais vous permet de fournir un éventail de rayons, pour une exécution plus rapide. La taille de 'rayFromPositions' doit être égale à la taille de'rayToPostion'. Vous pouvez obtenir un résultat par rayon, même s'il n'y a pas d'intersection : vous devez utiliser le champ objetUniqueId pour vérifier si le rayon a touché quelque chose : si l'objetUniqueID est -1, il n'est pas frappé. Dans ce cas, la « fraction de cham » est 1. Le nombre maximal de rayons par lot est pybullet.MAX RAY INTERSECTION BATCH SIZE. Les paramètres d'entrée de rayTest sont:
rayDePositions liste de vec3, liste de la liste de 3 flotteurs
liste des points de départ pour chaque rayon, en coordonnées mondiales
liste de 3 flotteurs requise
liste des points d'extrémité pour chaque rayon dans les coordonnées mondiales
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
La sortie est un résultat d'intersection par rayon d'entrée, avec les mêmes informations que dans la requête rayTest ci-dessus.
Vous pouvez interroger le type de géométrie de collision et d'autres informations sur la forme de collision de base de corps existante et des liens en utilisant cette requête. Il fonctionne très similaire à getVisualShapeData. Les paramètres d'entrée pour getCollisionShapeData sont:
objet requisUniqueId int objet unique id, reçu de chargeURDF etc
linkIndex index int lien ou -1 pour la base
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
La valeur de retour est une liste avec le contenu suivant:
objet unique id int objet unique

linkIndex index int lien ou -1 pour la base
dimensions vec3 dépend du type de géométrie : pour GEOM BOX : portées, pour GEOMM SPHERE dimensions[0] = rayon, pour GEOM CAPSULE et GEOM CYLINDER, dimensions[00] = hauteur (longueur), dimensions[1] = rayon. Pour GEOM MESH, les dimensions sont le facteur de graduation.
position locale du cadre pos vec3 Position locale du châssis de collision par rapport au centre du cadre de masse/inertie.
fram orn vec4 Orientation locale du cadre de collision par rapport au cadre d'inertie.
calculer InverseDynamics
calcule InverseDynamics calculera les forces nécessaires pour atteindre les accélérations d'articulation données, à partir de positions et vitesses spécifiées. Les paramètres d'entrée de calcul InverseDynamics sont:
bodyUniqueId int corps unique id, comme retourné par chargeURDF etc.
ObjPositions requises liste des positions de radeau (angles) pour chaque degré de liberté (DoF). Notez que les joints fixes ont 0 degré de liberté. La base est débordée/ignurée dans tous les cas (base flottante et base fixe).
liste des vitesses requises pour chaque degré de liberté (DoF)
ObjAccélérations requises liste des accélérations articulaires souhaitées pour chaque degré de liberté (DoF)
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
calculeInverseDynamics retourne une liste de forces interarmées pour chaque degré de liberté.
calculeJacobian calculera les jacobiens translationnels et rotationnels pour un point sur un lien, par exemple. x dot = J * q dot. Les jacobiens retournés sont légèrement différents selon que le lien racine est fixe ou flottant. Si flottant, les jacobiens comprendront des colonnes correspondant aux degrés de liberté du lien racine ; si fixé, les Jacobians n'auront que des colonnes associées aux articulations. L'appel de fonction prend la description complète de l'état cinématique, c'est parce que

calculeInverseDynamics est en fait appelé d'abord et les jacobiens désirés sont extraits de cela; il est donc raisonnable de passer zéro vecteur pour les vitesses articulaires et les accélérations si désiré. Les paramètres d'entrée de calcul jacobien sont:
bodyUniqueId int corps unique id, comme retourné par chargeURDF etc.
lien requisIndex index int lien pour le jacobian.
required localPosition liste de flotter le point sur le lien spécifié pour calculer le jacobian pour.
ObjPositions requises liste des positions de radeau (angles)
liste obligatoire des vitesses d'articulation de flotteurs
liste d'accélérations requises des accélérations de l'articulation souhaitées par le flotteur
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
calculer les retours jacobiens :
nébuleux (dof), dof, dof)
le jacobian translationnel, x dot = J t * q dot.
nébuleux Jacobien mat3x (dof), dof, dof) requis
le jacobien rotationnel, r dot = J r * q dot.
calculeMassMatrix calculera l'inertie du système pour un corps articulé en fonction de ses positions d'articulation.
bodyUniqueId int corps unique id, comme retourné par chargeURDF etc.
ObjPositions nécessaires tableau de flotteur
position commune pour chaque lien.
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
Le résultat est la matrice de masse carrée avec dimensions dofCount * dofCount, stockée sous forme de liste des lignes dofConnunt, chaque ligne est une liste des éléments de matrix de masse dofComut. Inverse Kinématique
Vous pouvez calculer les angles d'articulation qui font que l'effet final atteint une position cible donnée dans l'espace mondial cartésien. En interne, Bullet utilise une version améliorée de la bibliothèque Samuel Buss Inverse Kinematics. Pour le moment seulement la méthode Damped Lest Squares avec ou sans Null

La commande spatiale est exposée, avec une seule cible d'effet final. Vous pouvez également spécifier l'orientation de la cible de l'effecteur final. En outre, il existe une option pour utiliser l'espace nul pour spécifier les limites de joint et les poses de repos. Ce support optionnel en espace nul nécessite les 4 listes (lowerLimits, upperLimit, jointRanges, resetPoses), sinon l'IK sera utilisé régulièrement. Voir aussi inverse kinematics.py exemple dans le dossier Bullet/examples/pybullet/exemples pour plus de détails.
calculezInverseKinematics paramètres d'entrée sont:
bodyUniqueId int corps unique id, comme retourné par chargeURDF
nécessaire finEffetLinkIndex int effector lien index
cible requisePosition vec3, liste de 3 flotteurs position cible dans l'espace mondial cartésien
cible optionnel Orientation vec3, liste de 4 flotteurs orientation cible dans l'espace mondial cartésien, quaternion [x,y,w,z]. Si elle n'est pas spécifiée, on utilisera IK en position pure.
L'IC en option null-space nécessite les 4 listes (Limites inférieures, limits supérieurs, jointsRanges, resetPoses). Sinon, des IK ordinaires seront utilisés.
liste facultative des flotteurs [0..nDof] lowerLimit et lipsLimit spécifient les limites de joint
articulation optionnelle Liste des flotteurs [0..nDof]
Repos optionnel Liste de flotteurs [0..nDof] Favorisez une solution IK plus proche d'une pose de repos donnée
joint optionnelListe de damping des flotteurs [0..nDof] jointLe dampage permet d'ajuster la solution IK en utilisant les facteurs d'amortissement des joints
Intéressé par le résolveur facultatif p.IK DLS ou p.AK SDLS, les moindres carrés endommagés ou les moindres places dérangées sélectivement, comme décrit dans l'article de Samuel Buss "Sélectionnellement abaissé les moindres place pour la cinématique inverse".
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
calculeInverseKinematics retourne une liste de positions communes. Voir Bullet/exemples/pybullet/inverse kinematics.py pour un exemple. Notez que le calcul InverseKinematics peut donner un résultat approximatif dans l'emplacement de l'effet final. Vous pouvez obtenir des résultats plus précis en utilisant le code d'exemple " exactCalculateInverseKinematics".



Une suite d'environnements de gym RL sont installés lors de "pip installation pybullet". Cela inclut les versions PyBullet des environnements OpenAI Gym tels que fourmis, trémies, humanoïdes et marcheurs. Il existe également des environnements qui s'appliquent aussi bien à la simulation que sur de vrais robots, tels que le Ghost Robotics Minitaur quadruped, le MIT racecar et les environnements de saisie du bras robot KUKA. Le code source de pybullet, pybolet envs, pylullet data et les exemples sont ici: https://github.com/bulletphysics/bullets3/tree/master/examples/pybullet/gym Vous pouvez former les environnements avec des algorithmes d'entraînement RL tels que DQN, PPO, TRPO et DDPG. Plusieurs exemples pré-entrainés sont disponibles, vous pouvez les apprécier comme ceci: pip install pybullet, tensorflow, gym python -m pybollet envs.examples.enjoy TF HumanoidBulletEnv v0 2017may pyton -m Pybullets enVs.exemples.kukaGymEnvTest
Après avoir "sudo pip installe pybullet", les paquets pybollet envs et py Bullet data sont disponibles. L'importation du paquet pybullet envs enregistrera automatiquement les environnements dans OpenAI Gym. Vous pouvez obtenir une liste des environnements Bullet dans la salle de gym en utilisant la ligne Python suivante: print(









Simulation du Minitaur Robotique Ghost quadruplé sur un terrain plat. Récompense basée sur la distance parcourue. Créez la classe en utilisant Gym: env = gym.make('MinitaurBulletEnv-v0') ou créez l'environnement en utilisant directement la classe, avec les paramètres suivants : importer pybullet envs.bullet.minitaur gym enV comme e.MinitaurBuletteEnv(render=True)
Simulation de la course du MIT RC. Récompense en fonction de la distance jusqu'à la balle placée au hasard. Les observations sont des positions de bille (x,y) dans le cadre d'une caméra. L'espace d'action de l'environnement peut être discret (pour DQN) ou continu (pour PPO, TRPO et DDPG). import pybullet envs.bullet.racecarGymEnv as e env = e.Racecar GymEnV(isDiscrete=False ,renders=True) env.reset()
Comme le RacecarBulletEnv-v0, mais les observations sont des pixels de caméra.
Simulation du bras robotisé KUKA Iiwa, en saisissant un objet dans un plateau. La récompense principale se produit une fin, quand le grippé peut saisir l'objet au-dessus d'une certaine hauteur. Quelques très petites récompenses/coûts se produisent chaque étape: coût d'action et distance entre le gripper et l'objet. L'observation comprend la position x,y de l'objet. Remarque : cet environnement a des problèmes de formation pour le moment, nous y examinons.
KukaCamBulletEnv-v0 Même que KukaBulleteEnv -v0, mais l'observation sont des pixels de caméra.

Nous avons porté les environnements Roboschool à pybullet. Les environnements Roboschool sont plus difficiles que les environnements de musculation MuJoCo.
La fourmi est plus lourde, l'encourageant à avoir généralement deux ou plusieurs jambes sur le sol.
Les humanoïdes bénéficient d'un coût énergétique plus réaliste (= couple × vitesse angulaire) soustrait de la récompense.

Il est également possible d'accéder aux données, telles que les actifs robotisés URDF/SDF, les fichiers Wavefront .OBJ du paquet pybullet data. Voici un exemple de comment faire ceci : importer pybullet import pybolet data datapath = pyblolet dat.getDataPath() Pybullet.connect(pybullet.GUI) pybullet,etAdditionalSearchPath(datapath) pYbullet et chargeURDF("r2d2.urdf",[0,0,1]) Alternativement, ajouter manuellement le chemin de données au nom du fichier dans les commandes loadUDF/SDF.
Pour les environnements de gym tels que KukaBulletEnv-v0 et RacecarBulleteEnv -v0, vous pouvez utiliser OpenAI Baselines DQN pour former le modèle en utilisant un espace d'action discret. Quelques exemples sont fournis pour former et profiter de ces environnements discrets: python -m pybullet envs.baselines.train pybullet cartpole pyton -m Pybullets enVs.baselines .train pyrbullet@racecar OpenAI Baselines enregistrera un fichier .PKL à des intervalles spécifiés lorsque le modèle s'améliorera. Ce fichier .PKL est utilisé dans les scripts d'appréhension : python -m pybullet envs.baselines.frjoy pybullet cartpole python -m Pybullets enVs.baselines .frjoY pybollet racecar Il y a aussi des modèles pré-formés que vous pouvez profiter de la boîte. Voici une liste d'environnements pré-entrainés à apprécier:
BulletinPendulum inverséEnv-v0 · DoubleBullum inverséenv- v0 · Pendullum inverséSwingupBulletEnv -v0

python -m pybullet envs.examples.frjoy TF AntBulletEnv v0 2017may python -m Pybullets enves.examples.enjoy TF HalfCheetahBulletEnv v0 2017maay pyton -m pubullets-env.exambles.frjouy TF AntBullets v f 2017May pYthon-en vws.exexmples.n pybulles.engd de fichier pr c r du tre re le ve me ne se ce ter ent in te tr t t1 t2 t3 t4 t5 t6 t7 t9 t8 tb tg tk t12 t/t t2.
Vous pouvez former différents environnements de pybullet en utilisant TensorFlow Agents PPO . Installez d'abord les paquets Python requis : pip installation gym, tensorflow, agents, pybullet, ruamel.yaml Puis pour l'entraînement : pythan -m pybollet envs.agents.train ppo --config=pybullet pendulum --logdir=pendullum Les environnements suivants sont disponibles en tant qu'agents config: py Bullet pentullum pybullet doublependulllum pYbullet penduluswingup pyblolet cheetah pybllet ant pyBullet racecar pyballet minitaur Vous pouvez utiliser le tensorboard pour voir la progression de la formation : tensorsboard --logdire=pendullum --port=2222 Ouvrez un navigateur web et visitez localhost:2222 page. Voici un exemple de graphique de Tensorboard pour la formation du pendule:

Après la formation, vous pouvez visualiser le modèle formé, créer une vidéo ou la visualiser à l'aide d'un serveur physique (python -m pybullet envs.examples.runServeur ou ExempleBrowser en mode serveur physique ou en réalité virtuelle). Si vous démarrez un serveur de physique GUI local, le visualisateur (bullet client.py) se connectera automatiquement

à lui, et utiliser le rendu matériel OpenGL pour créer la vidéo. Sinon, il utilisera plutôt le petit livreur de CPU. Pour générer la vidéo, utilisez : python -m pybullet envs.agents.visualize ppo --logdir=pendulum/xxxxx --outdir=pentullum video De même, vous pouvez former et visualiser le robot Minitaur: python -m Pybullets envers.agents.train ppo --config=pybullet-minitaur --logdire=pybollet minitar Voici un exemple de vidéo de la démarche Minitaure :https://www.youtube.com/watch?v=tfqCHDoFHRQ Stratégies d'évolution (ES)
Il y a un article de blog de David Ha (hardmaru) comment former les environnements PyBullet en utilisant Evolution Strategies àhttp://blog.otoro.net/2017/11/12/stratégies évolutives - Oui. Train utilisant PyTorch PPO
Nous allons ajouter une description de la façon de commencer avec PyTorch et pybullet. En attendant, voir ce dépôt : https://github.com/ikostrikov/pytorch-a2c-ppo-acktr

Voir aussi le guide vrBullet Quickstart . Le serveur de physique VR utilise l'API OpenVR pour HTC Vive et Oculus Rift Touch support. OpenVR travaille actuellement sur Windows, Valve travaille également sur une version Linux. Voir aussihttps://www.youtube.com/watch?v=VMJyZtHQL50 pour une vidéo par exemple de l'exemple VR, partie de Bullet, qui peut être entièrement contrôlée en utilisant PyBullet sur la mémoire partagée, UDP ou connexion TCP. Pour les VR sous Windows, il est recommandé de compiler le SDK de physique Bullet en utilisant Microsoft Visual Studio (MSVC). Générer des fichiers de projet MSVC en exécutant le script "build visual studio vr pybullet double.bat". Vous pouvez personnaliser ce petit script pour pointer vers l'emplacement de Python etc. Assurez-vous de passer à la configuration 'Supprimer' de MSVC et de construire et exécuter l'App PhysicsServer SharedMemory VR*.exe. Par défaut, cette application VR présentera un monde vide montrant des trackers/contrôleurs (si disponible).

getVREvents retournera une liste d'événements pour un appareil VR sélectionné qui a changé d'état depuis le dernier appel à getVREvents. Lorsque vous ne fournissez aucun périphériqueTypeFilter, la valeur par défaut est de seulement signaler l'état VR DEVICE CONTROLLER. Vous pouvez choisir n'importe quelle combinaison de périphériques, y compris VR DEVICE CONTROLLER, VR DEVIGE HMD (appareil monté sur tête) et VR-DEVIce GENERIC TRACKER (comme le HTC Vive Tracker). Notez que VR DEVICE HMD et VR DEVIce GENERIC TRACKER ne rapportent que les événements de position et d'orientation. getVREvents a les paramètres suivants:
périphérique optionnelTypeFilter int par défaut est VR DEVICE CONTROLLER . Vous pouvez également choisir VR DEVICE HMD ou VR DEVIce GENERIC TRACKER ou n'importe quelle combinaison d'entre eux.
toutAnalog Axes int 1 en option pour tous les axes analogiques, 0 avec un seul axe
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez en choisir un.
Les paramètres de sortie sont :

contrôleurId index de contrôle d'entrée (0..MAX VR CONTROLLERS)
contrôleurPosition vec3, liste de 3 flotteurs position du régulateur, dans l'espace mondial Coordonnées cartésiennes
controllerOrientation vec4, liste de 4 flotteurs contrôleur orientation quaternion [x,y,z,w] dans l'espace mondial
contrôleurAnalogueAxe flotter valeur de l'axe analogique
numButtonEvents int nombre d'événements de bouton depuis le dernier appel pour obtenirVREvents
numMoveEvents int nombre d'événements de déménagement depuis le dernier appel pour obtenirVREvents
boutons int[64], liste des états de bouton (OpenVR a un maximum de 64 boutons)
drapeaux pour chaque bouton : VR BUTTON IS DOWN (actuellement maintenu en bas), VR BUTton WAS TRIGGERED (a été publié au moins une fois depuis la dernière cal pour obtenirVREvents, VR = BUTTON WAS DELEaseD (au moins une seule fois depuis le dernier appel pour obtenirVREvents). Notez que seul VR BUTTON IS DOWN signale l'état actuel réel. Par exemple, si le bouton est descendu et relevé, vous pouvez le dire à partir des drapeaux LIBE/TRIGGERED, même si IS DOWN est toujours faux. Notez que dans le fichier journal, ces boutons sont emballés avec 10 boutons en 1 entier (3 bits par bouton).
allAnalog Axes (seulement si explicitement demandé!)
liste de 10 flotteurs actuellement, MAX VR ANALOGUE AXIS est 5, pour chaque axe x et y valeur.
Voir Bullet/exemples/pybullet/exemple/vrEvents.py pour un exemple de dessin VR et Bullet / exemple/pybolt/échantillon/vrTracker.py afin de suivre le HMD et le traqueur générique. setVRCameraState
setVRCameraState permet de définir la position et l'orientation offset de transformation racine de caméra. Cela permet de contrôler la position de l'appareil photo VR dans le monde virtuel. Il est également possible de laisser la caméra VR suivre un objet, tel qu'un véhicule. setVRCameraState a les arguments suivants (il n'y a pas de valeurs de retour):
option rootPosition vec3, vecteur de 3 flotteurs position racine caméra
option rootOrientation vec4, vecteur de 4 flottes caméra orientation racine au format quaternion [x,y,z,w].
TrackObject vec3, vecteur de 3 flotte l'objet unique id à la piste
track optionnelObjectFlags d'inte.VR CAMERA TRACK OBJECT ORIENTATIO N (si activé, la position et l'orientation sont suivies)
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez choisir

Une.
PyBullet a certaines fonctionnalités pour faciliter le débogage, la visualisation et l'accord de la simulation. Cette fonctionnalité n'est utile que s'il existe une fenêtre de visualisation 3D, comme le mode GUI ou lorsqu'elle est connectée à un serveur physique distinct (comme Exemple de navigateur en mode 'Physics Server' ou Serveur Physique autonome avec OpenGL GUI).
Vous pouvez ajouter une ligne 3d spécifiée par un point de départ (à partir) et un point d'extrémité (à), une couleur [rouge, vert, bleu], une largeur de la ligne et une durée en secondes. Les arguments pour ajouterUserDebugline sont:
ligne requiseFromXYZ vec3, liste de 3 flotteurs
point de départ de la ligne dans les coordonnées du monde cartésien
lineToXYZ vec3, liste de 3 flotteurs
point de fin de ligne dans les coordonnées du monde cartésien
ligne optionnelleColorRGB vec3, liste de 3 flotteurs
Couleur RGB [Rouge, Vert, Bleu] chaque composant dans la gamme [0..1]
Largeur de ligne flottante (limitée par l'implémentation OpenGL)
en option lifeTime float utilisation 0 pour la ligne permanente, ou le temps positif en secondes (après la ligne avec être supprimé automatiquement)
parent optionnelObjectUniqueId int nouveau dans le prochain PyBullet 1.0.8: ligne de dessin en coordonnées locales d'un objet/lien parent.
option parentLinkIndex int nouveau dans le prochain PyBullet 1.0.8: tracer la ligne en coordonnées locales d'un objet/lien parent.
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez choisir un
addUserDebugLine retournera un id unique non négatif, qui vous permet de supprimer la ligne en utilisant removeUserDebogItem. ajouterUserDebugText
Vous pouvez ajouter un texte 3d à un emplacement spécifique en utilisant une couleur et une taille. Les arguments d'entrée sont les suivants:

texte requis texte représenté en chaîne (pour mémoire de caractères)
Texte requisPosition vec3, liste de 3 flotteurs
Position 3d du texte dans les coordonnées Cartésiennes [x,y,z]
TextColorRGB vec3, liste de 3 flotteurs
Couleur RGB [Rouge, Vert, Bleu] chaque composant dans la gamme [0..1]
Taille du texte en option
en option lifeTime float utiliser 0 pour le texte permanent, ou temps positif en secondes (après le texte avec être supprimé automatiquement)
texte optionnelOrientation vec4, liste de 4 flotteurs
Par défaut, le texte de débogage sera toujours face à la caméra, rotation automatique. En spécifiant une orientation textuelle (quaternion), l'orientation sera fixée dans l'espace mondial ou local (lorsque le parent est spécifié). Notez qu'un autre implémentation/shader est utilisé pour le texte face à caméra, avec une apparence différente: le texte orienté vers la caméra utilise des polices bitmap, le texte avec orientation spécifiée utilise des fontes TrueType.
parent optionnelObjectUniqueId int nouveau dans le prochain PyBullet 1.0.8: ligne de dessin en coordonnées locales d'un objet/lien parent.
option parentLinkIndex int nouveau dans le prochain PyBullet 1.0.8: tracer la ligne en coordonnées locales d'un objet/lien parent.
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez choisir un
addUserDebugText retournera un id unique non négatif, qui vous permet de supprimer la ligne en utilisant removeUserDebogItem. Voir aussi pybullet/exemples/debugDrawItems.py
addUserDebugParamètre vous permet d'ajouter des curseurs personnalisés pour régler les paramètres. Il vous rendra un identifiant unique. Cela vous permet de lire la valeur du paramètre en utilisant readUserDebugParamètre. Les paramètres d'entrée de addUserDebugParamètre sont:
nom de chaîne requis du paramètre paramName
Valeur minimale de flotteur minimal requise
plage requiseValeur maximale de flotteur maximum
valeur de départ du flotteur
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez choisir un

Les paramètres d'entrée de readUserDebugParamètre sont:
item requisUniqueId int l'identifiant unique retourné par 'addUserDebugParamètre)
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez choisir un
Les fonctions pour ajouter des lignes de débogage, du texte ou des paramètres d'utilisateur retourneront un id unique non négatif s'il réussit. Vous pouvez supprimer l'élément de débogage en utilisant cette id unique en utilisant la méthode removeUserDebugItem.Les paramètres d'entrée sont:
item requisUniqueId int unique id de l'élément de débogage à supprimer (ligne, texte etc)
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez choisir un
Cette API supprimera tous les éléments de débogage (texte, lignes etc.).
Les visualisateurs OpenGL intégrés ont une fonction de rendu de débogueur filaire: appuyez sur 'w' pour basculer. Le cadre filaire a quelques couleurs par défaut. Vous pouvez outrepasser la couleur d'un objet spécifique et un lien en utilisant setDebugObjectColor. Les paramètres d'entrée sont:
objet requisUniqueId int unique id de l'objet
lien obligatoireIndex index int link
objet optionnelDebugColorRGB vec3, liste de 3 flotteurs de couleur debug dans [Rouge, Vert, Bleu]. Si elle n'est pas fournie, la couleur personnalisée sera supprimée.
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez choisir un

Vous pouvez configurer certains paramètres du visualisateur OpenGL intégré, tels que l'activation ou la désactivation de wireframe, ombres et rendu GUI. Ceci est utile puisque certains ordinateurs portables ou des interfaces de bureau ont des problèmes de performance avec notre visualisateur OpenGL 3.
FLAG INT REQUIS POUR ACTIVER OU DÉSACTIVER LA FONCTION, COMME COV ENABLE WIREFRAME, COV ENABLE SHADOWS, COV ENIBLE GUI, COVA ENTABLE VR PICKING, COVI ENABLES PR TÉLÉPORTING, COVO ENABILITÉ RENDERING, COV ENABLE TINY ENDERERER, COVE ENRABLE VRR TENDER CONTROLLERS, COVA ENDABLE KEYBOARD COURTCUTS, CIV ENABILITY MOUSE PICKINAGE, COVA ENABLE Y AXIS UP (Z EST PAR DÉFAUT MONDE VERS L'AXE),COV ÉNABLE RGB BUFFER PREVIEW, CDV ENNABLE PROFONDEUR BUSPER PRESVIEW, CMV ENABILITE SEGMENTATION MARK PRÉVIEW
Activer int 0 ou 1
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez choisir un
Vous pouvez réinitialiser la distance de visionneuse 3D OpenGL (entre la position cible des yeux et de l'appareil photo), le lacet et la position cibles de la caméra.
caméra requiseDistance de flotteur distance entre la position cible d'un œil et celle de l'appareil photo
caméra obligatoireYaw flotter caméra angle de lacet (en degrés) gauche/droite
caméra requisePitch flotteur angle de pas de la caméra (en degrés) vers le haut/vers le bas
caméra requiseTargetPosition vec3, liste de 3 flotteurs cameraTarmarketPostion est le point focal de la caméra
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez choisir un

Vous pouvez obtenir la largeur et la hauteur (en pixels) de l'appareil photo, sa matrice de vision et de projection en utilisant cette commande. Le paramètre d'entrée est le physicsClientId optionnel. Les informations sur les produits sont:
largeur int largeur de l'image de la caméra en pixels
hauteur int hauteur de l'image de la caméra en pixels
vueMatrix float16, liste de 16 flotteurs
la matrice de vue de l'appareil photo
projectionMatrix float16, liste de 16 flotteurs
matrice de projection de la caméra
cameraUp float3, liste de 3 flotteurs
axe de la caméra, dans les coordonnées Cartésiennes de l'espace mondial
caméraFlottant vers l'avant3, liste de 3 flotteurs
axe avant de la caméra, dans les coordonnées Cartésiennes de l'espace mondial
flotteur horizontal3, liste de 3 flotteurs
- OUI. Il s'agit d'un vecteur horizontal qui peut être utilisé pour générer des rayons (pour la sélection de souris ou la création d'une simple traceur de rayon par exemple)
float vertical3, liste de 3 flotteurs
À déterminer.C'est un vecteur vertical qui peut être utilisé pour générer des rayons (pour la sélection de souris ou la création d'un traceur simple de rayon par exemple).
lacet flotteur angle de lacet de la caméra, dans les coordonnées locales cartésiennes
Pitch flotteur angle de pas de la caméra, dans les coordonnées locales cartésiennes
dist distance de flottement entre la caméra et la cible de l'appareil
cible flotteur3, liste de 3 flotteurs
cible de la caméra, dans les coordonnées mondiales cartésiennes
Vous pouvez recevoir tous les événements clavier qui se sont produits depuis la dernière fois que vous avez appelé 'getKeyboardEvents'. Chaque événement a un code clé et un état. L'état est une combinaison de drapeau de KEY IS DOWN, KEY WAS TRIGGERED et KEY = WAS RELEase. Si une clé passe de l'état « up » à l'État « down », vous recevez l'Etat KEY IS DOWN, ainsi que l'ÉTAT KEY WAS TRIGGERED. Si une clé a été pressée et libérée, l'état sera KEY IS DOWN et KEY WAS RELEASED.

CERTAINES TOUCHES SPÉCIALES SONT DÉFINIES : B3G F1 ... B3B F12, B3G LEFT ARROW, B4G RIGHT ARROW , B2G UP ARROW ., B5G DOWN ARROW., B6G PAGE UP ., B7G PAGE DOWN .,B3G PAGE END ., C'EST-À-DIRE B3 G HOME . L'entrée de getKeyboardEvents est une physique optionnelleClientId:
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez choisir un
La sortie est un dictionnaire de code clé 'clé' et l'état du clavier 'valeur'. events de l'émission getMouse
Similaire à getKeyboardEvents, vous pouvez obtenir les événements de la souris qui sont survenus depuis le dernier appel pour getMouseEvent. Tous les événements de déplacement de la souris sont fusionnés en un seul événement de mouvement de la loupe avec la position la plus à jour. En outre, tous les événements de bouton de souris pour un bouton donné sont fusionnés. Si un bouton est descendu et relevé, l'état sera 'KEY WAS TRIGGERED '. Nous réutiliserons le KEY WAS TRIGGERED /KEY IS DOWN /Key WAS RELEase pour les états des boutons de la souris. Les arguments d'entrée pour getMouseEvents sont :
physique optionnelleClientId int si vous êtes connecté à plusieurs serveurs, vous pouvez choisir un
La sortie est une liste d'événements de souris dans le format suivant:
eventType int MOUSE MOVE EVENT=1, MOUSSE BUTTON EVEN =2
sourisPosX flotter x-coordonnées du pointeur de la souris
sourisPosY flotter coordonnées y du pointeur de la souris
boutonIndex index index bouton pour gauche / mi-gauche / droite bouton de souris
boutonÉtat de l'indicateur int KEY WAS TRIGGERED /KEY IS DOWN /Key WAs RELEASED
Il y a plusieurs façons d'installer PyBullet sur Windows, Mac OSX et Linux. Nous utilisons Python 2.7 et Python 3.5.2, mais nous attendons que la plupart des versions Pyton 2.x et PYTON 3.x fonctionnent. Le plus facile à obtenir PyBullet pour travailler est d'utiliser pip ou python setug.py:

Assurez-vous que Python et pip sont installés, puis exécutez : pip install pybullet Notez que si vous avez utilisé pip pour installer PyBullet, il est toujours bénéfique d'installer le SDK de physique Bullet C++: il inclut des fichiers de données, des serveurs de physique et des outils utiles pour PyBullet. Vous pouvez également exécuter 'python setup.py build' et 'pyhon settment.py install' dans la racine du SDK de physique Bullet (obtenir le SDK à partirhttp://github.com/bulletphysics/bullets3) Voir aussiLes données relatives à la consommation de drogues et aux produits chimiques sont disponibles sur le site Web du Bureau. Vous pouvez également installer PyBullet à partir du code source en utilisant premake (Windows) ou cmake: Utiliser premaker pour Windows
Assurez-vous que la version Python est installée dans c:\python-3.5.2 (ou autre nom de dossier de version) Commencez par obtenir le code source de github, en utilisant le clone githttps://github.com/bulletphysics/bullets3 Cliquez sur build visual studio vr pybullet double.bat et ouvrez le projet 0 Bullet3Solution.sln dans Visual Studio, convertissez les projets si nécessaire. Passez en mode Release et compilez le projet 'pybullet'.

Puis il y a quelques options pour importer pybullet dans un interprète Python:

cd:\python-3.5.2\dlls
mklink pybullet.pyd c:\develop\bullet3\bin\pybullet vs2010.dll Ensuite, exécutez python.exe et importez p ybullet devrait fonctionner. Utilisation de cmake sur Linux et Mac OSX

○ Pybullet.connect(pybullet.GUI, options="--opengl2") ● Vous pouvez aussi exécuter le serveur physique sur la machine distante, avec UDP ou TCP bridge, et vous connecter de l'ordinateur portable local au serveur distant au moyen du tunnelage UDP. (todo: décrire les étapes en détail)
Question: Où allons-nous pour obtenir un soutien et signaler les problèmes? Réponse: Il y a un forum de discussion àhttp://pybullet.org/Bullet et un traqueur de problèmes àhttps://github.com/bulletphysics/bullets3 Question: Comment ajouter une citation à PyBullet dans notre document académique? Réponse : @MISC{coumans2018,
auteur = {Erwin Coumans et Yunfei Bai}, titre = {PyBullet, un module Python pour la simulation physique des jeux, de la robotique et de l'apprentissage automatique}, publié en anglais = {\url{http://pybullet.org } year = {2016--2018} } Question: Qu'arrive-t-il à Bullet 2.x et à la mise en œuvre de Bullet 3 OpenCL? Réponse: PyBullet enveloppe la Bullet C-API . Nous allons mettre l'API GPU Bullet 3 OpenCL (et la future API Bullet 4.x) derrière ce C-API. Donc, si vous utilisez PyBullet ou le C-API, vous êtes à l'épreuve du futur. Ne pas confondre avec l'API Bullet 2.x C++. Question: Devrais-je utiliser le mode couple/commande de force ou le mode vitesse/position? En général, il est préférable de commencer par le contrôle de la position ou de la vitesse. Il faudra beaucoup plus d'efforts pour obtenir le contrôle de la force/torque en travaillant de manière fiable. Question: Comment éteindre la gravité uniquement pour certaines parties d'un robot (par exemple le bras)? Réponse
Pour le moment, cela n'est pas exposé, donc vous devriez soit l'accélération de la gravité du tour pour tous les objets, et appliquer manuellement la pesanteur pour les objets qui en ont besoin.

Ou vous pouvez calculer activement les forces de compensation de gravité, comme sur un vrai robot. Comme Bullet a un système de contrainte complet, il serait trivial de calculer ces forces antigravité : Vous pourriez exécuter une seconde simulation (PyBullet vous permet de se connecter à plusieurs serveurs physiques) et positionner le robot sous gravité, définir la position commune pour garder la position comme désiré, et rassembler ces forces «antigravity». Ensuite, appliquez ceux de la simulation principale. Question: Comment faire pour augmenter / réduire les objets? Réponse : Vous pouvez utiliser la valeur globalScaleFactor comme argument optionnel pour chargerURDF et loadSDF. Sinon, l'échelle des formes visuelles et des formes de collision fait partie de la plupart des formats de fichiers, tels que URDF et SDF. Pour le moment, vous ne pouvez pas redimensionner les objets. Question: Comment puis-je obtenir des textures dans mes modèles? Réponse : Vous pouvez utiliser le format de fichier Wavefront .obj. Cela prendra en charge les fichiers matériels (.mtl). Il existe plusieurs exemples utilisant des textures dans le dossier Bullet/Data. Vous pouvez modifier la texture des objets texturés existants en utilisant l'API 'changeTexture'. Question: Quels formats de fichiers texture sont valides pour PyBullet? Réponse: Bullet utilise stb image pour charger des fichiers de texture, qui chargent PNG, JPG, TGA, GIF etc. voir stb image.h pour plus de détails. Question: Comment puis-je améliorer la performance et la stabilité de la détection des collisions? Réponse : Il existe de nombreuses façons d'optimiser, par exemple : type de forme 1) Choisissez un ou plusieurs types primitifs de formes de collision tels que boîte, sphère, capsule, cylindre pour approximation d'un objet, au lieu d'utiliser des mailles convexes ou concaves triangle. 2) Si vous avez vraiment besoin d'utiliser des mailles triangle, créez une décomposition convexe en utilisant la Décomposition Convex Approximate Hiérarchique (V-HACD). L'utilitaire test hacd convertit le triangle convexe dans un fichier OBJ en un nouveau fichier OOJ avec plusieurs objets de coque convex. Voir par exemple Bullet/data/teddy vhacd.urdf pointant vers Bullet / data/teddy2 VHACD CHs.obj, ou canard vHacd-urd f pointant sur canard vhacD.obJ. 3) Réduire le nombre de sommets dans un triangle. Par exemple Blender 3D a un grand modificateur de décimation de maille qui vous permet de voir de manière interactive le résultat de la simplification du maillage. 4) Utilisez la friction de roulement et la frottement de rotation pour des objets ronds tels que sphère et capsules et les pinces robotiques utilisant le et noeuds à l'intérieur les noeuds. Voir par exemple Bullet/data/sphere2.urdf 5) Utiliser une petite quantité de conformité pour les roues utilisant le à l'intérieur de la FDNR Un nœud xml. Voir par exemple le véhicule Bullet/data/husky/huski.urdf. 6) Utilisez la double précision de Bullet, ce qui est bon à la fois pour la stabilité du contact et la précision des collisions. Choisissez un bon réglage de résolveur de contrainte et l'étape du temps.

Réponse: par défaut, Bullet et PyBullet utilisent un frottement implicite exact du cône pour le modèle de friction Coulomb. En outre, vous pouvez activer le roulement et la friction en ajoutant un et noeud à l'intérieur du node, voir Bullet/data/sphere2.urdf par exemple. Au lieu de la friction du cône, vous pouvez activer l'approximation pyramidale. Question: Quel genre de constante ou seuil à l'intérieur de Bullet, qui rend les vitesses élevées impossibles?
Réponse : Par défaut, Bullet s'appuie sur une détection de collision discrète en combinaison avec la récupération de pénétration. En se fondant uniquement sur la détection discrète des collisions, on ne doit pas faire voyager plus rapidement que son propre rayon dans un délai donné. PyBullet utilise le paragraphe 1/240 comme étape de temps par défaut. Les étapes de temps supérieures à 1./60 peuvent introduire des instabilités pour diverses raisons (perceptions profondes, intégrateur numérique). La balle a une option pour la détection continue des collisions afin de capturer les collisions pour les objets qui se déplacent plus rapidement que leur propre rayon dans un délai donné. Malheureusement, cette détection continue de collision peut introduire ses propres problèmes (performance et réponse non physique, absence de restitution), d'où cette fonction expérimentale n'est pas activée par défaut.
Pages mentionnées dans ce manuel — fabricant, assistance et téléchargements.
Les utilisateurs et notre équipe répondent généralement sous 24 h — et votre question servira aussi aux suivants.
Soyez le premier à poser une question — d'autres utilisateurs ou notre équipe y répondront.