# Algorithmus zur Berechnung von BSplines



## Kona (24. Juni 2005)

Hallo, liebe Java-Gemeinde,
 ich hatte mich bereits vor einiger Zeit hier gemeldet, weil ich im Rahmen einer Projektarbeit Flächenmodulation mit B-Splines unter Java3D implementieren sollte.

  Nun habe ich zwar schon einiges in der Richtung erreicht, doch leider habe ich da noch ein kleines Problem.

 Der Algorithmus, den ich momentan noch verwende ist eine Modifikation der Bernstein-Polynome, wie sie ja auch bei Bezier-Flächen verwendet werden.
  Der sieht so aus:  
	
	
	



```
private Point3f computeSpline(Point3f[] q, double u, double v) {
  		/**
  		 * q ist das Array mit den Kontrollpunkten. 
  		 */
  		Point3f point = new Point3f();
  		double[] Bi = new double[4];
  		double[] Bj = new double[4];
  
  		Bi[3] = 	(u*u*u)/6;
  		Bi[2] = ((-3*u*u*u)+(3*u*u)+(3*u)+1)/6;
  		Bi[1] = (( 3*u*u*u)-(6*u*u)	  +4)/6;
  		Bi[0] = ((-1*u*u*u)+(3*u*u)-(3*u)+1)/6;
  
  		Bj[3] = 	(v*v*v)/6;
  		Bj[2] = ((-3*v*v*v)+(3*v*v)+(3*v)+1)/6;
  		Bj[1] = (( 3*v*v*v)-(6*v*v)	  +4)/6;
  		Bj[0] = ((-1*v*v*v)+(3*v*v)-(3*v)+1)/6;
  		
  		int n = (int) Math.sqrt(q.length);
  		for (int i=0; i<n; i++)
  			for (int j=0; j<n; j++) {
 		 	point.x = point.x + (float)(q[(i*n)+j].x*Bi[i]*Bj[j]);
 		 	point.y = point.y + (float)(q[(i*n)+j].y*Bi[i]*Bj[j]);
 		 	point.z = point.z + (float)(q[(i*n)+j].z*Bi[i]*Bj[j]);
  			}
  	   }
```
 
  Leider ergibts sich durch diesen Algorithmus eine kleinere Fläche, als es sein sollte.
  Hier der Screenshot. Doch ich möchte eine Fläche, wie sie z.B. bei Benutzung der reinen Bernstein-Polynome, also als Bezier-Fläche, dargestellt wird. Auch hierzu habe ich einen Screenshot. Der Code für diesen Algorithmus sieht so aus.

```
private Point3f computeSpline(Point3f[] q, double u, double v) {
  		/**
  		 * q ist das Array mit den Kontrollpunkten. 
  		 */
  		Point3f point = new Point3f();
  		double[] Bi = new double[4];
  		double[] Bj = new double[4];
  
  		Bi[0]=1-3*u+3*u*u-u*u*u;
  		Bi[1]=3*(u-2*u*u+u*u*u);
  		Bi[2]=3*(u*u-u*u*u);
  		Bi[3]=u*u*u;
  		
  		Bj[0]=1-3*v+3*v*v-v*v*v;
  		Bj[1]=3*(v-2*v*v+v*v*v);
  		Bj[2]=3*(v*v-v*v*v);
  		Bj[3]=v*v*v;
  		
  		int n = (int) Math.sqrt(q.length);
  		for (int i=0; i<n; i++)
  			for (int j=0; j<n; j++) {
 		 	point.x = point.x + (float)(q[(i*n)+j].x*Bi[i]*Bj[j]);
 		 	point.y = point.y + (float)(q[(i*n)+j].y*Bi[i]*Bj[j]);
 		 	point.z = point.z + (float)(q[(i*n)+j].z*Bi[i]*Bj[j]);
  			}
  		
  		return point;
  	}
```
 
  Also nochmal zusammengefasst:
  BSplines kann ich berechnen, doch leider ist die Fläche zu klein (Approximation).
 Wer kann mir dabei helfen, einen Algorithmus für BSplines zu finden, der Interpolation verwendet? Ich habe zwar schon den Ansatz, dass der deBoor-Algorithmus das machen würde, doch leider ist der im Moment etwas zu kompliziert für mich, um den selbst zu programmieren.

  Ich dankte euch jetzt schon für euer Bemühen.
  MfG, Kona


----------



## teppi (24. Juni 2005)

Ich bezweifele, dass du hier eine Antwort finden wirst. Dies ist ja eher eine mathematische als eine Javaspezifische Frage .. Ich würde es an deiner Stelle mal in einem guten Matheforum oder so versuchen.


----------



## Thomas Darimont (26. Juni 2005)

Hallo!

 Vielleicht hilft dir ja dies hier weiter:
http://192.18.37.44/forums/index.php?topic=9830.0

 Gruß Tom


----------

