Retrouvez cet article dans : Linux Magazine 88

Dans cet article, nous allons achever notre découverte du module Scene, et conclure la série consacrée à l’API Python de Blender. Comme nous allons le voir, ce module nous donne accès à tous les paramètres de rendu de Blender, nous permettant de programmer simplement des stratégies de rendu différentes. Bien sûr, nous n’allons pas tout explorer en détail, mais nous focaliser sur ce qu’il faut savoir pour, par exemple, paramétrer le rendu d’une image fixe, puis celui d’une animation. En particulier, les méthodes relatives au moteur de rendu Yafray ne seront pas abordées, de même que les spécificités liées au rendu Toon ou encore à l’Unified Renderer (dont les fonctionnalités ont disparu de l’interface des dernières versions de Blender, mais restent présentes au travers de l’API python de Blender).

1. Le sous-module Render

Render est un sous-module du module Scene. Il conviendra donc d’importer celui-ci avant toute chose :

import Blender
from Blender import Scene
from Blender.Scene import Render

Exactement comme le sous-module Radiosity du précédent article, tous les paramètres de rendu sont stockés dans un contexte spécifique, et seule la scène courante possède un contexte de rendu. Par exemple,

scn = Scene.GetCurrent()

permet de donner à Python accès à la scène courante. Vous pouvez bien évidemment sélectionner toute autre scène (par exemple en citant son nom) et en la définissant comme la scène courante :

scn = Scene.Get(‘[Nomdelascene]’)
scn.makeCurrent()

ainsi que nous l’avons vu dans la première partie de l’exploration du module Scene. Il est alors possible d’accéder au contexte de rendu de la scène grâce à la ligne :

 rendu = scn.getRenderingContext()

Dans les lignes d’exemple précédentes, scn et rendu sont des noms de variables arbitraires que vous êtes libre de modifier à votre guise.

1.1 Les fonctions du sous-module Render

Quelques fonctions génériques sont disponibles et pratiques d’accès sous Python. D’autres sont également existantes, mais ne seront pas étudiées ici, en particulier celles liées au rendu Toon.

La fonction CloseRenderWindow()

Lorsqu’elle est invoquée, cette fonction ferme la fenêtre de rendu. Exemple d’usage :

 Render.CloseRenderWindow()

La méthode currentFrame([valeur])

Cette méthode permet de définir la frame courante de la scène. Par défaut, ce sera celle qui sera rendue lors de l’appel de la méthode render(). Elle accepte une valeur comprise entre 1 et 30000. Exemple d’usage :

 rendu.currentFrame(25)

La fonction saveRenderedImage([nom],[0|1])

Cette fonction permet d’effectuer la sauvegarde d’une image rendue sous le nom de fichier donné en premier argument. Le deuxième argument spécifie si le tampon de profondeur (zbuffer) doit être enregistré avec l’image : 0 pou non, 1 pour oui. Par exemple :

rendu.saveRenderedImage(‘toto01’,0)

enregistre simplement l’image rendue sous le nom toto01, dans le répertoire défini par la méthode setRenderPath(). A noter que si un répertoire /images existe dans le chemin défini par la méthode setRenderPath(), vous pouvez utiliser : pour y stocker l’image rendue. Si le répertoire n’existe pas, il sera créé. Si vous voulez sauvegarder l’image à une adresse absolue, videz au préalable le chemin de rendu grâce à la commande rendu.setRenderPath(‘’) ou rendu.setRenderPath(‘/’).

1.2 Définition du format

Les premières informations importantes à définir sont le format de la ou des image(s) qui seront rendues. Généralement, il est suffisant de définir les dimensions de l’image (SizeX et SizeY) et éventuellement le ratio d’aspect de celle-ci (AspX et AspY), le format d’enregistrement (Jpeg, PNG, etc.) et éventuellement son niveau de qualité (Quality), ainsi que la coloration (noir et blanc, couleurs, ou couleurs avec fond transparent). Dans le cadre d’une animation, il est également possible de définir le nombre d’images par seconde qui seront jouées (Frs/sec) (voir figure 1).

Les méthodes aspectRatioX([valeur]) et aspectRatioY([valeur])

Ces méthodes permettent de déterminer les valeurs AspX et AspY, définissant respectivement le rapport d’aspect horizontal et vertical pour la scène. Elles admettent des valeurs allant de 0 à 200.

Par exemple : permet de mettre en place les mêmes rapports que le bouton PAL 16:9.

 

Les méthodes enableGrayscale(), enableRGBAColor() et enableRGBColor()

Ces méthodes exclusives l’une de l’autre permettent respectivement d’indiquer que les images devront être sauvegardées en couleur avec enableRGBColor(), en noir et blanc avec enableGrayscale() et en couleur avec support de la transparence pour le fond avec enableRGBAColor(), si celle-ci est supportée par le format d’image (par exemple PNG). Par exemple :

 rendu.enableRGBColor()

permet de sauvegarder l’image (fond inclus) en couleurs simples.

La méthode framesPerSec([valeur])

Cette méthode permet de déterminer le nombre d’images par seconde rendues lors d’une animation. Par exemple :

rendu.framesPerSec(24)

spécifie une vitesse d’animation égale à 24 images par seconde. La valeur admise peut aller de 1 à 120 images par seconde.

Bon à savoir : les méthodes sans set ou get Certaines méthodes ne sont pas déclinées en versions différentes selon que l’on souhaite récupérer une valeur (get...) ou la fixer (set...). C’est le cas d’un grand nombre de méthodes ici. Par exemple, si vous souhaitez déterminer la vitesse d’une animation, en images par seconde, vous utiliserez :

 

rendu.framesPerSec(25)

En revanche, si vous souhaitez récupérer le nombre d’images par seconde de votre animation, par exemple pour calculer la durée d’une animation ou autre, vous pouvez le faire ainsi :

curfr = rendu.framesPerSec()
print curfr

Il suffit en effet de ne pas préciser de valeur dans les parenthèses, et de stocker le résultat dans une variable de votre choix, ici curfr (pour current frame).

La méthode quality([valeur])

Cette méthode permet de déterminer la qualité de compression d’images Jpeg ou de films AVI Jpeg. La valeur admise va de 10 à 100 ; plus le chiffre est grand, plus la qualité est élevée. Par exemple, si vous prévoyez d’enregistrer votre rendu au format Jpeg, vous pouvez utiliser :

 rendu.quality(95)

Les méthodes imageSizeX([valeur]) et imageSizeY([valeur])

Ces méthodes permettent de déterminer respectivement la largeur (SizeX) et la hauteur (SizeY) de l’image rendue. Les valeurs admises vont de 4 à 10000. Par exemple :

rendu.imageSizeX(640)
rendu.imageSizeY(480)

permettent de définir une image rendue de dimensions 640 x 480.

La méthode imageType

Cette méthode permet de déterminer le type de fichier qui sera sauvegardé. De nombreux formats de fichiers sont disponibles, parmi lesquels JPEG90, PNG, TARGA, AVIRAW, AVIJPEG et bien d’autres. Par exemple :

rendu.imageType = Render.PNG

ordonne la sauvegarde des images rendues au format PNG.

1.3 Définition de la sortie

Dans certains cas, vous trouverez également intéressant de spécifier certains paramètres de sortie, comme le répertoire temporaire (le champ /tmp/) où seront stockées les images individuelles de votre animation, ou la vidéo finale elle-même, ou encore le chemin vers l’image devant servir de fond permanent (le champ //backbuf). Dans ce dernier cas, l’activation du bouton Backbuf se révélera nécessaire.

Les méthodes set et getBackbufPath()

Ces méthodes permettent respectivement de définir un chemin vers une image devant servir d’arrière-plan au rendu (méthode setBackbufPath()), ou de lire le chemin actuellement spécifié (méthode getBackbufPath()). Par exemple :

rendu.setBackbufPath(‘/home/olivier/images/backbuf.jpg’)

permet de spécifier une telle image en particulier. Cette image n’apparaîtra toutefois au rendu que conjointement utilisée avec la méthode enableBackbuf().

La méthode enableBackbuf([0|1])

Cette méthode permet d’activer une image d’arrière-plan, définie par la méthode setBackbufPath(), qui s’affichera lors du rendu. Il s’agira d’une image fixe, sur laquelle l’image rendue est photomontée. Cette méthode est distincte (et moins réaliste) que l’usage d’une image en guise de texture World. Cette méthode admet deux valeurs : 0 pour la désactiver, et 1 pour l’activer. Par exemple :

 rendu.setRenderPath(‘/home/olivier/tmp/’)

active l’image définie par la méthode setBackbuthPath() comme arrière-plan permanent au rendu.

Les méthodes set et getRenderPath()

Cette méthode permet de déterminer le chemin vers lequel le moteur de rendu écrira les images résultantes d’une animation (méthode setRenderPath()) ou lira celle actuellement définie (méthode getRenderPath()). Par exemple : permet de déterminer le répertoire temporaire de l’utilisateur comme étant le répertoire où seront stockées les images intermédiaires d’une animation. C’est également là que la vidéo finale sera montée, si le type de fichier est de type AVI Jpeg ou AVI Raw).

La méthode enableExtensions([0|1])

Cette méthode permet d’activer l’ajout d’extensions appropriées aux images, lors du rendu de celles-ci et de leur écriture dans l’emplacement spécifié par la méthode setRenderPath(). Elle admet deux valeurs : 0 désactive l’extension, 1 permet son ajout. Par exemple :

 rendu.enableExtensions(1)

ajoutera à tous les fichiers intermédiaires d’une vidéo l’extension appropriée.

Les méthodes enableShadow([0|1]), enableEnvironmentMap([0|1]), enablePanorama([0|1]), enableRayTracing([0|1]) et enableRadiosityRender([0|1])

Ces méthodes permettent d’activer respectivement le calcul des ombres, le rendu des Environment Maps (ancienne méthode de calcul des reflets), le rendu panoramique (où la largeur de l’image calculée est multipliée par Xparts), le lancer de rayons et enfin le rendu de radiosité. Chacune de ces valeurs n’admet que deux valeurs: 0 pour désactiver l’option, 1 pour l’activer. Ainsi, par exemple :

rendu.enableShadow(1)
rendu.enableEnvironmentMap(1)
rendu.enablePanorama(0)
rendu.enableRayTracing(1)
rendu.enableRadiosityRender(0)

reproduisent le paramétrage par défaut de Blender.

Les méthodes set et getRenderWinSize()

Ces méthodes permettent de spécifier (méthode setRenderWinSize()) ou de lire à partir de la scène courante la taille de la fenêtre de rendu, en pourcentage des dimensions spécifiées grâce aux méthodes imageSizeX() et imageSizeY(). Par exemple :

 rendu.setRenderWinSize(25)

permet d’effectuer un rendu égal au quart des dimensions de l’image spécifiées par l’utilisateur. Cette méthode admet des valeurs égales à 25, 50, 75 ou 100% des dimensions d’origine de l’image.

Les méthodes enableSky([0|1]), enablePremultiply([0|1]) et enableKey([0|1])

Ces méthodes de rendu sont exclusives l’une de l’autre et permettent, respectivement, d’activer le rendu du ciel en arrière-plan (méthode enableSky()), d’activer la prémultiplication des valeurs alpha (méthode enablePremuktiply()), et enfin de maintenir inchangées les valeurs alpha et de couleur (méthode enableKey()). Chacune de ces valeurs n’admet que deux valeurs : 0 pour désactiver l’option, 1 pour l’activer. Ainsi, par exemple :

 rendu.enableSky(1)

correspond à l’état par défaut de Blender, permettant l’usage d’une entité World en guise d’arrière-plan au rendu.

Les méthodes enableGaussFilter([0|1]) et gaussFilterSize([valeur])

La méthode enableGaussFilter() permet d’activer ou désactiver le filtre d’échantillonnage gaussien pour l’anti-crénelage. Elle admet deux valeurs : 0 pour la désactivation, et 1 pour l’activation. Blender admet aujourd’hui d’autres filtres d’échantillonnage, mais pour l’instant, seul le filtre gaussien est accessible au travers de l’API Python de Blender. Pour sa part, la méthode gaussFilterSize() permet de définir la taille du filtre gaussien ; elle admet une valeur numérique allant de 0.5 à 1.5. Exemple d’usage :

rendu.enableGaussFilter(1)
rendu.gaussFilterSize(0.83)

Les méthodes enableMotionBlur([0|1]) et motionBlurLevel([valeur])

La méthode enableMotionBlur() permet d’activer ou de désactiver le flou de mouvement lors d’une animation. Elle admet deux valeurs : 0 pour la désactivation, et 1 pour l’activation. La quantité de flou apportée est commandée par la méthode motionBlurLevel() qui accepte, pour sa part, une valeur comprise entre 0.01 et 5.0. Exemple d’usage :

rendu.enableMotionBlur(1)
rendu.motionBlurLevel(2.25)

Les méthodes partsX([valeur]) et partsY([valeur])

Ces méthodes permettent de déterminer en combien de morceaux le rendu doit être divisé dans les directions X et Y. La première accepte des valeurs comprises entre 1 et 512, tandis que la seconde ne les accepte qu’entre 1 et 64. Exemple d’usage :

rendu.partsX(64)
rendu.partsY(12)

Les méthodes enableOversampling([0|1]) et setOversamplingLevel([valeur])

La méthode enableOversampling() permet d’activer ou désactiver l’anti-crénelage des images lors du rendu. Elle admet deux valeurs : 0 pour la désactivation, et 1 pour l’activation. Le niveau de suréchantillonage est déterminé par la méthode setOversamplingLevel() et admet pour valeur 5, 8, 11 ou 16. Par exemple :

rendu.enableOversampling(1)
rendu.setOversamplingLevel(16)

permet de mettre en place l’anti-crénelage le plus complet de Blender.

La méthode render()

Cette présentation des méthodes liées au rendu serait incomplète sans la présentation de celle qui permet de réaliser effectivement le rendu. La méthode render() effectue simplement le rendu au moment où la commande est invoquée. Par exemple :

 rendu.render()

lance le calcul du rendu pour la scène et la frame d’animation courante.

La méthode renderer

Même si les (nombreuses) méthodes disponibles pour le moteur de rendu Yafray ne sont pas abordées dans cet article, nous allons simplement évoquer la façon de préciser le moteur que Blender doit utiliser pour effectuer le rendu. L’appel de cette méthode diffère quelque peu :

rendu.renderer = Render.YAFRAY

permet d‘invoquer Yafray en guise de moteur de rendu, tandis que :

rendu.renderer = Render.INTERNAL

invoque le moteur de rendu interne de Blender.

1.5 Paramètres d’animation

Les méthodes qui suivent ne sont utiles que dans le cas où vous voudriez piloter le rendu d’une animation (ou son paramétrage) au travers de scripts Python. Elles permettent, pour l’essentiel, de lancer le calcul d’une animation complète, depuis la frame Sta jusqu’à la frame End. Bien sûr, vous pouvez activer ou non les séquences ou rejouer une animation déjà calculée.

Les méthodes startFrame([valeur]) et endFrame([valeur])

Ces méthodes permettent de définir la frame de départ (méthode startFrame()) ainsi que la frame finale (méthode endFrame()) de votre séquence. Chacune admet une valeur comprise entre 1 et 18000. Par exemple :

rendu.startFrame(1)
rendu.endFrame(250)

permet de définir la plage par défaut de rendu d’une séquence dans Blender (Sta: 1 et End: 250).

La méthode renderAnim()

Cette méthode permet de lancer le calcul de toutes les images d’une animation, entre les bornes définies par les méthodes startFrame() et endFrame(), en enregistrant les images individuelles dans le chemin défini par la méthode setRenderPath(). On l’invoque simplement grâce à la commande :

 

 rendu.renderAnim()

La méthode play()

Une fois les images intermédiaires calculées, il est possible de rejouer une animation simplement en invoquant la méthode play(). Elle se contente alors de lire les images, dans l’ordre d’apparition dans la liste, depuis le chemin fixé par la méthode setRenderPath(). Exemple d’usage :

rendu.play()

La méthode enableSequencer([0|1])

Cette méthode, enfin, permet ou non d’activer les séquences définies dans l’éditeur de séquences. Elle admet deux valeurs : 0 pour désactiver la prise en compte des séquences, et 1 pour l’activer. Par exemple :

 rendu.enableSequencer(0)

permet d’effectuer le rendu d’une animation sans se soucier des séquences décrites par l’utilisateur.

2. Exemple de script faisant appel aux méthodes de rendu

Les exemples de script faisant usage des méthodes et fonctions de rendu ne sont pas très nombreux. Par chance, il en existe un, qui fait à peu près tout, et qu'il sera intéressant de disséquer. Il se trouve à l’URL suivante : http://uselessdreamer.byethost32.com/more_render_options.html Pour l’installer, commencez par le télécharger et le décompacter: http://uselessdreamer.byethost32.com/scripts/more_render_options.zip Copiez ensuite le fichier more_render_options.py dans le répertoire .blender/scripts de Blender, et affichez la fenêtre Scripts Window. Enfin, utilisez le menu Scripts et choisissez Update Menus.

Désormais, dans la rubrique Render du menu Scripts, vous trouverez l’option More Render Options. Choisissez-la pour afficher l’interface du script. Nous attirerons ici votre attention uniquement sur les fonctionnalités de ce script qui reposent pour l’essentiel sur les méthodes et fonctions abordées dans cet article.

Le champ Render presets permet de sélectionner parmi les paramètres de rendu prédéterminés existants. Bien sûr, au démarrage, il n’y en a pas : il vous faut cliquer sur le bouton > et choisir Add Preset pour en créer à partir des paramètres réglés dans le menu Scene [F10], en particulier les dimensions de l’image, les options de rendu, le facteur de la fenêtre de rendu, etc. Bien sûr, l’option Remove Preset permet de supprimer le préréglage courant, et Load preset d’activer le préréglage affiché : le simple fait de le sélectionner dans la liste déroulante n’est en effet pas suffisant. Enfin, en cliquant sur le bouton Render, l’image est calculée. Le champ Render folders marche selon le même principe. On définit un chemin de rendu, puis on clique sur le bouton > du champ pour choisir Add Current Folder. Le chemin courant est alors ajouté à la liste des possibilités. Load Folder Preset est choisi pour rendre le chemin choisi actif, et Remove Folder Preset permet de supprimer le chemin préréglé sélectionné. Le bouton All Camera permet d’effectuer un rendu depuis chaque caméra de la scène. Le bouton > qui lui est associé permet de choisir individuellement une caméra spécifique de la scène, mais aussi d’en ajouter une nouvelle. Il est également possible, en choisissant l’option Go to Camera View de transformer la vue active en vue de type Perspective. L’option Align Camera to View, enfin, permet d’aligner la caméra active de sorte qu’elle soit parfaitement orthogonale à la vue. Le bouton Ratio permet de déterminer le nombre de frames rendues lors de la prévisualisation d’une animation. Par exemple, dans le cas d’une simulation des fluides, ou des corps souples, vous souhaiterez peut-être, dans le cadre d’une simple prévisualisation, effectuer le rendu d’une image sur deux, ou d’une image sur cinq, par exemple. Ce bouton vous permet de choisir la fréquence de rendu entre 1:1, 1:2, 1:3, 1:5 et 1:10.

Conclusion

Le script More Render Options propose également d’autres fonctionnalités (comme la possibilité d’attribuer aux matériaux de la scène des préréglages particuliers pouvant faciliter leur observation) que nous vous laissons découvrir, car plus éloignées du présent article, mais demeurant toutefois une illustration intéressante des modules et sous-modules mis en œuvre jusqu’à présent dans les numéros successifs de GNU/Linux Magazine. L’étude du code de ce script (le fichier .py correspondant doit s’ouvrir sans problème dans un éditeur de texte comme Vim, Kate ou Gedit) est donc un exercice dont l’intérêt pédagogique ne vous échappera pas. Cet article est le dernier de la série consacrée à l’exploration de l’API Python de Blender. Vous avez normalement toutes les cartes en main pour réaliser des scripts intéressants, bien qu’il reste encore des domaines peu ou pas explorés par cette série, comme la génération de maillages complexes ou la gestion des armatures à partir de scripts. Nous y reviendrons peut-être dans le futur, mais dans l’immédiat, il est temps de vous attaquer à la réalisation de vos propres scripts !

Lien Documentation officielle de l’API de Blender 2.42 : http://www.blender.org/documentation/242PythonDoc/