Extrusion

  • Im Prinzip hat man sich dabei folgendes vorzustellen:
  • Gegeben ist eine Querschnittsfläche (Polygon) in der x-z-Ebene durch die (beiden) Koordinaten der Eckpunkte
  • weiters ein Polygon im Raum (Trajektorie), durch x-y-z-Koordinaten der Punkte gegeben.
  • der Querschnitt wird nun entlang der Trajektorie geführt und beschreibt dabei ein Polyeder. Denkt man sich an Stelle beider Polygone Kurven, so wird eine Querschnittkurve entlang eines Trajektorie geführt, und zwar so, dass die Ebene des Querschnittes immer normal zur Trajektorie ist. Dabei entsteht allerdings keine Schiebfläche (bei dieser wären die Querschnitte immer parallel). 
    Außerdem kann man nun noch den Querschnitt beliebig skalieren und ihm auch noch eine Rotation auferlegen
  • beginCap und endCap schließen das Objekt am Anfang und am Ende, scale kann einmal für alle eingetragen werden oder für jeden einzelnen Punkt des spine extra, ebenso eine allfällige Drehung des Querschnittes
 
Extrusion { beginCap TRUE
            endCap TRUE
            ccw TRUE
            convex TRUE
            creaseAngle 0
            crossSection [1 1,  1 -1,   -1 -1,   -1 0,   1 1]
            orientation 0 0 1 0
            scale 1 1
            solid TRUE
            spine [0 0 0,  0 1 0]
          }
Hier ist der Querschnitt ein Quadrat, es wird unten in vierfacher und oben in doppelter Größe eingesetzt. Ersetzt man das zweite scale durch 0 0, so ergibt sich eine Pyramide.
#VRML V2.0 utf8

Viewpoint { position 2 0 10 }

Transform { children
            Shape { appearance Appearance { material Material {}}
                    geometry Extrusion
                    {  endCap TRUE beginCap TRUE solid TRUE
                       crossSection [ 1 0  0 1  -1 0  0 -1  1 0 ]
                       spine        [ 0 0 0  0 2 0 ]
                       scale        [ 4 4  2 2 ]
                    }
                  }
          }
Mit Extrusionen lassen sich ganz einfach Drehflächen modelliern: als Trajektorie nimmt man eine lotrechte Gerade, als Querschnitt einen Kreis in der x-z-Eben bzw. eine polygonale Annäherung), wie z.B. hier:
#VRML V2.0 utf8

Viewpoint { position 3 4 16  orientation  0 1 0   0.01 }
Shape { appearance Appearance { material Material {diffuseColor    1 1 1 } }
        geometry Extrusion
        { endCap FALSE
          solid FALSE
          crossSection [ -1 -3,  -3 -1,  -3  1,  -1  3,  1 3,   3 1,  3 -1,  1 -3,  -1 -3   ]
          scale        [ 0.8 0.8,  0.1 0.1,  0.2 0.2,  0.4 0.4,  0.8 0.8,  1 1,    0.9 0.9 ]
          spine        [ 0 0 0,    0 0.3 0,  0 1.5 0,  0 2 0,    0 4 0,    0 7 0,  0 7 0 ]
         }
       }
Natürlich müsste man hier den Querschnitt besser an einen Kreis annähern. Man kann die Querschnitte aber auch noch etwas drehen, um ein weniger eckiges Objekt zu erhalten, siehe hier:
#VRML V2.0 utf8

Viewpoint { position 3 4 16  orientation  0 1 0   0.01  }
Shape { appearance Appearance { material Material {diffuseColor    1 1 1 } }
        geometry Extrusion
        { endCap FALSE
          solid FALSE
          crossSection [ -1 -3,  -3 -1,  -3  1,  -1  3,  1 3,   3 1,  3 -1,  1 -3,  -1 -3   ]
          scale        [ 0.8 0.8,    0.1 0.1,    0.2 0.2,      0.4 0.4,    0.8 0.8,    1 1,     0.9 0.9 ]
          spine        [ 0 0 0,      0 0.3 0,    0 1.5 0,      0 2 0,      0 4 0,      0 7 0,   0 7 0   ]
          orientation  [ 0 1 0 0.2   0 1 0 0.4   0 1 0 0.6 0   1 0 0.8 0   1 0 1 0 1   0 1.2 0  1 0 1.4 ]
       }
      }
Allgemeines Verfahren zur Abbildung von Drehflächen mit der Achse y und mit der Gleichung    r2 = x2 + z2 = f(y)2
crossSection   [ Punkte eines Kreises mit r=1 ]
spine             [ 0  yi  0,       i=1, ... n ]
scale             [ f(yi)  f(yi),   i=1, ... n ]

Angenommen: die Parabel  y = x2/4 soll um die y-Achse rotieren. r = x = f(y) = 2√y

#VRML V2.0 utf8

Viewpoint {  position 1 5 12    orientation  1 0 0   -0.1 }

Shape { appearance Appearance { material Material {diffuseColor    1 1 1 } }
        geometry Extrusion
        { endCap FALSE
          solid FALSE
          crossSection [0 1, 0.71 0.71, 1 0, 0.71 -0.71, 0 -1, -0.71 -0.71, -1 0, -0.71 0.71, 0 1 ]
          scale    [ 0 0 ,   0.63 0.63,  0.89 0.89,  1.26 1.26,  1.79 1.79,  2.19 2.19,  2.83 2.83  4 4   ]
          spine    [ 0 0 0,  0 0.1 0,    0 0.2 0,    0 0.4 0,    0 0.8 0,    0 1.2 0,    0 2 0      0 4 0 ]
        }
      }
Spätestens hier wird es Zeit, sich einige Dinge ein für allemal vorzubereiten: eine Punkteliste des Einheitskreises und einer Schraublinie (r=1, Ganghöhe = 4.8), beides auf 24 Unterteilungen des rechten Winkels (15°). Sollen Radius und Ganghöhe andere Werte haben, kann man sie mit scale einstellen.

Für die Spirale wurde genommen: x = 3*cos(t), y = 5, z = 3*sin(t), alles noch multipliziert mit exp(0.2*t)

Einheitskreis Einheitskreis Schraublinie Spirale
 1.000   0.000,
 0.966   0.259,
 0.866   0.500,
 0.707   0.707,
 0.500   0.866,
 0.259   0.966,
 0.000   1.000,
-0.259   0.966,
-0.500   0.866,
-0.707   0.707,
-0.866   0.500,
-0.966   0.259,
-1.000   0.000,
-0.966  -0.259,
-0.866  -0.500,
-0.707  -0.707,
-0.500  -0.866,
-0.259  -0.966,
 0.000  -1.000,
 0.259  -0.966,
 0.500  -0.866,
 0.707  -0.707,
 0.866  -0.500,
 0.966  -0.259,
 1.000   0.000
 
 1.000  0   0.000,
 0.966  0   0.259,
 0.866  0   0.500,
 0.707  0   0.707,
 0.500  0   0.866,
 0.259  0   0.966,
 0.000  0   1.000,
-0.259  0   0.966,
-0.500  0   0.866,
-0.707  0   0.707,
-0.866  0   0.500,
-0.966  0   0.259,
-1.000  0   0.000,
-0.966  0  -0.259,
-0.866  0  -0.500,
-0.707  0  -0.707,
-0.500  0  -0.866,
-0.259  0  -0.966,
 0.000  0  -1.000,
 0.259  0  -0.966,
 0.500  0  -0.866,
 0.707  0  -0.707,
 0.866  0  -0.500,
 0.966  0  -0.259,
 1.000  0   0.000
 
 1.000  0     0.000,
 0.966  0.2   0.259,
 0.866  0.4   0.500,
 0.707  0.6   0.707,
 0.500  0.8   0.866,
 0.259  1     0.966,
 0.000  1.2   1.000,
-0.259  1.4   0.966,
-0.500  1.6   0.866,
-0.707  1.8   0.707,
-0.866  2     0.500,
-0.966  2.2   0.259,
-1.000  2.4   0.000,
-0.966  2.6  -0.259,
-0.866  2.8  -0.500,
-0.707  3    -0.707,
-0.500  3.2  -0.866,
-0.259  3.4  -0.966,
 0.000  3.6  -1.000,
 0.259  3.8  -0.966,
 0.500  4    -0.866,
 0.707  4.2  -0.707,
 0.866  4.4  -0.500,
 0.966  4.6  -0.259,
 1.000  4.8   0.000
 
 3.000  5.000   0.000
 2.750  4.745   0.737
 2.340  4.503   1.351
 1.813  4.273   1.813
 1.217  4.055   2.107
 0.598  3.848   2.230
 0.000  3.652   2.191
-0.538  3.466   2.009
-0.987  3.289   1.709
-1.324  3.121   1.324
-1.539  2.962   0.889
-1.629  2.811   0.436
-1.600  2.667   0.000
-1.467  2.531  -0.393
-1.248  2.402  -0.721
-0.967  2.280  -0.967
-0.649  2.163  -1.124
-0.319  2.053  -1.190
 0.000  1.948  -1.169
 0.287  1.849  -1.072
 0.526  1.755  -0.912
 0.706  1.665  -0.706
 0.821  1.580  -0.474
 0.869  1.500  -0.233
 0.854  1.423   0.000
Paraboloide
Mit einigen Tricks kann man auch Paraboloide erledigen, weiß man doch, dass sie durch Verschieben einer Parabel längs einer anderen mit paralleler Achse entstehen.
D.h. cross section ist eine Parabel und spine ebenfalls, man kann eigentlich gleich dieselben Koordinaten verwenden. Und damit die Querschnittsparabel nicht senkrecht zur spine Parabel geführt wird, muss man sie nur um den Tangentenwinkel  arctan ( f' ) zurückdrehen. Je nachdem ob die Parabeln in dieselbe Richtung offen sind oder nicht, erhält man ein elliptisches oder hyperbolisches Paraboloid
#VRML V2.0 utf8

Shape         { appearance Appearance { material Material {}}
                geometry Extrusion { endCap FALSE beginCap FALSE solid FALSE
   crossSection
   [2.00  2      1.53  1.75   1.13  1.5   0.78  1.25   0.50  1     0.28  0.75   0.13  0.5   0.03  0.25   0.00  0
    0.03 -0.25   0.13 -0.5    0.28 -0.75  0.50 -1      0.78 -1.25  1.13 -1.5    1.53 -1.75  2.00 -2 ]
   spine
   [-2     2.00  0   -1.75  1.53  0  -1.5   1.13  0   -1.25  0.78  0   -1     0.50  0  -0.75  0.28  0   -0.5   0.13  0
    -0.25  0.03  0    0.00  0     0   0.25  0.03  0    0.5   0.13  0    0.75  0.28  0   1     0.50  0    1.25  0.78  0
     1.5   1.13  0    1.75  1.53  0   2     2.00  0 ]
   orientation
   [ 0 0 1  1.11   0 0 1  1.05   0 0 1  0.98   0 0 1  0.90   0 0 1  0.79   0 0 1  0.64   0 0 1  0.46  0 0 1  0.24
     0 0 1  0.00   0 0 1 -0.24   0 0 1 -0.46   0 0 1 -0.64   0 0 1 -0.79   0 0 1 -0.90   0 0 1 -0.98  0 0 1 -1.05   0 0 1  -1.11 ]
   }
  }
Man kann durchaus auch anspruchsvollere Objekte entwerfen, z.B. ein Kreiskonoid oder ein Plückerkonois.
#VRML V2.0 utf8

Viewpoint {  position 3 4 16  orientation  0 1 0   0.01  }
Shape { appearance Appearance { material Material {diffuseColor    1 1 1 } }
        geometry Extrusion
        { beginCap FALSE
          solid FALSE
          crossSection [1.000   0.000,
                        usw. usf. die ganze Liste
                        1.000   0.000   ]
          scale    [ 2 2,    2 0   ]
          spine    [ 0 0 0,  0 4 0 ]
         }
       }
Eine (halbe) Normalkreisschraubfläche. Wie bereits angemerkt wird die Querschnittsfläche so an der als Kurve gedachten Trajektorie geführt, dass ihre Ebene stets normal zur Trajektorie steht. Daher ergibt sich hier eben eine Normalkreisschraubfläche (oder Schraubrohrfläche). Darunter zu sehen ist eine Wendelfläche. Sie entsteht durch Extrusion einer Strecke mit einigen Zwischenpunkten entlang einer Schraublinie. Auf dieselbe Weise entsteht eine Spiralwendelfläche, die Extrusion wird entlang einer Spirale ausgeführt.
#VRML V2.0 utf8

Shape {
        appearance Appearance { material Material { } }
        geometry Extrusion { creaseAngle 1.57   endCap  FALSE   beginCap  FALSE   solid  FALSE
        crossSection
                [  1.000   0.000,   ... usw. usf. ... unser Kreis, oder auch nur ein Halbkreis ]
        spine   [  1.000  0  0.000, ... usw. usf. ... unsere Schraublinie, ev. mit halben y-Koordinaten  ] 
        scale   [0.8  0.8]
        }
}
#VRML V2.0 utf8
Background { skyColor 0.5 0.5 1.0 }
Viewpoint { position 1 5 12 orientation 1 0 0 -0.2 }

DEF schraub1
Transform { children
            Shape { appearance Appearance { material Material {}}
                    geometry Extrusion
                    {  endCap TRUE beginCap TRUE solid FALSE
                       crossSection [  2 0, 1.5 0, 1 0, 0.5 0, 0 0, -0.5 0, -1 0, -1.5 0, -2 0 ]

                       spine        [ 1.000 0 0.000,   ... usw. usf., unsere Schraublinie  ]   } }}

DEF  Uhr TimeSensor { cycleInterval 6.0 startTime 0 loop TRUE }
DEF  Animation OrientationInterpolator
{   key      [ 0,        0.33,       0.66,       1        ]
    keyValue [ 0 1 0  0, 0 1 0  2.1, 0 1 0  4.2, 0 1 0  0 ]
}
ROUTE Uhr.fraction_changed TO Animation.set_fraction
ROUTE Animation.value_changed TO schraub1.rotation

#VRML V2.0 utf8
Viewpoint {  position 1 5 12    orientation  1 0 0   -0.2 }
Shape {
        appearance Appearance { material Material { diffuseColor 0 1  0 } }
        geometry Extrusion { creaseAngle 1.57   endCap  FALSE   beginCap  FALSE   solid  FALSE
        crossSection
                [  1.000   0.000,   ... usw. usf. ... unser Kreis, oder auch nur ein Halbkreis ]
       spine
             [  3.000 5.000  0.000   usw. usf. die Spirale    ]
       scale [1.000 1.000   0.949 0.949  0.901 0.901  0.855 0.855   0.811 0.811  0.770 0.770   0.730 0.730
              0.693 0.693   0.658 0.658  0.624 0.624  0.592 0.592   0.562 0.562  0.533 0.533   0.506 0.506
              0.480 0.480   0.456 0.456  0.433 0.433  0.411 0.411   0.390 0.390  0.370 0.370   0.351 0.351
              0.333 0.333   0.316 0.316  0.300 0.300  0.285 0.285
             ]
      }
}
Shape {appearance Appearance {material Material {diffuseColor 1 0 0} }  geometry Sphere {radius 0.2 } }
Die nächsten Skripte zeigen Torusflächen. Das erste ist sehr grob interpoliert zur deutlicheren Sichtbarkeit des Gedankens, der zweite ist sehr fein und ist mit einer herumrollenden Kugel versehen.
Der Querschnitt ist ein der Wulstkreis mit w=3 angenommen und acht seiner Punkte eingetragen, dann wurde eine Folge von Hilfswinkeln t = 0", 45" usw. genommen und als spine die Punkte mit der Höhe sin(t) auf der y-Achse genommen und dann die scale Werte wie folgt berechnet: als erzeugender Kreisradius wurde r = 1 angenommen. Der Torusparallelkreis mit der geografischen Breite t hat den Radius p = r*cos(t) + (w-r), d.h. der Wulstkreis wird mit dem Faktor p/w geschrumpft. Der erste scale Wert ist 1 1, der zweite für t = 45° ist  (1*cos 45° + 2)/3 = 0.902 usw.
#VRML V2.0 utf8

Shape { appearance Appearance { material Material {}}
        geometry Extrusion
        {  endCap FALSE beginCap FALSE solid FALSE
           crossSection [ 0 3, 2.12 2.12, 3 0, 2.12 -2.12, 0 -3, -2.12 -2.12, -3 0, -2.12 2.12, 0 3 ]
           spine        [ 0 0 0, 0 -0.71 0, 0 -1 0, 0 -0.71 0, 0 0 0]
           scale        [ 1 1, 0.902 0.902, 0.667 0.667, 0.43 0.43, 0.333 0.333]
        }
      }
#VRML V2.0 utf8

Shape  { appearance Appearance { material Material {}}
         geometry Extrusion { endCap FALSE beginCap FALSE solid FALSE
         crossSection
         [  3     0,       2.97  0.39,     2.89  0.78,     2.77  1.14,
            2.59  1.50,    2.38  1.82,     2.12  2.12,     1.82  2.38,
            1.50  2.59,    1.14  2.77,     0.78  2.89,     0.39  2.97,
            0     3,      -0.39  2.97,    -0.78  2.89,    -1.14  2.77,
           -1.50  2.59,   -1.82  2.38,    -2.12  2.12,    -2.38  1.82,
           -2.59  1.50,   -2.77  1.14,    -2.89  0.78,    -2.97  0.39,
           -3     0,      -2.97 -0.39,    -2.89 -0.78,    -2.77 -1.14,
           -2.59 -1.50,   -2.38 -1.82,    -2.12 -2.12,    -1.82 -2.38,
           -1.50 -2.59,   -1.14 -2.77,    -0.78 -2.89,    -0.39 -2.97,
            0     -3,      0.39 -2.97,     0.78 -2.89,     1.14 -2.77,
            1.50 -2.59,    1.82 -2.38,     2.12 -2.12,     2.38 -1.82,
            2.59 -1.50,    2.77 -1.14,     2.89 -0.78,     2.97 -0.39,
            3     0  ]
         spine
         [  0  0     0,    0 -0.130 0,    0 -0.258 0,    0 -0.382 0,
            0 -0.5   0,    0 -0.608 0,    0 -0.707 0,    0 -0.793 0,
            0 -0.866 0,    0 -0.923 0,    0 -0.965 0,    0 -0.991 0,
            0 -1     0,    0 -0.991 0,    0 -0.965 0,    0 -0.923 0,
            0 -0.866 0,    0 -0.793 0,    0 -0.707 0,    0 -0.608 0,
            0 -0.5   0,    0 -0.382 0,    0 -0.258 0,    0 -0.130 0,    0  0   0 ]
         scale
         [  1     1    ,   0.997 0.997,   0.988 0.988,   0.974 0.974,
            0.955 0.955,   0.931 0.931,   0.902 0.902,   0.869 0.869,
            0.833 0.833,   0.794 0.794,   0.752 0.752,   0.710 0.710,
            0.666 0.666,   0.623 0.623,   0.580 0.580,   0.539 0.539,
            0.5   0.5  ,   0.463 0.463,   0.430 0.430,   0.402 0.402,
            0.377 0.377,   0.358 0.358,   0.344 0.344,   0.336 0.336,   0.333 0.333 ]
    }
  }
}
DEF Kugel Transform  {  children
                        [  Transform
                           {  translation 0 0 2
                              children   [  Shape    { appearance Appearance { material Material { diffuseColor 1 0 0} }
                                                       geometry Sphere {radius 0.99}   }
                                         ]
                           }
                        ]
                     }
DEF Rotierer OrientationInterpolator  {  key [0 0.5 1]   keyValue  [0 1 0  0, 0 1 0  3.14, 0 1 0  6.28]  }
DEF Uhr TimeSensor  {  startTime 0.0  stopTime 1.0   cycleInterval 5.0  loop TRUE   }
DEF Schalter TouchSensor {}

ROUTE Schalter.touchTime TO Uhr.set_startTime
ROUTE Uhr.fraction_changed TO Rotierer.set_fraction
ROUTE Rotierer.value_changed TO Kugel.set_rotation
Sogar ein etwas schräges Bauwerk wie der Murturm lässt sich leicht entwerfen (wobei aber nur auf die prinzipielle Geometrie geachtet wurde).
#VRML V2.0 utf8

Viewpoint { position 2 6 10  orientation  1 0 0   -0.3  }

Shape { appearance Appearance { material Material {diffuseColor    0.5 0.5 1}}
        geometry Extrusion {  endCap  FALSE   beginCap  FALSE   solid  FALSE
        crossSection          [  1 0, 1 -0.75, 1 0, 2 0, 2 -0.75, 2 0  ]
        spine                 [  1.000  0     0.000,
                                 0.707  0.3   0.707,
                                 0.000  0.6   1.000,
                                -0.707  0.9   0.707,
                                -1.000  1.2   0.000,
                                -0.707  1.5  -0.707,
                                 0.000  1.8  -1.000,
                                 0.707  2.1  -0.707,
                                 1.000  2.4   0.000
                                 0.707  2.7   0.707,
                                 0.000  3     1.000,
                                -0.707  3.3   0.707,
                                -1.000  3.6   0.000,
                                -0.707  3.9  -0.707,
                                 0.000  4.2  -1.000,
                                 0.707  4.5  -0.707,
                                 1.000  4.8   0.000 ]
        scale                 [  1  1 ]
                         }
     }