door Carlos Calzada <ccgrau /at/ disca.upv.es> Over de auteur: Ik ben student (op het moment) computerwetenschappen en sinds ik een Spectrum had, vind ik graphics leuk, verder ben ik ook een fan van Linux en alles dat niets te maken heeft met Micro$oft. Twee van mijn niet-computer-gerelateerde hobbies zijn bonsais en visvijvers. Vertaald naar het Nederlands door: Guus Snijders <ghs(at)linuxfocus.org> Inhoud: Introductie Beginselen van Camera-positionering Motion blur (simuleren van bewegende objecten) Veld diepte (focus)

Beginselen van Camera-positionering Kort: In dit tweede artikel over RenderMan bespreken we de configuratie en positie van de camera en bekijken we enkele speciale effecten die je kunt gebruiken. Hoewel het positioneren niet zo intuïtief is als Pov-Ray, is het een voordeel bij het beschrijven van camera trajecten. Een deel van dit laatste onderwerp wordt beschreven in een derde artikel. _________________ _________________ _________________

Introductie

In dit tweede artikel bekijken we het camera model in RenderMan in detail. De camera is een van de belangrijkste elementen van een renderer, deze laat je de interessantste effecten genereren, zoals Motion Blur (wat je ziet als je een foto maakt van een bewegend model) en Depth of Field (focus). Hoewel er nog veel meer effecten in de camera gemodelleerd hadden kunnen worden, zoals Lens Flare (de flits of overbelichting die je ziet bij fotos van lichten), zouden die het model te gecompliceerd maken. In plaats daarvan worden veel van deze effecten bereikt door de eigenschappen van de objecten aan te passen met behulp van een geavanceerd systeem van shaders (een shader is een tool voor het renderen van texturen op objecten). Met families van shaders kunnen we onze eigen "shaders" bouwen en indrukwekkende effecten genereren. De procedure voor het programmeren en compileren van deze shaders zullen we in een ander artikel bespreken, dit is echter een erg omvangrijk onderwerp (heel erg uitgebreid en op het moment weet ik niet hoe ik het beter kan voorbereiden).

Zoals in het vorige artikel uitgelegd, voor het renderen van een afbeelding, gebruiken we:

rendrib fichero.rib

rendrib -d fichero.rib

Beginselen van Camera-positionering

Het coördinaten systeem voor de camera is "linkshandig" en komt overeen met het oppervlak van de monitor. Het beginpunt bevindt zich in het midden van het scherm, waarbij de x-as naar rechts wijst, de y-as naar boven en de z-as naar de binnenkant van de monitor. Standaard is het "huidige coördinaten systeem" gelijk aan het camera systeem van coördinaten, precies zoals geïllustreerd in de eerste afbeelding (de x-as is rood, y groen en z blauw). De eerste afbeelding geeft een bovenaanzicht van de scene en de tweede is de eigenlijke scene ( de lichtbronnen bevinden zich op verschillende plaatsen in beide afbeeldingen om deze duidelijker te maken). Hoewel de scene niet bijzonder complex is (eigenlijk is hij verschrikkelijk), maar hij dient om de RIB voorbeeld bestanden duidelijk te maken, zonder deze vol te stoppen met complexe geometrische modellen.

Laten we eens kijken hoe de camera te positioneren. Het meest logische om te doen, vooral voor Pov_ray gebruikers, is om de camera te verplaatsen. Om de scene van een grotere afstand te bekijken, zouden we de camera willen verplaatsen (vertalen), naar de positie <0,0,-20>, dit is hetzelfde als de camera naar achteren bewegen. Onder Renderman vind deze vertaling plaats met het commando Translate 0 0 -20 voor WorldBegin:

Dit commando heeft de camera echter naar voren gebracht! Eigenlijk was het niet de camera die werd verplaatst, maar het coördinaten systeem: het hele coördinaten systeem werd terug vertaald, waarbij de camera voorin bleef. Daarom, om de camera achterwaats te verplaatsen, moeten we het tegenovergestelde doen, een voorwaatse vertaling en er niet over denken als het verplaatsen van de camera, maar het verplaatsen van het coördinaten systeem (met Translate 0 0 20):

Nu is de camera exact waar we hem wilden. Van nu af aan zal iedere geometrie verandering in de scene refereren aan het huidige coördinaten systeem. In het volgende voorbeeld blijft het model op de origin (nulpunt) maar roteren we de camera er omheen:

Bekijk het RIB bestand met de geometrische vertalingen van de camera:

Display "camara_default2.tif" "file" "rgb"
Projection "perspective" "fov" 45
Format 320 240 1

LightSource "ambientlight" 1 "intensity"
            0.3 "lightcolor" [1 1 1]
LightSource "distantlight" 2 "intensity"
            1.0 "from" [10 10 -10] "to" [0 0 0]

Translate 0 0 20
Rotate 45 1 0 0
Rotate 135 0 1 0

WorldBegin
    Color 1 1 1
        # Blanco achtergrond
    Sphere 10000 -10000 10000 360

    # Objecten in de scene
    TransformBegin
        Color 1 0 0
        Sphere 3 -3 3 360
    TransformEnd
    TransformBegin
        Rotate -90 1 0 0
        Translate 0 0 2
        Cone 3 3 360
        Disk 0 3 360
    TransformEnd
    TransformBegin
        Rotate -90 0 1 0
        Cylinder 1 -4 4 360
        Disk 4 1 360
        Disk -4 1 360
    TransformEnd
WorldEnd

Er is een vertaling (Translate 0 0 20) en twee rotaties, een over de x-as (Rotate 45 1 0 0) en de andere over de y-as (Rotate 135 0 1 0). De volgorde van deze operaties is misschien verwarrend voor Pov-Ray gebruikers, daar worden de operaties in de volgorde van opgeven uitgevoerd, maar dat geldt niet voor RenderMan. RenderMan plaatst operaties in een wachtrij totdat het een signicant token vindt (in ons geval WorldBegin), pas dan worden deze operaties toegepast, in omgekeerde volgorde. In andere woorden, door het wachtrij systeem wordt de laatst opgegeven operatie als eerste uitgevoerd. De geometrische operaties in ons voorbeeld worden als volgt geïnterpreteerd:

1. Initiële Staat
2. Roteer het coördinaten systeem 135 graden over de y-as
3. Roteer het coördinaten systeem 45 graden over de x-as
4. Vertaal het huidige coördinaten systeem 20 eenheden over de z-as

Vergeet nooit dat alle transformaties van het huidige coördinaten systeem (rotaties en vertalingen) altijd relatief zijn ten opzichte van de camera, daarom zou een rotatie rond de x-as moeten worden gezien als een "rotatie rond de x-as van de camera"

Nu komen we bij het meest interessante deel van het artikel, hoe je RenderMan's camera model kunt gebruiken om speciale effecten te genereren.

Motion blur (simuleren van bewegende objecten)

Het eerste camere effect is Motion Blur, een effect dat probeer het spoor te imiteren dat op film wordt achtergelaten door bewegende objecten.

Motion Blur wordt gespecificeerd door het statement Shutter 0 1 in ons voorbeeld bestand in de sectie met de camera specs op te geven. Het commando Shutter 0 1 simuleert de openings tijd, in dit geval is de sluiter van de camera open op tijd 0 en blijft 1 tijdseenheid open. De parameter 0 1 voor de sluiter is vrij universeel en we zullen deze parameters altijd gebruiken, daar het alleen een bepaald gedrag van RenderMan's camera toont.

Vervolgens moeten we RenderMan vertellen welke elementen in de scene in beweging zijn, hiervoor voegen we de tags MotionBegin MontionEnd in. De volgende figuren geven een voorbeeld (en het RIB bestand) van een bal die beweegt van positie 0 10 5 op tijdstip 0 naar 5 10 0 op tijdstip 1. Het statement MotionBegin [0 1] in het RIB vertelt RenderMan welke exacte tijden corresponderen met de transformaties (instantie 0 komt overeen met de eerste en instantie 1 met de tweede) en d waarden moeten overeen komen met de opgegeven waarden in de Shutter sectie. De afbeelding laat duidelijk zien dat het effect erg realistisch lijkt en in de animatie is het effect zelfs nog sterker.

Natuurlijk zijn de toegestane vertalingen tussen MotionBegin MotionEnd niet beperkt tot verplaatsingen, RenderMan kan niet-lineare trajecten met Motion Blur renderen. In het volgende voorbeeld zien we een rotatie van 25 graden over de y-as.

Onder normale omstandigheden bewegen alleen objecten in de scene. RenderMan kent echter ook de mogelijkheid om de camera zelf te verplaatsen, daardoor kan het effect van Motion Blur ook op de camera zelf worden toegepast. In dit voorbeeld bewegen we de camera 5 eenheden naar rechts (oftewel, we bewegen het systeem van coördinaten 5 eenheden naar rechts), en alle objecten in de scene zullen "blur" (wazig) worden. Uiteraard moet het tag-paar MotionBegin MotionEnd in de sectie van de camera van het RIB bestand komen:

Veld diepte (focus)

Een ander interessant effect dat RenderMan biedt, is "Depth of Field" (veld diepte), of het camera-focus mechanisme. Het statement voor deze feature is DepthOfField. Dit token neemt drie parameters:f-stop, fov (field of view) en focus-length. De eerste parameter, f-stop geeft de brandpunt-afstand voor de focus tool, in ons voorbeeld zal een object dat zich 2 of minder eenheden van de camera bevind gelijk on-focussed (of focussed) verschijnen. De parameter fov krijgt meestal de waarde 1,0 als het perspectief eerder gedefinieerd was als Projection "perspective" "fov" 45 (zoals in ons voorbeeld), als je de waarde veranderd in iets anders dan 1, zal alleen het perspectief veld worden vermenigvuldigd met die factor. Ten slotte is focus-length de parameter waar we echt in geïnteresseerd zijn, deze definieert de afstand waarop objecten zich moeten bevinden om als buiten-focus te verschijnen op de afbeelding. In het volgende voorbeeld is de camera op de origine (nul punt) en zullen we verschillende voorbeelden laten zien met meerdere focus-length parameters.

De eerste afbeelding gebruikt DepthOfField 2.0 1.0 10, wat betekend dat ieder object dat zich 10 eenheden van de camera bevindt, gefocussed zal worden (zoals de rode bal):

In het tweede geval DepthOfField 2.0 1.0 20. Nu is de groene bal, die zich op 20 eenheden van de camera bevindt, on-focus:

Tenslotte, om het de focus op de laatste bol te richten (bevindt zich 30 eenheden ver), gebruiken we DepthOfField 2.0 1.0 30:

De bereikte effecten geven een grotere realiteit aan de gegenereerde afbeeldingen. Natuurlijk neemt de rekentijd die nodig is om de afbeeldingen te genereren toe, Motion Blur en Depth of Field vereisen meerdere passages door de renderer.

2005-04-16, generated by lfparser version 2.52