Genesis Physics Engine: Een stapsgewijze gids voor het instellen van Genesis

Vorig jaar werd Genesis gelanceerd als een spannende nieuwe tool voor het maken van realistische fysicasimulaties, interactieve 4D-werelden en meer. Ik stond te popelen om het te proberen, maar het aan de praat krijgen was niet makkelijk. Ik moet toegeven dat ik tijdens de installatie heel wat uitdagingen tegenkwam. 

In deze tutorial deel ik kort de problemen waar ik tegenaan liep en laat ik zien hoe ik het uiteindelijk werkend kreeg met Google Colab en een paar handige trucs.

Wil je alleen een overzicht van Genesis? Bekijk dan mijn eerdere artikel, Genesis Physics Engine: A Guide With Examples.

Mijn eerste installatie-ervaring met Genesis

Toen ik net met Genesis begon, volgde ik de installatiestappen in de documentatie. Meteen liep ik tegen afhankelijkheidsproblemen aan. Genesis vereist een specifieke versie van een module genaamd Taichi (1.7.x), maar mijn macOS ondersteunde die niet. Ter referentie: mijn Mac is 8 jaar oud….

Na wat onderzoek realiseerde ik me dat andere gebruikers dezelfde problemen hadden, zelfs met betere computers. Na uren ploeteren, en nadat ik ontdekte dat Genesis alleen met bepaalde Python-versies werkt, heb ik het uiteindelijk geïnstalleerd.

Maar er doken nieuwe problemen op. Er werd niets gerenderd en ik kreeg allerlei OpenGL-issues. Zelfs toen ik de voorbeeldbestanden van hun GitHub probeerde te draaien, kreeg ik meer fouten en conflicten.

En toen ik dacht dat ik het had opgelost, kreeg ik fouten zoals "uniform not found", wat betekende dat sommige renderinstellingen ontbraken.

Gedurende dit proces zocht ik online of anderen tegen dezelfde problemen waren aangelopen. Ik bleek niet de enige—veel mensen hadden dezelfde moeilijkheden en velen leken geen oplossing te vinden om hun scripts aan de praat te krijgen.

Hoe ik Genesis werkend kreeg: Google Colab als redder in nood

Na de eerste frustratie besloot ik Google Colab met een Pro-account te proberen, en dat bleek precies te zijn wat ik nodig had. Met de GPU-resources van Colab kon ik:

• Alle vereiste dependencies zonder problemen installeren.
• De GPU-backend gebruiken voor uitstekende prestaties en realistische rendering.
• Eindelijk basisvoorbeelden draaien en het potentieel van Genesis verkennen.

Ik koos de NVIDIA A100-SXM4-40GB, die krachtig genoeg bleek om Genesis-simulaties efficiënt te draaien. 

Zodra ik mijn Google Colab-omgeving had ingericht en Genesis had geïnstalleerd, probeerde ik het eenvoudigste voorbeeld uit de documentatie te draaien:

import genesis as gs
gs.init(backend=gs.cpu)
scene = gs.Scene(show_viewer=True)

Dit voorbeeld zou Genesis met de CPU-backend moeten initialiseren en een eenvoudige scène moeten tonen. Ik kreeg echter meteen de volgende foutmelding:

GenesisException: No display detected. Use show_viewer=False for headless mode.

De foutmelding geeft aan dat Genesis een grafisch venster probeert te maken om de scène te renderen, maar Google Colab ondersteunt geen realtime visualisatie. Colab draait in een externe omgeving zonder toegang tot een lokale display, dus de parameter show_viewer=True in de initialisatie van gs.Scene() werkt niet.

Zoals de foutmelding suggereerde, heb ik de code aangepast om de viewer uit te schakelen:

scene = gs.Scene(show_viewer=False)

Daardoor kon het script uitvoeren zonder te crashen. Deze aanpak betekende echter dat er geen manier was om de resultaten direct te bekijken.

Na online speuren ontdekte ik dat anderen hetzelfde probleem hadden. Veel voorgestelde oplossingen hielden in dat je remote OpenGL-omgevingen moest configureren of Xvfb moest gebruiken om een virtueel scherm te maken. Helaas kreeg ik deze methoden niet betrouwbaar werkend in Colab, waarschijnlijk door dependencyconflicten en beperkingen van de omgeving.

Op dat moment had ik een praktischere workaround nodig!

Omdat realtime rendering in Colab geen optie was, besloot ik de gerenderde output frame voor frame als afbeeldingen op te slaan. Met deze aanpak kon ik een reeks beelden genereren die later tot een animatie konden worden samengevoegd.

Implementatie en outputs

In deze sectie neem ik je mee door de implementatie van de code en de outputs die ik kreeg.

De GPU-omgeving instellen

Allereerst installeerde ik Genesis:

pip install genesis-world

Daarna initialiseerde ik Genesis met de CUDA-backend voor GPU-versnelling.

import genesis as gs
gs.init(backend=gs.cuda)

Dit is de output die ik kreeg:

[Genesis] [INFO] Running on [NVIDIA A100-SXM4-40GB] with backend gs.cuda. Device memory: 39.56 GB.
[Genesis] [INFO] 🚀 Genesis initialized. Version: 0.2.1, Seed: None, Precision: 32.

De scène maken en opbouwen

Maak een map om de resultaten op te slaan

Het eerste wat ik nodig had, was een map waar Genesis de gerenderde afbeeldingen kon opslaan. 

import os
save_dir = "/content/simulation_frames"
os.makedirs(save_dir, exist_ok=True)

De functie os.makedirs() maakt een map genaamd simulation_frames op het opgegeven pad, en met het argument exist_ok=True wordt voorkomen dat er een fout wordt gegenereerd als de map al bestaat.

Zo had ik een vaste plek om alle frames en outputs van mijn simulatie op te slaan.

Initialiseer de scène

Vervolgens moest ik een scène maken waar ik objecten aan kon toevoegen en ermee kon interacteren.

scene = gs.Scene(show_viewer=False)

gs.Scene() initialiseert een nieuwe simulatieruimte en show_viewer=False schakelt realtime visualisatie uit. Op dit punt had ik een lege scène klaar om op voort te bouwen.

Voeg een vlak en een kubus toe

Met de scène klaar begon ik objecten toe te voegen. Eerst voegde ik een vlak toe, dat als grond fungeert.

plane = scene.add_entity(gs.morphs.Plane())

Het vlak dient als een vlakke basis voor de simulatie. Standaard is het oneindig en ligt het plat langs de x-y-as.

Daarna voegde ik een kubus toe aan de scène:

box = scene.add_entity(
    gs.morphs.Box(
        pos=(0, 0, 0),        # Position of the box
        size=(0.5, 0.5, 0.5)  # Size of the box
    )
)

Ik plaatste de kubus op (0, 0, 0), precies in het midden van de scène, en verkleinde hem naar 0.5 eenheden breed, hoog en diep, zodat hij kleiner is dan de standaard.

Nu had ik een eenvoudige setup: een vlak als grond en een kubus die erop rust.

Voeg een camera toe

Om vast te leggen wat er in de scène gebeurde, voegde ik een camera toe.

cam = scene.add_camera(
    res=(320, 240),       # Resolution: 320x240 pixels
    pos=(3.5, 2.0, 2.5),  # Camera position
    lookat=(0, 0, 0.5),   # Point the camera is focused on
    fov=30                # Field of view (in degrees)
)

Ik stelde de beeldresolutie in op 320x240 pixels, een praktische keuze voor testen, en positioneerde de camera op (3.5, 2.0, 2.5), wat een goed zicht gaf op de scène van iets hoger en opzij. Om ervoor te zorgen dat de kubus in focus bleef, richtte ik de camera op (0, 0, 0.5), net boven het midden van de kubus. Met een gezichtsveld (FOV) van 30 graden ving de camera een smalle en gefocuste blik op de scène. 

Bouw de scène

De volgende stap was het opbouwen van de scène om deze voor te bereiden op simulatie en rendering.

scene.build()

Deze stap is cruciaal omdat Genesis just-in-time (JIT) compilatie gebruikt om de simulatie te optimaliseren. Toen ik de scène bouwde, deed Genesis het volgende:

• Geheugen toewijzen voor de objecten in de scène.
• GPU-kernels voorbereiden voor rendering en fysische berekeningen.
• Alle benodigde datastructuren opzetten zodat de simulatie soepel draait.

Nu was alles klaar—mijn vlak, kubus en camera waren ingesteld en de scène was opgebouwd.

Renderen en outputs opslaan

Om de simulatie te visualiseren, rendere ik en sloeg ik de outputs frame voor frame op. Elk frame werd als afbeelding opgeslagen in de map simulation_frames. 

from PIL import Image
import numpy as np

# Render and save images
for i in range(30):
    scene.step()  # Advance simulation
    if i % 5 == 0:  # Save every 5th frame
        print(f"Step {i}/30")
        rgb_data = cam.render(rgb=True)
        
        # Extract image data and save it
        img_array = rgb_data[0]
        img = Image.fromarray((img_array * 255).astype(np.uint8))
        img.save(f"{save_dir}/frame_{i:03d}.png")
        print(f"Frame {i} saved to {save_dir}")

Tijdens het renderen merkte ik dat de eerste frames snel werden gerenderd (tot 2.297 FPS), maar dat de prestaties afnamen naarmate de simulatie vorderde. Tegen frame 25 zakte de FPS uiteindelijk tot ongeveer 0,33 FPS. Dit kan komen door toenemende computationele complexiteit van de simulatie of mogelijk door GPU-resourcelimieten bij grotere scènes.

Dit is de output die ik kreeg:

[Genesis] [22:16:38] [INFO] Running at 2297.81 FPS.
INFO:genesis:Running at ~<2297.81>~ FPS.
Step 0/30
[Genesis] [22:16:56] [INFO] Running at 1.11 FPS.
INFO:genesis:Running at ~<1.11>~ FPS.
[Genesis] [22:16:56] [INFO] Running at 1.17 FPS.
INFO:genesis:Running at ~<1.17>~ FPS.
[Genesis] [22:16:56] [INFO] Running at 1.23 FPS.
INFO:genesis:Running at ~<1.23>~ FPS.
[Genesis] [22:16:56] [INFO] Running at 1.29 FPS.
INFO:genesis:Running at ~<1.29>~ FPS.
[Genesis] [22:16:56] [INFO] Running at 1.36 FPS.
INFO:genesis:Running at ~<1.36>~ FPS.
Frame 0 saved to /content/simulation_frames
Step 5/30
[Genesis] [22:17:14] [INFO] Running at 0.63 FPS.
INFO:genesis:Running at ~<0.63>~ FPS.
[Genesis] [22:17:14] [INFO] Running at 0.67 FPS.
INFO:genesis:Running at ~<0.67>~ FPS.
[Genesis] [22:17:14] [INFO] Running at 0.70 FPS.
INFO:genesis:Running at ~<0.70>~ FPS.
[Genesis] [22:17:14] [INFO] Running at 0.74 FPS.
INFO:genesis:Running at ~<0.74>~ FPS.
[Genesis] [22:17:14] [INFO] Running at 0.78 FPS.
INFO:genesis:Running at ~<0.78>~ FPS.
Frame 5 saved to /content/simulation_frames
Step 10/30
[Genesis] [22:17:32] [INFO] Running at 0.47 FPS.
INFO:genesis:Running at ~<0.47>~ FPS.
[Genesis] [22:17:32] [INFO] Running at 0.50 FPS.
INFO:genesis:Running at ~<0.50>~ FPS.
[Genesis] [22:17:32] [INFO] Running at 0.53 FPS.
INFO:genesis:Running at ~<0.53>~ FPS.
[Genesis] [22:17:32] [INFO] Running at 0.55 FPS.
INFO:genesis:Running at ~<0.55>~ FPS.
[Genesis] [22:17:32] [INFO] Running at 0.58 FPS.
INFO:genesis:Running at ~<0.58>~ FPS.
Frame 10 saved to /content/simulation_frames
Step 15/30
[Genesis] [22:17:49] [INFO] Running at 0.40 FPS.
INFO:genesis:Running at ~<0.40>~ FPS.
[Genesis] [22:17:49] [INFO] Running at 0.42 FPS.
INFO:genesis:Running at ~<0.42>~ FPS.
[Genesis] [22:17:49] [INFO] Running at 0.44 FPS.
INFO:genesis:Running at ~<0.44>~ FPS.
[Genesis] [22:17:49] [INFO] Running at 0.46 FPS.
INFO:genesis:Running at ~<0.46>~ FPS.
[Genesis] [22:17:49] [INFO] Running at 0.49 FPS.
INFO:genesis:Running at ~<0.49>~ FPS.
Frame 15 saved to /content/simulation_frames
Step 20/30
[Genesis] [22:18:07] [INFO] Running at 0.35 FPS.
INFO:genesis:Running at ~<0.35>~ FPS.
[Genesis] [22:18:07] [INFO] Running at 0.37 FPS.
INFO:genesis:Running at ~<0.37>~ FPS.
[Genesis] [22:18:07] [INFO] Running at 0.39 FPS.
INFO:genesis:Running at ~<0.39>~ FPS.
[Genesis] [22:18:07] [INFO] Running at 0.41 FPS.
INFO:genesis:Running at ~<0.41>~ FPS.
[Genesis] [22:18:07] [INFO] Running at 0.43 FPS.
INFO:genesis:Running at ~<0.43>~ FPS.
Frame 20 saved to /content/simulation_frames
Step 25/30
[Genesis] [22:18:24] [INFO] Running at 0.33 FPS.
INFO:genesis:Running at ~<0.33>~ FPS.
[Genesis] [22:18:24] [INFO] Running at 0.35 FPS.
INFO:genesis:Running at ~<0.35>~ FPS.
[Genesis] [22:18:24] [INFO] Running at 0.36 FPS.
INFO:genesis:Running at ~<0.36>~ FPS.
[Genesis] [22:18:24] [INFO] Running at 0.38 FPS.
INFO:genesis:Running at ~<0.38>~ FPS.
Frame 25 saved to /content/simulation_frames

Dit zijn de afbeeldingen die ik kreeg:

Elke afbeelding laat zien hoe de kubus zich in de tijd verplaatst ten opzichte van het vlak, bekeken door de camera. De simulatie loopt in stappen en bij elke stap verandert de positie van de kubus, waardoor het lijkt alsof de kubus beweegt.

Dit voorbeeld laat zien hoe Genesis eenvoudige fysieke interacties kan simuleren en weergeven. Hoewel deze setup basic is, krijg je zo een goed idee van hoe objecten zich in de scène gedragen. Maar je kunt met Genesis absoluut veel complexere en realistischere scenario’s maken! In de volgende sectie verkennen we enkele van deze mogelijkheden.

Genesis verkennen: mogelijkheden en features

Object- en scènecreatie

Met Genesis kun je complexe scènes maken door verschillende objecten en morphs toe te voegen. Objecten kunnen variëren van simpele primitieve vormen zoals vlakken, kubussen en sferen tot complexere entiteiten zoals robots en terreinen.

Vormprimitieven:

• gs.morphs.Plane
• gs.morphs.Box
• gs.morphs.Cylinder
• gs.morphs.Sphere

Ondersteuning voor externe bestanden:

• MJCF: gs.morphs.MJCF voor MuJoCo XML-robotconfiguraties.
• URDF: gs.morphs.URDF voor Unified Robot Description Format-bestanden.
• Mesh: gs.morphs.Mesh voor 3D-assets zoals .obj, .ply, .stl, .glb en .gltf.

Genesis gebruikt één overkoepelend concept, een "morph", dat geometrie- en houdingsinformatie bundelt. Dit objectgeoriënteerde ontwerp maakt directe interactie met entiteiten via hun methoden mogelijk.

Rendering en visualisatie

Een van de sterke punten van Genesis is de mogelijkheid om gedetailleerde visuele outputs te maken met geavanceerde camerafeatures. De camera’s werken in een "headless mode", wat betekent dat ze beelden kunnen genereren zonder een display. Ze kunnen verschillende soorten visuals produceren, waaronder reguliere kleurenbeelden (RGB), depth maps die afstanden tonen, segmentatiemasks die verschillende delen van de scène labelen, en normal maps die oppervlaktestructuren weergeven.

Video’s opnemen

Je kunt video’s maken door camera’s automatisch elk frame van de simulatie te laten opnemen. Je kunt de camera zelfs tijdens de opname verplaatsen om de video dynamischer en meeslepender te maken.

Je kunt bijvoorbeeld een camera zo configureren dat hij in een cirkelvormig pad om de scène beweegt terwijl hij frames vastlegt. De functie cam.start_recording() start de opname en tijdens elke simulatiestap wordt de positie van de camera bijgewerkt. Zodra alle frames zijn vastgelegd, slaat cam.stop_recording() de video op als "video.mp4".

De uiteindelijke video geeft een vloeiend beeld van de simulatie en laat zien hoe de objecten in de tijd interageren en bewegen.

Terreingeneratie voor locomotietaken

Je kunt ook verschillende soorten terreinen maken voor robotica en AI-training. Je kunt de ingebouwde terreinopties gebruiken of je eigen ontwerp maken met aangepaste hoogtekaarten via gs.morphs.Terrain. Deze terreinen zijn ideaal voor het testen en trainen van robotbewegingen, waardoor Genesis een uitstekende tool is voor robotica-onderzoek.

Uitbreidbaarheid

Je kunt je simulaties op verschillende manieren aanpassen. Je kunt realistische texturen aan objecten toevoegen, zodat ze levensechter ogen. Er is ook ondersteuning voor veel bestandsformaten om modellen te importeren, en als een formaat niet wordt ondersteund, kun je vragen om het toe te voegen. Daarnaast kun je je eigen aangepaste objectvormen (morphs) maken met gepersonaliseerde bestanden en instellingen.

Conclusie

Deze tutorial gaf een eenvoudig voorbeeld om je op weg te helpen met Genesis. We behandelden de basis, zoals scènes maken, objecten toevoegen en outputs renderen, om te laten zien hoe deze krachtige physics-engine werkt.

Dit is echter nog maar het begin van wat Genesis kan. Met de juiste hardware, zoals een sterke GPU en genoeg geheugen, zijn er ontzettend veel mogelijkheden. Je kunt het gebruiken voor complexe roboticasimulaties of voor het maken van hoogwaardige datasets voor AI-training. Hoewel de setup lastig kan zijn, is het zeker een tool met enorm veel potentie!