Esame di “Elementi di Grafica Digitale”
Prof. Matjaz Hmeljak
Lorenzo Dal Col
15 dicembre 2008
CONFRONTO TRA SPLINE
OPENGL E JAVA 3D
Cos’è spline
“Dato un insieme di punti si puo' definire una
curva ottenuta da spezzoni di curve polinomiali
che passa oppure approssima i punti dati
(interpola oppure passa vicino ad essi).”
Tecniche spline
 Linear Bezier spline
 Quadratic Bezier spline
 Cubic Bezier spline
Algoritmi spline
 Cubic Bezier spline
 Algoritmo deCasteljau (ricorsivo)
 Catmull-Rom splines
 Kochanek-Bartel
Spline in Open GL (glut)
glMap1f( GL_MAP1_VERTEX_3, uMin, uMax, stride, order,
&(PuntiContr[0][0]) );
glEnable( GL_MAP1_VERTEX_3 );
glColor4f(r,g,b,a);
glLineWidth(LineW);
glBegin( GL_LINE_STRIP);
for (k = 0; k<= nseg; k++ ){
kf = k;
glEvalCoord1f( kf/nsegf );
}
glEnd();
In OpenGL vengono interpolate curve
usando diverse tecniche spline:
•B-splines
•Bezier curves
•Hermite splines
Metodi in GLUT
 glMap1f , glMap2f
definisco degli evaluators (1 o 2 dimensioni)
 glEnable
 glEvalCoord
valuta le coordinate di un punto tra quelli
forniti nella glMap
 glMapGrid
valuta una griglia di coordinate interpolate
(utile per le superfici)
Java & splines?
Non esistono esempi di disegno di curve e
superfici usando direttamente librerie ufficiali
di Java 3D.
 Classi matematiche non ufficiali supportate
da Sun per l’interpolazione (SplineFactory,
ecc.)
 Java 2D (java.awt.geom)
 Java Open GL (jogl)
Spline in Java 3D
In Java 3D (j3d) non esiste un metodo diretto
per disegnare curve e superfici interpolate
tramite una tecnica “spline”.
Esiste il package:
com.sun.j3d.utils.behaviors.interpolators
Che contiene dei behaviors per l’interpolazione
di percorsi da fare seguire a degli oggetti.
Spline in Java 3D
Nel libro “Java 3D programming”
di Daniel Salman, considerato la
“bibbia” di Java 3D c’è un
esempio di un elicottero che
sorvola una città seguendo un
percorso interpolato tramite il
package:
behaviors / interpolators
Java 3D interpolators
Le classi del package interpolators sono state
create per poter generare delle mappature spline
da inserire in dei TransformGroup per impostare
il percorso che un oggetto in movimento deve
seguire.
L’interpolazione viene fatta utilizzando la spline
TCB (Tension-Continuity-Bias), un’estensione
delle funzioni di Hermite in cui è possibile
specificare per ogni punto la tensione della
curva, il grado di continuità e la prossimità al
punto di riferimento.
Path Interpolator con Java 3D
Java 3D splines
com.sun.j3d.utils.behaviors.interpolators Classes




CubicSplineCurve
CubicSplineSegment
KBCubicSplineCurve
KBCubicSplineSegment
(abstract)
(abstract)
(private constructor)
(private constructor)
 KBKeyFrame
 KBRotPosScaleSplinePathInterpolator
 KBSplinePathInterpolator



RotPosScaleTCBSplinePathInterpolator
TCBKeyFrame
TCBSplinePathInterpolator
(abstract)
(abstract)
(abstract)
KB Spline Interpolators
 Forniscono una rappresentazione delle spline
Kochanek-Bartel, della famiglia TCB.
 Bisogna inizializzare la classe dell’interpolatore
con 4 frame chiave, cioè oggetti KBKeyFrame.
 Se si interpola tra il frame [i] e il frame [i+1] è
necessario passare alla classe i 4 frame:
[i-1], [i], [i+1], [i+2]
 Si può impostare un parametro a 0 se si vuole
usare l’interpolazione lineare di hermite.
 Altrimenti vengono usate le cubiche, utilizzando
anche i coefficenti di tensione, continuità e
adesione.
Istanziare i KBKeyFrames
// Prepare spline keyframe data
Point3f p = new Point3f(pos0); // position
float head = (float) Math.PI / 2.0f; // heading
float pitch = 0.0f; // pitch
float bank = 0.0f; // bank
Point3f s = new Point3f(1.0f, 1.0f, 1.0f); // uniform scale
splineKeyFrames[0] = new KBKeyFrame(0.0f, 0, p,
head, pitch, bank, s,
0.0f, 0.0f, 0.0f);
Si devono impostare:
 Il punto di riferimento
 Head, pitch, bank
 Un punto “s” che determina lo scalaggio dell’oggetto in
movimento
 Tensione, Continuità, Aderenza
Tension, Continuity, Bias
I limiti degli interpolatori di
Java 3D
 Purtroppo (inspiegabilmente) la classe
KBSplinePathInterpolator non contiene alcun
metodo pubblico per poter ricavare i punti
interpolati tra i key frame. Questa funzionalità
viene usata solamente dalla classe
TransformGroup per determinare il percorso di
un oggetto.
 Le altre classi KBCubicSplineCurve e
KBCubicSplineSegment contengono i metodi
per accedere ai punti interpolati ma i loro
costruttori sono privati.
Estensione della classe KB
 Tuttavia è possibile estendere la classe:
KBCubicSplineSegment
 Creando un costruttore pubblico che fa le stesse
operazioni del costruttore privato originale
(copiando dai codici sorgenti di java3d)
 In questo modo sono riuscito a sfruttare l’algoritmo
di interpolazione dei percorsi di java 3d per calcolare
tutti i punti compresi tra due key frame).
 Bisogna istanziare un oggetto di tipo
myKBCubicSplineSegment e chiamare
iterativamente il metodo
getInterpolatedPosition
Disegnare una linea basata sui
KBKeyFrames
// Creo il segmento KB Spline
myKBCubicSplineSegment s = new myKBCubicSplineSegment(
splineKeyFrames[segm-1],
splineKeyFrames[segm],
splineKeyFrames[segm+1],
splineKeyFrames[segm+2]);
// disegno i segmenti spezzati tra i punti interpolati
Point3f[] points = new Point3f[20]; // risoluzione segmento
for(int i=0; i<(points.length-1); i++) {
points[i] = new Point3f();
s.getInterpolatedPosition((float)i/(points.length-1),
points[i]);
}
// Creo la retta spezzata
LineStripArray lsa = new LineStripArray(points.length,
LineArray.COORDINATES, new int[] { points.length});
lsa.setCoordinates(0, points);
Shape3D linelsa = new Shape3D(lsa, lineApp);
Classe Interpolator usata in
combinazione a LineStripArray
Java 2D
 Java 2D consente la realizzazione e la
manipolazione di immagini 2D. Grazie a Java 2D
è possibile creare delle interfacce grafiche con
look & feel avanzati.
 Disegna linee, curve, rettangoli, cerchi e altre forme
geometriche
 Riempie queste figure con colori pieni, gradienti o
textures.
 Disegna del testo bidimensionale con il controllo
totale sulle sue caratteristiche
 Disegna immagini ed eventualmente applica dei filtri
fotografici
Classi base per il disegno in
Java 2D
Package: java.awt.geom
 Point
Point2D.Double point =
new Point2D.Double(x, y);
 Line2D
g2.draw(new Line2D.Double(x1, y1, x2, y2));
Classi per interpolare curve in
Java 2D
 QuadCurve2D
Due punti (inizio e fine) con un punto di
controllo
q.setCurve(x1, y1, ctrlx, ctrly,
x2, y2);
CubicCurve2D
 CubicCurve2D
Rappresenta una curva cubica parametrica
con due punti di controllo.
c.setCurve(x1, y1, ctrlx1, ctrly1, ctrlx2, ctrly2, x2,
y2);
JOGL (Java Open GL)
Java Open GL è un port di GLUT
in Java.
Sono disponibili tutte le
funzionalità per le spline di
GLUT e si eseguono allo stesso
modo.
Permette di lavorare su curve e
superfici, fornendo la
possibilità di creare una griglia
di punti interpolati con una
sola chiamata.
Inizializzazione di JOGL
GL gl = drawable.getGL();
glu = new GLU();
glut = new GLUT();
private float ctrlpoints[][] = new flo
at[][] {
{ -4.0f, -4.0f, 0.0f },
{ -2.0f, 4.0f, 0.0f },
{ 2.0f, -4.0f, 0.0f },
{ 4.0f, 4.0f, 0.0f }
};
Evaluation dei punti
// inizializzo la Map
gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
gl.glShadeModel(GL.GL_FLAT);
gl.glMap1f(GL.GL_MAP1_VERTEX_3, 0.0f, 1.0f, 3, 4, ctrlpo
intBuf);
gl.glEnable(GL.GL_MAP1_VERTEX_3);
// disegno la linea spezzata con i punti calcolati
gl.glClear(GL.GL_COLOR_BUFFER_BIT);
gl.glColor3f(1.0f, 1.0f, 1.0f);
gl.glBegin(GL.GL_LINE_STRIP);
for (int i = 0; i <= 30; i++) {
gl.glEvalCoord1f((float) i / (float) 30.0);
}
gl.glEnd();
Bibliografia










Java 3D Programming, Daniel Selman
OpenGL Superbible (4th edition)
JAVA 2D Tutorial
http://java.sun.com/docs/books/tutorial/2d/
JAVA 2D API (Package java.awt.geom)
http://java.sun.com/javase/6/docs/api/java/awt/geom/packagesummary.html
http://www.java2s.com/Code/Java/3D/SplineAnimation.htm
http://download.java.net/media/java3d/javadoc/1.4.0/
Introduction to splines
http://www.ibiblio.org/e-notes/Splines/Intro.htm
http://escience.anu.edu.au/lecture/cg/Spline/index.en.html
Java 3D API
http://www.cs.indiana.edu/classes/jett/dgerman/java3d/
Java 3D manual
http://www.cs.indiana.edu/classes/jett/dgerman/java3d/