⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 cubicbsplsurf.cpp

📁 Hi guys, I have a B-spline curve algorithm by using Genetic algorithm. Any interested?
💻 CPP
字号:
#include "stdafx.h"
#include "GA.h"
#include "dlgFittingProcess.h"
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include "matrix.h"
#include <time.h>

#define PI 3.141593
#define Draw 1000
#define numtemp 10
int numFaces,vn[144][5];
int numver;
int tab1,tab2;
int surfu  =   12,surfv  =  12;
float vert[169][3];
float xtemp[numtemp+1][numtemp+1]; 
float ytemp[numtemp+1][numtemp+1]; 
float ztemp[numtemp+1][numtemp+1];

extern float DrawB2x[Draw],DrawB2y[Draw],DrawB2z[Draw];
extern int times;
extern int meshnumber;
//---------------------------------------------------------------------------
void cubicBSplSurf()
{
	int i,j,k,m,n;
	float u,v,du,dv,b0u,b1u,b2u,b3u,b0v,b1v,b2v,b3v; 

	tab1 = times;
	tab2 = meshnumber;
	for   (i=1;   i<=numtemp;   i++) {
		for   (j=1;   j<=numtemp;   j++) {
			xtemp[i][j] = 0;
			ytemp[i][j] = 0;
			ztemp[i][j] = 0;
		}
	}

	for   (i=0;   i<=numtemp-1;   i++) {
		for   (j=0;   j<=numtemp-1;   j++) {
			xtemp[i][j] = DrawB2x[j+1+i*numtemp];
		}
	}

	for   (i=0;   i<=numtemp-1;   i++) {
		for   (j=0;   j<=numtemp-1;   j++) {
			ytemp[i][j] = DrawB2y[j+1+i*numtemp];
		}
	}

	for   (i=0;   i<=numtemp-1;   i++) {
		for   (j=0;   j<=numtemp-1;   j++) {
			ztemp[i][j] = DrawB2z[j+1+i*numtemp];
		}
	}

	for   (i=1;   i<tab1;   i++) {
		xtemp[i][0]   = xtemp[i][2]+6*(xtemp[i][0]-xtemp[i][1]);
		ytemp[i][0]   = ytemp[i][2]+6*(ytemp[i][0]-ytemp[i][1]);
		ztemp[i][0]   = ztemp[i][2]+6*(ztemp[i][0]-ztemp[i][1]);
		xtemp[i][tab2]= xtemp[i][tab2-2]+6*(xtemp[i][tab2]-xtemp[i][tab2-1]);
		ytemp[i][tab2]= ytemp[i][tab2-2]+6*(ytemp[i][tab2]-ytemp[i][tab2-1]);
		ztemp[i][tab2]= ztemp[i][tab2-2]+6*(ztemp[i][tab2]-ztemp[i][tab2-1]); 
	}
		
	for   (j=1;j<tab2;j++) {
		xtemp[0][j]=xtemp[2][j]+6*(xtemp[0][j]-xtemp[1][j]);
		ytemp[0][j]=ytemp[2][j]+6*(ytemp[0][j]-ytemp[1][j]);
		ztemp[0][j]=ztemp[2][j]+6*(ztemp[0][j]-ztemp[1][j]);
		xtemp[tab1][j]=xtemp[tab1-2][j]+6*(xtemp[tab1][j]-xtemp[tab1-1][j]);
		ytemp[tab1][j]=ytemp[tab1-2][j]+6*(ytemp[tab1][j]-ytemp[tab1-1][j]);
		ztemp[tab1][j]=ztemp[tab1-2][j]+6*(ztemp[tab1][j]-ztemp[tab1-1][j]);
	}
	for(i=0;i<=tab1;i++){
		xtemp[i][1]=0.5*(3*xtemp[i][1]-xtemp[i][2]);
		ytemp[i][1]=0.5*(3*ytemp[i][1]-ytemp[i][2]);
		ztemp[i][1]=0.5*(3*ztemp[i][1]-ztemp[i][2]);
		xtemp[i][tab2-1]=0.5*(3*xtemp[i][tab2-1]-xtemp[i][tab2-2]);
		ytemp[i][tab2-1]=0.5*(3*ytemp[i][tab2-1]-ytemp[i][tab2-2]);
		ztemp[i][tab2-1]=0.5*(3*ztemp[i][tab2-1]-ztemp[i][tab2-2]);
	}

	for   (j=0;   j<=tab2;   j++) {
		xtemp[1][j]=0.5*(3*xtemp[1][j]-xtemp[2][j]);
		ytemp[1][j]=0.5*(3*ytemp[1][j]-ytemp[2][j]);
		ztemp[1][j]=0.5*(3*ztemp[1][j]-ztemp[2][j]);
		xtemp[tab1-1][j]=0.5*(3*xtemp[tab1-1][j]-xtemp[tab1-2][j]);
		ytemp[tab1-1][j]=0.5*(3*ytemp[tab1-1][j]-ytemp[tab1-2][j]);
		ztemp[tab1-1][j]=0.5*(3*ztemp[tab1-1][j]-ztemp[tab1-2][j]);
	}

	xtemp[0][0]=36*xtemp[0][0]-4*xtemp[0][1]-4*xtemp[1][0]-16*xtemp[1][1]-xtemp[0][2]-xtemp[2][0]-4*xtemp[1][2]-4*xtemp[2][1]-xtemp[2][2];
	ytemp[0][0]=36*ytemp[0][0]-4*ytemp[0][1]-4*ytemp[1][0]-16*ytemp[1][1]-ytemp[0][2]-ytemp[2][0]-4*ytemp[1][2]-4*ytemp[2][1]-ytemp[2][2];
	ztemp[0][0]=36*ztemp[0][0]-4*ztemp[0][1]-4*ztemp[1][0]-16*ztemp[1][1]-ztemp[0][2]-ztemp[2][0]-4*ztemp[1][2]-4*ztemp[2][1]-ztemp[2][2];
	xtemp[0][tab2]=36*xtemp[0][tab2]-4*xtemp[0][tab2-1]-4*xtemp[1][tab2]-16*xtemp[1][tab2-1]-xtemp[0][tab2-2]-xtemp[2][tab2]-4*xtemp[1][tab2-2]-4*xtemp[2][tab2-1]-xtemp[2][tab2-2];
	ytemp[0][tab2]=36*ytemp[0][tab2]-4*ytemp[0][tab2-1]-4*ytemp[1][tab2]-16*ytemp[1][tab2-1]-ytemp[0][tab2-2]-ytemp[2][tab2]-4*ytemp[1][tab2-2]-4*ytemp[2][tab2-1]-ytemp[2][tab2-2];
	ztemp[0][tab2]=36*ztemp[0][tab2]-4*ztemp[0][tab2-1]-4*ztemp[1][tab2]-16*ztemp[1][tab2-1]-ztemp[0][tab2-2]-ztemp[2][tab2]-4*ztemp[1][tab2-2]-4*ztemp[2][tab2-1]-ztemp[2][tab2-2];
	xtemp[tab1][tab2]=36*xtemp[tab1][tab2]-4*xtemp[tab1][tab2-1]-4*xtemp[tab1-1][tab2]-16*xtemp[tab1-1][tab2-1]-xtemp[tab1][tab2-2]-xtemp[tab1-2][tab2]-4*xtemp[tab1-1][tab2-2]-4*xtemp[tab1-2][tab2-1]-xtemp[tab1-2][tab2-2];
	ytemp[tab1][tab2]=36*ytemp[tab1][tab2]-4*ytemp[tab1][tab2-1]-4*ytemp[tab1-1][tab2]-16*ytemp[tab1-1][tab2-1]-ytemp[tab1][tab2-2]-ytemp[tab1-2][tab2]-4*ytemp[tab1-1][tab2-2]-4*ytemp[tab1-2][tab2-1]-ytemp[tab1-2][tab2-2];
	ztemp[tab1][tab2]=36*ztemp[tab1][tab2]-4*ztemp[tab1][tab2-1]-4*ztemp[tab1-1][tab2]-16*ztemp[tab1-1][tab2-1]-ztemp[tab1][tab2-2]-ztemp[tab1-2][tab2]-4*ztemp[tab1-1][tab2-2]-4*ztemp[tab1-2][tab2-1]-ztemp[tab1-2][tab2-2];
	
	du=(float)(tab1-2)/(float)surfu; 
	dv=(float)(tab2-2)/(float)surfv; 
	n = 0;

	for   (j=3;j<=tab2;j++){
		if   (j==3) v  =   0.; 
		else v  =  v  -  1.0; 
		while   (v<(1.+.001*dv)){
			b0v = v*v*v/6.;b1v = (1.+3.*v+3.*v*v-3.*v*v*v)/6.;b2v = (4.-6.*v*v+3.*v*v*v)/6.;b3v = (1.-3.*v+3.*v*v-v*v*v)/6.;
			m = 0;
			for   (i = 3;   i<=tab1;   i++){
				if   (i==3)	u  =  0.; 
				else u  =  u  -  1.0; 
				while   (  u<(1.+.001*du)   ) {
					k = m + n*(surfu+1);
					b0u  = u*u*u/6.;
					b1u  = (1.+3.*u+3.*u*u+3.*u*u*u)/6.;
					b2u  = (4.-6.*u*u+3.*u*u*u)/6.;
					b3u  = (1.-3.*u+3.*u*u-u*u*u)/6.;
					vert[k][0] = xtemp[i-3][j-3]*b3u*b3v
						+ xtemp[i-3][j-2]*b3u*b2v + xtemp[i-3][j-1]*b3u*b1v
						+ xtemp[i-3][j]*b3u*b0v + xtemp[i-2][j-3]*b2u*b3v 
						+ xtemp[i-2][j-2]*b2u*b2v + xtemp[i-2][j-1]*b2u*b1v 
						+ xtemp[i-2][j]*b2u*b0v + xtemp[i-1][j-3]*b1u*b3v 
						+ xtemp[i-1][j-2]*b1u*b2v + xtemp[i-1][j-1]*b1u*b1v 
						+ xtemp[i-1][j]*b1u*b0v + xtemp[i][j-3]*b0u*b3v 
						+ xtemp[i][j-2]*b0u*b2v + xtemp[i][j-1]*b0u*b1v 
						+ xtemp[i][j]*b0u*b0v;
					vert[k][1] = ytemp[i-3][j-3]*b3u*b3v
						+ytemp[i-3][j-2]*b3u*b2v + ytemp[i-3][j-1]*b3u*b1v 
						+ytemp[i-3][j]*b3u*b0v + ytemp[i-2][j-3]*b2u*b3v 
						+ytemp[i-2][j-2]*b2u*b2v + ytemp[i-2][j-1]*b2u*b1v 
						+ytemp[i-2][j]*b2u*b0v + ytemp[i-1][j-3]*b1u*b3v 
						+ytemp[i-1][j-2]*b1u*b2v + ytemp[i-1][j-1]*b1u*b1v 
						+ytemp[i-1][j]*b1u*b0v + ytemp[i][j-3]*b0u*b3v 
						+ytemp[i][j-2]*b0u*b2v + ytemp[i][j-1]*b0u*b1v 
						+ytemp[i][j]*b0u*b0v;
					vert[k][2]=ztemp[i-3][j-3]*b3u*b3v
						+ztemp[i-3][j-2]*b3u*b2v+ztemp[i-3][j-1]*b3u*b1v
						+ztemp[i-3][j]*b3u*b0v+ztemp[i-2][j-3]*b2u*b3v 
						+ztemp[i-2][j-2]*b2u*b2v+ztemp[i-2][j-1]*b2u*b1v
						+ztemp[i-2][j]*b2u*b0v+ztemp[i-1][j-3]*b1u*b3v
						+ztemp[i-1][j-2]*b1u*b2v+ztemp[i-1][j-1]*b1u*b1v 
						+ztemp[i-1][j]*b1u*b0v+ztemp[i][j-3]*b0u*b3v 
						+ztemp[i][j-2]*b0u*b2v+ztemp[i][j-1]*b0u*b1v 
						+ztemp[i][j]*b0u*b0v; 
					u   =  u   +   du;   
					m++; 
				}
			}
			v  = v  +  dv;   n++; 
		} 
	}
	for   (n=0;   n<surfv;   n++){
		for   (m=0;   m<surfu;   m++){
			k = m + n*surfu; 
			vn[k][0] = vn[k][4] = k+n; 
			vn[k][1] = k+n+1; 
			vn[k][2] = k+n+surfu+2; 
			vn[k][3] = k+n+surfu+1; 
		} 
	} 

	numver = k;
	numFaces = (surfu-1)+(surfv-1)*surfu+1;
}

//---------------------------------------------------------------------------
void plotSurface(CDC *pDC)
{
	int   m,n,k,vnum,xplot,yplot,xcen=320,yb=360,scale = 7,orgx,orgy;
	float  phi,sinp,cosp,xw,yw,zw,sf = 1.5;
	phi = 90*PI/180; 
	sinp = sin(phi); 
	cosp = cos(phi);

	for (m=0; m<=9; m++) {	
		for (n=0; n<=5; n++) {
			xw = vert[9*m+n][0]*200 ; 
			yw = vert[9*m+n][1]*200 ;
			xplot = (int)xw;
			yplot = (int)yw;	
			if (n==0) pDC->MoveTo(xplot, yplot);
			else pDC->LineTo(xplot, yplot);	
		}
	}


}

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -