Yazan : Selim Aksu

1.Spline

Çizim terminolojisinde Spline, noktalar kümesi tarafından belirlenen düzgün bir eğri oluşturmak için kullanılan esnek bir şerittir. Şerit boyunca dağıtılmış birçok küçük ağırlıklar, çizim masasında sabit konumda duran bir eğri oluşmasını sağlarlar.
Spline’lar genelde endüstriyel tasarımda kullanılır. (otomobil, gemi, uçak, uzay aracı gövdeleri, ürün tasarımı gibi.)

1.1 Spline Eğrileri

Spline eğrileri de temelde bu yolla oluşturulur.Matematiksel olarak bu tür bir eğri, ilk ve ikinci türevleri, farklı eğri bölümlerinde sürekli olan kübik polinom fonksiyonu ile tanımlanır.Bilgisayar grafiklerinde Spline eğrileri, parçaların sınırlarında süreklilik şartlarını sağlayan polinom kısımları tarafından biçimlendirilen bileşik eğrilerdir.

1.2 Kontrol Noktaları

Spline eğrileri, kontrol noktası adı verilen koordinat konum kümeleri verilerek tanımlanırlar. Kontrol noktaları, eğrinin genel şeklini belirler ve sürekli parametrik polinom fonksiyon parçalarında kullanılır. Bunun iki yolu vardır.

1.3 Spline Gösterimlerinin Sınıflandırılması

1. Aradeğerleme (Interpolation) Spline’ları
   

Eğri tüm kontrol noktalarından geçer.

1. Yaklaşım (Approximation) Spline’ları

Eğrinin tüm kontrol noktalarından geçme şartı yoktur

1.4 Spline Eğri ve Yüzeylerinin Önemi

• Spline eğrileri, tanımlanıp değiştirilebilirler.
  
• Yeni kontrol noktaları eklenebilir.
  
• Kontrol noktaları silinebilir.
  
• Etkileşimli grafik ve CAD paketlerinde kullanıcılar, tasarımları üzerinde fare ile değişiklikler yaparak istenen modelleri elde edebilirler.
  

2.Bezier Splines

• Fransız otomobil üreticisi Renaultbünyesinde P. Bezier1962 yılında geliştirmiştir.
  
• Bezier eğrileri, eğriler üzerinde daha çok manipülasyon yapabilmek amacıyla geliştirilmiştir.
  
• Karmaşık araba yüzey tasarımlarını gerçekleştirmek için kullanılan bir araçtır.
  
• Bezier eğrisi bir kontrol poligonu tarafından kontrol edilmektedir
  
• İkinci derece (quadratic)ve kubik (cubic)Bézier eğrileri en çok kullanılanlardır.
  
• Daha yüksek dereceli eğrileri kullanması daha masraflıdır
  
• Karmaşık şekiller gerektiği zaman düşük dereceli Bézier eğrileri birbirine yamanır.
  
• Ayrıca, Bézier eğrilerinin programlanması da oldukça kolaydır. Bu tür özelliklerinden dolayı, Bézier eğrileri bilgisayar grafiklerinde yaygın olarak kullanılır.
  

n+1 adet Pikontrol noktası tarafından kontrol edilen B(t) eğrisi aşağıdaki genel Beziereğri formu ile verilmiştir;

Burada

n. derece Bernstein polinomlarıolarak adlandırılır.

Not: (t0= 1 and (1 ‐t)0= 1)

: binom katsayıdır (2 terimli)

Polinomunderecesi, kullanılan kontrol noktalarının sayısından bir azdır.

• Pinoktaları Béziereğrisinin kontrol noktalarıdır.
  
• P0 ile başlayan ve Pnile son bulan noktaların çizgilerle birleşmesinden şekillenen poligon Bézierpoligonu ya da kontrol poligonu olarak adlandırılır. Bézier poligonunun dış bükeyyapısı Béziereğrisini içerir.
  
• Eğri P0′da başlar ve Pn’de biter. Buna uç nokta interpolasyonözelliği (endpoint interpolation property) denir.
  
• Eğri sadece ve sadece kontrol noktaları aynı doğru çizgi üzerinde ise düz çizgi olabilir.
  
• Eğrinin başlangıcı (sonu) Bézierpoligonunun ilk (son) bölümüne teğettir.
  
• Eğri her hangi bir noktadan 2 eğri halinde parçalanabilir.Bu parçalanma ile herhangi birçok alt eğri elde edilebilir. Bunların her biri Bézier eğrisidir.
  

2.1 Linear Bezier Spline

Doğrusal bir Béziereğrisinin t=[0,1] arası formu doğrusal interpolasyon formuna dönüşür.

P(t) = (1-t)P₀ + tP₁ ,     0 ≤ t ≤ 1

2.2 Quadratic Bezier Spline

Eğri P0,P1& P2 noktalarından geçer.

• 2. derece Bézier eğrileri için t=[0‐1] arasında Q0ve Q1adında ara noktalar oluşturulabilir.
  
• Q0noktası P0ileP1 arasında değişir ve doğrusal birBézier eğrisi oluşturur.
  
• Q1noktası P1ileP2arasında değişir ve doğrusal birBézier eğrisi oluşturur.
  
• B(t)noktasıQ0′dan Q1′e değişir ve 2. derece bir Bézier eğrisi tanımlar.
  

  
  

2.3 Cubic Bezier Spline

Eğri P0,P1, P2& P3 noktalarından geçer.

Kubikform için;

• Doğrusal Béziereğrisi tanımlayan Q0, Q1& Q2ara noktaları ve
  
• 2. derece Béziereğrisi tanımlayan R0& R1noktaları oluşturulur.
  

2.4 Yüksek Derece Eğriler

Dördüncü Derece Bezier Eğrisi

Eğri P0,P1, P2, P3 & P4 noktalarından geçer.

Dördüncü derece form için;

• Doğrusal Béziereğrisi tanımlayan Q0, Q1, Q2&Q3 ara noktaları ve
  
• 2. derece Bézier eğrisi tanımlayan R0,R1&R2 noktaları ve
  
• Kubik Bézier eğrisi oluşturan S0&S1 noktaları oluşturulur.
  

2.5 Polinom Formu

• Bazen Bézier eğrisini Bernstein polinomlarının toplamı olarak ifade etmek yerine polinom olarak ifade etmek daha kolaydır.
  
• Binom teoreminin eğrinin tanımına uygulanması ve tekrar düzenlenmesi aşağıdaki formu verir:

• Eğer CjB(t)’ninbir çok kez hesaplanmasından önce hesaplanırsa bu yöntem pratik ve verimli olur.
  
• Fakat yüksek dereceli eğriler sayısal kararsızlık konusunda sorunlu olabileceği için dikkatli olmak gerekir. (Bu durumda de Casteljau’nun algoritması kullanılmalıdır).

2.6 Bezier Eğrileri Dezavantajları

• Eğrinin kontrol noktalarından geçmemesi kontrolü ve hassasiyeti zora sokar.
  
• Bezier eğrisinde lokal değişiklik yapılamaz.
  

2.7 Bezier Yüzeyleri

Üç boyutlu Beziér yüzeylerinin (diğer adıyla Beziér yamalarının) tanımlanması için Beziér eğrilerinin gösteriminin genelleştirilmesi mümkündür. Matematiksel olarak, üç boyutlu yüzeyler iki eğrinin kartezyen çarpımından elde edilebilir. Dolayısıyla, (m+1)(n+1) kontrol noktası tarafından belirtilen Beziér yüzeyinin gösterimi şöyle olacaktır:

16 kontrol noktası ile tanımlanmış bir Beziér yüzeyi

16 kontrol noktasıyla tanımlanmış üç boyutlu Beziér yüzeyi

3. B-Spline Eğrileri

• B‐Splineeğrileri Bezier eğrilerinin genelleştirilmiş halidir
  
• En önemli avantajı lokal kontrole izin vermesidir
  
• Bir temel teoriye göre verilen derece, düzgünlük ve alan bölümünde bütün eğri fonksiyonları B‐Spline eğrilerin aynı derece, düzgünlük ve alan bölümünde doğrusal kombinasyonu olarak ifade edilebilir.
  
• B‐Splineadı Isaac Jacob Schoenberg tarafından konulmuştur ve “basis spline”nın kısaltılmış formudur.
  
• B‐Splineeğriler de Boor algoritması ile sayısal denge içinde değerlendirilebilirler.
  
• B‐Spline eğrileri yüksek dereceliBézier,eğrilerinde karşılaşılan problemleri polinomun derecesini yükseltmeden önleyebilir.
  
• Elde edilen eğrinin derecesi kullanılan kontrol noktası sayısından bağımsızdır.
  

Verilen n+1 sayıda kontrol noktası;Pitarafından tanımlanan B‐Splineeğri tanımı:

Burada Ni,k(u) Cox ve de Boor tarafından 1972′de önerilen B‐Splinefonksiyonlarıdır.

k parametresi B‐Splineeğrinin derecesini (k‐1) kontrol eder ve genellikle kontrol noktası sayısından bağımsızdır.

Ui parametrik düğüm (knots) ya da düğüm değerleri olarak adlandırılır. Açık bir eğri için şu formda verilmiştir:

(k‐1) derecesinde eğriyi (n+1) sayıda kontrol noktası ile tanımlamak için (n+k+1) sayıda düğüm (knots) gereklidir.

Bu eşitlik gösterirki;

Doğrusal eğri için en az 2

2.derece eğri için en az3

Kubik eğri için ise en az 4 kontrol noktası gerekir.

Aşağıdaki şekiller B‐Splinefonksiyonlarının şekillerini göstermektedir:

Doğrusal fonksiyon

k=2

2.derecefonksiyon

k=3

kubikfonksiyon

k=4

3.1 B‐Spline Eğrileri Özellikleri

Kontrol noktası sayısı polinomunderecesinden bağımsızdır.

Sarı noktalar: verteks

Sol üst ok: Doğrusal k=2

Sağ üst ok: 2.derece B-spline k=3

Sağ orta ok: Kubik B-spline k=4

Sağ alt ok: 4.derece B-spline k=5

• B‐Splinederecesi yükseldikçe yakın kontrol noktasına etkisi azalır.
• B‐Splinedaha iyi lokal kontrole izin verir.
• Eğrinin şekli kontrol noktalarını hareket ettirerek ayarlanabilir.
• Local kontrol: Bir kontrol noktası sadece k bölümüne etki eder.
  

3.2 Bezier/B‐Spline Eğrileri

BezierHarmanlama Fonksiyonları (BezierBlendingFunctions); Bi,n

B‐splineHarmanlama Fonksiyonları (B‐splineBlendingFunctions); Ni,k

Sağ alt okla gösterilen nokta hariç diğer 3 belirtilen nokta hareket ettiriliyor.

3.3 Uniform B‐Spline Eğrileri

B‐splineuniformolduğu zaman n dereceli B‐splinefonksiyonlarıbirbirinin kaydırılmış kopyasıdırlar. Eğri boyunca, düğümler (knots) eşit mesafelerde yerleşmiştir.

4. Rasyonel Eğriler ve NURBS(Rational Curves and NURBS)

• Rasyonel polinomlar hem analitik hem de polinom eğrileri düzenli (uniform) tanımlayabilirler.
• Eğriler kontrol noktalarının ağırlıkları (weighting) değiştirilerek düzenlenebilirler.
• Genel kullanılan şekli NURBS (Non‐Uniform Rational B‐spline)’dür.

4.1 Rasyonel Bezier Eğrileri

Rasyonel Bézier formunda, rastgele şekiller elde edilebilmesi için kontrol noktalarına ayarlanabilir ağırlıklar eklenmiştir.

n + 1 kontrol noktası; Pi için rasyonel Bézier eğrisi:

Pay kısmında yeralanterim ağırlıklı BernsteinşeklindeBéziereğrisidir ve paydada ise Bernsteinpolinomlarınınağırlıklı toplamları yer almaktadır.
Daha basitçe;

formunda ifade edilebilir.

4.2 Rasyonel B‐Spline Eğrileri

Bir rasyonel eğri 2 polinomun birbirine oranı olarak tanımlanmıştır.Rasyonel eğride kontrol noktaları homojen koordinatlarda tanımlanmıştır.

dolayısıyla rasyonel B‐Spline eğrisi:

formunda ifade edilebilir.

Ri,k(u) rasyonel B‐Spline taban fonksiyonlarıdır.

Yukarıdaki eşitlik gösterir ki;Ri,k(u) rasyonel olmayan taban fonksiyonları;

Ni,k(u)’nıngenelleştirilmiş halidir.

Ri,k(u) eşitliğine hi=1 yerleştirilmesi durumunda rasyonel olmayan formla

yaklaşık aynı özellikleri gösterir.

4.3 NURBS

• Düzgün olmayan, rasyonel B‐Spline formülü olup, matematik modelidir ve genellikle eğriler ve yüzeyler oluşturmak ve göstermek için bilgisayar grafiğinde kullanılır.
• NURBS eğrisi , derecesi, bir set ağırlıklı kontrol noktaları ve düğüm vektörü (knot vector) ile tanımlanır.
• NURBS eğrileri ve yüzeyleri hem B‐spline hem de Bézier eğrileri ve yüzeylerinin genelleştirilmiş halidir.
• En önemli farkı kontrol noktaları ağırlıklarıdır ki bu NURBS’ü rasyonel eğri (rational curve) yapar.
• NURBS eğrileri sadece bir parametrik yön içerir (genellikle s ya da u olarak adlandırılır). NURBS yüzeyleri iki parametrik yön içerir.
• NURBS eğrileri konik eğrilerin tam modellenmesini sağlar.

NURBS eğrisinin genel formu;

k: kontrol noktası (Pi) sayısı

wi: ağırlıklar (weigths)

Payda normalleme faktörüdür (normalizingfactor).

NURBS genel formu aşağıdaki gibi ifade edilebilir:

Rinfonksiyonları, rasyonel taban fonksiyonları (rational basis functions) olarak adlandırılır.

4.4 NURBS Örnekleri

Uniform düğüm (knot) vektörü

Uniformolmayan (nonuniform) düğüm (knot) vektörü

4.5 NURBS’ün Gelişimi

• Boeing: TigerSystem‐979
  
• SDRC: Geomod‐1993
  
• University of Utah: Alpha‐1‐1981
  
• Endüstri Standartları : IGES, PHIGS, PDES,Pro/E, vb.
  

4.6 NURBS Avantajları

• Rasyonel olmayan (non‐rational)B‐spline olduğu kadar rasyonel (rational) ve rasyonel olmayan (non‐rational)Bezier eğrileri ve yüzeyleri için gerçek genelleştirme sağlar.
• Hem standart analitik şekillerin matematiksel formlarını (koniler, 2. derece eğriler, döndürme yüzeyler, vb.) hem de serbest şekilli eğriler ve serbest şekilli yüzeyleri hassasiyetle modeller.B‐splineeğriler sadece konik eğrileri modeller.
• NURBS eğrisini parametrenin değişik değerlerinde hesaplayarak eğri 2 ya da 3 boyutlu kartezyen uzayda tanımlamak mümkündür.
• Aynı durum NURB yüzeyleri için de geçerlidir.
• Kontrol noktası ve ağırlık kullanımı ile birçok şeklin tasarımı esnekliğini sağlar.
• Ağırlıkları artırmanın eğriyi kontrol noktasına çekme etkisi vardır.
• Güçlü bir alet takımı vardır. (düğüm ekleme/detaylandırma/kaldırma/derece yükseltme/bölme/vb.)
• Döndürme ve öteleme gibi perspektif transformasyonlarda değişmezdir (invariant). Bu işlemleri sadece kontrol noktalarına uygulamak yeterlidir.
• Makul hızda ve dengeli hesaplanabilirlerdir.
• Şekilleri saklarken az hafızaya gereksinim gösterirler.

5. Catmull-Rom Splines

Eğri bütün kontrol noktalarından geçmelidir.Bir noktaı hesaplamak için Şekilde görüldüğü gibi o noktanın iki yanınadki noktalar gereklidir.P1,P2,P3,P4 gibi kontrol noktaları ve t değeriyle noktanın yeri şu şekilde hesaplanabilir.

q(t) = 0.5 *( (2 * P₁) +

(-P₀ + P₂) * t +
(2*P₀ - 5*P₁ + 4*P₂ - P₃) * t² +
(-P₀ + 3*P₁- 3*P₂ + P₃) * t³)

6. Hermite Splines

Oluşturmak için her kontrol noktasının tanjant vektörlerini gerektirir.

P1:Eğrinin başlangıç noktası.

P2:Eğrinin bitiş noktası

T1:Eğrinin başlangıç noktasından nasıl çıktığının tanjantu

T2:Eğrinin bitiş noktasına nasıl vatdığının tanjantı

Bu 4 vektör ve Hermite Fonksiyonları bir araya getirildiğinde;

h1(s) = 2s^3 – 3s^2 + 1

h2(s) = -2s^3 + 3s^2

h3(s) = s^3 – 2s^2 + s

h4(s) = s^3 – s^2

7. Beta-splines:

Otomatik süreklilik ve tanjant ile kavis uzunluğu üzerinde tam manasıyla kontrol sağlar.

8. Programlama Örnekleri

C++( Bu C++ programı ekrana bezier eğrisi çizer.4 nokta var.2′si kontrol noktası)

#include <GL/glut.h>

GLfloat ctrlpts[4][3] = {
{-0.4, 0.4,  0.0},
{-0.1, 2.0,  0.0},
{ 0.1,-2.0,  0.0},
{ 0.4, 0.4,  0.0}
};
void display()
{
GLint k;
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0, 0.0, 1.0);
glBegin(GL_LINE_STRIP);
for (k= 0; k<= 50; k++)
glEvalCoord1f((GLfloat) (k)/50.0);
glEnd();
glPointSize(5.0);
glColor3f(1.0, 0.0, 0.0);
glBegin(GL_POINTS);
for (k= 0; k< 4; k++)
glVertex3fv(&ctrlpts[k][0]);
glEnd();

glutSwapBuffers();
}
void init()
{
glClearColor(1.0,1.0,1.0,0.0);
glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, *ctrlpts);
glEnable(GL_MAP1_VERTEX_3);
}
int main(int argc, char ** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize(400,400);
glutInitWindowPosition(50, 50);
glutCreateWindow(“Bezier Eğrisi”);
init();
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

1. C++(Mouse ile işaretlenen noktalardan geçen bezier eğrisi çizdirmek.)
   

#include “gl/glut.h”

static int Genislik = 500;
static int Yukseklik =500;

GLfloat cpts[4][3];
int ncpts = 0;

void Baslat(void)
{
glClearColor(1.0,1.0,1.0,0.0);
glEnable(GL_MAP1_VERTEX_3);
}

void Goster(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0, 0.0, 0.0);
glPointSize(5.0);
}
void EgriCiz(){
glColor3f(0.0, 0.0, 0.0);
glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, &cpts[0][0]);
glMapGrid1f(30, 0.0, 1.0);
glEvalMesh1(GL_LINE, 0, 30);
glFlush();

}

void FareDinle(GLint button,GLint action,GLint x,GLint y)
{
float wx, wy;
if(button==GLUT_LEFT_BUTTON && action==GLUT_DOWN){
wx = (2.0 * x) / (float)(Genislik – 1) – 1.0;
wy = (2.0 * (Yukseklik – 1 – y)) / (float)(Yukseklik – 1) – 1.0;
if (ncpts ==4)
return;
cpts[ncpts][0] = wx;
cpts[ncpts][1] = wy;
cpts[ncpts][2] = 0.0;
ncpts++;
glBegin(GL_POINTS);
glVertex3f(wx, wy, 0.0);
glEnd();
glFlush();
}
else
if(button==GLUT_RIGHT_BUTTON)
EgriCiz();
}

void main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(Genislik,Yukseklik);
glutInitWindowPosition(100, 150);
glutCreateWindow(“İnteraktif Eğri Çiz”);
glutDisplayFunc(Goster);
glutMouseFunc(FareDinle);
Baslat();
glutMainLoop();
}

8.3 Java(İnteraktif 2D Bezier splines)

import java.awt.*;

import java.awt.event.*;

import java.util.StringTokenizer;

public class Bezier extends java.applet.Applet

  implements MouseMotionListener{

Image buffImage;          Graphics buffGraphics;

int n = 4, n1,  w,h,h1,w2;

double[] Px,Py;

public void drawFun(){

  double step = 1./w2, t = step;

  double[] B = new double[n1], Bo = new double[n1], Bold = new double[n1];

  B[1] = Bo[1] = h1;

  Color[] iColor = {Color.gray, Color.red, new Color(0f,.7f,0f),

   Color.blue, Color.magenta, new Color(0f,.8f,.8f), new Color(.9f,.9f,0f) };

  for (int k = 1; k < w2; k++){

   System.arraycopy(B,1,Bold,1,n);

   System.arraycopy(Bo,1,B,1,n);

   for (int j = 1; j < n; j++)        //  basis functions calculation

    for (int i = j+1; i > 0; i--)

     B[i] = (1-t)*B[i] + t*B[i-1];

   for (int m = 1; m <= n; m++){

    buffGraphics.setColor(iColor[m % 7]);

    buffGraphics.drawLine(w2+k-1, h1-(int)Bold[m], w2+k, h1-(int)B[m] );}

   t += step;

  }

}

public void drawSpline(){

  double step = 1./w2, t = step;

  double[] Pxi = new double[n], Pyi = new double[n];

  int X,Y, Xold = (int)Px[0], Yold = h1-(int)Py[0];

  buffGraphics.clearRect(0,0, w2, h);

  buffGraphics.setColor(Color.blue);

  for (int i = 0; i < n; i++){

   X = (int)Px[i];  Y = h1-(int)Py[i];

   buffGraphics.drawRect(X-1,Y-1, 3,3);}

  if ( n > 2 ){

   int Xo = Xold, Yo = Yold;

   for (int i = 1; i < n; i++){

    X = (int)Px[i];  Y = h1-(int)Py[i];

    buffGraphics.drawLine(Xo,Yo, X,Y);

    Xo = X;  Yo = Y;}

  }

  buffGraphics.setColor(Color.red);

  for (int k = 1; k < w2; k++){

   System.arraycopy(Px,0,Pxi,0,n);

   System.arraycopy(Py,0,Pyi,0,n);

   for (int j = n-1; j > 0; j--)        //  points calculation

    for (int i = 0; i < j; i++){

     Pxi[i] = (1-t)*Pxi[i] + t*Pxi[i+1];

     Pyi[i] = (1-t)*Pyi[i] + t*Pyi[i+1];}

   X = (int)Pxi[0];  Y = h1-(int)Pyi[0];

   buffGraphics.drawLine(Xold,Yold, X,Y );

   Xold = X; Yold = Y;

   t += step;

  }

}

public void init() {

  w = Integer.parseInt(getParameter("width"));

  h = Integer.parseInt(getParameter("height"));  h1 = h-1; w2 = w/2;

  String s = getParameter("N"); if (s != null) n = Integer.parseInt(s);

  n1 = n+1;

  Px = new double[n];  Py = new double[n];

  s=getParameter("pts");

  if (s != null){

   StringTokenizer st = new StringTokenizer(s);

   for (int i = 0; i < n; i++){

    Px[i] = w2*Double.valueOf(st.nextToken()).doubleValue();

    Py[i] = h1*Double.valueOf(st.nextToken()).doubleValue();}}

  else{

   Px[0] = .1*w2; Px[1] = .1*w2; Px[2] = .9*w2; Px[3] = .9*w2;

   Py[0] = .1*h1; Py[1] = .9*h1; Py[2] = .9*h1; Py[3] = .1*h1;}

  buffImage = createImage(w, h);

  buffGraphics = buffImage.getGraphics();

  setBackground(Color.white);

  buffGraphics.clearRect(0,0, w, h);

  addMouseMotionListener(this);

  drawFun();

  drawSpline();

}

public void destroy(){ removeMouseMotionListener(this); }

public void mouseMoved(MouseEvent e){}  //1.1 event handling

public void mouseDragged(MouseEvent e) {

  int x = e.getX();  if (x < 0) x = 0;  if (x > w2-3) x = w2-3;

  int y = h1 - e.getY();  if (y < 0) y = 0;  if (y > h1) y = h1;

  int iMin = 0;

  double Rmin = 1e10, r2,xi,yi;

  for (int i = 0; i < n; i++){

   xi = (x - Px[i]); yi = (y - Py[i]);

   r2 = xi*xi + yi*yi;

   if ( r2 < Rmin ){ iMin = i; Rmin = r2;}}

  Px[iMin] = x; Py[iMin] = y;

  drawSpline();

  repaint();

}

public void paint(Graphics g) {

  g.drawImage(buffImage, 0, 0, this);

//  showStatus( " " + x +"  " + y);

}

public void update(Graphics g){ paint(g); }

}

8.4 C++
						
						

GLfloat ctrlpoints[4][4][3] = {

{{-1.5, -1.5, 4.0}, {-0.5, -1.5, 2.0},

{0.5, -1.5, -1.0}, {1.5, -1.5, 2.0}},

{{-1.5, -0.5, 1.0}, {-0.5, -0.5, 3.0},

{0.5, -0.5, 0.0}, {1.5, -0.5, -1.0}},

{{-1.5, 0.5, 4.0}, {-0.5, 0.5, 0.0},

{0.5, 0.5, 3.0}, {1.5, 0.5, 4.0}},

{{-1.5, 1.5, -2.0}, {-0.5, 1.5, -2.0},

{0.5, 1.5, 0.0}, {1.5, 1.5, -1.0}}

};

void display(void)

{

int i, j;

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glPushMatrix ();

glRotatef(15.0, 1.0, 1.0, 1.0);

for (j = 0; j <= maxJ; j++) {

glColor3f(1.0, 0.0, 0.0);

glBegin(GL_LINE_STRIP);

for (i = 0; i <= 30; i++)

glEvalCoord2f((GLfloat)i/30.0, (GLfloat)j/8.0);

glEnd();

glColor3f(0.0, 0.0, 1.0);

glBegin(GL_LINE_STRIP);

for (i = 0; i <= 30; i++)

glEvalCoord2f((GLfloat)j/8.0, (GLfloat)i/30.0);

glEnd();

}

glPopMatrix ();

glFlush();

}

void init(void)

{

glClearColor (0.0, 0.0, 0.0, 0.0);

glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4,

0, 1, 12, 4, &ctrlpoints[0][0][0]);

glEnable(GL_MAP2_VERTEX_3);

glEnable(GL_DEPTH_TEST);

glShadeModel(GL_FLAT);

}