3.3.1.1 Le blob
Les blobs sont un type d'objet intéressant et flexible. Mathématiquement, ce sont des isosurfaces de champs scalaires, c'est-à-dire que leur surface est définie par la force d'un champ en chaque point. Si cette force est égale à un seuil, vous êtes sur la surface, sinon non.
Représentez-vous chaque composant d'un blob comme un objet flottant dans l'espace. Cet objet est rempli d'un champ qui a son maximum en son centre, et décline vers zéro à sa surface. Le champ de force de chaque composant est additionné aux autres pour donner le champ du blob. Maintenant, POV-Ray cherche les points où ce champ a une valeur donnée, la valeur seuil. Tous ces points forment la surface du blob. Les points avec un champ plus élevé sont internes, les autres, externes.
Il y a une autre façon plus simple de voir les blobs. Ils peuvent être vus comme l'union de composants flexibles qui s'attirent ou se repoussent pour former une forme organique globuleuse. Les surfaces des composants se rejoignent doucement comme s'ils étaient fait de miel, ou de quelque chose du même genre.
Un blob est défini comme ceci :
BLOB: blob { BLOB_ITEM... [BLOB_MODIFIERS...]} BLOB_ITEM: sphere {<Center>, Radius, [ strength ] Strength[COMPONENT_MODIFIER...] } | cylinder {<End1>, <End2>, Radius, [ strength ] Strength [COMPONENT_MODIFIER...] } | component Strength, Radius, <Center> | threshold Amount COMPONENT_MODIFIER: TEXTURE | PIGMENT | NORMAL | FINISH | TRANSFORMATION BLOB_MODIFIER: hierarchy [Boolean] | sturm [Boolean] | OBJECT_MODIFIER
Les valeurs par défaut du blob :
hierarchy : on sturm : off threshold : 1.0
Le mot clé threshold, suivi d'une valeur numérique, détermine la valeur de force que POV-Ray recherche. La valeur par défaut, si elle n'est pas spécifiée, est threshold 1.0. En suivant le rayon et en vérifiant comment chaque composant du blob affecte le rayon, POV-Ray trouvera les points de l'espace où la force du champ est égale à la valeur seuil. La liste suivante montre certaines choses que vous devez savoir sur la valeur seuil.
- Elle doit être positive.
- Un composant disparaît si la valeur seuil est plus grande que sa force.
- Plus la valeur seuil est élevée, plus la surface visible se rapproche du centre des composants.
- Plus la valeur seuil est petite, plus la surface visible se rapproche de la surface des composants.
Les composants cylindriques sont spécifiés par une déclaration cylinder. Le centre des bases est défini par les vecteurs <End1> et <End2>. Ensuite se trouvent des valeurs numériques pour le rayon et la force. Ces éléments sont requis et séparés par des virgules. Le mot clé strength peut optionnellement précéder la valeur de la force. Le cylindre a des embouts hémisphériques à la base et au sommet.
Les composants sphériques sont spécifiés par le mot clé sphere. La position est définie par le vecteur <Center>. Ensuite vient la valeur numérique du rayon suivie de celle de la force. Ces éléments doivent être séparés par des virgules. Le mot clé strength peut optionnellement précéder la valeur de la force.
Vous appliquerez habituellement une seule texture à tout l'objet, et vous utiliserez les transformations pour changer sa taille, sa position et son orientation. Toutefois, les déclarations cylinder et sphere peuvent avoir des textures, pigments, normales, finitions et transformations individuelles. Vous ne pouvez pas appliquer des interior différents, mais vous pouvez en spécifier un pour l'ensemble.
Note : en retaillant de façon non proportionnelle un composant sphérique, vous pouvez le rendre elliptique. La section didacticielle sur "L'objet blob" illustre des blob individuels texturés et d'autres exemples.
Le mot clé component est une méthode obsolète pour un composant sphérique, et est seulement utilisé pour la compatibilité avec les versions antérieures de POV-Ray. Il ne peut pas avoir de textures ou de transformations individuelles.
Le paramètre strength est une valeur numérique spécifiant la force du champ au centre de l'objet. La force peut être positive ou négative. Une valeur positive rend le composant attractif, tandis qu'une force négative le rend répulsif. Les composants de formes blob différentes ne s'affectent pas.
Vous devez garder les choses suivantes en mémoire.
- La valeur d'une force peut être positive ou négative. Zéro est une mauvaise valeur, avec comme seul résultat que le champ n'est pas ajouté (vous auriez aussi bien pu ne pas mettre ce composant).
- Si la force est positive, POV-Ray ajoutera le champ du composant à l'espace autour de son centre. Si cet ajout est suffisant pour dépasser la valeur seuil, vous verrez une surface.
- Si la force est négative, POV-Ray retranchera le champ du composant de l'espace autour de son centre. Cela n'aura de l'effet que s'il y a un composant positif dans le voisinage. Ce qui se passe est que la surface de tout composant positif voisin sera creusée par le composant négatif.
Après avoir spécifié tous les composants et les valeurs de seuil optionnelles, vous pouvez ajouter des modificateurs de blob. Ils sont tout modificateur régulier d'objet ou les mots clés hierarchy ou sturm.
Les composants de chaque blob sont encapsulés en interne par une hiérarchie de capsules sphériques, pour accélérer les tests d'intersection des blobs, et les autres opérations. Par l'utilisation du mot clé hierarchy, suivi d'une valeur booléenne optionnelle, vous pouvez désactiver ceci. Le défaut est l'activation.
Les calculs pour les blobs doivent être très précis. Si cette forme ne se rend pas correctement, vous pouvez ajouter le mot clé sturm, suivi d'une valeur booléenne optionnelle, pour utiliser le calculateur de racine de Sturmian, plus lent mais plus précis. C'est désactivé par défaut.
Un exemple d'un blob à trois composants est :
BLOB: blob { threshold 0.6 sphere {<.75, 0, 0>, 1, 1} sphere {<-.375, .64952, 0>, 1, 1} sphere {<-.375,-.64952, 0>, 1, 1} scale 2 }
Si vous utilisez un seul composant de blob, alors la surface visible ressemblera à l'objet lui-même, c'est-à-dire une sphère ou un cylindre, avec la surface quelque part à l'intérieur de la surface même de l'objet. La position exacte de la surface peut être déterminée avec l'équation donnée plus loin (vous n'aurez probablement jamais besoin de vous en soucier, les blobs sont plus pour des attraits visuels que pour du modelage exact).
Pour les esprits plus mathématiques, voici la formule utilisée par POV-Ray pour créer des blobs. Vous n'avez pas besoin de la comprendre pour utiliser des blobs. La densité d'un champ blob pour un composant unique est :
Densité d'un champ blob
où distance est la distance entre un point donné et le centre d'un blob sphérique, ou l'axe d'un blob cylindrique. La formule a la jolie propriété d'être exactement égale au paramètre strength au centre du composant, et de chuter exactement à 0 à la distance égale au rayon. La formule de densité pour plus d'un composant blob est la somme des densités de chaque composant.
3.3.1.2 La boîte
Une simple boîte peut être définie en donnant ses deux coins en utilisant la syntaxe suivante d'une déclaration box :
BOX: box { <Corner_1>, <Corner_2> [OBJECT_MODIFIERS...] }
La géométrie d'une boîte
Où <Corner_1> et <Corner_2> sont les vecteurs définissant les coordonnées x, y, z des coins opposés de la boîte.
Note : toutes les boîtes sont définies avec leurs faces parallèles aux axes de coordonnées. Elles peuvent être tournées, plus tard, en utilisant le mot clé rotate.
Les boîtes sont calculées efficacement, et font de bonnes formes encapsulantes (si l'encapsulage manuel semble nécessaire).
3.3.1.3 Le cône
Un cône de longueur finie ou tronqué peut être défini ainsi :
CONE: cone { <Base_Point>, Base_Radius, <Cap_Point>, Cap_Radius [ open ][OBJECT_MODIFIERS...] }
La géométrie du cône
Où <Base_Point> et <Cap_Point> sont les vecteurs définissant les coordonnées x, y, z du centre de la base et du sommet, et Base_Radius et Cap_Radius sont les valeurs numériques des rayons correspondants.
Normalement, les fins de cône sont fermées par des plans parallèles entre eux, et perpendiculaires à l'axe du cône. L'ajout du mot clé optionnel open après Cap_Radius enlèvera les fermetures de bout, pour donner un tube creux comme un mégaphone.
3.3.1.4 Le cylindre
La déclaration cylinder crée un cylindre de longueur finie, avec des terminaisons parallèles. La syntaxe est :
CYLINDER: cylinder { <Base_Point>, <Cap_Point>, Radius [ open ][OBJECT_MODIFIERS...] }
La géométrie d'un cylindre
Où <Base_Point> et <Cap_Point> sont les vecteurs définissant les coordonnées x, y, z de la base et du sommet du cylindre, et Radius est une valeur numérique pour le rayon.
Normalement, les extrémités sont fermées par des plans parallèles entre eux, et perpendiculaires à l'axe du cylindre. L'ajout du mot clé open après le rayon, éliminera les fermetures, et donnera un tube creux.
3.3.1.5 Le champ de niveaux
Les champs de niveaux sont des objets rapides, et efficaces, qui sont généralement utilisés pour créer des montagnes, ou d'autres surfaces élevées, à base de centaines de triangles dans un réseau. La syntaxe de la déclaration height_field est :
HEIGHT_FIELD: height_field { [HF_TYPE] "filename" [HF_MODIFIER...] [OBJECT_MODIFIER...] } HF_TYPE: gif | tga | pot | png | pgm | ppm | jpeg | tiff | sys HF_MODIFIER: hierarchy [Boolean] | smooth | water_level Level
Les valeurs par défaut sont :
hierarchy : on smooth : off water_level : 0.0
Un champ de niveaux est essentiellement un carré d'une unité de côté, avec une surface montagneuse au sommet. La hauteur de la montagne, à chaque point, est déduite du numéro de la couleur, ou de l'index de palette, des pixels d'un fichier image. La hauteur maximale est un, qui correspond à la couleur, ou à la valeur de l'index de la palette, maximale dans le fichier image.
La taille et l'orientation d'un champ de niveaux non retaillé
Le réseau de triangles correspond directement aux pixels du fichier image. Chaque carré, formé de quatre pixels voisins, est divisé en deux triangles. Une image avec une résolution de N*M pixels a (N-1)*(M-1) carrés qui sont divisés en 2*(N-1)*(M-1) triangles.
Relation entre les pixels et les triangles dans un champ de niveaux
La résolution du champ de niveaux est influencée par deux facteurs : la résolution de l'image, et la résolution des valeurs de couleur/index. La taille de l'image détermine la résolution dans les axes x et z. Une image plus grande utilise plus de triangles, et paraît plus douce. La résolution des valeurs de couleur/index détermine la résolution le long de l'axe y. Un champ de niveaux d'une image 8 bit peut avoir 256 niveaux différents, tandis que celui d'une image 16 bit peut en avoir 65536. Donc le second champ de niveaux paraît plus doux dans la direction y, s'il est créé correctement.
La taille/résolution de l'image n'affecte pas la taille du champ de niveaux. Il sera toujours un carré d'une unité de côté, à l'origine. Des images de haute résolution créeront des triangles plus petits, pas des champs plus grands.
Il y a huit ou neuf types de fichiers qui peuvent définir un champ de niveaux. Le fichier image utilisé pour créer un champ de niveaux et spécifié par un des mots clés gif, tga, pot, png, pgm, ppm, tiff, jpeg et également sysqui est spécifique au système (comme Windows BMP ou Macintosh Pict). La spécification du type de fichier est optionnelle. S'il n'est pas défini, il sera celui déclaré comme fichier de sortie. Cela est pratique quand le source pour le height_field est aussi généré par POV-Ray.
Les formats GIF, PNG, PGM et celui du système sont les seuls pouvant être créés en utilisant un programme de dessin standard. Bien qu'il y ait des programmes de dessin pour créer des images TGA, ils ne sont pas de grande utilité pour le TGA 16 bit utilisé par POV-Ray (voir plus loin et 'HF_Gray_16' pour plus de détails).
Dans une image, comme GIF, qui utilise une palette de couleurs, le numéro de couleur est l'index de la palette, pour un pixel donné. Utilisez un programme de dessin pour voir la palette de l'image GIF. La première couleur de la palette est à l'index 0, la seconde à l'index 1, et ainsi de suite. La dernière entrée de la palette est à l'index 255. Les portions de l'image qui utilisent des entrées basses de la palette, auront les points bas du champ de niveaux. Et inversement pour les portions d'entrée élevée dans la palette.
Les champs de niveaux créés à partir de fichiers GIF, ne peuvent avoir que 256 niveaux différents.
La couleur de l'entrée de la palette n'affecte pas la hauteur du pixel. La couleur d'index 0 peut être rouge, bleu, noire ou orange, mais la hauteur de tout pixel utilisant cette entrée sera toujours 0. De même, quelle que soit la couleur de l'entrée 255, sa hauteur sera de 1.
Vous pouvez créer des images GIF pour un champ de niveaux, avec un programme de dessin, ou de fractales, comme Fractint. Vous pouvez trouver Fractint sur les mêmes sites que POV-Ray.
Un fichier POT est essentiellement un fichier GIF avec une palette 16 bit. Le maximum de couleurs d'un fichier POT est de 65536. Donc, son champ de niveaux peut avoir 65536 niveaux différents. Cela rend possible la création de champs de niveaux plus lissés.
Note : la hauteur maximale pour un champ de niveaux est toujours 1, seul le nombre de valeurs intermédiaires change.
Au moment de cette rédaction, le seul programme créant des fichiers POT est Fractint. Les fichiers générés par ce programme de fractales donnent de fantastiques paysages.
Les fichiers au format TGA et PPM peuvent être utilisés pour le stockage de nombres en 16 bits, plutôt que comme fichier image. Ces formats utilisent les bytes verts et rouges pour chaque pixel, pour stocker les bytes hauts et bas d'une hauteur. Ces fichiers sont aussi lissés que les POT, mais ils doivent être générés avec des programmes spéciaux. Plusieurs programmes peuvent créer des champs de niveaux TGA au format de POV, comme Gforge et Terrain Maker.
Les champs de niveaux au format PNG sont habituellement enregistrés sous la forme d'une image en tons de gris, avec le noir correspondant aux faibles niveaux. Parce que les fichiers PNG peuvent enregistrer jusqu'à 16 bits en tons de gris, ils seront aussi lissés que les images TGA et PPM. Puisqu'ils sont en tons de gris, vous pouvez les visualiser avec un visualiseur d'image classique. Gforge peut créer des champs de niveaux de 16 bits au format PNG. Les images colorées de type PNG seront utilisées de la même manière que les TGA et PPM.
Pour le format SYS spécifique à la plate-forme, voyez votre documentation pour plus de détails.
En plus de tous les modificateurs d'objet usuels, il y a trois modificateurs supplémentaires pour les champs de niveaux.
Un paramètre optionnel water_level peut être ajouté après le nom du fichier. Il est constitué du mot clé water_level suivi d'une valeur numérique, disant au programme d'ignorer les parties du champ de niveaux inférieures à cette valeur. La valeur par défaut est zéro, et les valeurs légales sont entre zéro et un. Par exemple, water_level 0.5 dit de ne rendre que la moitié haute du champ de niveaux. L'autre moitié est au-dessous du niveau de l'eau, et ne peut pas être vu. L'utilisation de water_level est rendu plus vite que le découpage de la partie basse par l'utilisation d'un CSG ou d'une découpe. Ce terme vient de l'utilisation populaire des champs de niveaux pour rendre des paysages. Un champ de niveaux peut être utilisé pour rendre des îles, et une autre forme simulera l'eau autour d'elles. Une large portion du champ de niveaux sera cachée par l'eau, aussi, le paramètre water_level a été introduit pour autoriser le raytraceur à ignorer les parties non visibles. water_level est aussi utilisé pour éliminer les valeurs basses inutiles d'un champ de niveaux. Par exemple, si vous avez une image d'une fractale sur un arrière plan plein coloré, où la couleur de l'arrière-plan est à l'index 0 de la palette, vous pouvez enlever l'arrière-plan du champ de niveaux en spécifiant water_level 0.001.
Normalement, l'aspect d'un champ de niveaux est rugueux et découpé, car il est constitué d'une multitude de triangles. En ajoutant le mot clé smooth, POV-Ray modifiera la normale de surface des triangles de manière à ce que leur aspect soit plus lissé. Cela peut vous permettre d'utiliser un fichier de résolution plus basse que nécessaire. Toutefois, les triangles lissés seront plus longs à rendre. La valeur par défaut est off.
Pour pouvoir accélérer les tests d'intersection, une hiérarchie d'encapsulage de premier niveau est disponible. Par défaut, elle est toujours utilisée, mais elle peut être désactivée pour, éventuellement, améliorer la vitesse de rendu des petits champs de niveaux (c'est-à-dire les images en basse résolution). Vous pouvez utiliser optionnellement une valeur booléenne comme hierarchy on ou hierarchy off.
3.3.1.6 La fractale Julia
Une fractale Julia est une tranche en 3-D d'un objet en 4-D créé par généralisation du processus utilisé pour créer la classique Julia. Vous pouvez faire une grande variété d'objets étranges en utilisant la fractale de Julia, incluant ce qui semble être des blobs bizarres en caramel vrillé. La syntaxe de la fractale Julia est :
JULIA_FRACTAL: julia_fractal { <4D_Julia_Parameter> [JF_ITEM...] [OBJECT_MODIFIER...] } JF_ITEM: ALGEBRA_TYPE | FUNCTION_TYPE | max_iteration Count | precision Amt | slice <4D_Normal>, Distance ALGEBRA_TYPE: quaternion | hypercomplex FUNCTION_TYPE: QUATERNATION: sqr | cube HYPERCOMPLEX: sqr | cube | exp | reciprocal | sin | asin | sinh | asinh | cos | acos | cosh | acosh | tan | atan |tanh | atanh | ln | pwr( X_Val, Y_Val )
Les valeurs par défaut sont :
ALGEBRA_TYPE : quaternion FUNCTION_TYPE : sqr max_iteration : 20 precision : 20 slice, DISTANCE : <0, 0, 0, 1>, 0.0
Le vecteur 4-D requis <4D_Julia_Parameter> est le paramètre Julia p classique dans la formule itérée f(h) + p. L'objet fractal Julia est calculé en utilisant l'algorithme qui détermine si un point arbitraire h(0) dans un espace 4-D est dans ou hors l'objet. Il requiert la génération de la séquence de vecteurs h(0), h(1), ... par itération de la formule h(n+1) = f(h(n)) + p (n = 0, 1, ..., max_iteration-1) où p est le paramètre vectoriel 4-D fixé de la fractale et f() est une des fonctions sqr, cube, ... spécifiée par le mot clé correspondant. Le point h(0), qui débute la séquence, est considéré interne à la fractale si aucun des vecteurs, dans la séquence, n'échappe à une hypersphère de rayon 4, par rapport à l'origine, avant que le numéro de l'itération n'atteigne la valeur max_iteration. Au fur et à mesure que vous augmentez max_iteration, des points s'échapperont, alors qu'ils ne le faisaient pas avant, formant la fractale Julia. Selon le <4D_Julia_Parameter>, l'objet fractal n'est pas forcément massif, il peut être divisé en poussière fractale. L'utilisation d'un faible max_iteration peut faire fusionner la poussière pour faire un objet massif. Un grand max_iteration est plus précis, mais moins rapide. Même si elle est moins précise, la forme pleine que vous obtenez avec un faible max_iteration peut être assez intéressante. Si rien n'est spécifié, le défaut est max_iteration 20.
Puisque l'objet mathématique est en quatre dimensions, et que POV-Ray rend des objets en trois dimensions, il y a un moyen pour réduire le nombre de dimensions de quatre à trois. Cela est accompli par l'intersection de la fractale 4D avec un plan 3D défini par un modificateur slice, puis en projetant l'intersection dans l'espace 3D. Le mot clé est suivi d'un vecteur 4D et un numérique, séparés par une virgule. Le plan est l'espace 3D perpendiculaire à <4D_Normal> et est à Distance unités de l'origine. Les vecteurs <4D_Normal> de longueur zéro ou avec un quatrième composant à zéro sont interdits. Si rien n'est spécifié, le défaut est slice <0, 0, 0, 1>, 0.
Vous pouvez vous faire une bonne idée de la nature quadri dimensionnelle de la fractale de Julia en utilisant les attributs d'animation de POV-Ray, pour varier le paramètre Distance de la tranche. Vous pouvez la faire apparaître du néant, grandir, puis disparaître dans le néant, au gré du changement de Distance, comme si la section d'un objet 3D changeait en passant à travers un plan.
Le paramètre precision est une tolérance sur la position des points à l'intérieur ou à l'extérieur de l'objet fractale. De grandes valeurs donnent des résultats plus précis, mais se rendent plus lentement. Utilisez une valeur aussi faible que possible, sans dégrader l'apparence visible de l'objet fractal mais sachez que des valeurs inférieures à 1.0 seront ramenées à 1.0. Le défaut est precision 20.
La présence du mot clé quaternion ou hypercomplex détermine quelle équation 4D est utilisée pour le calcul de la fractale. Le défaut est quaternion. Les deux sont des généralisations en 4D de nombres complexes, mais qui ne satisfont pas toutes les propriétés des champs (toutes ces propriétés des nombres réels et complexes qui nous endorment dans les grandes écoles). Les quaternions ont une multiplication non commutative, et les nombres hypercomplexes peuvent échouer dans la multiplication inverse de quelques éléments non nuls (il a été prouvé que vous ne pouvez pas généraliser les nombres complexes en gardant toutes les propriétés de champs intactes, quelque chose doit casser). Ces deux équations ont été découvertes au XIXème siècle. Des deux, les quaternions sont plus connus, mais on peut répondre que les hypercomplexes sont plus utiles pour nos desseins, puisque les fonctions à valeur complexe comme sin, cos, etc. peuvent être généralisées pour travailler avec les nombres hypercomplexes de manière uniforme.
Pour les curieux en mathématiques, les propriétés algébriques de ces deux équations peuvent être dérivées des propriétés de multiplication des vecteurs de base 1 = <1, 0, 0, 0>, i = <0, 1, 0, 0>, j = <0, 0, 1, 0> et k = <0, 0, 0, 1>. Dans les deux équations 1 x = x 1 = x pour tout x (1 est identité multiplicative). Les vecteurs de base 1 et i se comportent exactement comme les nombres complexes familiers 1 et i.
| Les règles de multiplication des vecteurs de base quaternion | ||
|---|---|---|
ij = k |
jk = i |
ki = j |
ji = -k |
kj = -i |
ik = -j |
ii = jj = kk = -1 |
ijk = -1 |
|
| Les règles de multiplication des vecteurs de base hypercomplexe | ||
|---|---|---|
ij = k |
jk = -i |
ki = -j |
ji = k |
kj = -i |
ik = -j |
ii = jj = kk = -1 |
ijk = 1 |
|
Un calcul d'estimation de distance est utilisé avec les calculs de quaternion pour les accélérer. La preuve que le fonctionnement de cette formule d'estimation de distance ne généralise pas de deux vers quatre dimensions, mais elle semble fonctionner malgré tout, en dépit de l'absence de preuve !
La présence de l'un des mots clé de fonction sqr, cube, etc. détermine quelle fonction est utilisée pour f(h) dans la formule itérée h(n+1) = f(h(n)) + p. Le défaut est sqr. La plupart des mots clés de fonction ne fonctionnent que si le mot clé hypercomplex est présent. Seuls sqr et cube fonctionnent avec quaternion. Les fonctions sont toutes des fonctions complexes familières généralisées à quatre dimensions.
Un simple exemple d'un objet fractal de Julia est :
julia_fractal { <-0.083, 0.0,-0.83,-0.025> quaternion sqr max_iteration 8 precision 15 }
Les premiers rendus de fractales de Julia utilisant des quaternions ont été faits par Alan Norton, puis par John Hart dans les années 80. Cette nouvelle implémentation de POV-Ray suit Fractint en poussant ce qui est connu dans la littérature comme l'utilisation de nombres hypercomplexes, et la généralisation de la formule itérative pour utiliser une variété de fonctions transcendantales au lieu de la classique formule de Mandelbrot z^2 + c. Avec deux dimensions supplémentaires et dix-huit fonctions pour travailler, les explorateurs intrépides seront capables de localiser quelques nouvelles bêtes fractales dans l'hyperespace !
3.3.1.7 Le 'lathe'
Le lathe est un objet généré par la rotation d'une courbe en deux dimensions autour d'un axe. Cette courbe est définie par une série de points connectés par des courbes linéaires, quadratiques, cubiques ou de Bezier. La syntaxe est :
LATHE: lathe { [SPLINE_TYPE] Number_Of_Points, <Point_1> <Point_2>... <Point_n> [LATHE_MODIFIER...] } SPLINE_TYPE: linear_spline | quadratic_spline | cubic_spline | bezier_spline LATHE_MODIFIER: sturm | OBJECT_MODIFIER
Les valeurs par défaut sont :
SPLINE_TYPE : linear_spline sturm : off
Le premier élément est un mot clé spécifiant le type de génératrice. Le défaut est linear_spline. L'entier requis Number_Of_Points détermine le nombre de points à deux dimensions formant la courbe. Les points suivent et sont représentés par des vecteurs 2D. La courbe n'est pas fermée automatiquement, c'est-à-dire que le premier et le dernier point ne sont pas connectés automatiquement. Vous devez le faire vous-mêmes, si vous voulez une courbe fermée. La courbe ainsi définie est tournée autour de l'axe des y pour former la forme centrée sur l'origine.
Les exemples suivants créent un objet 'lathe' qui ressemble à un épais cylindre, c'est-à-dire à un cylindre aux parois épaisses :
lathe { linear_spline 5, <2, 0>, <3, 0>, <3, 5>, <2, 5>, <2, 0> pigment {Red} }
Le cylindre a un rayon interne de 2 et un rayon externe de 3, lui donnant des parois de 1. Sa hauteur est 5, et il est positionné à l'origine, en pointant vers le haut, c'est-à-dire que son axe de rotation est l'axe y.
Note : les premiers et derniers points sont identiques pour donner une courbe fermée.
Les génératrices qui sont utilisées par le 'lathe' et le prisme sont un peu difficiles à comprendre. Le concept de base d'une génératrice est de dessiner une courbe selon un certain nombre de points, et d'une façon déterminée. La génératrice linéaire est la plus simple, car ce n'est rien de plus que la connexion des points consécutifs avec une ligne droite. Cela signifie que la courbe dessinée entre deux points ne dépend que de ces deux points. Aucune information complémentaire n'est prise en compte. Les autres génératrices sont différentes, car elles prennent d'autres points en compte. Cela crée une courbe adoucie, et, dans le cas de la génératrice cubique, produisent des transitions plus lissées à chaque point.
Le mot clé quadratic_spline crée des génératrices faites de courbes quadratiques. Chacune d'elle connecte deux points consécutifs. Puisque ces deux points (disons le second et le troisième) ne sont pas suffisants pour décrire une courbe quadratique, le prédécesseur du second point est pris en compte quand la courbe est dessinée. Mathématiquement, la relation (leur position dans le plan) entre le premier et le second point, détermine l'inclinaison de la courbe en ce second point. L'inclinaison de la courbe au troisième point est hors de contrôle. Ainsi, les génératrices quadratiques paraissent plus lisses que les linéaires, mais les transitions à chaque point ne sont généralement pas lisses, car les inclinaisons sont différentes des deux côtés du point.
Le mot clé cubic_spline crée des génératrices qui résolvent le problème des transitions, car elles prennent également le quatrième point en compte, lors du dessin de la courbe entre le second et le troisième point. L'inclinaison au quatrième point est maintenant sous contrôle, et autorise une transition lisse à chaque point. Ainsi, les génératrices cubiques donnent les courbes les plus flexibles, et les plus lisses.
Le bezier_spline est un type alternatif des génératrices cubiques. Les points 1 et 4 sont les bouts du segment, et les points 2 et 3 sont les contrôles donnant la pente des extrémités. Les points 2 et 3 ne sont pas liés à la génératrice. Ils ajustent seulement la pente. Si vous dessinez une ligne imaginaire entre les points 1 et 2, elle représente l'inclinaison au point 1. C'est la tangente de la courbe au point 1. Plus la distance entre le point 1 et 2 est grande, plus la courbe est plate. Avec une tangente courte, la courbe peut être plus inclinée. Le même lien existe entre les points 3 et 4. Si vous voulez une courbe lissée entre deux segments, les points 3 et 4 d'un segment et les points 1 et 2 de l'autre segment, doivent faire une ligne droite, et le point 4 d'un segment doit être le même que le point 1 de l'autre.
Vous devez noter que le nombre de segments de génératrice, c'est-à-dire les courbes entre deux points, dépend du type de génératrice utilisée. Pour les génératrices linéaires, vous obtenez n-1 segments connectant les points P[i], i=1,...,n. Une génératrice quadratique vous donnera n-2 segments, car le dernier point est seulement utilisé pour calculer l'inclinaison, comme expliqué précédemment (ainsi, vous avez, au moins, besoin de trois points pour définir une génératrice quadratique). Même chose pour les génératrices cubiques où vous aurez n-3 segments avec le premier et le dernier point utilisés seulement pour le calcul de l'inclinaison (nécessite donc au moins quatre points). La génératrice de Bezier nécessite 4 points par segment.
Si vous voulez une génératrice quadratique ou cubique fermée, avec des transitions lisses aux points de fin, vous devez vous assurer que, dans le cas de la cubique P[n-1] = P[2] (pour avoir une courbe fermée), P[n] = P[3] et P[n-2] = P[1] (pour lisser la transition). Dans le cas des quadratiques P[n-1] = P[1] (pour fermer la courbe) et P[n] = P[2].
Le mot clé sturm peut être utilisé pour spécifier que le lent, mais plus précis, calculateur de racine de Sturmian doit être utilisé. Utilisez-le, si la forme ne se rend pas correctement. Puisqu'un polynôme de quatrième degré est résolu pour les génératrices linéaire, le calculateur de racine de Sturmian n'est pas nécessaire.
3.3.1.8 Le prisme
Le prisme est un objet généré par glissement d'une, ou plus, courbe fermée le long d'un axe. Ces courbes sont définies par une série de points connectés par des génératrices linéaires, quadratiques, cubiques ou de Bezier. La syntaxe est :
PRISM: prism { [PRISM_ITEMS...] Height_1, Height_2, Number_Of_Points, <Point_1>, <Point_2>, ... <Point_n> [ open ] [PRISM_MODIFIERS...] } PRISM_ITEM: linear_spline | quadratic_spline | cubic_spline | bezier_spline | linear_sweep | conic_sweep PRISM_MODIFIER: sturm | OBJECT_MODIFIER
Les valeurs par défaut sont :
SPLINE_TYPE : linear_spline SWEEP_TYPE : linear_sweep sturm : off
Le premier élément spécifie le type de génératrice et de glissement. Le défaut est linear_spline et linear_sweep. C'est suivi de deux valeurs numériques Height_1 et Height_2 qui sont les coordonnées y du sommet et de la base du prisme. Puis vient une valeur numérique donnant le nombre de points 2D utilisés pour définir le prisme (cela inclut tous les points de contrôle nécessaires pour les génératrices quadratique, cubique et de Bezier). C'est suivi par le nombre de vecteurs 2D qui définissent la forme dans le plan x - z.
L'interprétation des points dépend du type de génératrice. L'objet prisme vous autorise l'utilisation de plusieurs sous-prismes dans la déclaration d'un prisme (ils sont du même type de déplacement et de génératrice). Partout où un nombre pair de sous-prismes se chevauchent, un trou apparaît.
Note : vous n'avez pas besoin d'avoir de multiples sous-prismes et ils n'est pas nécessaire qu'ils se chevauchent comme dans l'exemple.
Dans linear_spline, le premier point donne le début du premier sous-prisme. Les points suivants sont connectés par des lignes droites. Si vous spécifiez une valeur identique au premier point, cela ferme le premier sous-prisme, et le point suivant commence un nouveau sous-prisme. Quand vous donnez une valeur identique à ce début de sous-prisme, alors il se termine. Chaque sous-prisme est fermé de cette manière. Dans cet exemple, il y a deux sous-prismes rectangulaires emboîtés pour faire une forme.
prism { linear_spline 0, 1, 10, <0, 0>, <6, 0>, <6, 8>, <0, 8>, <0, 0>, //anneau extérieur <1, 1>, <5, 1>, <5, 7>, <1, 7>, <1, 1> //anneau intérieur }
Le dernier sous-prisme d'un prisme à génératrice linéaire est automatiquement fermé, comme le dernier sous-polygone d'une déclaration de polygone, si le premier et le dernier point du sous-prisme ne sont pas identiques. Cela rend la conversion entre les polygones et les prismes très simple. Les génératrices quadratiques, cubiques et de Bezier ne sont jamais fermées automatiquement.
Dans quadratic_spline, chaque sous-prisme demande un point de contrôle au début de sa séquence. Le premier point est un point de contrôle qui ne fait pas partie de la génératrice. Le second point est le début de la génératrice. Le sous-prisme est terminé quand le second point est dupliqué. Le point suivant est le contrôle du sous-prisme suivant. Puis viennent les points du second sous-prisme. Voici un exemple :
prism { quadratic_spline 0, 1, 12, <1,-1>, <0, 0>, <6, 0>, // anneau extérieur; <1,-1> est un point de contrôle et <6, 8>, <0, 8>, <0, 0>, // <0, 0> est le premier & dernier point <2, 0>, <1, 1>, <5, 1>, // anneau intérieur; <2, 0> est un point de contrôle et <5, 7>, <1, 7>, <1, 1> // <1, 1 > est le premier & dernier point }
Dans cubic_spline, chaque sous-prisme demande deux points de contrôle, un au début et un à la fin. Le premier point est un contrôle qui ne fait pas partie de la génératrice. Le second est le départ de la génératrice. Le sous-prisme est terminé quand le second point est dupliqué. Le point suivant est le contrôle de la fin du sous-prisme. Ensuite vient le point de contrôle du second sous-prisme. Puis vient le premier point du second sous-prisme.
Voici un exemple :
prism { cubic_spline 0, 1, 14, <1,-1>, <0, 0>, <6, 0>, // anneau extérieur; le premier contrôle est <1,-1> et <6, 8>, <0, 8>, <0, 0>, // <0, 0> est le premier & dernier point. <-1, 1>, // Le dernier contrôle de la première génératrice est <-1, 1> <2, 0>, <1, 1>, <5, 1>, // anneau intérieur; le premier contrôle est <2, 0> et <5, 7>, <1, 7>, <1, 1>, // <1, 1> est le premier & dernier point <0, 2> // Le dernier contrôle de la deuxième génératrice est <0, 2> }
La bezier_spline est une autre forme de génératrice cubique. Les points 1 et 4 donnent les extrémités du segment, et les points 2 et 3 sont des contrôles. Ils ne font pas partie de la génératrice. Ils ajustent son inclinaison. Si vous dessinez une ligne imaginaire entre les points 1 et 2, elle représente la pente au point 1. C'est la tangente de la courbe en 1. Plus la distance entre le point 1 et 2 est grande, plus la courbe est plate. Avec une tangente courte, la courbe peut être plus inclinée. Le même lien existe entre les points 3 et 4. Si vous voulez une courbe lissée entre deux segments, les points 3 et 4 d'un segment et les points 1 et 2 de l'autre segment, doivent faire une ligne droite, et le point 4 d'un segment doit être le même que le point 1 de l'autre.
Par défaut, le glissement linéaire est utilisé pour créer les prismes, c'est à dire que les parois sont perpendiculaires au plan x - z (la taille de la courbe ne change pas pendant la projection). Vous pouvez aussi utiliser conic_sweep donnant des parois coniques en réduisant la courbe au fil de la projection.
Comme les cylindres, les prismes sont normalement fermés. Vous pouvez ôter les terminaisons par l'utilisation du mot clé open. Si vous faites cela, vous ne devrez pas l'utiliser dans un CSG, car le résultat serait mauvais.
Pour une explication sur le concept des génératrices, lisez la description de l'objet "lathe". Voyez aussi les didacticiels sur "l'objet lathe" et "l'objet prisme".
Le mot clé sturm spécifie le lent, mais précis, calculateur de racine de Sturmian qui peut être utilisé avec les prismes à génératrice cubique, ou de Bezier, si le rendu est incorrect. Les prismes à génératrice linéaire ou quadratique, n'en ont pas besoin.
3.3.1.9 La sphère
La syntaxe de l'objet sphere est :
SPHERE: sphere { <Center>, Radius [OBJECT_MODIFIERS...] }
La géométrie d'une sphère
Où <Center> est le vecteur spécifiant les coordonnées x, y, z du centre de la sphère, et Radius est une valeur numérique spécifiant le rayon. Les sphères peuvent être modifiées inégalement en taille, donnant des ellipses.
Parce que les sphères sont hautement optimisées, elles font de bonnes formes encapsulantes (si l'encapsulage manuel est nécessaire).
3.3.1.10 La traînée de sphère
La syntaxe de l'objet sphere_sweep est :
SPHERE_SWEEP: sphere_sweep { linear_spline | b_spline | cubic_spline NUM_OF_SPHERES, CENTER, RADIUS, CENTER, RADIUS, ... CENTER, RADIUS [tolerance DEPTH_TOLERANCE] [OBJECT_MODIFIERS] }
Les valeurs par défaut sont :
tolerance : 1.0e-6 (0.000001)
Une traînée de sphère est l'enveloppe d'une sphère en déplacement avec un rayon variant, ou, en d'autres mots, l'espace occupé par une sphère pendant son mouvement le long d'une génératrice.
Les traînées de sphère sont modelées en spécifiant une liste de sphères qui sont interpolées.
Trois types d'interpolation sont supportées :
linear_spline: interpolation des données en entrée avec une fonction linéaire, ce qui signifie que les sphères sont connectées par des tubes rectilignes.b_spline: approximation des données en entrée en utilisant une fonction cubique b-spline, qui donne un objet incurvé.cubic_spline: approximation des données en entrée en utilisant une fonction cubique, qui donne un objet incurvé.
La liste de sphères (centre et rayon de chaque sphère) peut contenir autant de sphères que vous voulez pour décrire l'objet, mais vous avez besoin d'au moins deux sphères pour linear_spline, et quatre pour b_spline ou cubic_spline.
Optionnel : la profondeur de la tolérance qui doit être utilisée pour les calculs d'intersection. Cela est fait par ajout du mot clé tolerance et de la valeur désirée : la distance par défaut est 1.0e-6 (0.000001) et convient pour la plupart de ces objets.
Vous devez changer cela si vous voyez des points noirs sur la surface de l'objet. Ils sont probablement causés par ce que l'on appelle le "Self-Shading". Cela signifie que l'objet se porte des ombres sur lui-même en certains points à cause des erreurs de calcul. Un programme de traçage définit usuellement la distance minimale qu'un rayon doit parcourir avant de toucher un autre objet (ou le même) pour éviter cet effet. Si cette distance est trop petite, auto-ombrage peut apparaître.
Dans ce cas, spécifiez tolerance 1.0e-4 ou plus.
Note : si ces points noirs persistent après la hausse de la tolérance, vous pouvez en venir à bout en utilisant le super échantillonnage adaptatif (méthode 2) pour l'anti-crénelage. Les images paraîssent de tout façon meilleures avec l'anti-crénelage.
Note : l'opération de fusion CSG n'est pas recommandée avec les traînées de sphères : il peut y avoir un petit trou entre les objets fusionnés !
3.3.1.11 L'ellipsoïde superquadrique
L'objet superellipsoid crée une forme connue comme un objet ellipsoïde superquadrique. L'ellipsoïde superquadrique est une extension de l'ellipsoïde quadrique. Il peut être utilisé pour créer des boîtes et des cylindres aux angles arrondis, et d'autres formes intéressantes. Mathématiquement, ils sont donnés par l'équation :
Les valeurs de e et n, appelées exposant est-ouest et nord-sud, déterminent la forme de l'ellipsoïde superquadrique. Ils doivent être plus grands que zéro. La sphère est donnée, par exemple, avec e = 1 et n = 1.
La syntaxe de l'ellipsoïde superquadrique est :
SUPERELLIPSOID: superellipsoid { <Value_E, Value_N> [OBJECT_MODIFIERS...] }
Les vecteurs 2D donnent les valeurs e et n. L'objet se tient à l'origine et occupe un espace de la taille de box {<-1,-1,-1>, <1, 1, 1>}.
Deux objets utiles sont la boîte arrondie et le cylindre arrondi. Ils sont déclarés de la manière suivante.
#declare Rounded_Box = superellipsoid {<Round, Round>} #declare Rounded_Cylinder = superellipsoid {<1, Round>}
La valeur de Round détermine l'arrondi des angles, et doit être plus grande que zéro, et plus petite que un. Plus cette valeur est petite, plus les angles sont prononcés.
De très petites valeurs de e et n peuvent causer des problèmes avec le calculateur de racines (le calculateur de racine de Sturmian ne peut pas être utilisé).
3.3.1.12 La surface de révolution
L'objet sor est une surface de révolution générée par rotation du graphe d'une fonction autour de l'axe y. Cette fonction détermine la dépendance du rayon avec la position sur l'axe de rotation. La syntaxe est :
SOR: sor { Number_Of_Points, <Point_1>, <Point_2>, ... <Point_n> [ open ] [SOR_MODIFIERS...] } SOR_MODIFIER: sturm | OBJECT_MODIFIER
Les valeurs par défaut sont :
sturm : off
La valeur numérique Number_Of_Points donne le nombre de vecteurs 2D qui suivent. Les points <Point_1> à <Point_n> sont des vecteurs à deux dimensions, constitués du rayon et de la hauteur, c'est-à-dire de la position sur l'axe de rotation. Ces points sont connectés sans à-coups (la courbe passe à travers les points) et tournent autour de l'axe y pour former l'objet SOR. Les premiers et derniers points ne sont utilisés que pour déterminer l'inclinaison de la fonction aux points de départ et de fin. Ils ne font pas partie de la courbe. Cette fonction est similaire aux génératrices de l'objet 'lathe'. La différence est que le SOR est moins flexible, car il souligne les restrictions de toute fonction mathématique, c'est-à-dire qu'à tout point y sur l'axe de rotation, ne correspond qu'une valeur de fonction, qu'un rayon. Vous ne pouvez pas faire tourner des courbes fermées avec l'objet SOR. Aussi, assurez-vous que la courbe ne coupe pas l'axe y car cela peut donner des cylindres encapsulants dégradés. POV-Ray échouera probablement dans le rendu de grandes parts de la génératrice contenant de tels segments.
Le mot clé optionnel open vous autorise l'élimination des terminaisons de l'objet. Si vous le faites, vous ne pouvez pas l'utiliser dans une CSG, car le résultat serait faussé.
Le SOR est utile pour créer des bouteilles, des vases, et des choses s'en approchant. Un simple vase peut ressembler à cela :
#declare Vase = sor { 7, <0.000000, 0.000000> <0.118143, 0.000000> <0.620253, 0.540084> <0.210970, 0.827004> <0.194093, 0.962025> <0.286920, 1.000000> <0.468354, 1.033755> open }
On pourra demander pourquoi avoir besoin d'un objet SOR si c'est la même chose qu'un 'lathe' qui est plus flexible. La raison est relativement simple. Le test d'intersection avec un SOR appelle la résolution d'un polynôme cubique, tandis que pour un 'lathe', c'est un polynôme de sixième degré (vous avez besoin d'une génératrice cubique pour le même lissé). Puisque la plupart des objets SOR et 'lathe' auront plusieurs segments, cela fait une grande différence en temps de calcul. Les racines des polynômes de troisième degré sont également plus précises, et plus faciles à trouver.
Le mot clé sturm peut être ajouté pour demander le calculateur de racine de Sturmian, plus lent mais plus précis. Il peut être utilisé avec les surfaces de révolution, si la forme n'est pas correctement rendue.
Les explications suivantes sont pour les lecteurs intéressés par les mathématiques, et qui veulent savoir comment est calculée la surface de révolution. Bien qu'il ne soit pas nécessaire de lire cette suite, cela peut aider à la compréhension des objets SOR.
La fonction qui est tournée autour de l'axe des y est donnée par
avec le rayon r et la hauteur h. Puisque c'est une fonction cubique en h, c'est assez flexible pour autoriser le lissage des courbes.
La courbe, elle-même, est définie par une série de n points P(i), i=0...n-1, qui sont interpolés en utilisant une fonction pour chaque segment de la courbe. Un segment j, j=1...n-3, va du point P(j) au point P(j+1) et utilise les points P(j-1) et P(j+2) pour déterminer les inclinaisons aux extrémités. S'il y a n points, vous aurez n-3 segments. Cela signifie que vous devez avoir au moins quatre points pour une courbe. Les coefficients A(j), B(j), C(j) et D(j) sont calculés pour tous les segments utilisant l'équation
où r(j) est le rayon et h(j) est la hauteur du point P(j).
La figure ci-dessous montre la configuration des points P(i), la position du segment j, et la courbe définie par ce segment.
Points sur une surface de révolution
3.3.1.13 Le texte
Un objet texte crée un texte en 3-D comme un bloc de lettre extrudé. Actuellement, seules les polices TrueType (ttf) et les collections TrueType (ttc) sont supportées, mais la syntaxe autorise l'ajout d'autres polices dans le futur. Si les collections TrueType sont utilisées, la première police de la collection est choisie. La syntaxe est :
TEXT_OBECT: text { ttf "fontname.ttf/ttc" "String_of_Text" Thickness, <Offset> [OBJECT_MODIFIERS...] }
Où fontname.ttf ou fontname.ttc est le nom de fichier de la police TrueType. C'est une chaîne littérale entre apostrophes, ou une expression de chaîne. L'expression de chaîne qui suit est le texte actuel de l'objet. Il peut également être une chaîne littérale entre apostrophes, ou une expression de chaîne. Voir la section "Les chaînes" pour en savoir plus sur les expressions de chaîne.
Le texte commencera avec l'origine en bas à gauche, devant le premier caractère, et s'étendra dans la direction des x. La base du texte suit l'axe des x. La face des caractères se tient dans le plan x-y et le texte est extrudé dans la direction z. L'épaisseur est spécifiée par la valeur obligatoire Thickness.
Les caractères ont généralement la taille pour que 1 unité d'espace vertical soit correct. Ils ont entre 0.5 et 0.75 unités de haut.
L'espacement horizontal est géré en interne par POV-Ray en incluant les informations de la police. Le vecteur obligatoire <Offset> définit un déplacement supplémentaire entre chaque caractère. Normalement, vous devez spécifier un zéro pour cette valeur. La spécification de 0.1*x ajoutera 0.1 unité d'espace entre chaque caractère. Voici un exemple :
text { ttf "timrom.ttf" "POV-Ray" 1, 0 pigment {Red} }
Seuls les caractères imprimables sont autorisés dans le texte. Ceux comme le retour, le saut de ligne, la tabulation, l'espace arrière etc. ne sont pas supportés.
Pour un accès facilité à vos polices, renseignez le Library_Path vers votre dossier qui contient votre collection de polices.
3.3.1.14 Le tore
Un torus est une forme polynomiale quartique de quatrième ordre, qui ressemble à un beignet. Parce que cette forme est utile, et que les quartiques sont difficiles à définir, POV-Ray vous permet de prendre un raccourci, et de définir un tore avec :
TORUS: torus { Major, Minor [TORUS_MODIFIER...] } TORUS_MODIFIER: sturm | OBJECT_MODIFIER
Les valeurs par défaut sont :
sturm : off
où Major est une valeur numérique donnant le rayon majeur, et Minor est un nombre donnant le rayon mineur. Le rayon majeur s'étend du centre du trou, jusqu'à la moitié de la jante, tandis que le rayon mineur est le rayon de la jante. Le tore est centré à l'origine, et repose sur le plan x - z avec l'axe des y passant à travers le trou.
Les rayons majeur et mineur d'un tore
Le tore est encapsulé en interne par deux cylindres, et deux anneaux formant un cylindre épais. Avec cet encapsulage, la performance du test d'intersection du tore est grandement améliorée. Le test pour une intersection valide, c'est-à-dire la résolution d'un polynôme de quatrième ordre, est seulement effectué lorsque la capsule est touchée. Ainsi, de nombreux calculs de racine sont évités.
Les calculs pour tous les polynômes d'ordre élevé doivent être très précis. Si le tore est mal rendu, vous pouvez ajouter le mot clé sturm pour que POV-Ray utilise le calculateur de racine de Sturmian, plus lent, mais plus précis.
3.3 Les objets