ALIs
kommt nochExponent Graphics fuer C und Fortran von Visual Numerics
Exponent Graphics ist eine an den Sun-Workstations des LRZ interaktiv benutzbare Graphikbibliothek von urspruenglich in C geschriebenen Funktionen. Sie kann sowohl ueber C- als auch Fortran-Programme aufgerufen werden.
Inhalt
-
Allgemeine Themen
- Grundstruktur: der Graphikbaum
- das C-Programm für den eg-Start
- Use- und tag-Files
-
Über die Interaktivität von eg
- Möglichkeiten für den Endbenutzer
- Einfache Veränderung von Menues durch den Programmierer
- Der Call-back Mechanismus
Spezielle Themen
- Hilfsattribute
-
Dreidimensionale Probleme
- Facettierung von Objekten/Flächen
- Erzeugung von Plots der drei
Grundkörper:
Ellipsoid, Kegel/Kegelstumpf, Toroid - Gegeben: Diskrete Punkte im Dreidimensionalen
- Spezialfall von 6.3:
Flächendarstellung über Hermite Patches
- Kurvendarstellungen in der Ebene
- Höhenlinien und Niveauflächen (contour lines and surfaces)
Übersicht über die Dokumentation zu
eg
Exponent Graphics im Vergleich zur LRZ-Graphik
Einleitung
Exponent Graphics (eg) ist eine interaktiv benutzbare Graphikbibliothek von ursprünglich in C geschriebenen Funktionen.
Am LRZ wurde Exponent Graphics für C (egc) von Visual Numerics (frü- her IMSL) in der Version 2.0 im Mai 1994 an den Sun-Workstations unter SunOS installiert. Wegen der Umstellung unserer Sun-Workstations auf das Betriebssystem Solaris 2.4 (=SunOS 5.4) wurde eine Neuinstallation erforderlich.
Bisher konnte Exponent Graphics nur über C-Programme aufgerufen wer- den. Die jetzt erfolgte Neuinstallation dieser Graphikbibliothek in der Version 2.1 ermöglicht auch die Benutzung von Fortran-Programmen aus - ganz analog zur Benutzung über C.
Diese Schrift ersetzt nicht die zu Exponent Graphics gehörige Doku- mentation. Sie möchte aber die Benutzung von eg erleichtern, indem sie mehr Gewicht auf Darstellung gewisser Themen legt. Die interaktiv zugängliche Dokumentation liefert dazu stets die Details und eine Fülle von Beispielen, die den richtigen Einsatz der eg-Strukturen de- monstrieren.
Durch die Integration der eg-f77-Variante sind in dieser Hinsicht einige zusätzliche Erklärungen in dieser Schrift erforderlich. Jedoch werden nur die allgemeinen Unterschiede zwischen C und Fortran f77 angeführt, wie
- Übersetzung, Laden und Starten für C bzw. f77
- Unterschiedliches Aussehen der C- bzw. f77-Funktionen, wobei jede C-Funktion ein f77-Pendant hat.
- Unterschiede bei den Attributangaben für C und f77 sowie bezüglich use- und tag-Files.
Das wird unter
- Benutzung am LRZ
- Konzept von Exponent Graphics (im wesentlichen
1. - 3.)
behandelt.
Die folgenden Abschnitte beschreiben die Leistungen des Systems weiter- hin von der C-Anwendung aus gesehen, sollten aber für Fortran formal leicht übertragbar sein, zumal die Herstellerdokumentation beide Sprachvarianten parallel führt.
Auf die eg-Dokumentation wird über Zahlen in eckigen Klammern verwie- sen. Diese sind im Abschnitt "Übersicht über die Dokumentation zu eg" in dieser Schrift erklärt.
Wie eg am LRZ aufgerufen werden kann, folgt im nächsten Abschnitt die- ser Schrift unter "Benutzung am LRZ".
Intern zugrunde liegendes Graphiksystem in eg ist das HOOPS Graphics System von Ithaca Software (s.[1] Overview).
Benutzung am LRZ
Exponent Graphics (eg), Version 2.1, von Visual Numerics läuft am LRZ jetzt auf den SUN-Workstations unter Solaris 2.4. Man kann direkt an einer Sun bzw. an einem X-Terminal oder am PC über Vista-eXceed das Graphikpaket auf den Suns (sun1 - sun6) auf einer X-Window-Oberfläche aufrufen.
Was ist der Reihe nach zu tun, um eg zu starten?
- Wichtig:
die DISPLAY-Variable muß für X-Window richtig gesetzt sein. - Ausführen eines der folgenden Setup-Scripten, das die für eg not-
wendigen Environmentvariablen setzt, d.h. also auch die im folgen- den
verwendeten (LINK_EG, CFLAGS, AC_EXAMPLES, AC_INCLUDE, ...)
- in der Bourne- oder Korn-Shell:
. imsleg.setup.sh - in der C-Shell:
source /client/bin/imsleg.setup.csh
- in der Bourne- oder Korn-Shell:
- Mit dem Aufruf von
/client/bin/imslhelpwird die Online-Dokumentation für verschiedene IMSL-Software zur Verfügung gestellt, wozu neben der Dokumentation zur Fortran- und C-Library von IMSL auch die Dokumentation zu Exponent Graphics ge- hört. - Der eigentliche Start von eg erfolgt über ein übersetztes und
geladenes C-Programm (oder jetzt auch ein f77-Programm), das die
entsprechenden eg-Funktionen aufruft und zu dem use- und tag-Files als
Direktivenfiles gehören können.
Die Environmentvariable LINK_EG enthält alle notwendigen Biblio- theken (gleich für C und f77).Einfache Beispielprogramme (Quelle und startbares File) stehen im Verzeichnis $AC_EXAMPLES/lrz. Dazu gehört auch das unter 2.3 zi- tierte Beispiel hello.c bzw. world.f.
Für einen ersten Versuch mit eg ruft manhello.exebzw.world.exeauf.
Dabei folgt auf diesen Aufruf die Eingabeanforderung:Enter n [plot [file]] - DEVICE `n' [optional plot node, output file] ? - LIST available device numbers, names, descriptions t - TOGGLE the meaning of `q' to leave graphics OPEN q - EXIT this routine, CLOSE (shutdown) graphics To continue, click the mouse on the plot Choice: Eingabe von 1müßte die Graphik in einem neuen Fenster am Sichtgerät erschei- nen lassen. Dieses Fenster wird wieder geschlossen, indem man in ihm eine beliebige Stelle anklickt. Obiges "Enter"-Menue wird mit Eingabe vonqverlassen.Im gleichen Directory steht z.B. auch das Beispiel test.c, dessen Aufruf nach Übersetzung (s. weiter unten) die Ansicht von dreidi- mensionalen "Grundkörpern" auf Ihrem Sichtgerät erzeugt.
- Zur Einarbeitung in eg bieten sich viele Beispiele des Herstellers
an. So gibt es mindestens ein Beispiel zu jedem Attribut oder jeder
eg-Funktion: über die Online-Dokumentation in [2] bzw. direkt über die
Pfade $AC_EXAMPLES/attribute und $AC_EXAMPLES/application. Da der
Hersteller den Ansi-C-Compiler empfiehlt, sind auch diese Beispiele in
Ansi-C geschrieben.
Unter Verwendung der vorher gesetzten Environmentvariablen sehen die Compileraufrufe mit den notwendigen Parametern wie folgt aus:
für C
cc -o prog1.exe $CFLAGS prog1.c $LINK_EGbzw. für Fortranf77 -o prog2.exe prog2.f $LINK_EGDiese Parameterbesetzung aktiviert nicht die Motif-Oberfläche, die in der vom Hersteller empfohlenen Weise nicht funktioniert. Das bedeutet, daß der Benutzer nicht den MOTIF-Parameter aus- wählen soll, der bei den Funktionenac_interact, ac_plot bzw. ac3_plot , ac_multiple_plotangebbar wäre.
Gestartet wird eg mit dem Aufruf von "prog1.exe" bzw. "prog2.exe".Besonderheit der Fortran-Variante (include-File af.i):
In jedes Fortran-Programm muß das eg-include-File af.i des Direc- torys $AC_INCLUDE über das Statement
include 'af.i'eingeführt werden.
Dieses File definiert Konstanten und return-types der Funktionen. Position des obigen include-Statements:
Dabei wird das File af.i beim Laden nur gefunden, wenn es im aktu- ellen Work-Directory steht.stets nach dem program-Statement, falls dieses vorhanden ist, sonst vor den vorhandenen Programmcode als erstes setzen.
Die Angabe -I im f77-Statement beeinflußt nicht das Auffin- den eines Files, das im include-Statement steht, sondern nur in #include-Präprozessor-Direktiven.
Empfehlung:
Kopie des Files $AC_INCLUDE/af.i ins Work-Directory setzen und/oder über Soft-link innerhalb des eigenen eg-Arbeitsbereichs ohne be- sondere Pfadangabe verfügbar halten.Include-Files für C-Programme:
über die Environmentvariable CFLAGS:
Darin stehen u.a. die über den Parameter -I angebbaren Pfade für anzuschließende Include-Files, also-I $AC_INCLUDE -I/client/includeIn diesem Directory $AC_INCLUDE steht das primäre Include-File, das mit eg mitgeliefert wird: ac.h. Es besteht im wesentlichen aus Funktions-Prototypen. Überdies stehen die #include-Direktiven für die Standardfiles stdio.h und math.h sowie für das eg-spezifische File options.h darin. Alle diese genannten Include-Files werden daher im jeweiligen C- Programm mit der Direktive#includeeingefügt werden, unabhängig vom aktuellen Directory. - Wohin kann die Graphikausgabe geleitet werden ?
-
Dynamische Gerätewahl
Das ist der übliche Weg, wenn man sich eine Graphik zuerst am Bildschirm ansehen und ggf. verändern will, bevor man sie auf Pa- pier ausgibt.
Dazu setzt man beim Aufruf der Funktionenac_plot, ac_interact, ac_multiple_plotden Integer-Parameter unit = 0. Dadurch wird ein interaktiver Prompt ausgelöst, der die Eingabe von einem Index (ganze Zahl zwischen 1 und 14) des Gerätetreibers ermöglicht.Ausgelöster Prompt des eg-Systems (wie vorher unter 4.):
Enter n [plot [file]] - DEVICE `n' [optional plot node, output file] ? - LIST available device numbers, names, descriptions t - TOGGLE the meaning of `q' to leave graphics OPEN q - EXIT this routine, CLOSE (shutdown) graphics To continue, click the mouse on the plot Choice: Eingabemöglichkeiten nach "Choice:" : 1.) 1 --> neues Fenster mit Graphik des Programms erscheint 2.) 9 --> Ausgabe der Graphik in eine Postscriptdatei vnieg.ps (landscape-Format) 3.) 10 --> Ausgabe der Graphik in eine Postscriptdatei vnieg.ps (portrait-Format) 4.) 9 --> die Ausgabe der Graphik wird in eine Postscriptdatei ge- schrieben, deren Namen der Benutzer vorgibt. (landscape-Format der Ausgabe) Beispiel der Eingabe für den Plotknoten 1 und gewünschter Graphikausgabe ins File plotfile1.ps: 9 1 plotfile1.ps Bemerkung: einfache Programme haben meist nur einen Plotknoten, der dann die Nummer 1 hat. 5.) 10 --> die Ausgabe der Graphik wird in eine Postscriptdatei ge- schrieben, deren Namen der Benutzer vorgibt. (portrait-Format der Ausgabe) 6.) ? --> auf dem Bildschirm erscheint eine Liste der Indices der Gerätetreiber, die dem File $AC_DEVICES entnommen sind. (die Environmentvariable AC_DEVICES wird durch das Setupscript für eg gesetzt). Welche der Indices sinnvoll am LRZ zu verwenden sind, wurde bereits unter 1. - 5. dargestellt. Die z.Zt. bei der Solaris-Version auftretende Fehlermeldung nach Eingabe von 9 bzw. 10 oder länger mit dazu benanntem Plotfile kann ignoriert werden, da die Postscriptfiles richtig erzeugt werden (Die Nachfolger-eg-Version 3.0 soll ohne diesen Fehler sein). Aussehen dieser Fehlermeldung (bei Aufruf von ac_set und ac_plot): **** VNI-HOOPS error in ac_Pause has severity 3. **** There was an unexpected Hoops internal error - **** Nothing to wait for - no events are enabled **** Traceback =======> **** ac_Await_Event **** called from ac_Await_Event **** called from ac_Pause **** called from ac_plot **** called from ac_set (analoge Meldung für ac3_set oder ac3_plot) -
feste Geräteauswahl per C-Programm
Dabei gibt man in den Ploterzeugungsfunktionen von eg, also in
ac_plot, ac3_plot, ac_multiple_plotfür den integer-Parameter unit den entsprechenden Index (s.o.) an, d.h. insbesondere für die Erzeugung eines Postscriptfiles den Wert 9 oder 10.Ein Beispiel dafür steht unter 4.3 bzw. in
$AC_EXAMPLES/lrz/button.cDer Aufruf von ac_plot erfolgt dort mitac_plot (ps_device, AC_PLOT_NODE_OPTION, plotnr, 0);wobei die Parameter bestimmt sind durch:int ps_device = 9; int plotnr; plotnr = ac_query_plot_node();Das Beispiel demonstriert u.a. wie die Plotnummer per Programm ein- getragen und das Ausgeben des Plotfiles erst beim Ansehen des Plots am Sichtgerät über den speziellen Button "PostScript" ausgelöst werden kann.
-
Dynamische Gerätewahl
Konzept von Exponent Graphics
- Grundstruktur: der Graphikbaum von eg
- Aufruf von eg über ein C- bzw. Fortran-Programm, das der Benutzer schreiben muß (unter Verwendung der Kenntnis der eg-Attribute und eg-Funktionen) oder fertig vorfindet.
- eg-spezifische Hilfsfiles (use- und tag-Files) ermöglichen Bildvariationen ohne Programmneuübersetzung.
- Interaktivität über Menues zu Plotelementen eines erzeugten Bildes beim Default, d.h. bei der auf dem HOOPS-Graphiksystem basierenden Interaktivität, über eine X11-Oberfläche. Die zusätzlich vorgesehene Interaktivität über eine Motif-Oberfläche funktioniert nicht.
Der Graphikbaum von Exponent Graphics
--------------
| |-------------
-------------- |
---------------
| .i |
---------------
------------------- |
| .1 ... .N(PLOT) |-----------
-------------------
|
----------------------------------------------------
| | | |
| | | |
--------------- --------------- --------------- ---------------
| .PLOT-TITLE | | .LEGEND | | .AXIS | | .BACKGROUND |
--------------- --------------- --------------- ---------------
|
-------------------
| .1 ... .9(AXIS) |
-------------------
|
-----------------------------------
| | |
--------------- ---------------- -------------
| .DATA | | .X, .Y, .Z | | .BOX |
--------------- ---------------- -------------
| |
------------------- |
| .1 ... .N(DATA) | |
------------------- |
|
|
----------------------------------------------------------
| | | | |
----------- ------------ ------------ --------------- -----------
| .LINE | | .LABELS | | .TICKS | | .AXIS-TITLE | | .GRID |
----------- ------------ ------------ --------------- -----------
|
------------------
| |
-------------- --------------
| .MAJOR | | .MINOR |
-------------- --------------
1. Grundstruktur: der Graphikbaum
1.1 Allgemein
s. dazu:
[1] Getting Started
Overview
Der Graphikbaum wird von eg als Abbildung der vom Benutzer gemachten
Eingaben erzeugt. Dabei baut eg auf einer vorgegebenen hierarchischen
Basisstruktur, dem Basis-Graphikbaum, auf.
Jeder Knoten dieses Baums enthaelt Information zu einem speziellen As-
pekt des Plots. Die Knoten PLOT, AXIS, DATA enthalten Referenznummern
und markieren lediglich eine Position. Die anderen Knoten besitzen
vier Komponenten:
- eine Menge von Attributen (Variable von speziellem Typ, ev. auch
mit ersetzbarem default-Wert), deren Namen die Wirkung beschreiben.
- Liste von "Kindern" (Vererbbarkeit von Attributen)
- Enter Funktion
- Exit Funktion.
Umseitige Abbildung gibt den vordefinierten Basis-Baum wieder, der
bei fortgeschrittener Kenntnis von eg auch erweitert werden kann.
Die Displays der Plots und Graphs entstehen durch "Ausfuehrung des
Baums", d.h. intern ueber Enter- und Exit-Funktionen unter Benutzung
der eingetragenen Attributwerte und vom Benutzer aus ueber entspre-
chende Aufrufe von eg-Funktionen in einem C- bzw. f77-Programm (s. 2.2).
Die Kenntnis dieser Baumstruktur ist Voraussetzung fuer das Verstaend-
nis dafuer, wie man jeweils relevante Attribute besetzt oder allgemei-
ner Aenderungen im Graphikbaum vornimmt.
1.2 Überblick ueber die eg-Attribute
s. dazu:
[1] Overview --> General Features
--> Attributes
[3] Additional Information --> Picture Index (anschauliche Uebersicht)
Sie sind Platzhalter an vordefinierten Knoten und stellen Variable
dar, denen ein syntaktischer Typ (int, float, char) zugeordnet ist und
die i.a. einen default-Wert besitzen, den der Benutzer aendern kann.
Zusaetzliche vordefinierte Typen von Attributen stehen im Directory
$AC_INCLUDE in den Files ac.h (fuer C) bzw. af.i (fuer f77) (siehe
dazu "Benutzung am LRZ" am Anfang dieser Schrift). Dazu gehoeren z.B.
in C Typen wie Ac_text_attributes, Ac_line_attributes (mit den Struk-
turen txatt, lnatt).
Die in eg vorhandenen Attribute werden i.a. entweder nach Knotenzuge-
hoerigkeit oder inhaltlich (nach ihrer Leistung) eingeteilt:
Einteilung nach Knotenzugehoerigkeit:
- Dabei sind zuerst die an allen Knoten verwendbaren Attribute (globale
Attribute) interessant:
Wesentliches globales Attribut: "activate"
mit den zwei Werten
0 d.h. der Knoten und alle darunterliegenden werden bei der
Ploterzeugung uebergangen.
1 d.h. der Knoten wird bei der Ploterzeugung "ausgefuehrt".
Waehrend die meisten Knoten defaultmaessig "aktiv" eingetragen sind,
sind die Knoten .LEGEND und .GRID von eg aus inaktiv gesetzt, d.h.
fuer ihre Benutzung ist explizit an ihnen "activate 1" zu setzen.
Die meisten globalen Attribute beziehen sich auf:
Text, Linien, Marker, Schraffuren (fill characteristics).
Diese Elemente wiederum sind farbig oder schwarz/weiss waehlbar.
- die zum speziellen Attribut gehoerige Beschreibung gibt ueber des-
sen Verwendbarkeit, insbesondere an welchem Knoten, Auskunft.
Inhaltliche Einteilung:
- Farb-Attribute,
wie text_color, fill_color,...
erhalten als Werte den Farbnamen oder ein (rgb)-Zahlentripel
(3 Gleitpunktzahlen fuer die Farben rot, gruen, blau).
- Text-Attribute
gibt es fuer Font, Farbe, Winkel, Justierung, Zwischenraeume.
S. auch [3] Fonts. Dort werden auch "Inline Text Commands" erklaert,
d.h. Einfuegung von speziellen Anweisungen in Texte, z.B. fuer
Fettdruck, Italics, Indizes, Exponenten usw.
Syntax dieser Kommandos: zwei Buchstaben (Bedeutung s. Liste) zwi-
schen senkrechten Strichen, ev. mit Argument, im betreffenden Text
(z.B. von Achsen- oder Plotbeschriftungen) einzufuegen.
- Linien-Attribute,
wie line_color, line_width, line_type (z.B. solid, dashed, dotted)
- fill-Attribute (Schraffuren):
Schraffurtypen mit fill_type (hollow, solid, pattern, hatch)
- Marker-Attribute,
wie marker_color, marker_size, marker_type (30 vordef. Typen)
- 2-dimensionale Attribute:
Dazu gehoeren z.B.
"autoplot", um die Plotgroesse kleiner als "viewport area" anzuge-
ben,
"move", "insert", "delete" fuer interaktive Benutzung,
Attribute fuer die Erzeugung eines 2-dim. Gitters (nach Aktivie-
rung des GRID-Knotens),
die am BOX-Knoten verwendbaren Attribute top, bottom, left, right
zur Raenderauswahl.
Das flag-Attribut hat speziell Werte fuer 2-dim. Plots, auch die
Attribute, die "error bars" und "bar charts" betreffen, sind nur
2-dim.
- 3-dimensionale Attribute:
das sind alle Attribute, die notwendig zur Darstellung einer 3-dim.
Szene als 2-dim. Bild sind.
Einige wichtige 3-dim. Attribute werden in der vorliegenden Schrift
unter 5. ausfuehrlicher behandelt.
1.3 Übersicht über im folgenden behandelte Attribute mit zugehöriger Abschnittsangabe und Kontext
I n t e r a k t i v e B e n u t z u n g:
fuer Menueveraenderungen s. 4.2
interactive, create
fuer aufwendigere Veraenderungen s. 4.3
call_before- und call_after-Attribute
A l l g e m e i n e a e u s s e r e G e s t a l t u n g:
Festlegungen fuer die Projektion einer 3-dim. Szene
auf ein 2-dim. Bild s. 5.1.1
origin window*
autoscale_input* autoscale_output* --> plot_corner
eye perspective aspect
(mit * auch fuer 2-dim. Szenen)
Festlegungen fuer Beleuchtung, Schattierung s. 5.2.1
light shade --> depth
Gestaltung der "Ausgabeseite" s. 5.2.1
viewport scale autoplot
Einbringen von Daten an einen Knoten s. 5.2.2
number_sets number
flag fancy
Achseneinteilungen ("tick marks") s. 5.2.3
start end
interval_start interval_end interval_number
S p e z i e l l e D a r s t e l l u n g:
Facettierung von Flaechen (allgemein) s. 6.1
flag
shade/smooth
hermite_flag --> normal_grid_copy s. 6.4.2
hermite_scale hermite_multipliers s. 6.4.3
Facettierung der Grundkoerper s. 6.2.2
charakteristische Groessen:
ellipsoid_radii
frustum_bottom_radii frustum_top_radii
frustum_length frustum_cap
torus_major_radii torus_minor_radii
Facettierungswerte:
horizontal_facets horizontal_start horizontal_end
vertical_facets vertical_start vertical_end
Achsenlage:
orientation_axis
2. das C- bzw. f77-Programm für den eg-Start
Exponent Graphics kann immer nur ueber den Aufruf eines C- bzw. f77-Programmes aktiv werden, in dem entsprechende eg-Funktionen aufgerufen werden und das mit den erforderlichen Bibliotheken, insbes. natuerlich aus eg, aber auch fuer X-Window gelinkt wurde.
2.1 Eintragungen im Graphikbaum
Man unterscheidet zwei Eintragungsmoeglichkeiten im Graphikbaum:
- einfache Wertzuweisungen an eg-Attribute
(Liste und Erlaeuterungen in [2])
Das ist innerhalb vom C-Programm
fuer 2-dim. Plots ueber Aufruf der eg-Funktion ac_set bzw.
fuer 3-dim. Plots ueber Aufruf der eg-Funktion ac3_set,
innerhalb eines f77-Programms
fuer 2-dim. Plots ueber Aufruf der eg-Funktion af_set bzw.
fuer 3-dim. Plots ueber Aufruf der eg-Funktion af3_set
moeglich (zu einem Pfad, einem oder mehreren Attributen werden
die erforderlichen Werte zugeordnet):
C:
ac_set(" ... ",
... );
oder speziell fuer 3-dim. Bilder ist statt ac_set die Funktion
ac3_set(" ... ",
... );
f77:
call af_set(' ... $',
... );
oder
call af3_set (' ... $',
... );
Entsprechend erweitert fuer mehr als einen Pfad funktioniert
ac_multiple_set bzw. af_multiple_set
Daneben kann im C- bzw. f77-Programm einem Plotknoten eine speziel-
le Art von einem File (sogenanntes use- oder tag-File) zugeordnet
werden, das ebenfalls Wertzuweisungen an Attribute ermoeglicht. Der
Vorteil dieser use-/tag-Files besteht darin, dass ein fertig ueber-
setztes C- bzw. f77-Programm mit wechselnden use-/tag-Files gestar-
tet werden kann, wodurch ohne Neuuebersetzung mit jedem solchen
veraenderten File eine andere Attributbesetzung realisiert wird (s.
unter 3.).
- Aufruf von eg-Anwendungsfunktionen
(Liste und Erlaeuterungen in [2])
Dabei handelt es sich um C-Funktionen, die eg zur Verfuegung stellt,
die eine groessere Flexibilitaet fuer die Graphikerzeugung erlauben,
und die der Benutzer wiederum in sein C- bzw. f77-Programm mit den
entsprechen den Parametern eintragen muss.
Diese Anwendungsfunktionen erleichtern durch die zur Verfuegung ge-
stellten Argumente die notwendigen Angaben
- einmal zu den Daten, die in der Form mehr der Natur der Anwendung
entsprechen koennen als es vielleicht das zugrundeliegende graphi-
sche Verfahren erfordern wuerde.
- zum anderen zu allen aeusseren fuer die Graphikerstellung notwendi-
gen Details, wie Plazierung der Daten fuer den Plot im Graphikbaum,
Erzeugung von Achsen, Titeln zu Achsen und Plots, Legenden, Text-
fonts, Schraffuren, Faerbungen, usw.
Namenskonvention bei Argumenten
-------------------------------
Die eg-Anwendungsfunktionen haben i.a. eine Reihe notwendiger Parame-
ter. Dazu koennen beim Aufruf noch weitere optionale Argumente zuge-
fuegt werden: das sind einmal optionale Argumente, die zu jeder An-
wendungsfunktion gelistet sind sowie allgemeine optionale Argumente,
die in [3] unter "Generic Application Function Options" stehen.
Es gibt zwei Schreibweisen der optionalen Argumente in der Aufrufse-
quenz:
- "enumerated type":
In C: Klammerung des Argumentnamens mit AC__OPTION,
z.B. AC_FILE_OPTION
in f77: Voranstellen von AF_ vor den Argumentnamen , also
AF_, z.B. AF_FILE
- als String:
Diese Option gibt es nur fuer C , NICHT fuer Fortran!
Argumentname als "", z.B. "FILE"
Besonderheit dabei ist, dass Gross-/Kleinschreibung beliebig ver-
wendbar ist, also auch "fiLE".
Angabe des richtigen Pfades
---------------------------
Den Beschreibungen von Attributen und Funktionen ist zu entnehmen, zu
welchem Knoten und damit ueber welchen Pfad die Zuordnung erfolgen
soll. Dabei ist der Aufbau des eigenen Graphikbaums zu beruecksichti-
gen.
So koennen z.B. zur Darstellung mehrerer Datenmengen im gleichen Plot
diese durch die laufende Nummer dn am Datenknoten mit vorausgehend
gleichem Pfad unterschieden werden, z.B.
.pn.AXIS.an.DATA.dn
wobei pn feste Plotnummer, an feste Achsennummer sind.
Verschiedene eg-Funktionen haben festdefinierte "Aliases" fuer be-
stimmte Knoten, die dadurch vereinfacht dargestellt werden koennen.
Sie werden stets mit "!" eingeleitet.
Siehe dazu z.B. in [2] die Beschreibungen zu "ac_scatter_plot",
"ac_block_chart", "ac_box_plot".
Weitere Information, auch bezueglich Prefix-Bildung zum Alias, steht
unter [2] bei "set_alias", "set_prefix".
2.2 Ausführung des Graphikbaums
Die Erzeugung der Ausgabe auf ein graphisches Geraet, d.h. die "Ausfueh-
rung des Graphikbaums", erfolgt ueber speziell dafuer vorgesehene Funk-
tionen, die der Benutzer im C- bzw. f77-Programm nach Ploterzeugung
aufrufen muss:
ac_plot/ac3_plot (nicht interaktiv)
ac_multiple_plot (fuer mehrere Plots auf einer Bildflaeche,
nicht interaktiv)
ac_interact (fuer interaktive Plotbetrachtung:
Menues zu den verschiedenen Plotelementen)
In Fortran: call af_...
2.3 Ein einfaches C-Beispiel-Programm
/*
* Dieses Beispielprogramm aus dem Exponent Graphics Manual erzeugt
* einen Stern, dessen Ecken die eingegebenen Punkte sind. Der Plot
* traegt die Ueberschrift "Hello World"
*/
#include
#define NUM_VALUES 6
main()
{
int error_flag, iunit = 0;
static float x[NUM_VALUES] = {2.0, 3.0, 4.0, 1.5, 4.5, 2.0};
static float y[NUM_VALUES] = {1.0, 2.5, 1.0, 2.0, 2.0, 1.0};
/*
* Die Datenpunkte (x[i],y[i]),i=1,...,NUM_VALUES werden durch die
* eg-Funktion ac_scatter_plot am aktuellen Datenknoten in den
* Graphikbaum fuer den spaeteren Display als Punkte (Marker)
* eingetragen.
* Der Ergebniswert der Funktion ac_scatter_plot ist 0, falls kein
* Fehler auftritt, andernfalls von 0 verschieden.
*
* Erster Aufruf von ac_set:
* Am Knoten .1.plot-title wird das Attribut "title" mit dem Text
* "Hello World" besetzt.
*
* Zweiter Aufruf von ac_set:
* Am Datenknoten .1.axis.1.data.1 wird das Attribut "flag" mit
* 3 besetzt, d.h. die vorher an diesem Datenknoten eingetragenen
* Datenpunkte (x[i],y[i]) werden durch Geradenstuecke verbunden.
*
*/
error_flag = ac_scatter_plot (NUM_VALUES, x, y, 0);
ac_set(".1.plot-title title", "Hello World");
ac_set(".1.axis.1.data.1 flag", 3);
/*
* Display des Plots mittels der eg-Funktion ac_plot, wenn kein
* Fehler beim Aufruf der Funktion ac_scatter_plot auftrat.
*/
if (!error_flag)
ac_plot (iunit, 0);
}
Dasselbe ohne ausfuehrlichen Comment als f77-Programm:
program world
include 'af.i'
parameter (num_values=6)
C
integer iunit, istatus
real x(num_values), y(num_values)
C
data iunit/0/
C
data x/2.0, 3.0, 4.0, 1.5, 4.5, 2.0/
data y/1.0, 2.5, 1.0, 2.0, 2.0, 1.0/
C
istatus = af_scatter_plot (num_values, x, y, 0)
call af_set('.1.plot-title title$','Hello World')
call af_set('.1.axis.1.data.1 flag$', 3)
C
call af_plot (iunit, 0)
end
3. Use- und tag-Files
Sie gestatten die Modifikation von Attributen des Graphikbaums (ueber
Direktiven in use-Files) sowie von Parameterwerten der Anwendungsfunk-
tionen (ueber Direktiven von tag-Files), ohne das Programmm neu ueber-
setzen und linken zu muessen.
Die Zuordnung dieser Files, hier im Beispiel mit "file.use" und "file.
tag" bezeichnet, erfolgt fuer das use-File meist in einem Aufruf von
ac_set (bzw. ac3_set fuer 3-dim. Plots), fuer das tag-File in einem
Aufruf der gerade aktuellen Anwendungsfunktion, deren Parameterwerte
eingetragen werden sollen, also z.B.
in C:
ac_set (".1.use". "file.use");
in f77:
call af_set('.1 use$', 'file.use$')
bzw.
in C:
check = ac3_block_chart (number_x, number_y, z, AC_FILE_OPTION,
"file.tag", "$BLOCK", 0);
in f77:
istatus = af3_block_chart (number_x, number_y, z, AF_FILE,
& 'file.tag$','#BLOCK', 0)
wobei die notwendigen Argumente der Funktion block_chart
number_x, number_y, z
sind, AC_FILE_OPTION bzw. AF_FILE als "generic" optionales Argument
FILE die Zuordnung von zwei character-Werten erfordert, in der Reihen-
folge
1. tag-Filename (im Beispiel: file.tag)
2. tag, d.h. mit $ (fuer C) bzw. # (fuer f77) beginnendes Schluessel-
wort (im Beispiel: "$BLOCK" bzw. '#BLOCK').
Syntax des use-Files:
---------------------
Die Direktiven fuer das use-File sind nur gering verschieden von der
Information, die in ac_set-Aufrufen ohne Verwendung des use-Files im
C-Programm stehen wuerde.
use-File-Zeile:
...
im Gegensatz zur Verwendung von set:
in C:
ac_set(" ... ",
... );
in f77:
call af_set(' ... $'
... )
Syntax des tag-Files:
---------------------
Jede Zeile wird fuer die betrachtete Anwendungsfunktion mit demselben
mit $ bzw. # beginnenden Schluesselwort (= "tag") eingeleitet. Dadurch
wird fuer den Interpreter die Zuordnung der aktuell auszufuehrenden Di-
rektiven geschaffen. Verschiedene "tags" koennen im gleichen File ste-
hen, die verschiedenen Funktionsaufrufen zugeordnet sind.
tag-File-Zeile:
fuer C:
$ ...
fuer f77:
# ...
Dabei gehoeren die Argumente zur betreffenden Anwendungsfunktion, in
deren Aufruf das tag definiert wurde.
Die Argumentarten sind:
- notwendige Argumente
- optionale Argumente:
allgemein (generic) oder anwendungsspezifisch.
Ausnahme bei Argumentnamen der optionalen Argumente:
"enumerated names" fuer Argumente in tag-File-Zeilen sind verboten,
d.h. z.B. AC_FILE_OPTION ist nicht zulaessig, aber "FILE".
Als use- und als tag-File kann ein und dasselbe File angegeben werden,
sogar koennen die use-File- und tag-File-Direktiven ins C- bzw.
Fortran-Programm integriert werden, und zwar
use-File-Zeilen als Comment, vor erstes #include gestellt.
tag-File-Zeilen sind durch mit $ (fuer C) bzw. # (fuer f77)
beginnende Zeilen kenntlich.
Nun folgt ein C-Beispiel-Programm, das das unter 2.3 zitierte Programm
so abaendert, dass die Attributwerte am Knoten plot-title zu "title"
und am Datenknoten zu "flag" im use-File gesetzt werden. Dabei ist
das use-File gleich dem Programm-File hello.c:
-------
/*****************************************************************\
Die folgenden USE-File-Zeilen sollen die vorigen ac_set_Aufrufe
im Programm ersetzen:
.1.plot-title title "Hello World"
.1.axis.1.data.1 flag 3
\*****************************************************************/
#include
#define NUM_VALUES 6
main()
{
int error_flag, iunit = 0;
static float x[NUM_VALUES] = {2.0, 3.0, 4.0, 1.5, 4.5, 2.0};
static float y[NUM_VALUES] = {1.0, 2.5, 1.0, 2.0, 2.0, 1.0};
/*
* Die Datenpunkte (x[i],y[i]),i=1,...,NUM_VALUES werden durch die
* eg-Funktion ac_scatter_plot am aktuellen Datenknoten in den
* Graphikbaum fuer den spaeteren Display als Punkte (Marker)
* eingetragen.
* Der Ergebniswert der Funktion ac_scatter_plot ist 0, falls kein
* Fehler auftritt, andernfalls von 0 verschieden.
*
* Mit dem ac_set-Aufruf wird das use-Attribut besetzt, d.h.
* der Name des use-Files (hier das gleiche File) angegeben.
*/
error_flag = ac_scatter_plot (NUM_VALUES, x, y, 0);
ac_set(".1 use", "hello.c");
/*
* Display des Plots mittels der eg-Funktion ac_plot, wenn kein
* Fehler beim Aufruf der Funktion ac_scatter_plot auftrat.
*/
if (!error_flag)
ac_plot (iunit, 0);
}
4. Über die Interaktivität von eg
s. dazu: [1] Interactivity Ein "Graphisches User Interface" (Abk. GUI) muss in der Lage sein, di- rekte, interaktiv erzeugbare Aenderungen am dargestellten Plot vorzu- nehmen, und zwar sowohl bezueglich der Datenpunkte als auch der ver- schiedenen Darstellungsformen.
4.1 Möglichkeiten für den Endbenutzer (der ein fertiges C-Programm aufruft)
Auswahl (Anklicken) eines Plotelements (z.B. Datenpunkte,
Berandung=Box, Plot-Titel,...).
--> zugeordnetes Menue (aus einzelnen Buttons bestehend) erscheint.
Ein ausgewaehlter (angeklickter) Button kann in einer von drei moegli-
chen Weisen reagieren:
- Der Button fuehrt zu unmittelbarer Aktion
("close" zum Verlassen des Menues,
"quit" zum Verlassen des gesamten Plots, defaultmaessig ist dieser
Button meist nur beim .line-Menue vorhanden)
- Der Button fuehrt in einen der drei Modi:
move, insert oder delete
(das bedeutet dynamisches Plazieren, Einfuegen oder Entfernen).
Diese Modi sind fuer Datenwerte nur im 2-Dim. wirksam.
Der genauere Leistungsumfang:
Move: fuer 7 verschiedene Typen von Plotelementen, und zwar fuer
die Knoten von plot-title, legend, note, axis-title.
An Datenknoten sind nur die Datenwerte verschiebbar.
Insert: nur fuer Datenknoten.
Drei Typen:
- append (default), z.B. ein angeklickter Punkt wird zum
letzten einer Kurve.
- insert after, d.h. Einfuegen hinter einem ausgewaehlten
Datenpunkt
- insert before, d.h. Einfuegen vor einem ausgewaehlten Da-
tenpunkt.
Delete: Entfernen von Datenwerten
Fuer Fehler ist maximal 1 Level von Undo (toggle) vorgesehen:
undo_move, undo_insert, undo_delete.
- Der Button fuehrt auf ein Widget:
ein Attributwert kann geaendert werden, wobei der zulaessige Werte-
bereich unmittelbar ersichtlich ist. Eventuell kann auch die Aende-
rung durch Verschiebung laengs eines "Sliders" oder Auswahl eines
"Farbfeldes" bei Color erfolgen.
Zur unten stehenden Buttonfolge
"Set" "Refer" "Close" "?"
Mit "Set" wird ein eingetragener Wert im Display sichtbar. Erst ein
darauffolgendes "Close" bedeutet Uebergeben an die Anwendung und
Schliessen des Menues. Eine Eingabefolge "Wert1" "Set" "Wert2" "Set"
... ohne "Close" ermoeglicht visuell die Qualitaet verschiedener
Eingabewerte zu beurteilen.
Statt "Set" kann "Refer" gewaehlt werden. Das bedeutet: Setzen des
Wertes an dem Knoten, von dem das betreffende Attribut durch Verer-
bung gesetzt wuerde, wenn es jetzt nicht diesen Wert erhielte. Ist
kein "Erbwert" da, wird der Wert an der Spitze des Baums gesetzt.
Menues ermoeglichen den Zugang zu der Attributmenge, die am betreffen-
den Graphikbaumknoten gegeben ist (durch das fertige Programm).
Auch der Programmierer des C-Programms muss sich um diese Menues nur
kuemmern, wenn er andere als die Default-Menues verwenden will.
Ueber die Defaults eines Menues:
- Ueberschriftsbutton ("title-bar") mit Namen des Knotens, zu dem das
Menue gehoert.
- Close-Button zum Verlassen des Menues
- Quit-Button zum Verlassen des gesamten Displays, ist meist nur beim
.line-Menue als default vorhanden.
Die im Manual angebotene Moeglichkeit, ueber ein key-Attribut eine in-
teraktive "Plotbewegung" zu erzeugen, funktioniert voreinstellungsge-
maess nicht beim Default, der auf dem HOOPs-Graphicsystem basierenden
Interaktivitaet.
4.2 Einfache Veränderung von Menues durch den Programmierer
Die defaultmaessig vorgegebenen Menues kann der Programmierer ueber im wesentlichen zwei Attribute im i-Graphikbaum erreichen: "interactive" und "create". Diese Erweiterungen des i-Graphikbaums koennen dann im aktuellen use- File stehen. interactive-Attribut -------------------- Argument zu "interactive" ist ein Textstring, der eine Liste von Attri- buten erwartet, die als Button des betreffenden Knoten-Menues erschei- nen. (aber das speziell zitierte Titelbeispiel im Manual demonstriert zwar, wie es gehen sollte, aber es ist fehlerhaft vom eg-Programm her: Konfusion bzgl. zu aendernder Ueberschrift zu .plot-title und dem ein- zufuegenden Button "title"). Zu einem bereits fertigen Menue kann ueber die Attribute "interactive_plus" bzw. "interactive_minus" eine geringe Abaenderung vererbter Eigenschaften am zugehoerigen Kno- ten erreicht werden. create-Attribut --------------- Es dient innerhalb eines Menues dem Zugang zum Knoten eines (vorein- stellungsgemaess) vorhandenen Buttons, dessen zugehoeriges Widget ver- aendert werden soll, aber auch zum Kreieren eines zusaetzlichen neuen Buttons, dessen Funktionalitaet ueber das Attribut call_after_widget und einer ihm zugeordneten C-Funktion beispielsweise erzielt wird. Das Argument zu "create" ist wieder ein Textstring, der die Verlaenge- rung des Knotennamens vom Menue-Knotennamen darstellt, genauer: es muss der Name des Attributs sein, das die Buttonwirkung verursacht. Beispiel 1: Zum Menue .plot-title sollen vom Button text_font das zugehoerige Widget mit veraenderter Hintergrund- und Textfarbe erscheinen. Folgende use-File-Zeilen sind dafuer notwendig: .i.1.plot-title create "text_font.widget" .i.1.plot-title.text_font.widget fill_color "green" text_color "black". Beispiel 2 s. das Beispiel im folgenden Abschnitt 4.3. Dort wird ein "Print"-Button im .line-Menue kreiert.
4.3 Aufwendigere Veränderung eingebauter interaktiver Möglichkeiten durch den Programmierer: der Call-back Mechanismus
Das bedeutet:
Ausblenden und/oder Zufuegen von Funktionen bei Menue-Auswahl bzw.
bei Auswahl in der tieferen Menuestruktur.
Im Zusammenhang mit Menues und deren weiterer Unterstruktur gibt es
die Moeglichkeit vor einer gewissen Aktion oder nach dieser ueber Set-
zen eines call-back-Attributs eine Funktion auszufuehren, die vom Be-
nutzer geschrieben wird, aber mit fest von eg definierten Parametern,
d.h. in Uebereinstimmung zum vorgegebenen Funktionsprototyp (s. die
Attribut-Beschreibungen in [2]).
Wie bei jedem Attribut sind auch die gesetzten call-back-Attributwerte
vererbbar.
Es gibt 8 call-back Atttribute innerhalb des interaktiven Graphikbaums
(i-tree):
call_before-Attribut call_after-Attribut | beinhaltet call backs
| vor oder nach
----------------------------------------------------------------------
call_before_menu call_after_menu | Auswahl eines Plotelements
| (Menueerzeugung)
call_before_mode call_after_mode | Auswahl eines mode-Buttons
| (move, insert oder delete),
| nur fuer Datenknoten!
call_before_widget call_after_widget | Erscheinen des Widgets
| (nach gedruecktem Button
| im Menue)
call_before_action call_after_action | einer Widget-Aktion, wie
| Set, Refer oder Close
----------------------------------------------------------------------
Verwendung dieser Attribute im Programm ueber den Aufruf von
ac_set ("path call", sub) bzw. ac3_set ("path call", sub),
wobei
path irgendein gueltiger Pfad im i-tree
call ist entweder ein call_before-Attribut
oder ein call_after-Attribut
sub Name einer vom Benutzer erstellten C-Funktion, deren Parameter
in Abhaengigkeit vom jeweiligen Attribut von eg genau festge-
legt sind (s. Reference: Attributes and Notes).
Einheitlich muessen alle zu call_before-Attributen eingesetzten Benut-
zerfunktionen sub einen integer-Wert als Ergebnis liefern, und zwar
0 die normal vorgesehene Funktion bei der Auswahl (s.o. rechte Ta-
bellenseite) entfaellt, d.h. die Benutzerfunktion ersetzt die
bisherige Funktion, wobei allerdings die Benutzerfunktion auch
k e i n e Aktion ausfuehren kann.
1 die normal vorgesehene Funktion bei der Auswahl bleibt erhalten,
d.h. die Benutzerfunktion wird als zusaetzliche Leistung "vorge-
schaltet".
Die einem call_after-Attribut zugeordnete Funktion kann nochmals Ein-
fluss auf Werte nehmen, die eventuell nach der vorher ausgefuehrten
(dem Attribut zugeordneten) Funktion veraendert wurden. Dabei koennen
aktuelle Attributwerte zum relevanten Knoten ueber die Funktion
"ac_query_data"
abgefragt werden. Mit
"ac_query_plot_node", "ac_query_axis_node"
erhaelt man ueberdies aktuelle Knotenwerte (Nummern).
Beispiel:
Das C-Programm dafuer steht in $AC_EXAMPLES/lrz/button.c und wird mit
$AC_EXAMPLES/lrz/button
in einem Arbeitsverzeichnis aufgerufen (nach Bereitstellen von eg,
s. im Abschnitt "Benutzung am LRZ" dieser Schrift).
Dieses Beispiel ist unter [1] "Advanced Usage" (--> Generating Printed
entnommen Images from a Menu Button Callback) zu finden.
Es enthaelt zwei wesentliche C-Funktionen:
- "define_print_button"
*********************
Diese C-Funktion kreiert einen "Print"-Button (mit "PostScript" be-
zeichnet) im .line-Menue.
***********************************************************************
/*
* This function uses the special attribute to create a
* CALL_AFTER_WIDGET button named "PostScript" which executes the
* call-back function GENERATE_POSTSCRIPT
*/
void define_print_button()
{
int plot, axis;
plot = ac_query_plot_node();
axis = ac_query_axis_node();
/*
* Define an x-axis LINE menu button for printing PostScript
*/
ac_set(".i.%d.AXIS.%d.X.LINE create", plot, axis, "special");
ac_set(".i.%d.AXIS.%d.X.LINE.special title call_aft_wid",
plot, axis, "PostScript", generate_postscript);
ac_set(".i.%d.AXIS.%d.X.LINE interactive_plus",
plot, axis, "special");
}
**********************************************************************
- "generate_postscript"
*********************
Diese C-Funktion ist dem "call_after_widget"-Attribut zugeordnet
und vom Benutzer geschrieben worden.
Sie soll folgendes leisten:
- Feststellen, ob aktueller z-Achsenknoten vorhanden oder nicht vor-
handen ist, d.h. ob zwei- oder dreidimensionaler Plot vorliegt.
- Ploausgabe auf "Geraet" Nr. 9 ("landscape"-Format der Postscript-
datei, s. unter "Installation am LRZ" am Ende dieser Schrift).
**********************************************************************
/*
* This call-back function is executed when the special "PostScript"
* menu button is pressed on the x-axis LINE menu. It passes the
* site-dependent PostScript device number to the plot-function
* ac_plot rsp. ac3_plot.
*/
static int generate_postscript()
{
int ps_device = 9;
int plot, axis;
char path[32];
Ac_tree_node *z;
/*
* Get current plot and axis nodes
*/
plot = ac_query_plot_node();
axis = ac_query_axis_node();
/*
* Query tree for z-axis node and set dimension
*/
sprintf(path, ".%d.axis.%d.z", plot, axis);
z = ac_find_node(path, 0, NULL);
/*
* Create PostScript hardcopy file of plot
*/
if (z == NULL)
ac_plot(ps_device, AC_PLOT_NODE_OPTION, plot, 0);
else
ac3_plot(ps_device, AC_PLOT_NODE_OPTION, plot, 0);
return(1);
}
**********************************************************************
Spezielle Themen
5. Hilfsattribute
5.1 Wesentliche Attribute für eine dreidimensionale Darstellung
Von einem geeigneten Punkt A (Betrachtungsstandpunkt, "eye position")
ausserhalb der darzustellenden Szene wird speziell ein Punkt im Be-
reich dieser 3-dim. Szene, der als Betrachtungsmittelpunkt C
(= "origin", "viewing center") festgelegt wurde, fixiert.
Ueber diesen Vektor CA wird dann der Normalenvektor der Betrachtungs-
flaeche berechnet. Die Punkte A und C werden durch die Attribute "eye"
und "origin" bestimmt - fuer beide gibt es default-Werte.
Waehlt man selbst ueber das "origin"-Attribut einen Punkt C, sollte die-
ser Punkt auch naeherungsweise ein zentraler Punkt der 3-dimensionalen
Szene sein.
Die folgenden inhaltlich gekoppelten Attribute betreffen:
5.1.1 Festlegungen fuer die Projektion der 3-dimensionalen Szene auf
ein 2-dimensionales Bild:
origin (Betrachtungsmittelpunkt)
window (Fenstermasse)
autoscale_input autoscale_output --> plot_corner
eye (Betrachterstandpunkt)
perspective
aspect (relative Achsenskalierung)
5.1.2 Festlegungen fuer die Beleuchtung, Schattierung u.a.m.
light (Position der Lichtquelle)
shade --> depth
fill_type mapper (RGB-Werte)
Alle oben erwaehnten Attribute benutzen default-Werte, die i.a. fuer
ein Standardproblem geeignet sind. Aenderungen der Parameter eines
dieser Attribute erfordert i.a. Aenderungen auch der Parameter anderer
Attribute.
Zu 5.1.1
----------------------------------------------------------------------
origin-Attribut
---------------
Setzt einen Punkt im 3-dim. kartesischen Koordinatensystem als Be-
trachtungsmittelpunkt C mit den Koordinaten (xorigin,yorigin,zorigin).
Aus dieser Zuordnung erklaert sich die im Manual oft synonyme Verwen-
dung der Bezeichnungen "origin" und "viewing center".
Der Default (0.0,0.0,0.0) bedeutet, dass als "origin" der Mittel-
punkt der 3-dim. Szene gewaehlt wird, wobei diese so skaliert ge-
dacht ist, dass sie in den Einheitswuerfel -0.5 <= x,y,z <= 0.5
passt. Die tatsaechlichen Benutzerkoordinaten des Mittelpunkts im
vom Benutzer definierten "window" sind i.a. anders.
window-Attribut
---------------
(unterschiedliche Parameter fuer 2- und 3-dim. Plots)
Fuer beide Dimensionen stehen minimale und maximale Werte fuer je-
de Koordinatenachse am Anfang der Parameterfolge:
(xmin,xmax,ymin,ymax,...).
Dazu im 2-dim.: Achsenschnittpunkt (xorig,yorig)
Achsentyp (ixflag,iyflag):
1 (linear), 2 (logarithmisch), 3 (polar)
Default fuer Koordinatenwerte im 3-dim.:
Einheitswuerfel 0.0 <= x,y,z <= 1.0
Erst ueber die Attribute autoscale_input / autoscale_output wer-
den die window-Werte wirksam.
Bei Verwendung des defaults fuer window (keine Angabe) ist i.a.
der default von autoscale_input und autoscale_output sinnvoll
(s. dort).
Bei Angabe von vom default verschiedenen window-Werten muss auf
jeden Fall autoscale_input und autoscale_output dazu geeignet ge-
waehlt werden.
autoscale_input-Attribut
------------------------
Es bestimmt, welche "Datenquelle" zu untersuchen ist, um die auto-
matische Achsenskalierung durchzufuehren, d.h. die Achsengrenzwer-
te zu erhalten.
Wert "Datenquelle"
0 keine (Ausschalten von autoscaling)
1 Datenwerte, die am Datenknoten gesetzt werden (default)
2 window-Werte
4 Werte der Attribute interval_start und interval_end
(Summen der Attributwerte sind zulaessig)
Beim default=1 koennen "marker" auf den Koordinatenachsen u.U. nicht
voll sichtbar sein.
autoscale_output-Attribut
-------------------------
Gewisse Attributwerte koennen fuer die Plotausgabe geaendert werden,
insbes. koennen zu ein und derselben Szene verschiedene Ausgaben er-
zeugt werden.
Wert Wirkung
0 keine Aenderungen bei Ausgabe (Ausschalten von autoscaling)
1 Neuskalierung durch Benutzung der Achsengrenzwerte statt
der in window spezifizierten Werte
2 Neuskalierung von
interval_start, interval_end, interval_number,
density (der minor ticks)
statt der momentanen Werte
4 Lege Achsenschnittpunkt zur Plotecke, die ueber das Attri-
but plot_corner bestimmt wird, statt in dem ueber window
spezifizierten Achsenschnittpunkt
8 Zwinge die Achsengrenzen in X und Y dieselbe Ausdehnung zu
haben (nur pie charts)
(Summen der Attributwerte sind zulaessig)
Default: 7
plot_corner-Attribut
--------------------
Es definiert eine oder mehrere Plotecken, um die Lage der auf dem Plot
einzuzeichnenden Achsen festzulegen bzw. zu einer bestimmten Plotecke
eine Legende zuzuordnen.
Die Realisierung der Achsenlage leistet die autoscale-Funktion:
autoscale_output muss den Attributwert 4 mit enthalten (was z.B. beim
default=7 der Fall ist), damit die mit plot_corner angegebenen Ecken
auch Achsenschnittpunkte werden.
Die Attributwerte:
Es gibt 8 Werte (d.h. Plotecken) im 3-dim. Fall, im 2-dim. sind es nur
4, und zwar die ersten Werte 0 bis 3, entsprechend den 4 Ecken eines
Plotrechtecks (keine raeumliche Koordinate z bzw. stets z=0).
In der folgenden Wertetabelle bedeutet z die dritte raeumliche Koordi-
nate, neben den ebenen Koordinaten x und y. Dabei sei
zmin = kleinster z-Wert auf dem Plot
zmax = groesster z-Wert auf dem Plot.
Attributwerte
in der Ebene z=zmin in der Ebene z=zmax
welche Ecke (im 2-dim. z=0) (nur fuer 3-dim. Plot)
----------------------------------------------------------------------
untere linke Ecke 0 4
untere rechte Ecke 1 5
obere rechte Ecke 2 6
obere linke Ecke 3 7
Das Attribut plot_corner kann sowohl einem Achsenknoten als auch einer
Legende zugeordnet werden.
1. Zuordnung zu einem Achsenknoten (an):
Die ueber plot_corner angegebenen Plotecken (mit p bzw. a,b,c be-
zeichnet, s.u.) werden Achsenschnittpunkte.
2-dimensionaler Plot:
.pn.axis.an plot_corner p
wobei p=0,1,2 oder 3 ist
3._________.2
| |
| |
|_________|
0 1
Default: 0 ---> Achsenlage: ^ y
|
|
--------->
x
3-dimensionaler Plot:
.pn.axis.an plot_corner abc
wobei a,b,c ganzzahlig, 0 <= a,b,c <= 7,
d.h. die x-,y-,z-Achse gehen durch die Plotecken a,b,c in dieser
Reihenfolge.
Plotecken des "window-Quaders":
Grundflaeche z=zmin Deckflaeche z=zmax
3._________.2 7._________.6
| | | |
| | | |
|_________| |_________|
0 1 4 5
Default: c=1 (keine Angabe von a,b, was bedeutet, dass bzgl.
x,y-Achse der 2-dim. Default gilt)
---> Achsenlage:
^ z
|
|
|
\ /1
\ /
\ /
y \ / x
\ /
\./
0
Die uebliche Achsenlage (alle 3 Achsen vom Ursprung ausgehend) ent-
entsteht mit
.pn.AXIS.an plot_corner 0
Dass alle drei Achsen oberhalb der Zeichnung vom Punkt 6 ausgehen,
kann man mit
.pn.AXIS.an plot_corner 666
erreichen.
2. Zuordnung zu einer Legende
Zum gewaehlten Legend-Knoten (.pn.legend) sind die Attribute
plot_corner u n d legend_corner anzugeben. Die so definierte Punkt-
ecke und Legendenecke werden zur Deckung gebracht, z.B.
Legende an die rechte obere Ecke im 2-dim. ueber
plot_corner 2 legend_corner 3
Default: 2 (sowohl 2- als auch 3-dim.).
eye-Attribut (zu .pn.axis.an)
-----------------------------
Die Koordinaten (xeye,yeye,zeye) des Betrachterstandspunkts A ("eye po-
sition") werden festgelegt, wobei A moeglichst ausserhalb der in dem
(x,y,z)-window (Quader) dargestellten Szene liegen soll.
Die Default-Betrachterkoordinaten: (-3.0, -2.4, 1.4)
sind geeignet zum ueber den window-default definierten Einheitswuerfel
0.0 <= x,y,z <= 1.0 mit Betrachtermittelpunkt C = (0.0, 0.0, 0.0)
(origin-default).
Ueber den Vektor CA wird der Normalenvektor der Betrachtungsebene
("viewing plane") berechnet, der die Richtungscosinus dieser Ebene
bestimmt.
Geometrisch:
Der "window-Quader" wird auf die ueber das eye- und origin-Attribut
definierte Betrachtungsebene projiziert. Die minimalen und maximalen
Werte des projizierten Quaders bestimmen eine rechteckige Betrach-
tungsflaeche, im Falle des default-Einheitswuerfels ist diese Flaeche
quadratisch.
perspective-Attribut (zu .pn.axis.an)
-------------------------------------
Werte
0 keine perspektivische Darstellung fuer Achsen und Daten
1 perspektivische Darstellung von Achsen und Daten
2 Daten werden auf gesamtes Betrachtungsfenster ausgedehnt
(default)
Mit dem Attributwert 1 werden die dreidimensionalen Koordinaten des
darzustellenden Bildes zuerst so transformiert, dass die dritte raeum-
liche Koordinate z in die Richtung der Normalen der Betrachtungsebene
faellt und betragsmaessig gleich der auf die Normale projizierten Dis-
tanz zur Betrachterposition ("eye position") ist. Die transformierten
x,y-Koordinaten in der Betrachtungsebene werden dann noch durch den
Betrag der neuen z-Koordinate dividiert.
aspect-Attribut (zu .pn.axis.an)
--------------------------------
steuert das Verhaeltnis der Achsenlaengen im 3-Dimensionalen, d.h. die
relative Achsenskalierung.
Werte (z.Zt.) nur:
0.0 default. Skalierung aller Achsen, um die Groesse der Szene zu ma-
ximieren
1.0 Die Entfernungen laengs jeder Achsenrichtung bleiben erhalten.
Zu 5.1.2
----------------------------------------------------------------------
light-Attribut
--------------
Mit der Angabe der kartesischen Koordinaten (xlight,ylight,zlight) der
Position der Lichtquelle L wird eine Beleuchtung der 3-dim. Szene er-
zeugt (aber: nur mit dem Attribut shade>=2 sinnvoll).
Default: (-3.0, -2.4, 1.4)
d.h. identisch mit dem default des eye-Attributs, also Betrachter und
Beleuchtung an gleicher Position.
Allgemein: L ist geeignet ausserhalb des window-Quaders zu waehlen.
Die Richtung, aus der das Licht kommt, wird durch den Vektor LC
(Lichtquelle -> Betrachtungsmittelpunkt) festgelegt, alle Lichtstrahlen
sind parallel zu dieser Richtung ankommend zu denken.
Die Intensitaet der Beleuchtung ist lokal auf einem ebenen Flaechen-
stueck der 3-dim. Szene abhaengig von der Summe der Skalarprodukte aus
Flaechennormale nv des betrachteten Flaechenstueckes mit dem "eye nor-
mal vector" (AC) und dem "light normal vector" (LC), d.h.
I proportional nv * (AC + LC)
I ist klein oder verschwindend, falls AC und LC entgegengesetzt gerich-
tet sind.
Die Beleuchtungsintensitaet fuer ein sich aus verschiedenen Facetten
zusammensetzendes Objekt wird in Abhaengigkeit des Attributs shade be-
rechnet (u.U. Beruecksichtigung differierender Flaechennormalen in den
Scheitelpunkten der Polygone).
shade-Attribut (CPU-intensiv!)
------------------------------
Festlegung des Typs der Schattierung fuer 3-dim. Oberflaechen eines
Plots.
Wert Lichquelle vorhanden Art der Schattierung
1 nein hollow shading (wire-frame mesh)
2 ja flat shading
(eine Farbe gleicher Intensitaet inner-
halb einer Polygonfacette)
3 ja Gouraud shading
(Farbschattierung wird auf "pixel level"
berechnet)
4 ja Phong shading
(Interpolation ueber Flaechennormalen in-
nerhalb einer Polygonfacette)
Defaults:
1 ohne Lichtquelle
2 mit Lichtquelle.
Abhaengig von den Attributen fill_type und depth.
depth-Attribut
--------------
um verdeckte Flaechen bei 3-dim. Objekten auch als verdeckt darzustel-
len.
eg unterstuetzt als Methode zur Ermittlung verdeckter Flaechen nur
den "depth buffer" (Z-buffer), keine Sortieralgorithmen.
Prinzip des "depth buffers":
Betrachte Distanzen vom Auge zu jedem Pixel. Bei Zufuegung eines neu-
en Elements zur Szene wird ein Distanzvergleich aller relevanten Pixel
durchgefuehrt. Ueberschreibung der Pixel mit groesserer Entfernung.
Attributwerte fuer Entfernung verdeckter Flaechen:
depth 2 (fuer begrenzten Speicher, einfache Szene, als
"software painters algorithm" bezeichnet)
depth 3 (fuer komplexe Szene, als "software Z-buffer"
bezeichnet)
Keine Entfernung verdeckter Flaechen mit
depth 0
5.2 Verschiedene weitere Attribute
5.2.1 Attribute bezueglich der Ausgabeseite:
----------------------------------------------------------------------
viewport
--------
dient dem Arrangieren eines oder mehrerer Plots auf einer "Ausgabesei-
te". Vier Koordinaten fuer die Plotausdehnung als Bruchteile der ge-
samten Ausgabeseite sind eingebbar.
Mit den Default-Werten fuer
xmin, xmax, ymin, ymax
0.0, 1.0, 0.0, 1.0 (2-dim.)
bzw.
0.0, 0.95, 0.0, 0.95 (3-dim.)
wird der Plot auf der gesamten Ausgabeseite erzeugt, auch wenn diese
Seite nicht quadratisch ist.
Bei Verwendung der Funktion "ac_multiple_plot" kann der Benutzer ueber
den Parameter "viewport_array" die Position und Groesse der auf einer
Seite einzutragenden Plots verschieden von den Default-Werten erzeu-
gen.
scale
-----
Angebbar ist der Faktor, um den die zu viewport gehoerigen vier Koor-
dinaten (default oder explizit gesetzt) verkleinert werden.
Das bewirkt eine Anpassung der Fenstergroesse, damit u.U. gewisse
"Randdaten" nicht abgeschnitten werden, was insbes. im 3-Dim. erfor-
derlich sein kann wegen der dort fehlenden autoplot-Faehigkeit.
I.A. braucht der eingetragene Default-Wert nicht geaendert zu werden
(0.01 im 2-Dim., 0.25 im 3-Dim.)
autoplot
--------
nur 2-dim.: ac_set (".pn autoplot", Wert)
Wert
0 Benutzerflaeche fuellt Ausgabeseite (viewport)
1 ganzer Plot ist innerhalb von Ausgabeseite (viewport).
5.2.2 Attribute fuer das Einbringen von Daten an einen Knoten:
----------------------------------------------------------------------
number_sets
-----------
Wert: Anzahl der Datenmengen an einem Datenknoten (default: 1, d.h.
Attributangabe entfaellt).
Dadurch wird die Erzeugung getrennter "Polylines" oder Polygone an
einem Datenknoten moeglich. Alle Punkte in jeder solchen Datenmenge
des betreffenden Datenknotens werden mit derselben Attributmenge er-
zeugt.
number
------
Wert: Anzahl der Datenpunkte in e i n e r Datenmenge eines Daten-
knotens.
Um Daten in diese Datenmengen eimes Datenknotens zu schreiben, dienen
folgende Attribute:
x, y, z Uebergeben von Pointern auf x-, y-, z-arrays
x_copy, y_copy, z_copy Kopieren von x,y,z-arrays in den Graphikbaum
(Laenge: number-Attribut!)
x_another, y_another, z_another kreieren weitere Datenmengen mit glei-
chen Attributen (Konzept: mehrfache getrennte Polylinien oder Polygone
an einem Knoten).
x_append, y_append, z_append
Fuer die Darstellung bzw. Interpretation der kopierten Daten sind fol-
gende zwei Attribute nuetzlich:
flag
----
fuer Datendarstellung, wie Markierung, Verbinden oder nicht, bar chart,
Splines,... (default: 2, d.h. Punkte sind markiert).
fancy
-----
nur fuer 3-Dim. Kein Default. In Abhaengigkeit von gewissem flag-Wert
zu interpretieren.
Einlesen eines Rasterbildes (funktioniert in Version 2.1 nicht!)
---------------------------
Obwohl es sich nicht um die Wertzuordnung zu einem Attribut handelt,
soll hier, da es sich um den Aspekt des Einbringens von Daten handelt,
die Moeglichkeit zitiert werden, ein Rasterbild einzulesen.
Das leistet die eg-Funktion:
ac_read_raster_file
Das in einem File gespeicherte Rasterbild wird eingelesen und in den
Graphikbaum plaziert, so dass ueber die uebliche Darstellungsfunk-
tion ac_plot ein Display erzeugt werden kann.
Wesentlich: Rastertypangabe nach Liste in [2] ermitteln und Parameter
entsprechend setzen (ohne Rastertypangabe fuer GIF-Format-File).
Ausserdem sind die Intervalle anzugeben, in denen das Rasterbild ent-
stehen soll (durch Expansion oder Kompression):
[x_start, x_stop], [y_start, y_stop].
5.2.3 Attribute fuer "tick marks" (Achseneinteilungen)
----------------------------------------------------------------------
Achseneinteilungen koennen nur ueber die Knoten "major" und "minor"
vorgenommen werden.
Relevant sind:
start, end Laenge der Einteilungsstriche
interval_start, interval_end Wert, um den erstes bzw. letztes
"tick mark" relativ zum Fenster ver-
schoben ist.
interval_number Anzahl der "tick marks" des Intervalls
Weglassen der Einteilungen ueber "activate 0".
6. Dreidimensionale Probleme
6.1 Facettierung ("tesselation") von Objekten/Flächen
In eg koennen
(1) die Grundkoerper Ellipsoid, Kegel, Torus sowie
(2) Hermite Patches bei der Flaechendarstellung und darueberhinaus
(3) 3-dimensionale Marker, Linien oder Vektoren
facettiert dargestellt werden.
Durch folgende gesetzten Attribute erfolgt die Zuordnung der Daten am
betreffenden Knoten zu einer dieser Klassen:
(1) Grundkoerper: flag 1024
Unterteilung mit "object":
Ellipsoid: object 1
Kegel: object 2
Torus: object 3
(2) Hermite Patches: flag 16
dazu:
hermite_flag 1
(--> normal_grid_copy)
(3) fuer alle drei Arten: fancy 1
Unterteilung mit "flag":
3-dim. Marker: flag 2
3-dim. Linien: flag 1
3-dim. Vektoren: flag 32
Allgemein wird die Schattierungsart eines 3-dimensionalen Objekts ueber
das s h a d e - Attribut (s. dort) bestimmt.
Wird speziell Gouraud shading (shade 3) oder Phong shading (shade 4)
fuer ein facettiertes Objekt (s.o.) gewaehlt, so werden diese Schattie-
rungsarten zusaetzlich ueber das Attribut
smooth
mit den zwei Werten 0 oder 1 gesteuert:
smooth 0 : facettierte Darstellung o h n e Normaleneingabe
smooth 1 : facettierte Darstellung m i t Normaleneingabe fuer diese
Schattierungsarten (-> normal_grid_copy).
6.2 Erzeugung von Plots der drei Grundkörper: Ellipsoid, Kegel/Kegelstumpf, Torus
6.2.1 "Facettierung" (= tesselation) der Grundkoerper
----------------------------------------------------------------------
Die Darstellung der Grundkoerper erfolgt durch zusammengesetzte ebene
Flaechenstuecke (Facetten). Das Programm berechnet aber die exakten
Flaechennormalen des Grundkoerpers.
Moeglichst glatte Oberflaechen der Grundkoerper sind naeherungsweise
mittels des Attributs "smooth" und einer grossen Anzahl von Facetten
moeglich.
Mit nur sehr wenigen Facetten kann "prismatisches" Aussehen entstehen.
Die Aufteilung in Facetten erfolgt bei Ellipsoid und Torus in 2 Ebe-
nen (in der x,y-Ebene und der dazu senkrechten Ebene), beim Kegel
bzw. Kegelstumpf nur durch "Sektorisierung" der Deckflaechen (fuer
beide gleich), wobei man in allen drei Faellen stets von der Default-
Lage (Achse parallel zur z-Achse) ausgeht, d.h. die Logik der Facet-
tierungsparameter betrachtet den Koerper v o r jeder Transformation.
Auf diese Defaultlage bezieht sich auch die Bezeichnungsweise
"horizontal": Winkelmessung in (x,y)-Ebene, entgegen Uhrzeigersinn
"vertical": Winkelmessung in zur (x,y)-Ebene senkrechten Ebene
6.2.2 Beschreibung der Grundkoerper ueber Attribute
----------------------------------------------------------------------
| Ellipsoid | Kegel | Torus
______________________________________________________________________
flag-Attribut
-------------
| | |
| flag 1024 | flag 1024 | flag 1024
| | |
notwendiger Eintrag fuer jeden der drei Grundkoerper; denn:
Wird an einem Datenknoten der flag-Wert auf 1024 gesetzt, so werden
die dort eingetragenen (x,y,z)-Werte als Mittelpunkt des betreffenden
Grundkoerpers markiert. Steht zusaetzlich noch das "number"-Attribut
dabei, so gibt dessen Wert die Anzahl der Grundkoerper an diesem Kno-
ten an (nur derselben Art).
object-Attribut
---------------
| | |
| object 1 | object 2 | object 3
| | |
dient der Klassifikation des Grundkoerpers
Mittelpunkt
-----------
Er wird z.B. ueber x_copy, y_copy, z_copy eingetragen
| | |
| x,y,z | x,y | x,y,z
| Mittelpunkt des | Mittelpunkt der | Mittelpunkt des
| Ellipsoids | Kegelgrundflaeche | "Loches"
Radien ("_radii"-Attribute)
---------------------------
Sie sind stets als (x,y)- bzw. (x,y,z)-Koordinaten relativ zum be-
treffenden Mittelpunkt als Ursprung anzugeben.
| | |
| ellipsoid_radii |frustum_bottom_radii| torus_major_radii
| a b c | a1 b1 | R1 R2
| | | ("Lochradien")
| | frustum_top_radii | torus_minor_radii
| | a2 b2 | r1 r2
| | | ("Wurstradien")
Default: alle Radien fuer einen Koerper gleich, mit folgenden Werten
| | |
| Default: 1.0 | Default: 0.707 | Default: 0.7
| | |
spezielle Attribute fuer Kegel/Kegelstumpf
------------------------------------------
frustum_length
bestimmt den Abstand h zwischen Grund- und Deckflaeche.
frustum_cap
legt fest, welche der beiden Deckflaechen sichtbar sein soll.
Wert von n
1 Grundflaeche sichtbar
2 Deckflaeche sichtbar
3 Grund- und Deckflaeche sichtbar.
horizontale Facettierung ("horizontal"-Attribute)
-------------------------------------------------
Fuer alle 3 Koerper in analoger Weise vorhanden.
horizontal_facets Anzahl hf der Facetten innerhalb des Intervalls
fuer den "horizontalen" Winkel (theta):
horizontal_start <= theta <= horizontal_end
Default: hf = 8
Zulaessige Werte in (0,1000000).
Bedeutet Einbeschreiben eines hf-Ecks in Ellipse
der (x,y)-Ebene.
horizontal_start Anfangs- und Endwinkel (in Grad) in (x,y)-Ebene
horizontal_end Default: horizontal_start 0
horizontal_end 360
Beide Winkel muessen im Intervall (-360, 360) liegen, d.h. sogar
"Doppelumlauf" z.B. laengs eines Kegels moeglich, was bei ungerader
Facettenanzahl hf zu "sternartiger" Grundflaeche fuehrt, bei geradem
hf aber die Facettenanzahl halbiert erscheinen laesst.
vertikale Facettierung ("vertical"-Attribute)
---------------------------------------------
Nur fuer Ellipsoid und Torus vorhandene Attribute.
vertical_facets Anzahl vf der Facetten innerhalb des Intervalls
fuer den "vertikalen" Winkel (phi):
vertical_start <= phi <= vertical_end
Default: vf = 8
Zulaessige Werte in (0,1000000).
Bei Ellipsoid: Schnitte laengs Breiten"kreisen"
(die genauer Ellipsen sind)
Bei Torus: Einbeschreiben eines vf-Ecks in
Querschnittsellipse des Torus
(der "Wurst").
vertical_start Anfangs- und Endwinkel (in Grad) in der zur
vertical_end (x,y)-Ebene senkrechten Ebene
Default: vertical_start 0
vertical_end 360
Beide Winkel muessen im Intervall (-360, 360) liegen, sollten aber
nur einen Winkel <= 360 einschliessen.
Achse des Grundkoerpers
-----------------------
Fuer alle 3 Koerper in analoger Weise mit dem "orientation_axis"-
Attribut veraenderbar.
Default: Koerperachse parallel zur z-Achse und durch Koerpermittel-
punkt, der durch die (x,y,z)-Werte am Knoten definiert ist.
Aenderung des Defaults:
3 Koordinaten (xa,xb,xc) sind einzugeben, also
orientation_axis xa xb xc
Die Parameterdarstellung der Geraden durch (0,0,0)
x = xa * t, y = ya * t, z = za * t
liefert die Parallele zur neuen Achse durch den Mittelpunkt.
6.3 Gegeben: Diskrete Punkte im Dreidimensionalen
6.3.1 Scatter-Plots
-------------------
Wiedergabe als Punkte eines Scatter-Plots mit der eg-Funktion
ac3_scatter_plot
6.3.2 Flaechenerzeugung und -darstellung
----------------------------------------
Durch geg. Gitterpunkte (in arrays) soll eine Flaeche erzeugt und
graphisch dargestellt werden. Dafuer gibt es verschiedene Moeglich-
keiten:
--- Setzen der Attribute x,y,z_grid_copy und "flag 16" (d.h. "gridded
data as a surface plot"), also z.B. ueber
ac3_set (" number_x_grid number_y_grid number_z_grid flag
x_grid_copy y_grid_copy z_grid_copy", ...)
Das gegebene Gitter ist dabei rechtwinklig.
--- Verwendung der eg-Funktion: ac3_grid_surface_plot
Aussehen des gegebenen Gitters:
- Rechtwinkliges Gitter (default):
Zu den Vektoren x(i), i=1,...,n und y(j), j=1,...,m
ist ein Array mit den zugehoerigen Werten z(j)(i) einzugeben.
- Nicht rechtwinkliges Gitter (Gittereingabe etwas anders):
im Prinzip muessen fuer die Flaeche Wertetriple
( x[i], y[i], z[i] ), i=1,...n
eingegeben werden, aber als 3 Arrays.
Optionale Parameter fuer Berechnung der Flaeche im Sinne der Aus-
gleichsrechnung:
SURFACE_EXACT_FIT oder SURFACE_APPROX_FIT
Zusaetzliche Parameter fuer
Normalenberechnung (CALC_SURFACE_NORMAL),
Schattierungsmoeglichkeit
--- Verwendung der eg-Funktion: ac3_parametric_surface_plot
Aussehen des gegebenen Gitters:
f(i,j,k) = f(x(i),y(j),z(k)),
wobei
x(i-1) < x(i) < x(i+1)
y(i-1) < y(i) < y(i+1)
z(i-1) < z(i) < z(i+1)
gefordert ist und von der Funktion f nur die Werte in den Gitter-
punkten bekannt sind.
Gezeichnet wird die gewuenschte Anzahl von Flaechen f = const
(contour level).
Ueber ein tag-File sind verschiedene Eingaben ueberschreibbar.
--- Flaechendarstellung nach Berechnung der Koeffizienten einer in-
terpolierenden Spline-Funktion (Tensor-Produkt-Spline):
ny-1 nx-1
Sum Sum c(n,m)*B(n,kx,tx)[x]*B(m,ky,ty)[y]
m=0 n=0
Gegebenes Gitter:
x[i], y[j], f[i,j] = f(x(i),y(j)), i=1,...,n und j=1,...,m
Die Funktion f ist nur an den diskreten Stellen bekannt.
Zuerst Spline-Erzeugung
mit eg-Support-Funktion: ac_f_spline_2d_interp
Funktionsausgabe: sp=ac_f_spline_2d_interp(n,x,y,f,0);
wobei sp Pointer auf Spline-Funktion s(x,y): Ac_spline *sp
Danach:
Werte des Splines s an beliebigen (x,y)-Stellen:
mit der eg-Supportfunktion: ac_f_spline_2d_value
Flaechendarstellung der Splinefunktion s(x,y)
mit der eg-Funktion: ac3_Bspline_surface_plot
Zusaetzliche Parameter fuer
Normalenberechnung (CALC_SURFACE_NORMAL),
Schattierungsmoeglichkeit
--- Flaechendarstellung ueber Hermite Patches
s. unter 6.4
6.3.3 Berechnung einer interpolierenden glatten Funktion durch die
Gitterpunkte
----------------------------------------------------------------------
Gegeben: (x(i),y(i)), f(i), i=1,...,n
Aufruf der eg-Supportfunktion: ac_f_scattered_2d_interp
Funktionsausgabe: Pointer auf array (float *s),
der Werte der Interpolationsfunktion an gewuenschten Stellen (x,y)
enthaelt.
Berechnet wird:
- Delaunay Triangulierung der Gitterpunkte
- s(x,y) als Polynom 5-ten Grades in (x,y) auf jedem Dreieck
- s(x(i),y(i)) = f(i)
- s stetig differenzierbar laengs der Raender benachbarter Dreiecke.
Ergebnis:
zu Werten (xn(j),yn(k)) zugehoeriges s(xn(j),yn(k)) als neues Gitter
(ueber Pointer), mit j=1,...nx, k=1,...,ny.
6.4 Spezialfall von 6.3: Flächendarstellung über Hermite Patches
Geometrisches Konzept:
Die Hermite Patches (d.h. Flecken) werden durch die Punkte gelegt, die
der Benutzer im Dreidimensionalen vorgibt, und sie besitzen die auch
vom Benutzer zu spezifizierenden Normalenwerte. Dabei handelt es sich
um kubische Gleichungen.
Allerdings verhalten sich die Ableitungen laengs der Raender der
"Patches" nicht unbedingt stetig.
Die mit den "*_facets" Attributen angegebenen Anzahlen verursachen
eine weitere Unterteilung ("tesselation") der Hermite Patches.
Unter 6.4.1 - 6.4.3 werden die Attribute angegeben, die der Benutzer
am betreffenden Datenknoten setzen muss, um die Hermite Patches rich-
tig dargestellt zu bekommen, d.h. fuer Gitter, Normalen und Skalierung.
6.4.1 Gittererzeugung
---------------------
Sie kann mittels des Attributs
x,y,z_grid_copy
erfolgen, ueber gegebene arrays (x(i),y(k),z(i,k)) oder eine Werte-
liste, alles als Gleitpunktzahlen.
Die Art der Darstellung dieses Gitters verlangt ueberdies einen Wert
zum flag-Attribut, hier: flag 16, d.h. es wird eine Flaeche erzeugt
(nur die einzelnen Punkte, etwa besonders markiert, sind so nicht
darstellbar).
6.4.2 Normalenwertzuordnung
---------------------------
Um die Normalen in den Gitterpunkten fuer die Hermite Patches zu
erhalten, muss das Attribut
hermite_flag 1
und
normal_grid_copy i1 i2 i3
besetzt werden.
Dabei sind die einzugebenden Normalenwerte als integer-Werte i1, i2,
i3 einzutragen. Egc normiert sie automatisch auf den Bereich
[-255,255]. Sie sind jedem Gitterpunkt z(x,y) als Normalenrichtungen
zuzuordnen.
Beispiel:
- Eingabe als array:
Der "array" normal[n][n][3] wird im C-Programm ueber
ac3_set (" normal_grid_copy", normal)
den Gitterpunkten zugeordnet.
- Eingabe im use-File durch Liste aller einzelnen Werte zum Attribut
normal_grid_copy
Im Gegensatz dazu werden die Flaechennormalen von anderen Flaechen,
die keine Hermite Patches sind, automatisch von eg erzeugt
(das Attribut hermite_flag muss dabei 0 sein, was der default ist).
6.4.3 Skalierungsfaktoren / Facettenanzahlen
--------------------------------------------
hermite_scale
-------------
steuert den Skalierungsfaktor fuer die Normalen auf den Hermite
Patches.
default: 1.0
hermite_multipliers wert1 wert2 wert3
-------------------------------------
steuert die Skalierung der Hermite Patches bei groessenordnungsmaessig
unterschiedlichen x-, y- bzw. z-Werten.
Die einzugebenden Gitterwerte fuer die H.P. bestimmen die Intervalle,
fuer die im Bild die x-, y- und z-Achse dargestellt wird. xl, yl, zl
seien die ohne Veraenderung entstehenden Achsenlaengen. Die H.P. sind
nun so konzipiert, dass sie sich am besten fuer folgende Achsenver-
haeltnisse darstellen:
xl = yl = L
zl = 0.25*L
Dementsprechend sollen die Parameterwerte (s.o.) wert1, wert2, wert3
gewaehlt werden.
horizontal_facets und vertical_facets
-------------------------------------
Mit diesen Attributen werden die Facettenanzahlen in der jeweiligen
Richtung fuer e i n solches Patch festgelegt.
7. Kurvendarstellungen in der Ebene
Gegeben:
Punkte (Messwerte z.B.) x[i],f[i], i=1(1)n, im Intervall [a,b].
Gesucht:
Kurve, die entweder genau (interpolierend) oder naeherungsweise
durch die gegebenen Punkte geht.
Ausgabeformen: Funktionswerte zu vorgegebenen Abszissen und/oder
graphische Darstellung (Plot).
eg-Realisierung:
-----------------
- fuer einfache Darstellungen beachte man das flag-Attribut (unter
5.2.2).
- Splineerzeugung:
Mit einer eg-Funktion wird eine Splinefunktion berechnet, die in
der gewuenschten Form durch die geg. Punkte geht. Das Ergebnis die-
ser Funktion ist stets nur Zwischenergebnis fuer die numerische Aus-
wertung bzw. graphische Darstellung.
Egc erzeugt verschiedene Spline-Typen.
- Werte des Splines an diskreten Stellen:
Eine weitere eg-Funktion leistet die Berechnung von Werten der vor-
her erzeugten Splinefunktion an beliebigen vom Benutzer gegebenen x-
Werten xneu[j] des Eingabeintervalls.
- Graphische Darstellung:
die graphische Darstellung der betreffenden Funktion kann an ver-
schiedenen Stellen ansetzen:
- gewisse eg-Funktionen uebernehmen den "return value" der eg-
Funktionen, die Splines berechnen (Pointer auf eine Struktur, die
die Spline-Funktion enthaelt) und erzeugen den gewuenschten Plot.
- die eg-Funktion ac_function_plot benoetigt eine vom Benutzer zu
liefernde Funktion, die die Werte berechnet. An dieser Stelle
koennen die Splineauswertungsfunktionen
ac_f_spline_value, ac_f_cub_spline_value
stehen.
Zu im folgenden verwendeten Bezeichnungen, die die Parameter fuer den
Spline-Unterraum betreffen:
m lineare Dimension,
k Ordnung des Teilraums, fuer den die Knoten berechnet werden sollen,
wobei k <= m < n.
7.1 Splines berechnende eg-Funktionen mit "return value" vom Typ Ac_spline *sp
7.1.1 Least-squares Splines
----------------------------------------------------------------------
eg-Support-Funktion fuer Spline: ac_f_spline_least_squares
---------------------------------
berechnet
n-1 m-1
Min { Sum w[i]*( f[i] - Sum a[j]*B[j](x[i]) )**2 }
a[j] i=0 j=0
wobei
w[i] Gewichte,
B[j] (B-Spline)-Basis fuer den Spline-Unterraum,
a[j] gesuchte Koeffizienten.
Funktionsausgabe: sp=ac_f_spline_least_squares(n,x,f,m,0);
wobei sp Pointer auf Spline Approximation: Ac_spline *sp
Werteberechnung:
----------------
eg-Support-Funktion: ac_f_spline_value
mit Ausgabe sp von ac_f_spline_least_squares
einfachster Aufruf: y = ac_f_spline_value (x,sp,0);
Graphische Darstellungen:
-------------------------
eg-Funktion fuer Plot der Kurve: ac_piecewise_Bspline
mit Ausgabe sp von ac_f_spline_least_squares
Aufruf: ac_piecewise_Bspline(sp,a,b,0);
oder
eg-Funktion fuer Plot der Kurve: ac_least_square_poly_curve
benoetigt keine vorherigen Berechnungen.
Aufruf: ac_least_square_poly_curve(n,x,f,0);
7.1.2 B-Splines
----------------------------------------------------------------------
eg-Support-Funktion fuer Spline: ac_f_spline_interp
---------------------------------
berechnet einen Spline-Interpolanten als Linearkombination von B-Spli-
nes.
Zusaetzlich u.a.:
Parameter ORDER fuer Angabe der Ordnung des Spline-Unterraums
(default: 4, d.h. kubische Splines).
Auch eine Knotenvorgabe ist moeglich.
Funktionsausgabe: sp=ac_f_spline_interp(n,x,f,0);
wobei sp Pointer auf Spline Interpolant: Ac_spline *sp
Werteberechnung:
----------------
eg-Support-Funktion: ac_f_spline_value
mit Ausgabe sp von ac_f_spline_interp
einfachster Aufruf: y = ac_f_spline_value (x,sp,0);
Graphische Darstellungen:
-------------------------
eg-Funktion fuer Plot der Kurve: ac_piecewise_Bspline
mit Ausgabe sp von ac_f_spline_interp
Aufruf: ac_piecewise_Bspline(sp,a,b,0);
7.2 Splines berechnende eg-Funktionen mit "return value" vom Typ Ac_ppoly *ppoly (interpolierende Splines)
7.2.1 kubische Splines (Beruecksichtigung konkaver/konvexer Eigenschaf-
ten)
-----------------------------------------------------------------------
eg-Support-Funktion fuer Spline: ac_f_cub_spline_interp_shape
---------------------------------
berechnet einmal stetig differenzierbaren kubischen Spline-Interpolan-
ten.
Zusaetzlich u.a.:
Parameter CONCAVE fuer Konkavitaetserhalt der Daten,
Parameter zur Angabe der Maximalzahl von Iterationen fuer Newtons Me-
thode.
Funktionsausgabe: ppoly=ac_f_cub_spline_interp_shape(n,x,f,m,0);
wobei ppoly Pointer auf Spline Interpolant: Ac_ppoly *ppoly
Werteberechnung:
----------------
eg-Support-Funktion: ac_f_cub_spline_value
mit Ausgabe ppoly von ac_f_cub_spline_interp_shape
einfachster Aufruf: y = ac_f_cub_spline_value (x,ppoly,0);
Graphische Darstellungen:
-------------------------
eg-Funktion fuer Plot der Kurve: ac_piecewise_poly_curve
mit Ausgabe ppoly von ac_f_cub_spline_shape
Aufruf: ac_piecewise_poly_curve(ppoly,a,b,0);
7.2.2 kubische Splines (Ableitungen in Randpunkten angebbar)
----------------------------------------------------------------------
eg-Support-Funktion fuer Spline: ac_f_cub_spline_interp_e_cnd
---------------------------------
berechnet zweimal stetig differenzierbaren kubischen Spline-Interpo-
lanten.
Zusaetzlich u.a.:
1. oder 2. Ableitungen in den Randpunkten vorgebbar.
Parameter PERIODIC erzeugt periodischen Interpolanten.
Funktionsausgabe: ppoly=ac_f_cub_spline_interp_e_cnd(n,x,f,0);
wobei ppoly Pointer auf Spline Interpolant: Ac_ppoly *ppoly
Werteberechnung:
----------------
eg-Support-Funktion zur Werteberechnung: ac_f_cub_spline_value
mit Ausgabe ppoly von ac_f_cub_spline_interp_e_cnd
einfachster Aufruf: y = ac_f_cub_spline_value (x,ppoly,0);
Graphische Darstellungen:
-------------------------
eg-Funktion fuer Plot der Kurve: ac_piecewise_poly_curve
mit Ausgabe ppoly von ac_f_cub_spline_interp_e_cnd
Aufruf: ac_piecewise_poly_curve(ppoly,a,b,0);
7.3 Allgemeine Funktionsplots
7.3.1 ac_function_plot ---------------------- In allen Faellen, in denen der Benutzer eine Funktion fcn mit folgen- der Deklaration formulieren kann, die die Funktionswerte an beliebigen Stellen des betrachteten Bereichs berechnet, kann die eg-Funktion ac_function_plot zur graphischen Darstellung der Funktion benutzt werden. Von eg vorgeschriebene Deklaration fuer die Funktion fcn: double (*fcn) (double x) Bei Verwendung der eg-Support-Funktionen ac_f_spline_value bzw. ac_f_cub_spline_value innerhalb einer Funktion fcn ist zu beachten, dass diese Funktionen die x,y-Werte als float deklarieren. 7.3.2 ac_rev_comm_function_plot ------------------------------- Diese eg-Funktion benutzt eine adaptive Technik zur Berechnung einer zweimal stetig differenzierbaren kubischen Spline-Approximation s fuer eine Funktion f(x) im Intervall [a,b]. Der Benutzer muss den Aufruf dieser eg-Funktion mit der gekoppelten Auswertung der Funktion f(x) in eine unendliche Schleife (z.B. mit "for (;;)") setzen, deren Abbruch ueber die Abfrage nach dem ersten Parameterwert der Funktion (Schalter mit drei moeglichen Werten) aus- geloest wird. Dabei ist bereits defaultmaessig eine obere Schranke (4000) fuer die Anzahl von Funktionsauswertungen ueber den Parameter MAX_EVALUATIONS vorgegeben. Die eg-Funktion setzt die berechneten Funktionswerte fuer die Funktion f(x) des Intervalls [a,b] in den Graphikbaum, so dass ueber ac_plot die graphische Darstellung erfolgen kann. Anomalien koennen im Zusammenhang mit Unstetigkeiten auftreten, im Durchschnitt erfordert diese Methode jedoch weniger Funktionsauswer- tungen als nicht-adaptive Techniken.
8. Höhenlinien und Niveauflächen (contour lines and surfaces)
8.1 Höhenlinien (2-dim.Darstellung)
eg bietet verschiedene Funktionen zur Berechnung von Hoehenlinien, sogenannte "contour-Funktionen" sowie "tgrid_contour-Funktionen". Beides sind 2-dimensionale eg-Funktionen, die, wenn keine optionalen Parameter verwendet werden, zur Darstellung der Hoehenlinien in der Ebene fuehren. 8.1.1 ec-contour-Funktionen ---------------------------------------------------------------------- Sie berechnen die Hoehenlinien durch gegebene Werte bzw. Funktionen. "return value": vom Typ "Ac_error_code" (0, falls kein Fehler). ac_contour_plot --------------- Die Hoehenlinien gehen durch gleiche Werte des z-arrays. Einzugeben sind: x-array, y-array, z(x,y)-array, Anzahl gewuenschter Hoehenlinien. Varianten: - Eingabedaten sind ueberschreibbar, typischer Weise ueber tag-File. - Mit Angabe des Parameters "scattered_contour_data": Eingabe von m Datentriples (x,y,z) anstelle der getrennten arrays. ac_contour_Bspline_plot ----------------------- Die Hoehenlinien eines Tensor-Produkt B-Splines werden berechnet, wobei der B-Spline Ergebnis einer anderen eg-Funktion ist (s. dazu 7.1.2). ac_contour_function_plot ------------------------ Die Hoehenlinien werden durch gleiche Funktionswerte gelegt, wobei die Funktion als Parameter vom Benutzer zu liefern ist. 8.1.2 eg-tgrid_contour-Funktionen ---------------------------------------------------------------------- Sie berechnen die Hoehenlinien unter Benutzung eines triangulaeren Gitters. "return value": vom Typ "Ac_error_code" (0, falls kein Fehler). ac_tgrid_contour_plot ac_tgrid_contour_Bspline_plot ac_tgrid_contour_function_plot Vergleich zwischen contour- und entsprechender tgrid_contour-Funktion: auffaellig verschiedene Plots bei "sparse data" (laut Manual).
8.2 Höhenlinien (3-dim.Darstellung) und Niveauflächen
Die folgenden Funktionen dienen der "Weiterverarbeitung" von mit
2-dim. eg-contour-Funktionen berechneten Daten:
ac3_contour_fill
----------------
Sie dient dem Display eines Hoehenlinien-Plots, der ueber eine der
contour-Funktionen erzeugt wurde, als 3-dimensionalen "surface plot":
Flaechenstuecke gleichen Levels erscheinen als verschieden gefaerbte
Baender auf dem "surface plot" (Farbeinstellung defaultmaessig vorhan-
den, aber aenderbar).
"return value": aktuelle Nummer des 3-dim. Plotknotens.
Vorgehensweise:
- Aufruf einer der eg-contour-Funktionen. Dabei muss der optionale Pa-
rameter "contour_fill" angegeben werden.
- Aufruf:
int number_lines; /* Anzahl der berechneten Hoehenlinien der
contour-Funktion */
int new_plotnr=0; /* Nummer des 3-dim. Plotknotens */
new_plotnr = ac3_contour_fill (number_lines, new_plotnr);
ac3_contour_lines
-----------------
Diese Funktion transformiert 2-dim. "contour plots" in 3 Dimensionen.
Die "contour"-Daten (Daten fuer die Hoehenlinien) koennen ueber eine
beliebige contour-Funktion erzeugt werden, z.B. mit
ac_contour_funtion_plot
oder ueber
ac_tgrid_contour_function_plot
mit Angabe des Parameters "contour_fill".
"return value": aktuelle Nummer des 3-dim. Plotknotens.
Beispiele:
- Aufruf von ac_contour_function_plot (ohne optionale Parameter)
und danach von ac3_contour_lines erzeugt 3-dim. Hoehenlinien.
- Aufruf von ac_tgrid_contour_function_plot mit dem optionalen Parame-
ter "contour_fill" und danach von ac3_contour_lines erzeugt 3-dim.
Hoehenlinien mit farblich unterscheidbaren Flaechenstuecken konstan-
ten Levels.
ac3_contour_grid
----------------
Sie dient dem Display des triangulaeren Gitters, das von den
"tgrid_contour"-Funktionen erzeugt wurde, als 3-dim. "surface plot".
"return value": aktuelle Nummer des 3-dim. Plotknotens.
Vorgehensweise:
- Aufruf einer der drei tgrid_contour-Funktionen. Dabei muss der op-
tionale Parameter "contour_grid" eingetragen sein. Diesem ist als
Wert der gewuenschte Linientyp (s. integer-Werte des Attributs
line_type, default ist 1 und steht fuer "solid line") zugeordnet.
Wirkung: Gitterdaten werden im Graphikbaum gespeichert.
- Aufruf von ac3_contour_grid:
int new_plotnr=0; /* Nummer des 3-dim. Plotknotens */
new_plotnr = ac3_contour_grid (new_plotnr);
ac3_parametric-Flaechendarstellungen
------------------------------------
Die folgenden 3-dimensionalen eg-Funktionen berechnen aus gegebenen
3-dim. Daten die betreffende Funktion und erzeugen dann eine Darstellung
der Gitterdaten. Dabei ist vorzugeben, wieviele Niveaus der Funktion
(contour level) dargestellt werden sollen:
ac3_parametric_surface_plot
ac3_parametric_surface_function_plot
Übersicht ueber die Dokumentation zu eg
Interaktiv
==========
Die Online Dokumentation zu Exponent Graphics erhaelt man mit dem
Aufruf
/client/bin/imslhelp
Die gleichzeitig verfuegbare Dokumentation zu den IMSL-Bibliotheken
ist aber nicht fuer die Benutzung von eg erforderlich, es sei denn
man verwendet aus anderen Gruenden in seinem Programm Aufrufe von
IMSL-Routinen.
Die Information gliedert sich wie folgt:
[1] Using Exponent Graphics for C and Fortran
-----------------------------------------
Getting Started
Overview
Applications
Interactivity
Programming Environment
Advanced Usage
[.] Using Exponent Graphics for X (nicht installiert)
-----------------------------
[2] Exponent Graphics Reference
---------------------------
Summary of Functionality
Nodes
Attributes
Functions
[3] Additional Information
----------------------
Device Drivers
Generic Application Functions Options
Support Functions
Fonts
coms.dat
Product Support
Picture Index
eg-Manuale:
=============
Diese liegen zur Einsicht
im Benutzerarbeitsraum Ost des LRZ (Zi.S2532, S2533, S2534 2.OG)
bzw. bei der LRZ-Beratung (Zi.S2528 2.OG) auf.
Sie enthalten im wesentlichen die interaktiv abrufbare Information nur
etwas anders gegliedert.
[4] Exponent Graphics
Programmer's Guide
Copyright 1994 by Visual Numerics, Inc.
[5] Exponent Graphics
Reference: Attributes and Nodes
Copyright 1994 by Visual Numerics, Inc.
[6] Exponent Graphics
Reference: Functions
Copyright 1994 by Visual Numerics, Inc.
Exponent Graphics im Vergleich zur LRZ-Graphik
- Programmiersprache
Das LRZ-Graphiksystem entstand als Fortran-Unterprogrammbibliothek, das inzwischen auf allen Rechensystemen des LRZ - einschließlich PCs - zur Verfügung steht. Der Einsatz der LRZ-Graphik-Routinen erfolgt über ein vom Benutzer zu erstellendes Fortranprogramm. Daneben steht die Grundsoftware der LRZ-Graphik auch für die Programmiersprache C zur Verfügung. Diese Grundsoftware umfaßt Routinen für Kurvendarstellungen, interpolierende Splines, Achsenbeschriftungen, Schraffuren etc., aber z.B. keine 3D-Darstellungen oder Höhenlinien.
Die zuerst unter SunOS am LRZ installierte C-Variante von Exponent Graphics wurde insbesondere wegen der ausgeprägten Interaktivität dieses Graphic-Systems ausgewählt und basiert auf einer Bibliothek von C-Funktionen, die ein Benutzer von Exponent Graphics über ein von ihm zu schreibendes C-Programm aufrufen kann.
Inzwischen ist die Fortran-Variante von Exponent Graphics neu entwickelt worden und besitzt dieselbe Eigenschaft. - Interaktivität
eg verfügt über ein graphisches User Interface und ermöglicht interaktive Veränderungen am dargestellten Plot. Diese Möglichkeiten wurden ausführlicher unter 4. dargestellt.
Bei der interaktiven Variante der LRZ-Graphik wird zur Laufzeit des Benutzerprogramms Ausgabe am Bildschirm erzeugt, parallel zu optionalen Eintragungen in die Übergabedatei. Durch geeignete Programmsteuerung können Zeichnungen am Sichtgerät aufgebaut bzw. in maßen verändert werden. Spezielle Routinen ermöglichen die interaktive Punkteingabe (Fadenkreuz, Cursor) und die Steuerung der Ausgabe in eine Datei und/oder auf den Bildschirm.
Beim Previewing bestehender Übergabedateien steuert der Benutzer über Kommandos bzw. Menues, welche Zeichnungen oder Ausschnitte von Zeichnungen am Sichtgerät (PC, X-Window-Oberfläche) darzustellen bzw. auf ein Gerät/Datei auszugeben sind.
- Plotgestaltung
eg bietet eine Vielfalt von Möglichkeiten für die Plotgestaltung: Zuordnen von Attributwerten an den entsprechenden Knoten des Graphikbaums (siehe dazu die verschiedenen Attribute zu Farbe, Text, Linien, Markern, "fill"-Charakteristiken , s. 1.2). Es gibt vordefinierte Fonts, und über das alias_add-Attribut die Möglichkeit für den Benutzer, Fonts zu spezifizieren. Speziell für Beschriftungen sind die Funktionen ac_note, ac_set_title, ac_inline_text_extent nützlich. Des weiteren kann man Legenden zu einem Plot erzeugen. Außerdem gibt es die verschiedenen für statistische Darstellungen geeigneten Plots und Charts, wenn man die folgenden Funktionen verwendet:
ac_bar_chart, ac3_block_chart, ac_pie_chart, ac_box_plot, ac_error_bar, ac/ac3_histogram, ac_pareto_plot, ac_bode_plot
Die LRZ-Graphik bietet sicherlich vergleichbare Möglichkeiten der Plotgestaltung, allerdings mit einem anderen Ansatz: ein kleiner, überschaubarer Satz von Routinen für Grunddienste ermöglicht beliebige Varianten und Kombinationen - beliebige Flexibilität bei unter Umständen höherem Programmieraufwand. - Schnelle Erzeugung von Bildvarianten unter eg
Die schnelle Ausführung verschiedener graphischer Varianten durch Benutzung der use- und tag-Files bei eg ist besonders hervorzuheben. Jeder Aufruf eines C-Programms mit entsprechenden Funktionen führt zu einem Bild am Sichtgerät, mehrmaliger Aufruf desselben Programms mit geänderten use- und/oder tag-File liefert die Bildvarianten ohne Neuübersetzung.
Bei der LRZ-Graphik kann der Benutzer Ähnliches erreichen, muß dazu allerdings durch geeignete Parametrisierung seines Programms und Definition der Eingabe(datei) selbst festlegen, welche Varianten ermöglicht werden.
- Ausgabemöglichkeiten:
Die LRZ-Graphik erstellt normalerweise eine Übergabedatei (Metafile) mit symbolischer Zeichnungsbeschreibung, die durch einen Nachbearbeiter (Postprocessor) die eigentliche Zeichnung am gewünschten Gerät liefert. Dadurch ist die Ausgabe einer einmal erstellten Zeichnungsbeschreibung auf verschiedenen Bildschirmen, Druckern und Plottern in verschiedenen Größen, Auflösungen und Qualitäten möglich.
eg liefert sichtbare Ausgabe unmittelbar unter X-Windows und/oder auf ein Postscriptfile, die Entscheidung darüber erfolgt interaktiv und kann wechselweise gegeben werden. Das Postscriptfile kann Information für schwarz-weiße oder farbige Bildausgabe enthalten. Prinzipiell sind auch andere Ausgabemöglichkeiten vorgesehen, zum Beispiel HP/GL-Ausgabe, die aber derzeit am LRZ nicht installiert sind.
- Perspektivische Darstellung:
Die LRZ-Graphik bietet die perspektivische Darstellung beliebiger dreidimensionaler Objekte mit frei wählbarem Betrachterstandpunkt und Blickwinkel, allerdings nur als Drahtmodell und ohne Unterdrückung verdeckter Kanten. Letzteres ist nur für den Spezialfall einer Fläche f(x,y) über einem regulärem Gitter gegeben. Beleuchtungsmodelle werden nicht untestützt.
eg bietet praktikable Veränderungsmöglichkeiten, die durch aufeinanderfolgende "optische" Tests am Sichtgerät schnell überprüfbar sein sollten. Das schließt auch die leichte Steuerbarkeit von Betrachter- und Beleuchtungspositionen, Fenstergrößen, Skalierungen, Achsenlage und -beschriftungen sowie verdeckter Flächen ein. Siehe dazu unter 5.