
Rendering fotocamera sintetica 35
Erwin Coumans, Yunfei Bai , 2017/2018
Visita i forum .
Ciao PyBullet World 3
Query di rilevamento delle collisioni 39
loadURDF, loadSDF,loadMJCF 7
saveState, salvaBullet, restaurareStato 9
Dinamica Inversa, Kinematics 44
Rinforzo Imparare Palestra Envs 47
Ambiente e dati 47
Controllo di un robot 17
Base, Giunti, Links 17
GUI del Debug, Linee, Testo, Parametri 55
getNumBodies, ottenereBodyInfo, ottenere BodyUniqueId, rimuovereBody 26
creareConstraint, rimuovere Constrato, cambiareContraente 26
Costruisci e installa PyBullet 60
Supporto, Suggerimenti, Citazione 63

PyBullet è un modulo Python facile da usare per la simulazione fisica di robotica, giochi, effetti visivi e machine learning. Con PyBullet è possibile caricare corpi articolati da URDF, SDF, MJCF e altri formati di file. PyBullet fornisce simulazione di dinamiche in avanti, calcolo delle dinamiche inverse, kinematica avanzata e inversa, rilevamento della collisione e domande intersezione raggio. Il Bullet Physics SDK include esempi robot PyBullet come un Minitaur simulato quadruplicato, umanoidi in esecuzione utilizzando TensorFlow inference e KUKA armi afferrando oggetti.



Oltre alla simulazione fisica, ci sono dei binding da rendere con un renderer della CPU (TinyRenderer) e una visualizzazione OpenGL per cuffie di Realtà Virtuale come HTC Vive e Oculus Rift. PyBullet ha anche funzionalità per eseguire query di rilevamento delle collisioni (punti più stretti, coppie sovrapposte, test dell'intersezione del raggio ecc) e aggiungere il rendering debug (linee di abbattimento e testo). PyBullet ha il supporto integrato-in multipiattaforma per server client, memoria condivisa, rete UDP e TCP. Così è possibile eseguire PyBullet su Linux che si collega a un server Windows VR. PyBullet avvolge il nuovo Bullet C-API , che è progettato per essere indipendente dal motore fisico sottostante e rendering del motore, in modo da poter facilmente migrare alle versioni più recenti di Bullet o utilizzare un diverso motore fisica o motore di render. Per impostazione predefinita, PyBullet utilizza l'API Bullet 2.x sulla CPU. Smaschereremo Bullet 3.x in esecuzione su GPU utilizzando OpenCL pure. C'è anche un API C++ simile a PyBullet, vedi b3RobotSimulatorClientAPI . PyBullet può essere facilmente utilizzato con TensorFlow e quadri come OpenAI Gym. Ricercatori di Google Brain [ 1 , 2 , 3 ], X , Stanford AI Lab e OpenAI utilizzano PyBullet/Bullec C-API. L'installazione di PyBullet è semplice come (sudo) pip install PyBullit (Python 2.x), pip3 install PyBellet. Questo espone il modulo PyBullet così come gli ambienti di palestra PyBullit envs.

Ecco uno script di introduzione PyBullet che parliamo passo dopo passo:
import pybullet asp importare tempo pibullo dati fisicaClient = p.connect(p.GUI)#or p.DIRECT per la versione non grafica p.setUlteriori informazioniPath (pybullet data.getDataPath())]
Dopo aver importato il modulo PyBullet, la prima cosa da fare è "collegare" alla simulazione fisica. PyBullet è progettato attorno a un'API guidata client-server, con comandi di invio del cliente e server fisici che ritornano lo stato. PyBullet ha alcuni server fisici integrati: DIRECT e GUI. Sia le connessioni GUI che DIRECT eseguiranno la simulazione fisica e il rendering nello stesso processo di PyBullet. Nota che in modalità DIRECT non è possibile accedere alle funzionalità hardware OpenGL e VR, come descritto nei capitoli "Virtual Reality" e "Debug GUI, Lines, Text, Parameters". La modalità DIRECT consente di rendere le immagini utilizzando il software integrato tramite l'API 'getCameraImage'. Questo può essere utile per eseguire simulazioni nel cloud su server senza GPU. È possibile fornire i propri file di dati, o è possibile utilizzare il pacchetto PyBullet data che navighi con PyBullit. Per questo, importare pibullet data e registrare la directory utilizzando pybullet.setExploitSearchPath (pybullet data.getDataPath()). ottenereConnectionInfo
Data una fisicaClientId restituirà la lista [èconnessa, connessioneMethod]


Diagramma con varie opzioni del client di fisica (blu) e server fisico (verde). Verde scuro
La connessione DIRECT invia i comandi direttamente al motore fisico, senza utilizzare alcun livello di trasporto e nessuna finestra di visualizzazione grafica, e restituisce lo stato dopo l'esecuzione del comando. La connessione GUI creerà una nuova interfaccia grafica (GUI) con rendering 3D OpenGL, all'interno dello stesso spazio di processo di PyBullet. Su Linux e Windows questa GUI viene eseguita in un thread separato, mentre su OSX si corre nello stesso filetto a causa delle limitazioni del sistema operativo. Su Mac OSX è possibile vedere una ruota di filatura nella finestra OpenGL, fino a quando si esegue un comando 'stepSimulation' o altro PyBullet. I comandi e i messaggi di stato vengono inviati tra il client PyBullet ed il server di simulazione fisica GUI utilizzando un buffer normale della memoria. È anche possibile connettersi a un server fisico in un processo diverso sulla stessa macchina o su una macchina remota utilizzando SHARED MEMORY, UDP o TCP networking. Per maggiori dettagli, vedere la sezione dedicata a Memoria condivisa, UDP e TCP. A differenza di quasi tutti gli altri metodi, questo metodo non analizza argomenti chiave, a causa della compatibilità all'indietro.

Gli argomenti di input del collegamento sono:
connettere restituisce un client di fisica id o -1 se non collegato. Il cliente fisico Id è un argomento opzionale per la maggior parte degli altri comandi PyBullet. Se non lo fornisce, assumerà il cliente fisico id = 0. È possibile connettersi a più server fisici diversi, tranne per la GUI. Per esempio: pybullet.connect (pibullet.DIRECT) pybullet.connect (pibullet.GUI, opzioni="--opengl2") pybullet.connect (pibullet.SHARED MEMORY, 1234) pybullet.connect (pibullet.UDP,"192.168.0.1") pybullet.connect (pibullet.UDP,"localhost", 1234) pybullet.connect (pybullet.TCP,"localhost", 6667) si collegano utilizzando Memoria condivisa
Ci sono alcuni server fisici che permettono la connessione di memoria condivisa: App SharedMemoryPhysics, App SearedMemorityPhyseics GUI e Bullet Esempi Browser ha un esempio sotto Server sperimentale/pisico che consente una connessione di Memoria condivisa. Questo vi permetterà di eseguire la simulazione fisica e rendering in un processo separato.

Puoi anche connetterti alla memoria condivisa con App SharedMemoryPhysics VR, l'applicazione Virtual Reality con supporto per display testa-montato e controller tracciati 6-dof come HTC Vive e Oculus Rift con touch controller. Poiché la Valve OpenVR SDK funziona solo correttamente sotto Windows, l'App SharedMemoryPhysics VR può essere costruito soltanto in Windows utilizzando premake (preferibilmente) o cmake. connettersi utilizzando UDP o TCP di rete
Per la rete UDP, c'è un App PhysicsServerUDP che ascolta una certa porta UDP. Utilizza la libreria enet open source per una rete UDP affidabile. Questo consente di eseguire la simulazione fisica e rendering su una macchina separata. Per TCP PyBullet utilizza la libreria di clessidre. Questo può essere utile quando si utilizza il tunnel SSH da una macchina dietro un firewall a una simulazione robot. Ad esempio, è possibile eseguire uno stack di controllo o l'apprendimento automatico utilizzando PyBullet su Linux, mentre si esegue il server fisico in Windows nella realtà virtuale usando HTC Vive o Rift. Un'applicazione UDP è l'applicazione App PhysicsServerSharedMemoryBridgeUDP che funge da ponte per un server fisico esistente: puoi connetterti oltre UDP a questo bridge e il ponte si collega ad un server di fisica usando la memoria condivisa: il ponte passa messaggi tra client e server. In modo simile c'è una versione TCP (sostituire UDP da TCP). Nota: al momento, sia client che server devono essere compilazioni a 32 bit o 64bit! disconnessione
È possibile disconnettersi da un server fisico, utilizzando il client di fisica Id restituito dalla chiamata di connessione (se non negativo). Un server fisico 'DIRECT' o 'GUI' si spegne. Un server fisico separato (out-of-process) continuerà a funzionare. Vedi anche 'resetSimulation' per rimuovere tutti gli elementi. Parametri di disconnessione:
fisica opzionaleClientId int se si collega a più server di fisica, è possibile scegliere quale.
Per impostazione predefinita, non esiste una forza gravitazionale abilitata.setGravityconsente di impostare la forza gravitazionale predefinita per tutti gli oggetti. I parametri di input setGravity sono: (non valore di ritorno)
forza di gravità del galleggiante della gravità richiesta X lungo l'asse mondiale

Il loadURDF invierà un comando al server fisico per caricare un modello di fisica da un Universal Robot Descrizione File (URDF). Il file URDF viene utilizzato dal progetto ROS (Robot Operating System) per descrivere robot e altri oggetti, è stato creato dalla WillowGarage e la Open Source Robotics Foundation (OSRF). Molti robot hanno file URDF pubblici, è possibile trovare una descrizione e tutorial qui:http://wiki.ros.org/urdf/Tutorial Nota importante: la maggior parte delle articolazioni (slider, revolute, continua) hanno motori abilitati per impostazione predefinita che impediscono il movimento libero. Questo è simile a un giunto robot con una spinta armonica ad alta frizione. È necessario impostare la modalità di controllo del motore e le impostazioni di destinazione con pibullet.setJointMotorControl2. Per ulteriori informazioni, vedere il setJointMotorControl2 API. Attenzione: per impostazione predefinita, PyBullet memorizza alcuni file per accelerare il caricamento. È possibile disabilitare il file caching utilizzando setPhysicsEngineParameter(enableFileCaching=0). Gli argomenti di loadURDF sono:

loadURDF restituisce un id unico corpo, un valore integer non negativo. Se il file URDF non può essere caricato, questo intero sarà negativo e non un id unico corpo valido. loadSDF, loadMJCF
È inoltre possibile caricare oggetti da altri formati di file, come .bullet, .sdf e .mjcf. Quei formati di file supportano oggetti multipli, quindi il valore di ritorno è un elenco degli ids unici dell'oggetto. Il formato SDF è spiegato in dettagliohttp://sdformat.org Il comando loadSDF estrae solo alcune parti essenziali del SDF relative ai modelli robotizzati e alla geometria, ignorando molti elementi legati a telecamere, luci e così via. Il comando loadMJCF esegue l'importazione di base dei file MuJoCo MJCF xml, utilizzati in OpenAI Gym. Vedi anche la nota importante sotto loadURDF relativa alle impostazioni del motore congiunto predefinite e assicurati di usare setJointMotorControl2.
loadBullet, loadSDF e loadMJCF restituirà una serie di ids unici dell'oggetto:
oggettoUniqueIds elenco di int
l'elenco include il id unico oggetto per ogni oggetto caricato.

È possibile creare una snapshot approssimativa del mondo attuale come file PyBullet Python, memorizzato sul server. saveWorld può essere utile come una funzione di editing base, la creazione del robot, angoli comuni, posizioni degli oggetti e ambiente per esempio in VR. Più tardi si può solo caricare il file PyBullet Python per ricreare il mondo. L'istantanea pitone contiene comandi loadURDF insieme all'inizializzazione di angoli articolari e trasformazioni dell'oggetto. Si noti che non tutte le impostazioni sono memorizzate nel file mondiale. Gli argomenti di input sono:
Quando avete bisogno di simulazione deterministica dopo il ripristino a uno stato precedentemente salvato, tutte le informazioni importanti dello Stato, compresi i punti di contatto, devono essere memorizzati. Il comando saveWorld non è sufficiente per questo. È possibile utilizzare il comando ripristinaState per ripristinare da un'istantanea scattata utilizzando saveState (in-memory) o salvareBullet (su disco). Il comando saveState prende solo un client opzionaleServerId come input e restituisce lo stato id. Il comando saveBullet salverà lo stato in un file .bullet su disco. Gli argomenti di input dei comandi ripristinaState sono:
O il nome del file o lo stato id deve essere valido. Nota che restoreState resetterà le posizioni e gli angoli di oggetti comuni allo stato salvato, nonché ripristinando informazioni sul punto di contatto. È necessario assicurarsi che gli oggetti e i vincoli siano impostati prima di chiamare ripristinaState. Vedere l'esempio saveRestoreState.py.

Anche se il modo più semplice e raccomandato per creare cose nel mondo sta usando le funzioni di carico (loadURDF/SDF / MJCF/Bullet), è anche possibile creare collisione e forme visive programmaticamente e utilizzarle per creare un corpo multi utilizzando createMultiBody. Vedere il creareMultiBodyLinks.py e creareVisualShape.py esempio nel Bullet Physics SDK. I parametri di input per creareCollisionShape sono
Il valore di ritorno è un int non negativo unico id per la forma della collisione o -1 se il richiamo fallisce. creareVisualShape
È possibile creare una forma visiva in modo simile a creare una sagoma di collisione, con alcuni argomenti aggiuntivi per controllare l'aspetto visivo, come il colore diffuso e speculare. Quando si utilizza il tipo GEOM MESH, è possibile puntare su un file OBJ Fronte Onda e la visualizzazione

la forma parse alcuni parametri dal file materiale (.mtl) e caricare una texture. Nota che le grandi texture (sopra 1024x1024 pixel) possono rallentare il carico e la prestazione di run-time. Vedere esempi/pibullet/esamples/addPlanarReflection.py e creareVisualShape.py

I parametri di input sono

Il valore di ritorno è un int non negativo unico id per la forma visiva o -1 se il richiamo fallisce.
Anche se il modo più semplice per creare roba nel mondo sta usando le funzioni di carico (loadURDF/SDF / MJCF/Bullet), è possibile creare un corpo multi utilizzando createMultiBody. Vedere il creatoMultiBodyLinks.py esempio nel Bullet Physics SDK. I parametri di creareMultiBody sono molto simili ai parametri URDF e SDF. È possibile creare un corpo multi con una sola base senza giunti/collegamenti per bambini o è possibile creare il corpo multicon i collegamenti articolari / bambino. Se fornisci dei link, assicurati che la dimensione di ogni elenco sia uguale (len(linkMasses) == len (linkCollisionShapeIndices), ecc.). I parametri d'ingresso per creareMultiBody sono:

link opzionaleVisualShapeIndici elenco int della forma visiva id unico per ogni collegamento
elenco di linkPosizioni opzionali dell'elenco vec3 delle posizioni dei collegamenti locali, rispetto al genitore
elenco di orientamento del sito web, w.r.t. genitore
link opzionaleInertialFramePosizioni elenco di vec3 lista dei pos inerziali locali. in cornice di collegamento
link opzionaleInertialFrameOrientamenti elenco vec4 di struttura inerziale locale orn. in cornice di collegamento
link opzionaleParentIndices elenco int Link index del collegamento genitore o 0 per la base.
link opzionale Elenco di Tubi unitari dell'elenco int dei tipi articolati, uno per ogni collegamento. Solo JOINT REVOLUTE, JONT PRISMATIC e JOIN FIXED è supportato al momento.
link opzionaleEsame assiale di vec3 asse comune in cornice locale
uso opzionaleMaximalCoordinates int sperimentale, meglio lasciarla 0/false.
opzionale fisicaClientId int Se sei connesso a più server, puoi scegliere uno.
Il valore di ritorno del creatoMultiBody è un id non negativo unico o -1 per il fallimento. Esempio: cuid = pibullet.createCollisionShape(pybullet .GEOM BOX, halfExtents= [1, 1, 1]) mass= 0 #static box pybullet (pilastri), crea MultiBody (massa, cuid) Vedi anche creareMulti BodyLinks.py, createObstacleCourse.py e crei Bullpyexpy nelle cartelle di Visboby.
stepSimulation eseguirà tutte le azioni in un unico passo di simulazione della dinamica avanzata come il rilevamento delle collisioni, la risoluzione dei vincoli e l'integrazione. stepSimulation input argomenti sono facoltativi:
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
stepSimulation non ha valori di ritorno. Vedi anche impostareRealTimeSimulation per consentire automaticamente al server fisico di eseguire la simulazione dinamica in avanti basata sul suo orologio in tempo reale.

Per impostazione predefinita, il server fisico non eseguirà la simulazione, a meno che tu invii esplicitamente un comando 'stepSimulation'. In questo modo si può mantenere il determinismo di controllo della simulazione. È possibile eseguire la simulazione in tempo reale, lasciando che il server fisico passi automaticamente la simulazione secondo le sue ore di funzionamento (RTC) utilizzando il comando setRealTimeSimulation. Se si attiva la simulazione in tempo reale, non è necessario chiamare 'stepSimulation'. Nota che setRealTimeSimulation non ha effetto in modalità DIRECT: in modalità DIRETT il server fisico e client avvengono nello stesso thread ed è possibile attivare ogni comando. In modalità GUI e in Modalità Virtual Reality, e TCP/UDP mode, il server fisico viene eseguito in un thread separato dal client (PyBullet), e setRealTimeSimulation consente al filetto di Physicalserver di aggiungere chiamate aggiuntive alla stepSimulazione. I parametri di input sono:
abilitare la simulazione di tempo reale 0 per disabilitare la simulazione in tempo reale, 1 per consentire
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
getBasePositionAndOrientation riporta la posizione attuale e l'orientamento della base (o link radice) del corpo nelle coordinate mondiali cartesian. L'orientamento è un quaternione in formato [x,y,z,w]. I parametri di input getBasePositionAndOrientation sono:
oggetto richiestoUniqueId int object unico id, come restituito da loadURDF.
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
getBasePositionAndOrientation restituisce l'elenco di posizione di 3 carri e orientamento come elenco di 4 galleggianti in [x,y,z,w] ordine. Usare getEulerDal quaternion per convertire il quaternio in Euler se necessario. Vedi anche resetBasePositionAndOrientation per ripristinare la posizione e l'orientamento dell'oggetto.

Questo completa il primo script PyBullet. Avvicina le navi con diversi file URDF nella cartella Bullet/data.
È possibile ripristinare la posizione e l'orientamento della base (root) di ogni oggetto. È meglio solo farlo all'inizio, e non durante una simulazione in esecuzione, dal momento che il comando supererà l'effetto di tutta la simulazione fisica. La velocità lineare e angolare è impostata a zero. È possibile utilizzare resetBaseVelocity per ripristinare una velocità non-zero lineare e/o angolare. Gli argomenti di input per resetBasePositionAndOrientation sono:
oggetto richiestoUniqueId int object unico id, come restituito da loadURDF.
posObj vec3 resettare la base dell'oggetto nella posizione specificata nelle coordinate spaziali del mondo [X,Y,Z]
ornObj vec4 resettare la base dell'oggetto all'orientamento specificato come quaternion spazio mondo [X,Y,Z,W]
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
Non ci sono argomenti di ritorno.
La posizione degli oggetti può essere espressa nelle coordinate spaziali del mondo cartesiano [x,y,z]. L'orientamento (o rotazione) degli oggetti può essere espresso utilizzando quaternions [x,y,z,w], angoli euler [yaw, pitch, roll] o matrici 3x3. PyBullet fornisce alcune funzioni di helper per convertire tra quaternioni, angoli euler e matrici 3x3. Inoltre ci sono alcune funzioni per moltiplicare e invertire le trasformazioni. ottenereQuaterniondall'ultra e ottenereEulerDail quaternione
L'API PyBullet utilizza quaternions per rappresentare gli orientamenti. Poiché le quaternioni non sono molto intuitive per la gente, ci sono due API da convertire tra i quaternioni e gli angoli di Euler. Gli argomenti di input getQuaternionFromEuler sono:
Gli angoli X,Y,Z Euler sono in radianti, accumulando 3 rotazioni che esprimono il rullo intorno alla X, passo attorno a Y e zampa intorno all'asse Z.
fisica opzionaleClientId int non utilizzato, aggiunto per la consistenza API.
getQuaternionFromEuler restituisce un quaternione, vec4 elenco di 4 valori a punto galleggiante [X,Y,Z,W].

Gli argomenti di input getEulerFromQuaternion sono:
fisica opzionaleClientId int non utilizzato, aggiunto per la consistenza API.
getMatrixFromQuaternion è un'API di utilità per creare una matrice 3x3 da un quaternione. L'ingresso è un quaternione e l'output di una lista di 9 carri, che rappresentano la matrice. moltiplicareTrasformazioni, invertTransform
PyBullet fornisce alcune funzioni di helper per moltiplicare e inversare le trasformazioni. Questo può essere utile per trasformare le coordinate da uno all'altro sistema di coordinate. I parametri di input dei moltiplicatori Trasformi sono:
posizione richiestaA vec3, elenco di 3 galleggianti
orientamento richiestoUn vec4, elenco di 4 carri quaternion [x,y,z,w]
posizione richiestaB vec3, elenco di 3 galleggianti
orientamento richiestoB vec4, elenco di 4 carri quaternion [x,y,z,w]
fisica opzionaleClientId int non utilizzato, aggiunto per la consistenza API.
Il valore di ritorno è un elenco della posizione (vec3) e dell'orientamento (vet4, quaternion x,y,x,w). I parametri di ingresso e uscita dell'invertTransform sono:
posizione richiesta vec3, elenco 3 galleggianti
richiesto orientamento vec4, elenco di 4 carri quaternion [x,y,z,w]
L'output di invertTransform è una posizione (vec3) e l'orientamento (veco4, quaternion x,y,x,w).

È possibile query per la versione API in un formato anno-mese-0-giorno. È possibile connettersi solo tra client/server di fisica della stessa versione API, con lo stesso numero di bit (32-bit / 64bit). C'è un argomento inutilizzato opzionale fisicaClientId, aggiunto per la consistenza API.
fisica opzionaleClientId int non utilizzato, aggiunto per la consistenza API.
Nell'Introduzione abbiamo già mostrato come inizializzare PyBullet e caricare alcuni oggetti. Se si sostituisce il nome del file nel comando loadURDF con "r2d2.urdf" è possibile simulare un robot R2D2 dal tutorial ROS. Controlliamo questo robot R2D2 per muoversi, guardare intorno e controllare la presa. Per questo dobbiamo sapere come accedere ai suoi motori comuni.

Un robot simulato come descritto in un file URDF ha una base e link facoltativamente collegati da articolazioni. Ogni giunto collega un collegamento genitore a un link bambino. Alla radice della gerarchia c'è un singolo genitore root che chiamiamo base. La base può essere completamente fissa, 0 gradi di libertà o totalmente libera, con 6 gradi di liberta. Poiché ogni collegamento è collegato a un genitore con una singola giunzione, il numero di articolazioni è uguale al numero dei collegamenti. I collegamenti regolari hanno indici di collegamento nell'intervallo [0.getNumJoints()] Poiché la base non è un 'link' regolare, usiamo il convegno del -1 come suo link

Indice. Usiamo la convenzione che i telai articolari sono espressi rispetto al centro genitori di struttura inerziale di massa, che è allineato con l'asse principale dell'inerzia.
Dopo aver caricato un robot è possibile query il numero di articolazioni utilizzando l'API getNumJoints. Per la r2d2.urdf questo dovrebbe restituire 15. getNumJoints parametri di input:
corpo richiestoUniqueId int il corpo unico id, come restituito da loadURDF ecc.
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
Per ogni giunto possiamo interrogare alcune informazioni, come il suo nome e la sua tipologia. ottenerePati di ingresso su Singola
corpo richiestoUniqueId int il corpo unico id, come restituito da loadURDF ecc.
giunto necessarioIndex in un indice nella gamma [0 .. ottenereNumJoints(bodyUniqueId)
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
getJointInfo restituisce un elenco di informazioni:
JointIndex int lo stesso indice articolare del parametro input
stringa di nome comune il nome del giunto, come specificato nel file URDF (o SDF ecc)
articolazioneTipo int tipo del giunto, questo implica anche il numero di variabili di posizione e velocità. JOINT REVOLUTE, JOINT PRISMATIC, ARTICOLAZIONI SFERICHE, CONGIUNTE PLANAR, GIUNTO FISSO. Per maggiori dettagli, vedere la sezione su Base, Joint e Links.
qIndex int il primo indice di posizione nelle variabili dello stato posizionale per questo corpo
uIndex int il primo indice di velocità nelle variabili dello stato della velocita per questo corpo
jointDamping galleggia il valore di smorzamento delle articolazioni, come specificato nel file URDF
giuntoFrizione galleggiare il valore di attrito congiunto, come specificato nel file URDF
giuntoLowerLimit galleggiante Limite inferiore di posizione per cursore e articolazioni in rivoluto (chiusura).
giuntoUpperLimit galleggiante Limite superiore di posizione per cursore e articolazioni rivolute. Valori ignorati nel caso in cui la tomaia
bandiere int prenotate

limite
jointMaxForce galleggiante Forza massima specificata in URDF (forse altri formati di file) Nota che questo valore non viene utilizzato automaticamente. È possibile utilizzare maxForce in 'setJointMotorControl2'.
giuntoMassimaVelocità galleggiante Velocità massima specificata in URDF. Si noti che la velocità massima non viene utilizzata nei comandi di controllo motore reali al momento.
linkName stringa il nome del collegamento, come specificato nel file URDF (o SDF ecc.)
asse di giunzione assi vec3 in struttura locale (ignorato per JOINT FIXED)
genitoreFramePos vec3 posizione comune nella cornice madre
parentFrameOrn vec3 orientamento congiunto nella cornice madre
indice del collegamento genitoriale Index, -1 per base
Nota:setJointMotorControl è obsoleto e sostituito da impostaJointMorcontrol2 API. (O ancora meglio usare setJointMotorControlArray). Possiamo controllare un robot impostando una modalità di controllo desiderata per uno o più motori articolari. Durante il passaggioSimulation, il motore fisico simula i motori per raggiungere il valore di destinazione indicato che può essere raggiunto all'interno delle forze massime del motore e altri vincoli. Ogni giunto revoluto e articolazione prismatica è motorizzato per impostazione predefinita. Ci sono 3 diverse modalità di controllo del motore: comando della posizione, controllo velocità e regolazione coppia. È possibile disattivare efficacemente il motore utilizzando una forza di 0. È necessario disabilitare il motore per utilizzare il controllo di coppia diretta. Per esempio:
maxForce = 0 mode= p.VELOCITY CONTROL p.setJointMotorControl2(objUid, JointIndex, controlMode=mode, force=maxForce) Se si desidera che una ruota mantieni costante velocità, con una forza massima è possibile utilizzare:
maxForce = 500 p.setJointMotorControl2(bodyUniqueId=objUid,
JointIndex=0, controlMode=p.VELOCITY CONTROL, targetVelocity = targetVel, force = maxForce)

Gli argomenti di input per impostareJointMotorControl2 sono:
corpo richiestoUniqueId int body unico id come restituito da loadURDF ecc.
indice di collegamento obbligatorioIndex-int nell'intervallo [0.getNumJoints(bodyUniqueId) (nota che l'indice del link == indice articolare)
controllo richiestoMode int POSITION CONTROL (che è infatti CONTROL MODE POSIZIONE VELOCITY PD), VELOCITÀ CONTROLLO, TORQUE CONTRAOL
target opzionaleFilo di posizionamento in POSITION CONTROL l'obiettivoValore è la posizione bersaglio del giunto
opzionale targetVelocity galleggiare in VELOCITY CONTROL e POSITION CONTROOL il bersaglioLa velocità desiderata del giunto, vedi nota di implementazione qui sotto. Nota che laVelocità di destinazione non è la velocità massima del giunto. In POSITION CONTROL/CONTROLO MODE POSIZIONE VELOC ITY PD, la velocità finale del bersaglio viene calcolata utilizzando: kp*(erp* (desiredPosition-currentPosizione)/dt)+correnteVelocity+kd *(m desieredVelocità - correnteVelocia).
carburante opzionale in POSITION CONTROL e VELOCITY CONTROOL questa è la forza motore massima utilizzata per raggiungere il valore di destinazione. In TORQUE CONTROL questa è la forza/torque da applicare ogni fase di simulazione.
posizione opzionaleGain galleggiante Vedi nota di implementazione qui sotto
opzionale velocitàGain galleggiante Vedi nota di implementazione qui sotto
opzionale maxVelocity galleggiante in POSITION CONTROL questo limita la velocità ad un massimo
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
errore di costrizione dei componenti di implementazione del metodo da minimizzare
POSITION CONTROL vincolo velocità e costrizione di posizione
errore = posizione gain*(desired position-a ctual position)+velocity gaine* (de sired velocity-actual velocità)
VELOCITY CONTROL vincolo di velocità pura errore di costrizione = desiderato velocità - attualità
TORQUE CONTROL forza esterna

Generalmente è meglio iniziare con VELOCITY CONTROL o POSITION CONTROOL. È molto più difficile fare TORQUE CONTROL (controllo della forza) poiché simulare le forze corrette si basa su parametri di file URDF/SDF e l'identificazione del sistema (masse corrette, inerzia, centro di posizione di massa, attrito articolare ecc.). setJointMotorControlArray
Invece di fare chiamate individuali per ogni giunto, è possibile passare array per tutti gli input per ridurre la chiamata overhead drammaticamente. setJointMotorControlArray prende gli stessi parametri di insiemeJointMorcontrol2, tranne la sostituzione degli interi con liste dei interi. Gli argomenti di input per impostareJointMotorControlArray sono:
corpo richiestoUniqueId int body unico id come restituito da loadURDF ecc.
elenco degli indici dell'indice di int nell'intervallo [0.getNumJoints(bodyUniqueId) (nota l'indice del collegamento == indice articolare)
controllo richiestoModello int POSITION CONTROL, VELOCITY CONTROOL, TORQUE CONTRAOL
opzionale targetPositions list of float in POSITION CONTROL l'obiettivoValore è la posizione di destinazione dell'articolazione
opzionale targetVelocities list of float in VELOCITY CONTROL e POSITION CONTROOL il bersaglioValore è la velocità di destinazione del giunto, vedere nota di implementazione qui sotto.
elenco forze facoltative di galleggiamento in POSITION CONTROL e VELOCITY CONTROOL questa è la forza motore massima utilizzata per raggiungere il valore target. In TORQUE CONTROL questa è la forza/torque da applicare ogni fase di simulazione.
posizione opzionaleGains elenco galleggiante Vedi nota di implementazione qui sotto
elenco dei canali di galleggiamento Vedere nota di implementazione qui sotto
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
Vedere bullet3/esamples/pybullet/tensorflow/humanoid running.py per un esempio di utilizzo setJointMotorControlArray.
Possiamo interrogare diverse variabili di stato dal giunto utilizzando getJointState, come la posizione comune, velocità, forze di reazione articolari e coppia motore congiunto.

corpo richiestoUniqueId int body unico id come restituito da loadURDF ecc
indice di collegamento del punto Index richiesto nell'intervallo [0.getNumJoints(bodyUniqueId)]
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
giuntoFilo di posizionamento Il valore della posizione del giunto.
galleggiante diVelocità del giunto Il valore della velocità di questo congiunto.
Lista di 6 carri armati Questi sono le forze di reazione articolare, se un sensore coppia è abilitato per questo giunto si tratta [Fx, Fy, Fz, Mx, My, Mz]. Senza sensore di coppia, è [0,0, 0,0.0,-0,0].
applicatoJointMotorTorque galleggiante Questa è la coppia del motore applicata durante l'ultimo passaggioSimulation. Si noti che questo vale solo in VELOCITY CONTROL e POSITION CONTROOL. Se si utilizza TORQUE CONTROL allora la coppia di motore congiunto applicata è esattamente ciò che fornisce, quindi non c'è bisogno di segnalarlo separatamente.
getJointStates è la versione di array di ottenereJointStato. Invece di passare in un unico giuntoIndex, si passa in una lista di articolazioni Indici. resetJointState
Puoi resettare lo stato dell'articolazione. È meglio solo farlo all'inizio, mentre non si esegue la simulazione: resetJointState sovrascrive tutta la simulazione fisica. Si noti che supportiamo solo le giunzioni motorizzate 1-DOF al momento, i giunti scorrevoli o revoluti.
corpo richiestoUniqueId int body unico id come restituito da loadURDF ecc
indice comune Index-int giunto nella gamma [0.getNumJoints(bodyUniqueId)]
target richiestoValuta galleggiare la posizione comune (angolo in radianti o posizione)
bersaglio opzionaleVelocità galleggiare la velocità articolare (velocità angolare o lineare)
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
È possibile attivare o disabilitare un sensore di forza/torque congiunto in ogni giunto. Una volta abilitato, se si esegue un passoSimulazione, il 'getJointState' riferirà le forze di reazione comuni nei gradi fissi del
ottenere Parametri di inputJointState · getEmissione congiunta

libertà: un giunto fisso misura tutte le forze/torque comuni 6DOF. Un sensore di forza/torque con giunto revoluto / cerniera misura le forze di reazione 5DOF lungo tutto l'asse tranne l'assio della cerniera. La forza applicata da un motore congiunto è disponibile nella JointMotorTorque applicato di ottenereJointState. Gli argomenti di input per abilitareJointForceTorqueSensor sono:
corpo richiestoUniqueId int body unico id come restituito da loadURDF ecc
indice comune Index-int giunto nella gamma [0.getNumJoints(bodyUniqueId)]
abilitare il sensore 1/True opzionale per attivare, 0 / Filse per disabilitare la forza/sensore di coppia
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
Puoi anche interrogare la posizione e l'orientamento del mondo cartesiano per il centro di massa di ogni link utilizzando getLinkState. Si riferisce anche al telaio locale inerziale del centro di massa alla struttura URDF link, per rendere più facile calcolare la grafica / cornice di visualizzazione. ottenere parametri di input LinkState
corpo richiestoUniqueId int body unico id come restituito da loadURDF ecc
link Indice collegamento index
Se impostato su 1, la velocità del mondo cartesiano sarà calcolata e restituita.
computeForwardKinematics int se impostato a 1 (o Vero), la posizione/orientamento del mondo cartesiano sarà ricomputata utilizzando cinematica avanzata.
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
linkWorldPosition vec3, elenco di 3 carri Cartesian posizione del centro della massa
linkWorldOrientamento vec4, elenco di 4 carri Cartesian orientamento del centro della massa, in quaternion [x,y,z,w]
localeInertialFramePosition vec3, elenco di 3 galleggianti posizione locale offset del telaio inerziale (centro della massa) espresso nel frame URDF
localeInertialFrameOrientamento vec4, elenco di 4 galleggianti orientamento locale (quaternione [x,y,z,w]) compensato del telaio inerziale espresso nel frame URDF link.
ottenere i valori di ritorno LinkState

worldLinkFramePosition vec3, elenco di 3 carri posizionati a livello mondiale del telaio URDF
worldLinkFrameOrientamento vec4, elenco 4 carri di orientamento mondiale del telaio URDF link
worldLinkLinearVelocity vec3, elenco di 3 floats Cartesian velocità del mondo. Solo restituito se computeLinkVelocity non-zero.
worldLinkAngularVelocity vec3, elenco di 3 floats Cartesian velocità del mondo. Solo restituito se computeLinkVelocity non-zero.
Il rapporto tra il telaio di collegamento URDF e il centro della struttura in massa (entrambi nello spazio mondiale) è: urdfLinkFrame = comLinkFrama * localInertialFrame.inverse(). Per ulteriori informazioni sul link e la cornice inerziale, vedere il tutorial ROS URDF .

Esempio di script (potrebbe essere out-of-date, controllare effettivo Bullet / examples/pybullet/examples cartella.)
esempi/pibullet/tensorflow/humanoid runnin g.py
caricare un umanoide e utilizzare una rete neurale addestrata per controllare la corsa utilizzando TensorFlow, formato da OpenAI
esempi/pibullet/gym/pybullet envs/bullet / min itaur.py e minitaur gym enV.py
Ambiente Minitaur per OpenAI GYM e TensorFlow Puoi anche usare pitone -m pybullet envs.examples.minitaur gym envemple dopo aver fatto pip install pybullo per vedere il Minitauro in azione.
esempi/pibullet/examples/quadruped.py carica un quadruplicato dal file URDF, fai una simulazione, controlla i motori per un semplice guanto basato sulle onde sine.Vuoi anche registrare lo stato da archiviare utilizzando p.startStateLogging. Vedi video.
Esempi/quadruped playback.py Creare un quadruplicato (Minitaur), leggere file di registro e impostare posizioni come obiettivi di controllo del motore.
esempi/pybullet/examples/testrender.py carica un file URDF e rende l'immagine, ottieni i pixel (RGB, profondità, maschera di segmentazione) e visualizza l' immagine usando MatPlotLib.
esempi/pybullet/examples/testrender np.py Simile a testrender.py, ma velocizza il trasferimento dei pixel utilizzando gli array NumPy. Include anche semplici benchmark/timing.

esempi/pybullet/examples/saveWorld.py Salvare lo stato (posizione, orientamento) degli oggetti in uno script Python pilografico. Questo è principalmente utile per impostare una scena in VR e salvare lo stato iniziale. Non tutti gli stati sono serializzati.
esempi/pibullet/examples/inverse kinematic s.py
Mostra come utilizzare il comando Calcola InverseKinematics, creando un orologio Kuka ARM
esempi/pybullet/examples/rollPitchYaw.py Mostra come utilizzare widget di slider GUI
esempi/pibullet/examples/constraint.py Programmaticamente creare un vincolo tra i collegamenti.
esempi/pybullet/examples/vrhand.py Controllare una mano usando un guanto VR, tracciato da un controller VR. Vedi video.
Si ottiene l'accesso alla velocità lineare e angolare della base di un corpo utilizzando getBaseVelocity. I parametri di input sono:
corpo richiestoUniqueId int body unico id, come restituito dai metodi di carico*.
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
Questo restituisce un elenco di due valori vettoriali (3 galleggianti in una lista) che rappresentano la velocità lineare [x,y,z] e velocità angolare [wx,wy,wz] nelle coordinate spaziali del mondo cartesiano. È possibile ripristinare la velocità lineare e/o angolare della base di un corpo utilizzando resetBaseVelocity. I parametri di input sono:
oggetto richiestoUniqueId int corpo unico id, come restituito dai metodi di carico*.
opzionale lineareVelocity vec3, elenco di 3 carri velocità lineare [x,y,z] in coordinate del mondo cartesiano.
opzionale angularVelocity vec3, elenco di 3 galleggianti velocità angolare [wx,wy,wz] in coordinate del mondo cartesiano.
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
È possibile applicare una forza o coppia a un corpo utilizzando applichiExternalForce e applica laTorque esterna. Nota che questo metodo funzionerà solo quando si procede esplicitamente alla simulazione utilizzando stepSimulation, in altre parole: setRealTimeSimposition(0). Dopo ogni fase di simulazione, le forze esterne sono sgomberate a zero. Se si utilizza 'setRealTimeSimulation(1), applicareExternalForce/Torque avrà un comportamento non definito (o 0, 1 o più applicazioni di forza / coppia).

I parametri di input sono:
oggetto richiestoUniqueId int object unico id come restituito da metodi di carico.
linkIndex int link index o -1 per la base.
forza necessariaObj vec3, elenco di 3 carri armati forza / vettore coppia da applicare [x,y,z]. Vedere bandiere per il sistema di coordinate.
posObj vec3, elenco di 3 galleggianti posizione sul link in cui la forza viene applicata. Solo per applicareExternalForce. Vedere bandiere per il sistema di coordinate.
Specificare il sistema di coordinate della forza/posizione: WORLD FRAME per le coordinate mondiali cartesian o LINK FRIO per le coordinazioni dei link locali.
getNumBodies restituirà il numero totale di corpi nel server fisico. Se hai usato 'getNumBodies' puoi query il corpo unico ids usando 'getBodyUniqueId'. Nota che tutte le API già restituiscono ids corpo unico, in modo da tipicamente non è mai necessario utilizzare getBodyUniqueId se si tiene traccia di loro. getBodyInfo restituirà il nome di base, come estratto dal URDF, SDF, MJCF o altro
- Il file. removeBody rimuoverà un corpo dal suo unico id del corpo (da loadURDF, loadSDF ecc).
URDF, SDF e MJCF specificano corpi articolati come strutture albero senza loop. Il 'createConstraint' consente di collegare specifici link dei corpi per chiudere quei loop. Vedere Bullet/examples/pybullet/exmples/quadruped.py come collegare le gambe di un anello chiuso a 5 bar quadruplicato. Inoltre, è possibile creare vincoli arbitrari tra gli oggetti e fra un oggetto ed una cornice specifica del mondo. Vedere Bullet/examples/pybullet/exmples/constraint.py per un esempio. Può anche essere utilizzato per controllare il movimento degli oggetti fisici, guidato da cornici animate, come un controller VR. È meglio usare vincoli, invece di impostare la posizione o velocità direttamente a tale scopo, poiché tali costrizioni sono risolte insieme ad altri vincoli dinamici. createConstraint ha i seguenti parametri di input:
fisica opzionaleClientId int

genitore necessarioBodyUniqueId int corpo padre unico id
indice di collegamento genitoriale (o -1 per la base)
bambino obbligatorio Corpo unico nel corpo del bambino id, o -1 per nessun corpo (specificare un telaio non dinamico in coordinate mondiali)
bambino richiestoLinkIndex int baby link index, o -1 per la base
giunto richiestoAxis vec3, elenco di 3 assi articolari galleggianti, in cornice collegamento bambino
genitore necessarioFramePosition vec3, elenco di 3 galleggianti posizione del telaio articolare rispetto al centro padre della struttura in massa.
bambino richiestoFramePosition vec3, elenco di 3 galleggianti posizione del telaio articolare rispetto ad un determinato centro bambini della struttura di massa (o origine mondiale se non specificato alcun figlio)
opzionale genitoreFrameOrientamento vec4, elenco di 4 galleggianti l'orientamento della struttura articolare rispetto al centro madre del telaio coordinate in massa
opzionale bambinoFrameOrientamento vec4, elenco di 4 carri l'orientamento della struttura articolare rispetto al centro del bambino di coordinate in massa cornice (o telaio di origine mondiale se non specificato alcun figlio)
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
creareConstraint restituirà un id unico interi, che può essere utilizzato per cambiare o rimuovere il vincolo. Vedi esempi/pibullet/examples/mimicJointConstraint.py per un esempio di JOINT GEAR ed esempi/pybullet / examples / Minitaur.py di una JONT POINT2POINT e esempi/Pybullet-examples/constraint .py for JOANT FIXED. cambiamentoConstraint
changeConstraint consente di modificare i parametri di un vincolo esistente. I parametri di input sono:
utente richiestoConstraintUniqueId int unico id restituito da creareConstrato
opzionale giuntoChildPivot vec3, elenco di 3 galleggianti aggiornato bambino pivot, vedere 'createConstraint'
opzionale giuntoFrameOrientamento vec4, elenco di 4 carri galleggianti aggiornato cornice bambino orientamento come quaternione
opzionale maxForce galleggia la forza massima che il vincolo può applicare

opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
Vedi anche Bullet/examples/pybullet/exmples/constraint.py removeConstraint rimuoverà un vincolo, dato dal suo id unico. I suoi parametri di ingresso sono:
utente richiestoConstraintUniqueId int unico id come restituito da creareConstrato
fisica opzionaleClientId int unico id come restituito da 'connect'
È possibile query per il numero totale di vincoli, creati utilizzando 'createConstraint'. Il parametro opzionale è il fisico int ClientId. ottenereConstraintUniqueId
getConstraintUniqueId prenderà un indice seriale nell'intervallo 0..getNumConstrains, e segnala il vincolo unico id. Nota che il vincolo ids unico potrebbe non essere contiguo, dal momento che si possono rimuovere vincoli. L'ingresso è l'indice seriale interinale e facoltativamente un fisicoClientId.
È possibile query il vincolo info dare un id unico limite. I parametri di input sono
vincolo richiestoUniqueId int unico id come restituito da creareConstraint
fisica opzionaleClientId int unico id come restituito da 'connect'
L'elenco di output è:
genitoreBodyUniqueId int Vedere creareConstraint
genitoreJointIndex int Vedere creareConstraente
bambinoBodyUniqueId int Vedere creareConstraint
bambinoLinkIndex int Vedere creareConstraint
vincoloTipo int Vedere creareConstraint

giuntoAxis vec3, elenco di 3 galleggianti Vedere creareConstraint
JointPivotInParent vec3, elenco di 3 carri armati Vedere creareConstraint
JointPivotInChild vec3, elenco di 3 galleggianti Vedere creareConstraint
giuntoFrameOrientamentoParent vec4, elenco di 4 carri Vedi creareConstraint
giuntoFrameOrientamentoVec4, elenco di 4 carri armati Vedere creareConstraint
maxAppliedForce galleggiante Vedere creareConstraint
Dare un id unico vincolo, è possibile query per le forze di costrizione applicate nel passo più recente simulazione. L'ingresso è un id unico vincolo e l'uscita è un vettore di forze costruttive, la sua dimensione è il grado di libertà che sono colpiti dal vincolante (un vincolare fisso colpisce 6 DoF per esempio).
È possibile ottenere informazioni sulla massa, centro di massa, attrito e altre proprietà della base e collegamenti. I parametri di input per ottenereDynamicsInfo sono:
corpo richiestoUniqueId int oggetto unico id, come restituito da loadURDF ecc.
linkIndex int link (congiunto) o -1 per la base.
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
Le informazioni di ritorno sono limitate, esporremo ulteriori informazioni quando ne avremo bisogno:
massa doppia in kg
coefficiente di attrito doppio
vec3, elenco di 3 carri inerzia locale diagonale. Si noti che i collegamenti e la base sono centrati intorno al centro di massa ed allineati con gli assi principali dell'inerzia.
posizione del telaio inerziale locale pos vec3 nelle coordinate locali della struttura articolare
orientamento locale inerziale orn vec4 del telaio inerziale nelle coordinate locali della struttura articolare
restituzione doppio coefficiente di sostituzione
inerzia locale diagonale

doppio coefficiente di attrito rotante ortogonale per contattare normale
frizione filatura doppio coefficiente di attrito intorno al contatto normale
contatto smorzamento doppio -1 se non disponibile. smorzamento dei vincoli di contatto.
contatto rigidità doppia -1 se non disponibile. rigidità dei vincoli di contatto.
È possibile modificare le proprietà come i coefficienti di massa, attrito e restituzione utilizzando changeDynamics. I parametri di input sono:
corpo richiestoUniqueId int oggetto unico id, come restituito da loadURDF ecc.
linkIndex int link index o -1 per la base
opzionale massa doppia cambiare la massa del collegamento (o base per linkIndex -1)
opzionale lateraleFrizione doppia frizione laterale (lineare)
filatura opzionaleFrizione doppio torsione attrito intorno al contatto normale
opzionale rollingFriction doppio torsione attrito ortogonale per contattare normale
rimpatrio opzionale doppio bouncyness di contatto. Tienilo un po' meno di 1.
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
smorzamento lineare opzionale doppio linearDamping del link (0.04 per impostazione predefinita)
opzionale angolareDamping doppio smorzamento angolare del link (0.04 per impostazione predefinita)
contatto opzionaleStiffness doppia rigidità dei vincoli di contatto, utilizzato insieme a contactDamping.
contatto opzionaleDamping doppio smorzamento dei vincoli di contatto per questo corpo / collegamento. Usato insieme a contattoStiffness. Questo sovrascrive il valore se è stato specificato nel file URDF nella sezione contatti.
frizione opzionaleAnchor int abilita o disattiva un ancoraggio di attrito: correzione dell'attrito posizionale (disattivata per impostazione predefinita, a meno che non impostata nella sezione contatti URDF)
opzionale localeInertiaDiagnoal vec3 elementi diagonali del tenore di inerzia. Si noti che la base e i collegamenti sono centrati intorno al centro di massa ed allineati con gli assi principali dell'inerzia in modo da non ci sono elementi off-diagonali nell'inertia

Tensore.
È possibile impostare il tempo del motore di fisica che viene utilizzato quando si chiama 'stepSimulation'. È meglio chiamare questo metodo solo all'inizio di una simulazione. Non cambiare questo passo di tempo regolarmente. setTimeStep può essere raggiunto anche utilizzando il nuovo setPhysicsEngineParameter API. I parametri di input sono:
tempo necessarioCarburante di passo Ogni volta che si chiama 'stepSimulation' il timeStep procederà con 'timeStep'.
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
È possibile impostare i parametri del motore di fisica utilizzando il setPhysicsEngineParameter API. I seguenti parametri di input sono esposti:
opzionale fissoTimeStep galleggiante fisica motore passo in frazione di secondi, ogni volta che si chiama 'stepSimulation'. Stesso come 'setTimeStep'
opzionale numSolverIterations int Scegliere il numero di limitazioni risolte iterazioni.
funzione avanzata, solo quando si utilizzano le coordinate maximali: dividere la risoluzione dei vincoli di posizione e la risoluzione delle limitazioni della velocità in due fasi per evitare enormi forze di recupero di penetrazione.
opzionale splitImpulsePenetrationThreshold float Correlato a 'useSplitImpulsa': se la penetrazione per un particolare vincolo di contatto è inferiore a questa soglia specificata, nessun impulso diviso accadrà per quel contatto.
opzionale numSubSteps int Sottodividere la simulazione fisica passo più avanti di 'numSottositi'. Questo scambierà le prestazioni sulla precisione.
Opzionale collisioneFilterMode int Usa 0 per il filtro di collisione predefinito: (gruppo A&maskB) AND (groupB&maschera). Usare 1 per passare al filtro di collisione OR: (gruppo

contatto opzionaleBreakingThreshold float Punti di contatto con la distanza superiore a questa soglia non sono elaborati dal risolutore LCP. Inoltre, AABBs sono estesi da questo numero. Predefiniti a 0,02 nel proiettile 2.x.
opzionale maxNumCmdPer1ms int Experimental: aggiungere 1 ms di sonno se il numero dei comandi eseguiti supera questa soglia.
opzionale abilitareFileCaching int Set a 0 per disabilitare la cache dei file, come .obj carico del file ondulato
se la velocità relativa è al di sotto della soglia, la restituzione sarà zero.
parametro di riduzione degli errori del galleggiante dell'erp opzionale (non-contatto, non frizione)
parametro di riduzione degli errori del contatto con il galleggiante
parametro opzionale di riduzione dell'errore del galleggiante (quando sono abilitate le ancore d'attrito posizionali)
opzionale abilitareConeFriction int Set a 0 per disabilitare l'attrito implicito del cono e utilizzare il ravvicinamento della piramide (coni è predefinito)
opzionale deterministicaOverlappingPairs int Set to 1 per abilitare e 0 disabilitare la selezione di coppie sovrapposte (impostazione della compatibilità retromarcia).
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
setDefaultContactERP è un'API per impostare l'impostazione dei parametri di contatto predefinito. Verrà introdotto nel setPhysicsEngineParameter API. getPhysicsEngineParameters
È possibile query alcuni parametri del motore di fisica corrente utilizzando il comando getPhysicsEngineParameters, usando l'opzione 'physicSClientId'. Questo ritornerà chiamato tuples di parametri.
resetSimulation rimuoverà tutti gli oggetti dal mondo e reimposta il mondo alle condizioni iniziali. Ci vuole un parametro opzionale: il client fisico Id (nel caso in cui si creassero più connessioni di server fisici).
A&maskB) OR (gruppo B&maschera)

Logging di stato consente di registrare lo stato della simulazione, come ad esempio lo stato di uno o più oggetti dopo ogni fase di simulazione (dopo ciascuna chiamata a stepSimulation o automaticamente dopo ogni passo di simulazione quando impostatoRealTimeSimposition è abilitato). Questo consente di registrare traiettorie di oggetti. C'è anche la possibilità di registrare lo stato comune dei corpi, come posizione e orientamento base, posizioni comuni (angoli) e forze motorie articolari. Tutti i file di registro generati utilizzando startStateLogging possono essere letti usando script C++ o Python. Vedere quadruped playback.py e kuka with cube play back.py per gli script Python che leggono i file di registro. È possibile utilizzare bullet3/examples/Utils/RobotLoggingUtil.cpp/h per leggere i file di registro in C++. Per la registrazione video MP4 è possibile utilizzare l'opzione di registrazione STATE LOGGING VIDEO MP4 . Abbiamo intenzione di implementare vari altri tipi di registrazione, tra cui il collegamento dello stato dei controller VR. Come caso speciale, abbiamo implementato il logging del robot Minitaur. Il file di registro della simulazione PyBullet è identico al vero e proprio file di log quadruped Minitaur. Vedere Bullet/examples/pybullet/exmples/logMinitaur.py per esempio. Importante: vari logger includono il proprio timestamp interno che inizia a zero quando creato. Questo significa che devi iniziare tutti i logger allo stesso tempo, per essere in sincronia. È necessario assicurarsi che la simulazione non sia in esecuzione in modalità in tempo reale, mentre si avviano i logger: utilizzare pibullet.setRealTimeSimulation(0) prima di creare i registratori.
richiesto di registrazioneType int Ci sono vari tipi di logging implementato. STATE LOGGING MINITAUR: Questo richiederà di caricare il quadruped/quadruped.urdf e l'oggetto unico id dal quadruplicato. Esegue il log del timestamp, IMU roll/pitch/yaw, 8 posizioni motori a gamba (q0-q7), 8 coppie di coppia motore della gamba (u0-u7), la velocità in avanti del torso e modalità (non utilizzata nella simulazione). STATE LOGGING GENERIC ROBOT: Questo registra un registro dei dati di tutti gli oggetti o quelli selezionati (se è fornito l'oggettoUniqueIds). STATE LOGGING VIDEO MP4: questo aprirà un file MP4, e inizierà a trasmettere i pixel di visualizzazione OpenGL 3D al file utilizzando una tubazione ffmpeg. Richiederà ffmpeg installato. È anche possibile utilizzare avconv (default su Ubuntu), basta creare un link simbolico in modo che i punti ffmpeg di avConv. Su Windows, ffmpeg ha alcuni problemi che causano lacrima / artefatti di colore in alcuni casi. STATE LOGGING CONTACT POINTS STATE LOG VR CONTROLLERS.

STATE LOGGING PROFILE TIMINGS Questo scaricherà un file di tempistica in formato JSON che può essere aperto utilizzando Google Chrome su://tracing LOAD.
file richiesto Nome di file string (percorso assoluto o relativo) per memorizzare i dati del file log.
opzionale oggettoUniqueIds elenco di int Se lasciato vuoto, il logger può registrare ogni oggetto, altrimenti il logging semplicemente registra gli oggetti nell'elenco Oggetti UniqueIdi.
maxLogDof int Numero massimo di gradi comuni di libertà di log (esclusi i dof base). Questo vale per STATE LOGGING GENERIC ROBOT DATA. Il valore predefinito è 12. Se un robot supera il numero di dof, non verrà registrato.
corpo opzionaleUniqueIdA int si applica a STATE LOGGING CONTACT POINTS. Se fornito,solo i punti di contatto del registro che coinvolgono il corpoUniqueIdA.
corpo opzionaleUniqueIdB int si applica a STATE LOGGING CONTACT POINTS. Se fornito,solo i punti di contatto del registro che coinvolgono il corpoUniqueIdB.
linkIndexA int si applica a STATE LOGGING CONTACT POINTS. Se fornito,solo i punti di contatto del registro che coinvolgono linkIndexA per il corpoUniqueIdA.
linkIndexB int si applica a STATE LOGGING CONTACT POINTS. Se fornito,solo i punti di contatto del registro che coinvolgono linkIndexB per il corpoUniqueIdA.
dispositivo opzionaleTypeFilter int deviceTyPEFilter consente di selezionare quali dispositivi VR registrare: VR DEVICE CONTROLLER, VR DIVIZIO HMD ,VR DEVECIO GENERIC TRACKER o qualsiasi combinazione di essi. Riguarda STATE LOGGING VR CONTROLLERS. I valori di default sono VR DEVICE CONTROLLER.
log opzionaleFlags int (in arrivo PyBullet 1.3.1). STATE LOG JOINT TORQUES, per registrare le coppie di giunti a causa dei motori articolari.
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
Il comando restituirà un int non negativo per il logUniqueId, che può essere utilizzato con stopStateLogging. Todo: documentare i dati che sono registrati per ogni tipo di registrazione. Per ora, utilizzare le utility di lettura del registro per scoprire o controllare il codice sorgente C++ dello script logging o Python dumpLog.py. stopStateLogging
Puoi fermare un logger usando il suo loggamentoUniqueId. inviaProfileTiming
opzionale

PyBullet e Bullet hanno strumentato molte funzioni in modo da poter vedere dove il tempo è trascorso. È possibile scaricare i tempi di un profilo in un file, che può essere visualizzato con Google Chrome nella finestra su://tracing utilizzando la funzione LOAD. Nella GUI, è possibile premere 'p' per avviare/smettere la discarica del profilo. In alcuni casi si può desiderare di strumentalizzare i tempi del vostro codice client. È possibile inviare i tempi di profilo utilizzando PyBullet. Ecco un esempio di output:
PyBullet ha sia un visualizzatore OpenGL GPU che una CPU di compilazione basata su TinyRenderer. Questo rende molto facile da rendere le immagini da una posizione arbitraria della fotocamera. La fotocamera sintetica è specificata da due 4 per 4 matrici: la matrice di vista e la matrix della proiezione. Poiché questi non sono molto intuitivi, ci sono alcuni metodi di aiuto per calcolare la matrice della vista e proiezione da parametri comprensibili.
I parametri di input computeViewMatrix sono
fotocamera richiestaEyePosition vec3, elenco di 3 galleggianti posizione dell'occhio in coordinate del mondo cartesiano
fotocamera richiestaTargetPosition vec3, elenco di 3 galleggianti posizione del punto target (focus), in coordinate mondo cartesiano
richiesto macchina fotograficaUpVector vec3, elenco di 3 galleggianti su vettori della fotocamera, in coordinate del mondo cartesiano
fisica opzionaleClientId int non utilizzato, aggiunto per la consistenza API
L'uscita è la matrice di visualizzazione 4x4, memorizzata come un elenco di 16 galleggianti. computeViewMatrixDaYawPitchRoll
I parametri di input sono
fotocamera richiestaTargetPosition elenco di 3 galleggianti puntare punto focale in coordinate del mondo cartesiano
distanza di galleggiamento necessaria dalla vista al punto focale
richiesto yaw galleggiante angolo di paglia in gradi sinistra / destra intorno all'asse superiore.
campo di galleggiamento richiesto in gradi su / giù.

rotolo di galleggiamento richiesto in gradi intorno vettoriale avanti
upAxisIndex int sia 1 per Y o 2 per asse Z su.
fisica opzionaleClientId int non utilizzato, aggiunto per la consistenza API.
L'uscita è la matrice di visualizzazione 4x4, memorizzata come un elenco di 16 galleggianti.
I parametri di input sono
necessario sinistra galleggiante schermata di sinistra (canvas) coordinate
necessario destra galleggiare la schermata giusta (canvas) coordinate
necessario fondo galleggiante inferiore (canvas) coordinate
necessario superiore galleggiante (canvas) coordinate
richiesto vicino al galleggiante a distanza dell'aereo
richiesto lontano galleggiante distanza aereo
fisica opzionaleClientId int non utilizzato, aggiunto per la consistenza API.
L'uscita è la matrice di proiezione 4x4, memorizzata come un elenco di 16 galleggianti. ComputeProjectionMatrixFOV
Questo comando restituirà anche una matrice di proiezione 4x4, utilizzando diversi parametri. È possibile controllare la documentazione OpenGL per il significato dei parametri. I parametri di input sono:
campo di visualizzazione fov float richiesto
aspetto necessario galleggiare rapporto di aspetto
richiesto vicinoVal galleggiante a distanza dell'aereo
richiesto lontanoVal galleggiante distanza aereo lontana
fisica opzionaleClientId int non utilizzato, aggiunto per la consistenza API.
L'API getCameraImage restituirà un immagine RGB, una profondità buffer e un buffer di maschera segmentazione con ids unici del corpo degli oggetti visibili per ogni pixel. Si noti che PyBullet può essere compilato utilizzando l'opzione numpy: usando il nompy migliorerà le prestazioni di copia della fotocamera

pixel da C a Python. Nota: la vecchia API renderImage è obsoleta e sostituita da getCameraImaging. ottenereCameraImage parametri di input:
larghezza richiesta int risoluzione orizzontale dell'immagine in pixel
risoluzione verticale dell'immagine in pixel
matrice di visualizzazione 4x4, vedere computeViewMatrix 16 floats
proiezione opzionaleMatrix 16 galleggianti matrice di proiezione 4x4, vedi computeProjection*
opzionale luceDirezione vec3, elenco 3 carri leggeri direzione
luce opzionaleVac3, elenco 3 galleggianti colore di luce direzionale in [RED, GREEN,BLUE] nella gamma 0..1
opzionale lightDistance distanza galleggiante della luce lungo la luce normalizzataDirezione
ombretto opzionale int 1 per ombre, 0 senza ombra
luce opzionaleAmbientCoeff galleggiante leggero coefficiente ambientale
luce opzionaleDiffuseCoeff galleggiante leggero coefficiente diffuso
luce opzionaleSpecularCoeff galleggiante leggero coefficiente speculare
rendering opzionale int ER BULLET HARDWARE OPENGL o ER TINY RENDERER. Nota che la modalità DIRECT non ha OpenGL, quindi richiede ER TINY RENDER.
flag opzionali int ER SEGMENTATION MASK OBJECT AND L INKINDEX, Vedere di seguito nella descrizione della segmentazioneMaskBuffer e codice esempio.
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
getCameraImage restituisce un elenco di parametri:
larghezza int risoluzione immagine in pixel (orizzontale)
risoluzione dell'immagine di altezza int in pixel (verticale)
rgbPixels elenco di [char RED,char GREEN,char BLUE, lista dei colori pixel in R,G,B,A formato,

char ALPHA] [0.width*height] nella gamma [0,255] per ogni colore
elenco di profonditàPixels del galleggiante [0.width*height] buffer della profonditÃ
segmentazioneMaskBuffer elenco di int [0.width*height] Disponibile solo quando si utilizza ER TINY RENDERER. Per ogni pixel l'oggetto visibile unico id. Se viene utilizzato ER SEGMENTATION MASK OBJ ECT AND LINKINDEX, la segmentazioneMaskBuffer combina l'oggetto unico id e link index come segue: valore = oggettoUniqueId + (linkIndex+1) Vedi esempio . Così per un corpo libero galleggiante senza articolazioni / collegamenti, la maschera di segmentazione è uguale al suo id unico del corpo, dal momento che il relativo indice dei link è -1.
È possibile accedere alle informazioni di forma visiva utilizzando getVisualShapeData. Si potrebbe utilizzare questo per collegare il proprio metodo di rendering con la simulazione PyBullet, e sincronizzare il mondo si trasforma manualmente dopo ogni fase di simulazione. I parametri di input sono:
oggetto richiestoUniqueId int object unico id, come restituito da un metodo di carico.
fisica opzionaleClientId int client di fisica id come restituito da 'connect'
L'output è un elenco di dati della forma visiva, ogni forma visuale si trova nel seguente formato:
oggettoUniqueId int object unico id, stesso dell'ingresso
linkIndex int link index o -1 per la base
tipo di geometria visiva (TBD)
dimensioni vec3, elenco 3 dimensioni dei carri (dimensione, scala locale) della geometria
meshAssetFileName string, elenco di chars percorso per la maglia triangolo, se c'è. Tipicamente relativo alla posizione del file URDF, SDF o MJCF, ma potrebbe essere assoluto.

localVisualFrame position vec3, elenco 3 carri posizionati sul telaio visivo locale, relativo al collegamento/cornice congiunto
orientamento localeVisualFrame vec4, elenco 4 carri orientativi della cornice visiva locale rispetto al collegamento/cornice comune
rgbaColor vec4, elenco 4 galleggianti colore URDF (se specificato) in rosso/verde/blu/alfa
La simulazione fisica utilizza il centro di massa come riferimento per il mondo cartesiano trasforma, in getBasePositionAndOrientation e in getLinkState. Se si implementa il proprio rendering, è necessario trasformare la trasformazione visiva locale nello spazio mondiale, facendo uso del centro di massa trasformano e della (inversa) localInertialFrame. È possibile accedere alla localInertialFrame utilizzando l'API getLinkState.
È possibile utilizzare changeVisualShape per cambiare la texture di una forma. Questa texture influenzerà solo il software renderr (vedi getCameraImage), non la finestra di visualizzazione OpenGL (ancora).
oggetto richiestoUniqueId int object unico id, come restituito dal metodo di carico.
indice di collegamento
opzionale ShapeIndex int Sperimentale per uso interno, consigliato ignorare formIndx o lasciare -1. L'intenzione era quella di farvi scegliere un indice forma specifico per modificare, poiché URDF (e SDF ecc) può avere più di 1 forma visiva per collegamento. Questa formaIndex corrisponde all'ordine della lista restituito da getVisualShapeData.
texture opzionaleUniqueId int texture unico id, come restituito dal metodo 'loadTexture'
opzionale rgbaColor vec4, elenco di 4 galleggianti
componenti di colore per RED, GREEN, BLUE e ALPHA, ciascuno nella gamma [0.1]. Alpha deve essere 0 (invisibile) o 1 (visibili) al momento (non c'è ancora una trasparenza).
componenti di colore speculare opzionali, RED, GREEN e BLUE possono essere da 0 a gran numero (>100).
fisica richiestaClientId int cliente fisico id come restituito da 'connect'
Caricare una texture dal file e restituire un id non negativo unico se il caricamento riesce. Questo id unico può essere utilizzato con changeVisualShape.

È possibile query le informazioni del punto di contatto che esistevano durante l'ultima 'stepSimulation'. Per ottenere i punti di contatto è possibile utilizzare l'API 'getContactPoints'. Nota che i 'getContactPoints' non ricompenseranno le informazioni del punto di contatto.
Questa query restituirà tutti gli id unici di oggetti che hanno asse allineato scatola di rilegatura sovrapposizione con un determinato asse legato casella. Si noti che la query è conservatrice e può restituire oggetti aggiuntivi che non hanno reale AABB sovrapposizione. Questo accade perché le strutture di accelerazione hanno un po' euristico che allarga gli AABB (con margine extra ed estruso lungo il vettore velocità). I parametri di input getOverlappingObjects sono:
aabbMin vec3, elenco di 3 carri armati coordinate minime dell'abbronzatura
aabbMax vec3, elenco di 3 galleggianti coordinate massime dell'abbro
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
È possibile query l'asse allineato casella di rilegatura (in spazio mondiale) dato un oggetto unico id, e facoltativamente un indice di collegamento. (quando non si passa l'indice di collegamento, o utilizzare -1, si ottiene la AABB della base). I parametri di input sono
corpo richiestoUniqueId int oggetto unico id come restituito da metodi di creazione.
opzionale linkIndex int link index nella gamma [0.getNumJoints(.)]
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.

La struttura di ritorno è un elenco di vec3, aabbMin (x,y,z) e aaBBMax (x.y,Z) nelle coordinate spaziali mondiali. Vedi anche l'esempio getAABB.py.
L'API getContactPoints restituisce i punti di contatto calcolati durante la chiamata più recente a stepSimulation. I suoi parametri di input sono i seguenti:
bodyA int report solo punti di contatto che coinvolgono il corpo A
bodyB opzionale int solo segnalare punti di contatto che coinvolgono il corpo B
linkIndexA int Solo segnalare i punti di contatto che coinvolgono il collegamentoIndEXA del corpo
linkIndexB int Solo segnalare i punti di contatto che coinvolgono il collegamentoIndxB del corpo
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
getContactPoints restituirà un elenco di punti di contatto. Ogni punto di contatto ha i seguenti campi:
corpoUniqueIdA int body unico id del corpo A
corpoUniqueIdB int body unico id del corpo B
linkIndexA int collegamento indice del corpo A, -1 per base
indice di collegamento IndexB del corpo B, -1 per base
posizioneOnA vec3, elenco 3 carri posizionati sulla A, in coordinate mondiali cartesian
posizioneOnB vec3, elenco 3 carri posizionati sulla B, in coordinate mondiali cartesian
contattoNormalOnB vec3, elenco di 3 carri a contatto normale su B, puntando verso A
contattoDistance distanza di contatto galleggiante, positivo per separazione, negativo per penetrazione
normaleForce galleggiante forza normale applicata durante l'ultima 'stepSimulation'
contattoFlag int riservato

È anche possibile calcolare i punti più vicini, indipendenti dalla stepSimulation. Questo permette anche di calcolare i punti più vicini degli oggetti con una distanza arbitraria che separa. In questa domanda non ci saranno forze normali segnalate. getClosestPoints parametri di input:
bodyA int object unico id per primo oggetto (A)
bodyB int object unico id per il secondo oggetto (B)
distanza necessaria galleggiante Se la distanza tra gli oggetti supera questa massima distanza, non possono essere restituiti punti.
indice di collegamento opzionaleIndexA per oggetto A (-1 per base)
indice di collegamento opzionaleIndexB per oggetto B (-1 per base)
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
getClosestPoints restituisce un elenco di punti più vicini nello stesso formato come ottenereContactPoints (ma normalForce è sempre zero in questo caso)
È possibile eseguire un singolo raycast per trovare le informazioni di intersezione del primo oggetto colpito. I parametri di ingresso rayTest sono:
rayFromPosition vec3, elenco di 3 floats inizio del raggio in coordinate mondiali
rayToPosition vec3, elenco di 3 galleggianti fine del raggio in coordinate mondiali
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
La query raytest restituirà le seguenti informazioni in caso di incrocio:
oggettoUniqueId int object unico id dell'oggetto colpito
linkIndex int link index dell'oggetto colpito, o -1 se non e/o parante.
colpiscono la frazione di galleggiamento lungo il raggio in gamma [0,1] lungo l'eruzione.
posizione di successo vec3, elenco 3 carri posizionati nelle coordinate del mondo cartesiano
hit normale vec3, elenco di 3 carri ha colpito normal in coordinate del mondo cartesiano

Questo è simile al rayTest, ma consente di fornire una serie di raggi, per l'esecuzione più veloce. La dimensione di 'rayFromPositions' deve essere uguale alla dimensione del 'rayToPosition'. È possibile un risultato raggio per ray, anche se non c'è intersezione: è necessario utilizzare il campo oggettoUniqueId per verificare se la raggi ha colpito qualcosa: se l'oggetto UniqueID è -1, non vi è alcun colpo. In tal caso, la "frazione di accensione" è 1. Il numero massimo di raggi per lotto è pibullet.MAX RAY INTERSECTION BATCH SIZE. I parametri di ingresso rayTest sono:
rayFromPositions elenco di vec3, lista dell'elenco dei 3 galleggianti
elenco dei punti di partenza per ogni raggio, nelle coordinate mondiali
elenco rayToPositions richiesto di vec3, lista dell'elenco dei 3 galleggianti
elenco dei punti finali per ogni raggio nelle coordinate mondiali
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
L'uscita è un risultato di intersezione ray per raggio d'ingresso, con le stesse informazioni che in query rayTest sopra.
È possibile query il tipo di geometria della collisione e altre informazioni sulla forma delle collisioni della base del corpo esistente e dei collegamenti utilizzando questa richiesta. Funziona molto simile a ottenereVisualShapeData. I parametri di input per ottenereCollisionShapeData sono:
oggetto richiestoUniqueId int object unico id, ricevuto da loadURDF ecc
linkIndex int link index o -1 per la base
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
Il valore di ritorno è un elenco con i seguenti contenuti:
oggetto unico id int oggetti unico

linkIndex int link index o -1 per la base
dimensioni vec3 dipende dal tipo di geometria: per GEOM BOX: proporzioni, per le dimensioni GEOm SPHERE[0] = raggio, per GEoM CAPSULE e GEO M CYLINDER, dimensioni [0]= altezza (lunghezza), dimensione[1] = raggio. Per GEOM MESH, le dimensioni sono il fattore di scaling.
posizione locale del telaio di collisione rispetto al centro della struttura in massa/inerziale.
locale fram orn vec4 L'orientamento locale del telaio di collisione rispetto al frame inerziale.
calcolareInverseDynamics
Calcola InverseDynamics calcola le forze necessarie per raggiungere le specifiche accelerazioni articolari, a partire da determinate posizioni e velocità comuni. I parametri di input del calcoloInverseDynamics sono:
corpo richiestoUniqueId int body unico id, come restituito da loadURDF ecc.
elenco objPositions richiesto di posizioni articolari galleggianti (angoli) per ogni grado di libertà (DoF). Si noti che le giunzioni fisse hanno 0 gradi di libertà. La base viene saltata/ignorata in tutti i casi (base galleggiante e base fissa).
elenco di velocità comuni del galleggiante per ogni grado di libertà (DoF)
elenco di accelerimenti obbligatorie delle accelerazioni congiunte desiderate galleggianti per ogni grado di libertà (DoF)
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
Calcola InverseDynamics restituisce un elenco di forze comuni per ogni grado di libertà.
calcolaJacobian computerà i jacobi traduttivi e rotazionali per un punto su un link, ad esempio. x dot = J * q doT. I giacobini restituiti sono leggermente diversi a seconda che il link radice sia fisso o galleggiante. Se galleggianti, i giacobini includeranno colonne corrispondenti ai gradi di libertà del collegamento radice; se fissi, le jacobian avranno solo colonne associate alle articolazioni. La chiamata della funzione prende la descrizione completa dello stato cinematico, questo è perché

calcolareInverseDynamics è in realtà chiamato prima e i jacobian desiderati sono estratti da questo; quindi, è ragionevole passare zero vettori per velocità articolari ed accelerazioni se desiderato. I parametri di input calcola jacobian sono:
corpo richiestoUniqueId int body unico id, come restituito da loadURDF ecc.
linkIndex int link index per il jacobian.
richiesto localePosizione elenco di galleggiare il punto sul link specificato per calcolare la jacobian for.
elenco objPositions richiesto di posizioni articolari galleggianti (angoli)
elenco objVelocities richiesto di velocità articolari galleggianti
elenco di accelerimenti obbligatorie delle accelerazioni articolari desiderate galleggianti
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
Calcola i ritorni di Jacobian:
lineare Jacobian mat3x ((dof), df)
il jacobian traduttivo, x dot = J t * q doT.
angulari mat3x jacobian (dof), df, ddof)
il jacobian rotazionale, r dot = J r * q dotto.
CalcolaMassMatrix computerà l'inerzia del sistema per un corpo articolato dato le sue posizioni comuni.
corpo richiestoUniqueId int body unico id, come restituito da loadURDF ecc.
objPositions array richiesto di galleggiante
articolazionePosizioni per ogni link.
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
Il risultato è la matrice quadrata di massa con dimensioni dofCount * dofConte, memorizzato come un elenco delle righe del dofPaese, ogni riga è una lista degli elementi della matrice di massa del doFCount. Inversa Kinematics
È possibile calcolare gli angoli di giunzione che rende l'effetto finale raggiungere una data posizione bersaglio nello spazio del mondo cartesiano. Internamente, Bullet utilizza una versione migliorata della libreria Samuel Buss Inverse Kinematics. Al momento solo il metodo di campi da lavoro smorzato con o senza Null

Il controllo dello spazio è esposto, con un unico obiettivo di effetto finale. Opzionalmente è possibile specificare anche l'orientamento di destinazione dell'effetto finale. Inoltre, c'è un'opzione per utilizzare lo spazio nullo per specificare i limiti articolari e le posizioni di riposo. Questo supporto opzionale null-spazio richiede tutti i 4 elenchi (Limits inferiori, UpperLimit, JointRanges, RestPoses), altrimenti IK regolare sarà utilizzato. Vedi anche inverse kinematics.py esempio nella cartella Bullet/examples/pybullet/Examples per i dettagli.
calcolareI parametri di input InverseKinematics sono:
corpo richiestoUniqueId int body unico id, come restituito da loadURDF
fineEffectorLinkIndex int end Effector link index
target richiestoPosition vec3, elenco 3 galleggianti posizione di destinazione nello spazio del mondo cartesiano
opzionale targetOrientamento vec3, elenco di 4 galleggianti bersaglio orientamento nello spazio del mondo cartesiano, quaternion [x,y,w,z]. Se non specificato, la posizione pura IK sarà utilizzata.
opzionale inferioreLimits elenco di galleggianti [0.nDof] facoltativo null-space IK richiede tutti i 4 elenchi (lowerLimit, UpperLimites, JointRanges, RestPoses). Altrimenti IK sarà usato regolarmente.
opzionale superioreLimits elenco di galleggianti [0.nDof] inferioreLimito e tomaiaRichiesta limiti articolari
elenco opzionale di carri armati [0.nDof]
opzionale riposoPoses elenco di galleggianti [0.nDof] Favore una soluzione IK più vicino a un dato posto di riposo
opzionale giuntoClista di campionamento dei galleggianti [0.nDof] JointSamping permettono di sintonizzare la soluzione IK utilizzando fattori di smorzamento congiunto
opzionali solutori int p.IK DLS o p. IK SDLS, quadrati di leva smorzati o piazze separate per la superficie umida, come descritto nella carta da Samuel Buss "Piami selettivi della bestia per la cinematica inversa".
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
Calcola InverseKinematics restituisce un elenco di posizioni comuni. Vedere Bullet/examples/pybullet/inverse kinematics.py per un esempio. Notare che il calcoloInverseKinematics può dare un risultato approssimativo nella posizione dell'effetto finale. È possibile ottenere risultati più precisi utilizzando il " accurateCalculateInverseKinematics" codice esempio.



Una suite di ambienti RL Gym sono installati durante "pip install piybullet". Questo include versioni PyBullet degli ambienti OpenAI Gym come formica, tramoggia, umanoide e walker. Ci sono anche ambienti che si applicano nella simulazione e su veri robot, come il Minitaur Ghost Robotics quadruplicato, l'auto da corsa MIT ed gli ambienti di presa del braccio KUKA. Il codice sorgente di pybullet, pibullet envs, pybule dati e gli esempi sono qui: https://github.com/bulletphysics/bullets3/tree/master/examples/pybullet/gym È possibile formare gli ambienti con algoritmi di formazione RL come DQN, PPO, TRPO e DDPG. Sono disponibili diversi esempi pre-trained, puoi goderli come questo: pip install pybullet, tensorflow, gym python -m pybulet envs.examples.enjoy TF HumanoidBulletEnv v0 2017may pyton -m piybullets enves.esamples .kukaGymEnvTest
Dopo aver "sudo pip install pybullet", sono disponibili i pacchetti di pybule envs e pibullet data. Importando il pacchetto pybullet envs, irrupperà automaticamente gli ambienti alla Palestra OpenAI. Puoi ottenere una lista degli ambienti Bullet in palestra utilizzando la seguente linea Python: print(









La simulazione del Minitaur Ghost Robotics quadruplicato su un terreno pianeggiante. Ricompenso basato sulla distanza viaggiata. Creare la classe usando Gym: env = gym.make('MinitaurBulletEnv-v0') o creare l'ambiente utilizzando direttamente la classe, con parametri: import pybullet envs.bullet.minitaur gym enV as e env= e.MinitauroBulletoEnv (render=True)
Simulazione del MIT RC Racecar. Ricompensare in base alla distanza dalla palla posizionata casualmente. Le osservazioni sono posizione della palla (x,y) nella cornice della fotocamera. Lo spazio di azione dell'ambiente può essere discreto (per DQN) o continuo (per PPO, TRPO e DDPG). import pybullet envs.bullet.racecarGymEnv as e env = e.RacecarGimEnv(isDiscrete=False,renders=True) env.reset()
Stesso come il RacecarBulletEnv-v0, ma le osservazioni sono pixel della fotocamera.
Simulazione del braccio robotico KUKA Iiwa, afferrando un oggetto in una vaschetta. La ricompensa principale avviene alla fine, quando il gripped può afferrare l'oggetto sopra una certa altezza. Qualche piccolo premio/costo avviene ogni passo: costo di azione e distanza tra gripper ed oggetto. L'osservazione include la posizione x,y dell'oggetto. Nota: questo ambiente ha problemi di formazione al momento, ci occupiamo.
KukaCamBulletEnv-v0 Stesso di KukaBullecEnv - v0, ma l'osservazione sono pixel della fotocamera.

Abbiamo portato gli ambienti Roboschool a piloni. Gli ambienti Roboschool sono più difficili degli ambienti MuJoCo Gym.
Ant è più pesante, incoraggiandolo a tipicamente avere due o più gambe sul terreno.
I benefici umanioidi da un costo energetico più realistico (= coppia × velocità angolare) sottratto dalla ricompensa.

È anche possibile accedere ai dati, come ad esempio i beni robot URDF/SDF, file Wavefront .OBJ dal pacchetto pybullet data. Ecco un esempio come fare questo: importa pibullet import pybullet data datapath = pybulet dati.getDataPath() pybullet.connect(pybullet.GUI) pybullet .setExploitSearchPath (datapath) pibullet,loadURDF("r2d2.urdf",[0,0,1]) In alternativa, append manualmente il percorso dati al nome del file nei comandi loadURDF/SDF.
Per ambienti discreti come il KukaBulletEnv-v0 e RacecarBullecEnv -v0 è possibile utilizzare OpenAI Baselines DQN per formare il modello utilizzando uno spazio d'azione discreto. Alcuni esempi sono forniti come addestrare e godere di quegli ambienti discrete: python -m pibullet envs.baselines.train pybullet cartpole pyton -m pybullet-envS.baseline.traina pibullet/racecar OpenAI Baselines salverà un file .PKL ad intervalli specificati quando il modello migliora. Questo file .PKL viene utilizzato negli script di piacere: python -m pibullet envs.baselines.enjoy pybullet cartpole pyton -m pybullet-envS.baseline.engione pibullet/racecar Ci sono anche alcuni modelli pre-trained che si possono godere fuori della scatola. Ecco un elenco di ambienti pre-trained per godere:
InvertitoPendulumBulletEnv-v0 · DoublePenducalumbull env-V0 · InvertitoPendoulumSwingupBullec

-Studio di lavoro
È possibile formare vari ambienti pibullet utilizzando TensorFlow Agents PPO . Prima installare i pacchetti Python: pip install gym, tensorflow, agenti, pybullet, ruamel.yaml Quindi per l'uso di formazione: python -m pyloglet envs.agents.train ppo --config=pybullet pendulum --logdir=pendulo I seguenti ambienti sono disponibili come Agenti config: pj Ecco un grafico di esempio da Tensorboard per l'allenamento del pendolo:

Dopo l'allenamento, è possibile visualizzare il modello addestrato, creare un video o visualizzarlo utilizzando un server di fisica (python -m pybullet envs.examples.runServer o EsempiBrowser in modalità server fisici o nella realtà virtuale). Se si avvia un server fisico GUI locale, il visualizer (bullet client.py) connetterà automaticamente

a esso, e utilizzare il rendering hardware OpenGL per creare il video. Altrimenti userà il minuscolorenderer della CPU invece. Per generare il video, utilizzare: python -m pibullet envs.agents.visualize ppo --logdir=pendulum/xxxx --outdir =penduum video In modo simile è possibile addestrare e visualizzare il robot Minitaur: pjn - m pybullethttps://www.youtube.com/watch?v=tfqCHDoFHRQ Strategie evolutive (ES)
C'è un articolo del blog di David Ha (hardmaru) come formare gli ambienti PyBullet utilizzando Evolution Strategies athttp://blog.otoro.net/2017/11/12/evolving-stable-strategies. Treno con PyTorch PPO
Aggiungiamo qualche descrizione come iniziare con PyTorch e pilo. Nel frattempo, vedere questo repository: https://github.com/ikostrikov/pytorch-a2c-ppo-acktr

Vedi anche la guida rapida vrBullet . Il server di fisica VR utilizza l'API OpenVR per il supporto del controller HTC Vive e Oculus Rift Touch. OpenVR sta attualmente lavorando su Windows, Valve lavora anche in versione Linux . Vedi anchehttps://www.youtube.com/watch?v=VMJyZtHQL50 per un esempio video dell'esempio VR, parte di Bullet, che può essere completamente controllato utilizzando PyBullet su memoria condivisa, UDP o connessione TCP. Per VR su Windows, si consiglia di compilare il Bullet Physics SDK utilizzando Microsoft Visual Studio (MSVC). Generare file di progetto MSVC eseguendo lo script "build visual studio vr pybullet double.bat". È possibile personalizzare questo piccolo script per puntare alla posizione di Python ecc. Assicurarsi di passare alla configurazione 'Release' di MSVC e costruire ed eseguire l'App PhysicsServer SharedMemory VR*.exe. Per impostazione predefinita, questa applicazione VR presenterà un mondo vuoto che mostra tracker/controllers (se disponibile).

getVREvents restituirà un elenco eventi per una serie di dispositivi VR selezionati che hanno cambiato stato dall'ultima chiamata a ottenereVREventi. Quando non fornisce alcun dispositivoTypeFilter, il default è solo di segnalare VR DEVICE CONTROLLER stato. Puoi scegliere qualsiasi combinazione di dispositivi tra cui VR DEVICE CONTROLLER, VR DIVIZIO HMD (Dispositivo montato sul carico) e VR DAVICE/GENERIC TRACKER (come il tracciatore HTC Vive). Nota che VR DEVICE HMD e VR DIVICE GENERIC TRACKER riportano solo gli eventi di posizione ed orientamento. getVREvents ha i seguenti parametri:
dispositivo opzionaleTypeFilter int default è VR DEVICE CONTROLLER . Puoi anche scegliere VR DEVICE HMD o VR DIVIZIO GENERIC TRACKER oppure qualsiasi combinazione di loro.
opzionale allAnalogAxes int 1 per tutti gli assi analogici, 0 con un solo asse
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere uno.
I parametri di uscita sono:

controllerId int controller index (0.MAX VR CONTROLLERS)
controllerPosition vec3, elenco 3 posizioni di controllo floats, nello spazio mondiale coordinate cartesiane
controllerOrientamento vec4, elenco 4 galleggianti controllo quaternion orientamento [x,y,z,w] nello spazio mondiale
controllerAnalogueAxis galleggiante valore asse analogico
numButtonEvents int numero di eventi a pulsante da ultima chiamata per ottenereVREventi
numMoveEvents int numero di eventi di movimento dall'ultima chiamata per ottenereVREventi
pulsanti int[64], elenco degli stati dei tasti (OpenVR ha un massimo di 64 bottoni)
bandiere per ogni pulsante: VR BUTTON IS DOWN (attualmente tenuto premuto), VR BUTTON/WAS TRIGGERED (ha fatto scendere almeno una volta dall'ultima corsa a ottenereVREvents, VR PUTON WAS-RELEASed (è stato rilasciato almeno una sola volta da ultimo chiamata ad ottenereVreventi). Si noti che solo VR BUTTON IS DOWN riporta lo stato attuale reale. Ad esempio se il pulsante è andato giù e su, si può dire dalle bandiere RELEASE/TRIGGERED, anche se IS DOWN è ancora falso. Si noti che nel file di registro, questi pulsanti sono imballati con 10 tasti in 1 intero (3 bit per pulsante).
allAnalogAxes (solo se esplicitamente richiesto!)
elenco di 10 galleggianti attualmente, MAX VR ANALOGUE AXIS è 5, per ogni asse x e valore y.
Vedere Bullet/examples/pybullet/exmples/vrEvents.py per un esempio di disegno VR e Bullet / examples / Pybullet / Examples-VrTracker.py a tracciare HMD e tracker generico. setVRCameraState
setVRCameraState consente di impostare la posizione e l'orientamento della root della fotocamera. Questo permette di controllare la posizione della fotocamera VR nel mondo virtuale. È anche possibile lasciare che la fotocamera VR traccia un oggetto, come un veicolo. setVRCameraState ha i seguenti argomenti (non ci sono valori di ritorno):
opzionale rootPosition vec3, vettore di 3 galleggianti fotocamera posizione radice
opzionale rootOrientamento vec4, vettore di 4 carri fotografici orientazione radice in formato quaternion [x,y,z,w].
binario opzionaleObject vec3, vettore di 3 floats l'oggetto unico id per tracciare
binario opzionaleObjectFlag int flags.VR CAMERA TRACK OBJECT ORIENTATIO N (se abilitato, sia posizione che orientamento sono tracciati)
opzionale fisicaClientId int se sei connesso a più server, puoi scegliere

Uno.
PyBullet ha alcune funzionalità per rendere più facile debug, visualizzare e sintonizzare la simulazione. Questa funzione è utile solo se c'è una finestra di visualizzazione 3D, come la modalità GUI o quando si collega a un server fisico separato (come ad esempio Browser in modalità 'Physics Server' o Server Fisico standalone con OpenGL GUI).
È possibile aggiungere una linea 3d specificata da un punto di partenza 3D (da) e il punto finale (a), un colore [rosso, verde, blu], una larghezza della riga e una durata in pochi secondi. Gli argomenti da aggiungereUserDebugline sono:
linea richiestaDalXYZ vec3, elenco di 3 galleggianti
punto di partenza della linea nelle coordinate del mondo cartesiano
linea richiestaToXYZ vec3, elenco di 3 galleggianti
punto finale della linea nelle coordinate del mondo cartesiano
linea opzionaleColorRGB vec3, elenco di 3 galleggianti
Colore RGB [Red, Green, Blue] ogni componente nell'intervallo [0.1]
larghezza linea galleggiante opzionale (limitata dall'implementazione OpenGL)
opzionale lifeTime float use 0 per linea permanente, o tempo positivo in secondi (dopo la riga con essere rimosso automaticamente)
opzionale genitoreObjectUniqueId int new nel prossimo PyBullet 1.0.8: linea di estrazione nelle coordinate locali di un oggetto/link genitoriale.
opzionale genitoreLinkIndex int new nel prossimo PyBullet 1.0.8: tracciare la linea nelle coordinate locali di un oggetto/link genitoriale.
opzionale fisicaClientId int se sei connesso a più server, è possibile scegliere uno
addUserDebugLine restituirà un id unico non negativo, che ti consente di rimuovere la linea utilizzando removeUserDubgItem. addUserDebugText
È possibile aggiungere un testo 3d in una posizione specifica utilizzando un colore e dimensioni. Gli argomenti di input sono:

testo richiesto rappresentato come una stringa (array di caratteri)
testo richiestoVac3, elenco di 3 galleggianti
3d posizione del testo in coordinate mondiali cartesian [x,y,z]
testo opzionaleColorRGB vec3, elenco di 3 galleggianti
Colore RGB [Red, Green, Blue] ogni componente nell'intervallo [0.1]
testo opzionaleCarro di dimensione del testo
opzionale lifeTime float utilizzare 0 per il testo permanente, o tempo positivo in pochi secondi (dopo che il testo viene rimosso automaticamente)
testo opzionaleOrientamento vec4, elenco di 4 galleggianti
Per impostazione predefinita, il testo di debug dovrà sempre affrontare la fotocamera, rotazione automatica. Specificando un orientamento del testo (quaternione), l'orientamento sarà fissato nello spazio mondiale o in quello locale (se il genitore è specificato). Nota che un'implementazione/shader diverso viene utilizzato per il testo di fronte alla telecamera, con aspetto differente: la fotocamera affronta il testo utilizza caratteri bitmap, il testo con orientamento specificato usa i font TrueType.
opzionale genitoreObjectUniqueId int new nel prossimo PyBullet 1.0.8: linea di estrazione nelle coordinate locali di un oggetto/link genitoriale.
opzionale genitoreLinkIndex int new nel prossimo PyBullet 1.0.8: tracciare la linea nelle coordinate locali di un oggetto/link genitoriale.
opzionale fisicaClientId int se sei connesso a più server, è possibile scegliere uno
addUserDebugText restituirà un id unico non negativo, che ti consente di rimuovere la linea utilizzando removeUser DesbugItem. Vedi anche piloni/esampli/debugDrawItems.py
addUserDebugParameter consente di aggiungere cursori personalizzati ai parametri della sintonizzazione. Tornerà un id unico. Questo consente di leggere il valore del parametro utilizzando readUserDebugParameter. I parametri di input del addUserDebugParameter sono:
nome della stringa di paramName richiesto del parametro
range richiestoMin galleggiante valore minimo
range richiestoValore massimo del galleggiante max
valore di partenza del galleggiante Valore
opzionale fisicaClientId int se sei connesso a più server, è possibile scegliere uno

I parametri di input del readUserDebugParameter sono:
elemento richiestoUniqueId int il id unico restituito da 'addUserDebugParameter)
opzionale fisicaClientId int se sei connesso a più server, è possibile scegliere uno
Le funzioni per aggiungere linee di debug dell'utente, testo o parametri restituiranno un id unico non negativo se è riuscito. È possibile rimuovere l'elemento debug utilizzando questo id unico usando il metodo removeUserDebugItem.I parametri di input sono:
elemento richiestoUniqueId int unico id dell'elemento debug da rimuovere (linea, testo ecc)
opzionale fisicaClientId int se sei connesso a più server, è possibile scegliere uno
Questa API rimuoverà tutti gli elementi di debug (testo, linee ecc).
Gli visualizzatori OpenGL incorporati hanno una funzione di rendering del debug wireframe: premere 'w' per attivare. Il wireframe ha alcuni colori di default. È possibile sovrascrivere il colore di un oggetto specifico e collegare utilizzando setDebugObjectColor. I parametri di input sono:
oggetto richiestoUniqueId int unico id dell'oggetto
link Indice collegamento index
oggetto opzionaleDebugColorRGB vec3, elenco di 3 galleggianti colore debug in [Red,Green,Blue]. Se non fornito, il colore personalizzato verrà rimosso.
opzionale fisicaClientId int se sei connesso a più server, è possibile scegliere uno

È possibile configurare alcune impostazioni del visualizzatore OpenGL integrato, come ad esempio attivare o disabilitare wireframe, ombre e rendering GUI. Questo è utile perché alcuni computer portatili o GUI Desktop hanno problemi di prestazioni con il nostro visualizzatore OpenGL 3.
, E) IIII E A O DI S
abilitato necessario per 0 o 1
opzionale fisicaClientId int se sei connesso a più server, è possibile scegliere uno
È possibile ripristinare la distanza della fotocamera di debug 3D OpenGL (tra posizione dell'obiettivo oculare e della telecamera), sbavatura della macchina fotografica e posizione del bersaglio passo e della videocamera.
fotocamera richiestaDistance distanza galleggiante da occhio a posizione di destinazione della telecamera
fotocamera richiestaAgitare la macchina fotografica angolo di yaw (in gradi) sinistra/destra
fotocamera richiestaPitch angolo di lancio della macchina fotografica (in gradi) su/sotto
fotocamera richiestaTargetPosition vec3, elenco di 3 carri fotograficiTargetePosizione è il punto focale della telecamera
opzionale fisicaClientId int se sei connesso a più server, è possibile scegliere uno

È possibile ottenere la larghezza e l'altezza (in pixel) della fotocamera, la sua visualizzazione e matrice di proiezione utilizzando questo comando. Il parametro di input è la fisica opzionaleClientId. Le informazioni di uscita sono:
larghezza int di immagine della fotocamera nei pixel
altezza int dell'immagine della fotocamera nei pixel
viewMatrix float16, elenco di 16 carri
vista matrice della fotocamera
proiezioneMatrix float16, elenco di 16 carri
matrice di proiezione della fotocamera
cameraUp float3, elenco di 3 galleggianti
l'asse della fotocamera, in coordinate spaziali del mondo cartesiano
cameraForward float3, elenco di 3 galleggianti
asse in avanti della fotocamera, nelle coordinate spaziali del mondo cartesiano
galleggiante orizzontale3, elenco di 3 carri
TBD. Questo è un vettore orizzontale che può essere utilizzato per generare raggi (per il mouse di raccolta o la creazione di un semplice vagone ray ad esempio)
galleggiante verticale3, elenco di 3 carri
TBD.Questo è un vettore verticale che può essere utilizzato per generare raggi (per il mouse di raccolta o la creazione di un semplice vassoio ray, ad esempio).
yaw galleggiare angolo della fotocamera, in coordinate spaziali locali Cartesian
angolo di lancio del carreggiata della fotocamera, in coordinate spaziali locali Cartesian
dist galleggiare distanza tra la fotocamera e l'obiettivo della telecamera
bersaglio float3, elenco di 3 galleggianti
obiettivo della fotocamera, in coordinate spaziali del mondo cartesiano
Puoi ricevere tutti gli eventi della tastiera che sono accaduti dall'ultima volta che hai chiamato 'getKeyboardEvents'. Ogni evento ha un codice chiave e uno stato. Lo stato è una combinazione di bandiera bit KEY IS DOWN, KEy WAS TRIGGERED e KEJ Was RELEASED. Se una chiave va dallo stato "su" allo Stato 'down", si riceve lo stato KEY IS DOWN, così come il KEy WAS TRIGGERED. Se una chiave è stata stampata e rilasciata, lo stato sarà KEY IS DOWN e KEJ WAS RELEASED.

ALCUNI TASTI SPECIALI SONO DEFINITI: B3G F1 ... B3G F12, B3 G LEFT ARROW, B3,B3G/RIGHT ARROW L'ingresso di getKeyboardEvents è una fisica opzionaleClientId:
opzionale fisicaClientId int se sei connesso a più server, è possibile scegliere uno
L'output è un dizionario di codice chiave 'chiave' e stato tastiera 'valore'. ottenereMouseEvents
Come per ottenereKeyboardEvents, è possibile ottenere gli eventi del mouse che sono accaduti dall'ultima chiamata di getMouseEventi. Tutti gli eventi di spostamento del mouse sono uniti in un singolo evento di mossa del topo con la posizione più aggiornata. Inoltre, tutti gli eventi del pulsante per un determinato tasto sono fusi. Se un pulsante è andato giù e su, lo stato sarà 'KEY WAS TRIGGERED'. Riutilizzare il KEY WAS TRIGGERED /KEY IS DOWN /KEy Was RELEASED per gli stati del pulsante del mouse. Argomenti di input per ottenereMouseEvents sono:
opzionale fisicaClientId int se sei connesso a più server, è possibile scegliere uno
L'output è un elenco di eventi del mouse nel seguente formato:
eventoTipo int MOUSE MOVE EVENT=1, MOUSE/BUTTON EVE=2
mousePosX galleggiante x-coordinates del puntatore di topo
mousePosY galleggiare y-coordinates del puntatore di topo
pulsanteIndice del tasto Index int per il bottone sinistro/middle/destra
tastoSistema la bandiera KEY WAS TRIGGERED /KEY IS DOWN /KEy Was RELEAS
Ci sono alcuni modi diversi per installare PyBullet su Windows, Mac OSX e Linux. Usiamo Python 2.7 e Python 3.5.2, ma ci aspettiamo che la maggior parte delle versioni di Python 2.x e Python 3.x funzionino. Il più semplice per ottenere PyBullet lavorare è usare pip o python setup.py:

Assicurati che Python e pip siano installati, quindi esegui: pip install pybullet Notare che se hai usato il pip per installare PyBullet, è ancora utile installare anche la C++ Bullet Physics SDK: include file di dati, server fisici e strumenti utili per PyBullit. È inoltre possibile eseguire 'pithon setup.py build' e 'python install.py' nella radice del Bullet Physics SDK (ottenere il SDK dahttp://github.com/bulletphysics/bullets3) Vedi anchehttps://pypi.python.org/pypipi/pybullet In alternativa è possibile installare PyBullet dal codice sorgente utilizzando premake (Windows) o cmake: Utilizzando il premago per Windows
Assicurarsi che una versione Python sia installata in c:\python-3.5.2 (o altro nome della cartella di versione) Prima ottenere il codice sorgente da github, utilizzando git clonehttps://github.com/bulletphysics/bullets3 Clicca su build visual studio vr pybullet double.bat e apri il progetto 0 Bullet3Solution.sln in Visual Studio, converti i progetti se necessario. Passare alla modalità Release e compilare il progetto 'pybullet'.

Poi ci sono alcune opzioni per importare pilotti in un interprete Python:

cd c:\python-3.5.2 \dlls
mklink pybullet.pyd c:\develop\bullet3\bin\pybullet vs2010.dll Quindi eseguire pithon.exe e importare pilobullo dovrebbe funzionare. Utilizzo di cmake su Linux e Mac OSX

○ pybullet.connect (pybullet.GUI,options="--opengl2") ● In alternativa è possibile eseguire il server fisico sulla macchina remota, con UDP o TCP bridge e connettersi dal computer portatile locale al server remoto tramite tunneling UDP. (todo: descrivere i passi in dettaglio)
Domanda: Dove andiamo a sostenere e per segnalare i problemi? Risposta: C'è un forum di discussione inhttp://pybullet.org/Bullet e un tracker di problemihttps://github.com/bulletphysics/bullets3 Domanda: Come aggiungiamo una citazione a PyBullet nel nostro documento accademico? Risposta: @MISC{coumans2018,
autore = {Erwin Coumans and Yunfei Bai}, titolo= {PyBullet, un modulo Python per la simulazione fisica di giochi, robotica e machine learning}, howPublishing = {\url{http://pybullet.org }} anno = {2016--2018} } Domanda: Che cosa succede a Bullet 2.x e all'implementazione di Bullet 3 OpenCL? Risposta: PyBullet sta avvolgendo il Bullet C-API . Metteremo l'API GPU Bullet 3 OpenCL (e future API Bullet 4.x) dietro questo C-API. Quindi se si utilizza PyBullet o C-API siete in prova di futuro. Da non confondere con l'API Bullet 2.x C++. Domanda: Dovrei usare la coppia/controllo forza o velocità / modalità di controllo della posizione? In generale è meglio iniziare con il controllo di posizione o velocità. Ci vorrà molto più sforzo per ottenere il controllo forza / coppia di lavoro in modo affidabile. Domanda: Come spegnere la gravità solo per alcune parti di un robot (ad esempio il braccio)? Risposta:
Al momento questo non è esposto, quindi si dovrebbe o svolta di accelerazione della gravità per tutti gli oggetti e applicare manualmente la gravità per gli oggetti che ne hanno bisogno.

Oppure puoi calcolare attivamente le forze di compensazione della gravità, come accade su un vero robot. Poiché Bullet ha un sistema di vincolo completo, sarebbe banale calcolare quelle forze anti-gravità: si potrebbe eseguire una seconda simulazione (PyBullet consente di connettersi a più server fisici) e posizionare il robot sotto gravità, impostare controllo della posizione comune per mantenere la posizione come desiderato, e raccogliere le "forze anti-grietà". Quindi applicare quelli nella simulazione principale. Domanda: Come scalare oggetti in su/sotto? Risposta: È possibile utilizzare il valore globaleScaleFactor come argomento opzionale per caricareURDF e loadSDF. In caso contrario, la scalatura di forme visive e forme di collisione fa parte della maggior parte dei formati file come URDF e SDF. Al momento non si possono ridimensionare gli oggetti. Domanda: Come posso ottenere texture nei miei modelli? Risposta: È possibile utilizzare il formato di file Wavefront .obj. Questo supporterà i file materiali (.mtl). Ci sono vari esempi utilizzando texture nella cartella Bullet/data. È possibile modificare la texture per gli oggetti esistenti utilizzando l'API 'changeTexture'. Domanda: Quali formati di file con texture sono validi per PyBullet? Risposta: Bullet utilizza stb image per caricare i file di texture, che carica PNG, JPG, TGA, GIF ecc. vedi stb image.h per i dettagli. Domanda: Come posso migliorare le prestazioni e la stabilità del rilevamento delle collisioni? Risposta: Ci sono molti modi per ottimizzare, ad esempio: forma tipo 1) Scegliere uno o più tipi di forme primitive della collisione come scatola, sfera, capsula, cilindro a approssimare un oggetto, invece di utilizzare mesh triangolari convessi o concavi. 2) Se hai davvero bisogno di usare mesh triangolari, crea una decomposizione convessa utilizzando la Decomposizione approssimativa gerarchica della Convex (v-HACD). L'utilità test hacd converte la maglia triangolare convessa in un file OBJ in un nuovo file Obj con oggetti di scafo multiconvesso. Per esempio, Bullet/data/teddy vhacd.urdf indica to Bullet / data/tedy2 VHACD CHs.obj o paper vhad.urdaf che punta a paper vacd .obj. 3) Ridurre il numero di vertici in una maglia triangolare. Per esempio Blender 3D ha un grande modificatore di decimazione a rete che consente interattivamente di vedere il risultato della semplificazione delle maglie. 4) Utilizzare l'attrito rotante e la filatura di attriti per oggetti rotondi come sfera, capsule e pinze robotiche utilizzando le e nodi dentro Nodi. Vedere ad esempio Bullet/data/sphere2.urdf 5) Utilizzare una piccola quantità di conformità per le ruote utilizzando all'interno del URDF xml nodo. Vedere per esempio il veicolo Bullet/data/husky/huski.urdf. 6) Usare la doppia precisione di costruzione del Bullet, questo è buono sia per stabilità dei contatti che per accuratezza della collisione. Scegli un buon settaggio del risolutore di costrizione e passo temporale.

Risposta: per impostazione predefinita, Bullet e PyBullet utilizzano un preciso attrito implicito del cono per il modello di frizione Coulomb. Inoltre, è possibile attivare laminazione e filatura attrito aggiungendo un e nodo all'interno del nodo, vedi Bullet/data/sphere2.urdf per esempio. Invece dell'attrito del cono, è possibile abilitare l'approssimazione piramidale. Domanda: Che tipo di costante o soglia all'interno del Bullet, che rende le alte velocità impossibili?
Risposta: Per impostazione predefinita, Bullet si basa sul rilevamento di collisione discreto in combinazione con il recupero della penetrazione. Risolvere esclusivamente su rilevamento di collisione discreto significa che un oggetto non deve viaggiare più veloce del proprio raggio entro una sola volta. PyBullet utilizza 1./240 come ormeggio predefinito. I passi temporali più grandi di 1./60 possono introdurre instabilità per vari motivi (penetrazione profonda, integratore numerico). Bullet ha un'opzione per il rilevamento continuo della collisione per catturare le collisioni per oggetti che si muovono più velocemente del proprio raggio in una sola volta. Purtroppo, questo rilevamento continuo di collisione può introdurre i propri problemi (risposta performance e non fisica, mancanza di restituzione), quindi questa funzione sperimentale non è abilitata per impostazione predefinita.
Pagine di riferimento in questo manuale: produttore, supporto e download.
I possessori del prodotto e il nostro team di solito rispondono entro 24 ore, e la tua domanda sarà utile anche ad altri.
Invia la prima domanda: risponderanno altri possessori o il nostro team.