Main Page | Namespace List | Class Hierarchy | Class List | File List | Class Members | File Members

Bspline Class Reference

#include <bspline.h>

Inheritance diagram for Bspline:

Primitive List of all members.

Public Member Functions

 Bspline ()
 Bspline (const vector< Point3D * > &lPoints)
 Bspline (const Bspline &spl)
 ~Bspline ()
virtual void display (QPainter &paint)
virtual void setPrimitive (QPoint &refPoint, QPoint &modifPoint)
virtual void toXML (QDomElement &elem)
vector< Point3D * > getCtrlPointsList () const
void addPoint (Point3D *point)
void addPointPosI (Point3D *point, const unsigned int pos)
int nbPoints ()
double getNbSamples ()
void setNbSamples (double sample)

Public Attributes

vector< Point3D * > pointsList
vector< Point3D * > samplesPointsList
double nbSamples
int type

Private Member Functions

double blend (int k, int t, int *u, double v)
Point3D calculatePoint (int *u, int n, int t, double v)
void calculateNodes (int *u, int n, int t)

Detailed Description

La classe Bspline permet de spécifier et de dessiner des bsplines.

Author:
Guitteny Fabrice

Idiart Baptiste

Le Goff Erwan


Constructor & Destructor Documentation

Bspline::Bspline  ) 
 

constructeur par défaut

00005 { 00006 type = BSPLINE; 00007 nbSamples = NORMAL_SAMPLE; 00008 }

Bspline::Bspline const vector< Point3D * > &  lPoints  ) 
 

constructeur

Parameters:
lPoints liste de points de contrôle

00011 { 00012 for (unsigned int i = 0; i < lastPointsList.size(); i++) 00013 pointsList.push_back(lastPointsList[i]); 00014 type = BSPLINE; 00015 nbSamples = NORMAL_SAMPLE; 00016 }

Bspline::Bspline const Bspline spl  ) 
 

constructeur par copie

Parameters:
spl bspline

00018 : Primitive(spl) 00019 { 00020 vector<Point3D *> vect = spl.pointsList; 00021 for (unsigned int i = 0; i < vect.size(); i++) 00022 pointsList.push_back(vect[i]); 00023 type = BSPLINE; 00024 nbSamples = NORMAL_SAMPLE; 00025 }

Bspline::~Bspline  )  [inline]
 

00060 {};


Member Function Documentation

void Bspline::addPoint Point3D point  ) 
 

ajoute un point de contrôle à la liste de points de contrôle

Parameters:
point point à ajouter

00040 { 00041 pointsList.push_back(point); 00042 }

void Bspline::addPointPosI Point3D point,
const unsigned int  pos
 

ajoute un point de contrôle à une position définié de la liste de points de contrôle

Parameters:
point point à ajouter
pos position dans la liste

00046 { 00047 if (pos < pointsList.size()) // on peut insérer 00048 { 00049 vector<Point3D *> temp; 00050 for (unsigned int i = 0; i < pos; i++) 00051 temp.push_back(pointsList[i]); 00052 temp.push_back(point); 00053 for (unsigned int i = pos + 1; i <= pointsList.size(); i++) 00054 temp.push_back(pointsList[i-1]); 00055 pointsList = temp; 00056 } 00057 }

double Bspline::blend int  k,
int  t,
int *  u,
double  v
[private]
 

00065 { 00066 double valeur; 00067 00068 if (t == 1) 00069 { 00070 if ((u[k] <= v) && (v < u[k+1])) 00071 valeur = 1; 00072 else 00073 valeur= 0; 00074 } 00075 else 00076 { 00077 if ((u[k+t-1] == u[k]) && (u[k+t] == u[k+1])) 00078 valeur = 0; 00079 else 00080 if (u[k+t-1] == u[k]) 00081 valeur = (u[k+t] - v) / (u[k+t] - u[k+1]) * blend(k+1,t-1,u,v); 00082 else 00083 if (u[k+t] == u[k+1]) 00084 valeur = (v - u[k]) / (u[k+t-1] - u[k]) * blend(k,t-1,u,v); 00085 else 00086 valeur = (v - u[k]) / (u[k+t-1] - u[k]) * blend(k,t-1,u,v) + 00087 (u[k+t] - v) / (u[k+t] - u[k+1]) * blend(k+1,t-1,u,v); 00088 } 00089 return(valeur); 00090 }

void Bspline::calculateNodes int *  u,
int  n,
int  t
[private]
 

00116 { 00117 int j; 00118 00119 for (j=0;j<=n+t;j++) { 00120 if (j < t) 00121 u[j] = 0; 00122 else if (j <= n) 00123 u[j] = j - t + 1; 00124 else if (j > n) 00125 u[j] = n - t + 2; 00126 } 00127 }

Point3D Bspline::calculatePoint int *  u,
int  n,
int  t,
double  v
[private]
 

00096 { 00097 double xx = 0; 00098 double yy = 0; 00099 double zz = 0; 00100 00101 for (int k = 0; k <= n; k++) 00102 { 00103 double b = blend(k, t, u, v); 00104 xx += pointsList[k]->getCoordinate(0) * b; 00105 yy += pointsList[k]->getCoordinate(1) * b; 00106 zz += pointsList[k]->getCoordinate(2) * b; 00107 } 00108 00109 return Point3D(xx,yy,zz); 00110 }

void Bspline::display QPainter &  paint  )  [virtual]
 

méthode d'affichage d'une Bspline

Parameters:
paint affichage dans un QPainter

Implements Primitive.

00133 { 00134 int size = pointsList.size(); 00135 int degree = 4; 00136 int nodes[size+degree+1]; 00137 calculateNodes(nodes, size-1, degree); 00138 00139 double interval = 0; 00140 int precision = 250 * pointsList.size(); 00141 double increment = (double) ( (double) (size - 1 - degree + 2) / (double) (precision - 1) ); 00142 00143 int temp = 0; 00144 00145 samplesPointsList.clear(); 00146 00147 for (int i = 0; i < precision; i++) 00148 { 00149 Point3D res = calculatePoint(nodes, size - 1, degree, interval); 00150 interval += increment; 00151 00152 if (temp >= nbSamples) 00153 { 00154 samplesPointsList.push_back(new Point3D(res)); 00155 temp = 0; 00156 } 00157 temp++; 00158 paint.drawPoint( (int)(res.getCoordinate(0)), (int)(res.getCoordinate(1)) ); 00159 } 00160 samplesPointsList.push_back(new Point3D(*pointsList[size-1])); 00161 }

vector< Point3D * > Bspline::getCtrlPointsList  )  const
 

accesseur

Returns:
liste de points de contrôle

00033 { 00034 return pointsList; 00035 }

double Primitive::getNbSamples  )  [inline, inherited]
 

accesseur : valeur de l'échantillonage

Returns:
nombre d'échantillons

00081 {return nbSamples;}

int Primitive::nbPoints  )  [inline, inherited]
 

nombre de points définissant la primitive

00073 {return pointsList.size();}

void Primitive::setNbSamples double  sample  )  [inline, inherited]
 

modificateur : valeur de l'échantillonage

Parameters:
sample nouvelle valeur de l'échantillonage

00087 { 00088 if (type == CIRCLE) 00089 nbSamples = sample / 3; 00090 else 00091 nbSamples = sample; 00092 }

void Bspline::setPrimitive QPoint &  refPoint,
QPoint &  modifPoint
[virtual]
 

changement des points de contrôle de la Bspline

Parameters:
refPoint point à modifier
modifPoint nouvelle valeur du point

Implements Primitive.

00166 { 00167 Point3D * p = qPointToPoint3D(pointRef); 00168 for (unsigned int i = 0; i < pointsList.size(); i++) 00169 if (*p == *pointsList[i]) 00170 pointsList[i] = qPointToPoint3D(pointModif); 00171 }

void Bspline::toXML QDomElement &  elem  )  [virtual]
 

ecrit la primitive dans un fichier xml

Parameters:
elem balise courante dans le fichier XML

Implements Primitive.

00178 { 00179 string attributeName; 00180 for(int i = 0 ;i<nbPoints() ; i++) 00181 { 00182 char snumpt[256]=""; 00183 sprintf(snumpt,"%d",i); 00184 string temp = (string)snumpt; 00185 attributeName = "P"+temp+"x"; 00186 elem.setAttribute( attributeName, (*pointsList[i])[0]); 00187 char snumpt2[256]=""; 00188 sprintf(snumpt2,"%d",i); 00189 string temp2 = (string)snumpt2; 00190 attributeName = "P"+temp2+"y"; 00191 elem.setAttribute( attributeName, (*pointsList[i])[1]); 00192 } 00193 }


Member Data Documentation

double Primitive::nbSamples [inherited]
 

nombre d'échantillons

vector<Point3D*> Primitive::pointsList [inherited]
 

liste des points définissant la primitive

vector<Point3D*> Primitive::samplesPointsList [inherited]
 

liste des points pour l'échantillonage

int Primitive::type [inherited]
 

type de la primitive SEGMENT, CERCLE, BEZIER ou BSPLINE


The documentation for this class was generated from the following files:
Generated on Tue Nov 29 21:58:59 2005 for CylinderGenerator by doxygen 1.3.7