Jean Michel soler
MKCYL
(télécharger)
Outil pour povray



  a. LES PRIMITIVES.
  b. LES METHODES DE MODELAGE/MODELISATION.
  c. MODELAGE PAR SURFACE DE ROTATION: LE TOUR.
                Surfacique:SORG
                Volumique :MKCYL
  d. MODELAGE PAR BALAYAGE DE  FORME: L'EXTRUSION.
                Palliatif: Worm et CTDS.




   a. LES PRIMITIVES


  Les  Primitives sont des formes géométriques élémentaires 
  dont  on  se sert pour construire des objets complexes en
  2D ou en 3d. 

  En 3d il existe plusieurs types de primitives: 

  Les PRIMITIVES SOLIDES FINIES 

  POV  en  gère  7.  les  BLOBS (ou méta-sphères, groupe de 
  sphères  enrichies  d'un coefficient d'attraction qui les 
  déforme  en  fonction de la proximité d'autres éléments),
  les    BOITES,  les    CONES,  les   CYLINDRES,   Les
 "height_fields"( 'champs   de   hauteur',   et   c'est
  effectivement ce que c'est: une surface dont chaque point
  défini  vaut  pour  une  hauteur  ,  à noter que ce n'est
  qu'une  extension des boites.. tronquées, il est vrai, et
  en  apparence  cela ressemble beaucoup plus à un champ de
  triangle,  les  paramètres  de  hauteurs sont passés sous
  forme de code couleur dans une image), les SPHERES et les
  tores.

  Les PRIMITIVES "PATCHES" FINIES

  POV  en connaît 4: les surfaces BI-CUBIQUES ("surfaces de
  Bézier", surfaces définies par un certain nombre de point
  de  contrôle,  plutôt  un  groupe  de  triangles  dont la
  normale est contrôlée par les courbes que définissent les
  points  de  contrôle),  les  DISQUES,  les  TRIANGLES, et
  TRIANGLES    de    PHONG  (le    terme    anglais   est
 "smooth_triangle",  que  l'on   pourrait   traduire   par
 'triangle  adouci' ou 'triangle lissé', mais ce n'est pas
  le  triangle  qui est lissé c'est la forme qu'il définit,
  habituellement  avec  un  gros paquet de ses congénères).

  A quoi peut s'ajouter le POLYGONE...

  Les PRIMITIVES SOLIDES INFINIES

  Ce  sont  des  ...  demi-espaces?  dont la surface serait
  infinie. Le PLAN est le plus utilisé. Les autres sont des
  volumes  définis  pas  des  polynomes à n degrés dont les
  variations  sont  quasiment  infinies  et font la joie de
  tous les matheux.

  b. LES METHODES DE MODELAGE/MODELISATION


  Si  on  appelle   modelé  le résultat de l'assemblage de
  primitives pour obtenir une scène 3d, on peut considérer
  qu'il  existe  deux  manière  de modeler. Par primitives
  solides,  on  parle  alors  de  modelage  volumique, par
  primitives  patches  et  cela  se  nomme   le   modelage
  surfacique.

  POV  travaille entre les deux. Mais d'autres logiciels de
  rendu  d'images  3d sont exclusivement surfaciques (c'est
  le  cas  du plus célèbre d'entre eux: 3DStudio.
  


  c. MODELAGE PAR SURFACE DE ROTATION: LE TOUR.


  L'outil  principal du modelage surfacique est le tour. On
  décrit  par  une  série  de coordonnées 2D une surface de
  révolution.  En  lui  faisant  faire  une rotation de 360
  degrés  on  obtient  un  volume.  En  fait   une sphère
  paramétrée  n'est  rien  d'autre  qu'une  série de valeur
  organisées  en  cercle  à  laquelle on fait effectuer une
  rotation  sur  un  axe  coincidant  avec   le   diamétre.

  Le  plus  célèbre  des  tours  du domaine public est SORG
 (Surface  Of Revolution Generator) de sean KELLY. Comment
  fonctionne-t-il?  Simplement  à partir d'un fichier texte
  où  l'on  indique au début de l'objet son type, PHONG, on
  obtient en sortie un fichier contenant un objet constitué
  de  smooth_triangle,  ou  rien,  et  ce  ne seront que de
  simples triangles; ensuite on fournit un nom, la longueur
  de  l'arc  de rotation le nombre de division de l'arc, et
  les anneaux sous la forme d'une hauteur et d'une distance
 àparir du centre.

  Exemple:

 +------------------------> début de l'objet
 |    +-------------------> type
 |    |      +-------------> nom
 SOR PHONG name
   +--------------------> 360 = un tour complet
  ARC 360
   +--------------------> segmentation: 6 triangles
  SEG 6
       +----------------> hauteur, le premier, c'est
       |                     normal
  RING 0 5
         +--------------> distance du centre
  RING 1 6
  RING 2 5
   END_SOR  -----------------> fin de l'objet

  Le  fichier  SORG.EXE que je possède a été modifié par G.
  BILGER  pour  être compatible avec les dernières versions
  de  POV.  Le  résultat  de  l'exemple  ressemblera très
  exactement à a:
  #declare essai = object{
  union{
smooth_triangle{
 <2.5,0,4.33013>
 <0.5,0,0.866025>
 <5,0,0>
 <1,0,0>
 <3,1,5.19615>
 <0.5,0,0.866025>
 }
smooth_triangle{
 <5,0,0>
 <1,0,0>
 <3,1,5.19615>
 <0.5,0,0.866025>
 <6,1,0><1,0,0>
}
smooth_triangle{
 <-2.5,0,4.33013>
 <-0.5,0,0.866025>
 <2.5,0,4.33013>
 <0.5,0,0.866025>
 <-3,1,5.19615>
 <-0.5,0,0.866025>
}

  (une vingtaine de ligne plus loin:  ...)

smooth_triangle{
 <5,2,-1.22461e-15>
 <1,0,-2.44921e-16>
 <2.5,2,-4.33013>
 <0.5,0,-0.866025>
 <6,1,-1.46953e-15>
 <1,0,-2.44921e-16>
}
smooth_triangle{
 <2.5,2,-4.33013>
 <0.5,0,-0.866025>
 <6,1,-146953e-15>
 <1,0,-2.44921e-16>
 <3,1,-5.19615>
 <0.5,0,-0.866025>
 }
  }
 }

   Le  point  délicat:  il  n'y  a  pas de virgule entre les
   coordonnées  3D,  ce  que  POV  2.2  ne  digère pas trop.

   Le problème des objets 3d issus d'un tour: on ne peut pas
   les  utiliser  dans des opérations de CSG (sauf l'UNION).

   L'idée  de produire un tour pour modelage solide s'impose
   d'elle-même.  La réalisation en est d'une grande facilité
 (une  des raisons pour lesquelles je ne fournirai pas les
   sources),  en  fait  chaque  anneau  sera remplacé par un
   cône.  J'ai  d'ailleurs  écrit  un tour volumique dont le
   détail  du  langage  suit et que l'on trouvera en annexe:
  ; Fichier de donnés fcy.  ; (c) j.m. Soler.
  ;
  ;   Six types d'objets peuvent être définis:
  ;  ANEL_ et ANELC,
  ;  CONE_ et CONELC
  ;  ANNEA et LIENS
  ;   ANEL renvoie un cylindre plein , ANELC un cylindre évidé
  ;   de l'épaisseur indiquée
  ;
  FCY   ;   entrée d'objet
  ;
  NOM   cylindre   ; nom de l'objet
  DIRECTION z   ; direction du "tour"
  ;  Localisation
  ;  |   Longueur
  ;  |   |   Largeur
  ;  |   |   |
  ;  v   v   v
  ANEL_ <0.1,0.2,2.0> <2.001>  <2.11>
  ;
  ; Donne la formulation suivante acceptée par pov2.2:
  ;  object{ union{
  ;  object{ cylinder{<0,0,0>,<0,0,2>,2}}
  ;  // object_cylindre_1
  ; ...
  ;
  ANELC <0,0,0> <2> <2>  <0.1>
  ;   A
  ; |
  ;  Epaissseur de l'objet
  ;
  ;ajoute:
  ;  object{ difference{
  ;   object{ cylinder{<0,0,0>,<0,0,2>,2}}
  ;   object{ cylinder{<0,0,0.05>,<0,0,2.05>,1.9}}
  ;  }} // object_cylinder_2
  FCY_FIN
  ;termine par :
  ; } // fin_union
  ; } // object_cylinder_fin

   Le  seul  reproche  que  l'on  peut faire à SORG ou MKCYL
   c'est  de  laisser des traces horizontales. Le lissage de
   la  forme ne se faisant  que sur ce plan, des lignes sont
   visibles à la séparation de chaque anneau.


   d. MODELAGE PAR BALAYAGE DE FORME: L'EXTRUSION

   On  peut  se demander pourquoi dans MKCYL les objets sont
   localisés  en  3d  alors que sur un tour tous les volumes
   devraient  avoir  le  même  axe.  J'avais  pensé  dans un
   premier  temps à développer (et ce n'est pas complètement
   abandonné) un version capable de gérer le déplacement des
   formes  dans  l'espace.  Donc  à  réaliser  une  sorte de
   modelage  par  balayage  de  forme... Je dois avouer que
   L'operateur LIENS devait servir dans ce sens et qu'il n'a
   pas été implémenté parce que j'avais quelques difficultés
   à  réaliser  des  raccords  de  volumes satisfaisant dans
   l'espace (pour donner une idée du problème cela revient à
   combiner  une  paire  de  tangentes  et  deux  raccord de
   cercles dans une même formule. La partie est remise, mais
   je ne baisse pas définitevement les bras)

   En matière de modelage par balayage de forme, il n'existe
   pas grand chose dans le domaine public. Et pour tout dire

   je ne vois rien qui permette de définir une forme en 2D
   et lui fasse parcourir un chemin en 3D, tout en récuperant
   les données sous la forme de triangles.

   Ce  qui  s'en  rapproche  le  plus  c'est WORM de Robert
   Flores.  Et  WORM  tout  seul  ne  produit  guère que des
   sphères  positionnées dans l'espace (mais avec l'avantage
   d'une interface graphique). Le fichier de données fourni
   peut  être  destiné  à  POV,  VIVID ou apparaître sous la
   forme de données brutes, RAW, au format:

  [x],[y],[z], [rayon]

   Exemple:

  121
 -22,10,0,.5,0
 -23.74991,8.912839,0,.5833333,1
 -25.27064,7.523061,0,.6666666,1
 -26.51056,5.877853,0,.7499999,1
 ( ...
  et 115 lignes plus loin:
  ... )
   28,-3,0,1,1
   28,-10,0,1,1

   Si  on  veut réellement avoir un objet volumique plein il
   faut  utiliser  CTDS  de  Truman  Brown  (Connect The Dot
   Smoother)  qui  effectue des liens de sphères lissés dans
   l'espace  (pour reprendre textuellement la description de
   l'auteur).  Dans  ce cas particulier WORM peut fournir un
   fichier dans ce format:

  ; Worm 1
  ;
 -7.250  -1.750   0.0   0.5
 -5.5  -3.5   0.0   0.5
 -4.0  -5.0   0.0   0.5
   10.250  -7.0   0.0   8.0

   que CDTD transformera en :

//------------------------------------------------
// This file generated by CTDS 2.3 Copyright 1992,
// 1993 Truman Brown
//------------------------------------------------
 #declare CTDS_Texture =
  texture {
  color red 0.556863 green 0.419608 blue 0.137255
  ambient 0.2
  diffuse 0.7
 }

 #declare Dot =
  quadric {
 < 1 1 1 >
 < 0 0 0 >
 < 0 0 0 > -1
 }

 #declare Connector_1 =
  object {
  quadric {
 < 0 1 1 >
 < 0 0 0 >
 < 0 0 0 > -1
 }
  clipped_by {
  plane { < 1 0 0 > 1 }
  plane { <-1 0 0 > 0 }
 }
 }

 #declare Connector_2 =
   quadric {
 < 1 -1 1 >
 < 0  0 0 >
 < 0  0 0 > 0
   rotate < 0 0 90 >
 }

 #declare transx1 = 0
 #declare transy1 = 0
 #declare transz1 = 0

 #declare transx2 = 0
 #declare transy2 = 0
 #declare transz2 = 0

 #declare scalex1 = 1
 #declare scaley1 = 1
 #declare scalez1 = 1
 /*-----------------------------------------*/
 #declare YourThing =
   composite {
   object {
   quadric {
  Dot
  scale  < 0.50  0.50  0.50>
  translate <-7.25 -1.75  0.>
 }
  texture { CTDS_Texture }
 }
  object {
  Connector_1
  scale  < 2.474874  0.50  0.50>
  rotate  < 0.  0. -45.>
  translate <-7.25 -1.75  0.>
  texture { CTDS_Texture }
 }
  object {
  quadric {
  Dot
  scale  < 0.50  0.50  0.50>
  translate <-5.50 -3.50  0.>
 }
  texture { CTDS_Texture }
 }
   object {
   Connector_1
   scale  < 2.121320  0.50  0.50>
   rotate  < 0.  0. -45.>
   translate <-5.50 -3.50  0.>
   texture { CTDS_Texture }
 }
   object {
   quadric {
   Dot
   scale  < 0.50  0.50  0.50>
   translate <-4. -5.  0.>
 }
   texture { CTDS_Texture }
 }
   object {
   quadric { Connector_2 }
   clipped_by {
   plane { < 1.  0.  0.>  6.827441 }
   plane { < 1.  0.  0.>  0.426715 inverse }
 }
   translate <-0.426715  0.  0.>
   scale  < 1.637410  1.  1.>
   translate <-0.260604  0.  0.>
   rotate  < 0.  0. -7.989327>
   translate <-4. -5.  0.>
   texture { CTDS_Texture }
 }
   object {
   quadric {
   Dot
   scale  < 8.  8.  8.>
   translate < 10.25 -7.  0.>
 }
   texture { CTDS_Texture }
 }
   bounded_by {
   box { < -7.75 -15. -8.>
 < 18.25  1.  8.> }
 }
 }

   Etonnant  de  longueur pour quelques malheureuses données
   de départ. On doit pouvoir faire plus sobre, d'autant que
   ce  fichier ne sera pas accepté par POV2.2 san s l'option
 +M1.  MAis  c'est  une autre histoire... Par contre, CTDS
   n'est  pas la panacée en matière de liaison de forme. son
   gros défaut,  outre  la  longueur  des scripts, c'est sa
   gestion  des  "fenêtrages". Dans un groupe de sphères, il
   peut  y  avoir  un  vide cerné. Ce vide n'est pas pris en
   compte;  il  est  "comblé" tout simplement.