三维各向同性快速扫描法3DFSM

已于 2024-02-29 19:41:06 修改
阅读量1.1k 收藏 21
点赞数 24
分类专栏： 地球物理 计算物理 计算数学 文章标签： 3d c++ 算法
于 2024-02-27 09:47:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42262783/article/details/136314201
版权

之前快速扫描法的帖子中提供的二维代码稍显凌乱，为此追加提供一个新的三维的代码，更加清楚直观地展示三维FSM的过程，便于初学者学习

代码：

/****************************************************************************************/
/***********                         3D Fast Sweeping Method                          **********/
/**************************Written By Zhang Jianming, 2020.10.10****************/
/***************************************CopyRight************************************/

#include<stdio.h>
#include<iostream>
#include<fstream>
#include<math.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
#include<ctime>
using namespace std;
float pi=3.1415926;
int nx =101;
int ny=101;
int nz =101;
float dx= 10;
float dy= 10;
float dz =10;
int T_max=1e3;
int T_min=0;
float T_control(float a);
float min(float a,float b);
float max(float a,float b);
void BubbleSort(float* h, size_t len);
void Swap(float& a, float& b);


int main()
{
	int i,j,k;
	int x0 = nx/2;int y0=ny/2; int z0 = nz/2;
	float ***s3=new float** [nx];
	float ***T_old3=new float** [nx];
	float ***T3=new float** [nx];
	float ***v3=new float** [nx];
	for(int i=0;i<nx;i++)
	{
		s3[i]=new float *[ny];
		T_old3[i]=new float *[ny];
		T3[i]=new float *[ny];
		v3[i]=new float *[ny];
		for(int j=0;j<ny;j++)
		{
			s3[i][j]=new float[nz];
			T_old3[i][j]=new float[nz];
			v3[i][j]=new float[nz];
			T3[i][j]=new float[nz];
		}
	}



	//initial for 3D
	for(i=0;i<nx;i++)   
		for(j=0;j<ny;j++)
			for(k=0;k<nz;k++)
			{
				v3[i][j][k]=1000;
				s3[i][j][k]=(1.0/v3[i][j][k]);
				T3[i][j][k]=22.0;
				T_old3[i][j][k]=22.0;
			}
	int sx=x0;int sy=y0;int sz=z0;
	T_old3[sx][sy][sz]=0.0;

	float T_xmin=33.0;float T_ymin=33.0; float T_zmin=33.0;float A=0.0;float B=0.0;float C=0.0,D=0.0;
	int loop=0,Max_loop=1;
	/***********FP FSM for 3D*****************/
	float tt1=clock();
	for(loop=0;loop<Max_loop;loop++)
	{
		for(i=sx;i<nx;i++)
			for(j=sy;j<ny;j++)
				for(k=sz;k<nz;k++)
				{
					int xa=i+1;if(xa==nx) xa=nx-1;
					int xb=i-1;if(xb==-1) xb=0;
					int ya=j+1;if(ya==ny) ya=ny-1;
					int yb=j-1;if(yb==-1) yb=0;
					int za=k+1;if(za==nz) za=nz-1;
					int zb=k-1;if(zb==-1) zb=0;
					T_xmin=min(T_old3[xa][j][k],T_old3[xb][j][k]);
					T_ymin=min(T_old3[i][ya][k],T_old3[i][yb][k]);
					T_zmin=min(T_old3[i][j][za],T_old3[i][j][zb]);
					float a[3]={T_xmin,T_ymin,T_zmin};
					BubbleSort(a, 3);
					float W=a[0];float V=a[1];float U=a[2];
					T3[i][j][k]=W+s3[i][j][k]*dx;
					if(T3[i][j][k]>V) 
					{
						T3[i][j][k]=((V+W+sqrt(2.0*pow(s3[i][j][k]*dx,2)-pow(V-W,2))))/2.0;
						//T3[i][j][k]=((V+W+sqrt(-pow(V,2)-pow(W,2)+2.0*V*W))/(2.0*s3[i][j][k]*dx*s3[i][j][k]*dx))/2.0;
					}
					if(T3[i][j][k]>U)
					{
						T3[i][j][k]=(V+W+U+sqrt(3.0*pow(s3[i][j][k]*dx,2)-pow(V-W,2)-pow(V-U,2)-pow(U-W,2)))/3.0;
						float tssp=T3[xb][yb][zb]+s3[xb][yb][zb]*dx*sqrt(3);
						T3[i][j][k]=min(T3[i][j][k],tssp);
						//float b=-2.0*(W+V+U);
						//T3[i][j][k]=(2.0*(W+V+U)+sqrt(b*b-12*(W*W+V*V+U*U-pow(s3[i][j][k]*dx,2))))/6.0;
						//T3[i][j][k]=((2.0*pow(V+W+U,2)+sqrt(4.0*pow(V+W+U,2)))/(12.0*pow(W*W+V*V+U*U-s3[i][j][k]*dx,2)))/2.0;
					}
					T_old3[i][j][k]=min(T_old3[i][j][k],T3[i][j][k]);
				}
		/**/
		for(i=sx;i>=0;i--)
			for(j=sy;j<ny;j++)
				for(k=sz;k<nz;k++)
				{
					int xa=i+1;if(xa==nx) xa=nx-1;
					int xb=i-1;if(xb==-1) xb=0;
					int ya=j+1;if(ya==ny) ya=ny-1;
					int yb=j-1;if(yb==-1) yb=0;
					int za=k+1;if(za==nz) za=nz-1;
					int zb=k-1;if(zb==-1) zb=0;
					T_xmin=min(T_old3[xa][j][k],T_old3[xb][j][k]);
					T_ymin=min(T_old3[i][ya][k],T_old3[i][yb][k]);
					T_zmin=min(T_old3[i][j][za],T_old3[i][j][zb]);
					float a[3]={T_xmin,T_ymin,T_zmin};
					BubbleSort(a, 3);
					float W=a[0];float V=a[1];float U=a[2];
					T3[i][j][k]=W+s3[i][j][k]*dx;
					if(T3[i][j][k]>V) 
					{
						T3[i][j][k]=((V+W+sqrt(2.0*pow(s3[i][j][k]*dx,2)-pow(V-W,2))))/2.0;
						//T3[i][j][k]=((V+W+sqrt(-pow(V,2)-pow(W,2)+2.0*V*W))/(2.0*s3[i][j][k]*dx*s3[i][j][k]*dx))/2.0;
					}
					if(T3[i][j][k]>U)
					{
						T3[i][j][k]=(V+W+U+sqrt(3.0*pow(s3[i][j][k]*dx,2)-pow(V-W,2)-pow(V-U,2)-pow(U-W,2)))/3.0;
						float tssp=T3[xa][yb][zb]+s3[xa][yb][zb]*dx*sqrt(3);
						T3[i][j][k]=min(T3[i][j][k],tssp);
						//float b=-2.0*(W+V+U);
						//T3[i][j][k]=(2.0*(W+V+U)+sqrt(b*b-12*(W*W+V*V+U*U-pow(s3[i][j][k]*dx,2))))/6.0;
						//T3[i][j][k]=((2.0*pow(V+W+U,2)+sqrt(4.0*pow(V+W+U,2)))/(12.0*pow(W*W+V*V+U*U-s3[i][j][k]*dx,2)))/2.0;
					}
					T_old3[i][j][k]=min(T_old3[i][j][k],T3[i][j][k]);
				}

		for(i=sx;i<nx;i++)
			for(j=sy;j>=0;j--)
				for(k=sz;k<nz;k++)
				{
					int xa=i+1;if(xa==nx) xa=nx-1;
					int xb=i-1;if(xb==-1) xb=0;
					int ya=j+1;if(ya==ny) ya=ny-1;
					int yb=j-1;if(yb==-1) yb=0;
					int za=k+1;if(za==nz) za=nz-1;
					int zb=k-1;if(zb==-1) zb=0;
					T_xmin=min(T_old3[xa][j][k],T_old3[xb][j][k]);
					T_ymin=min(T_old3[i][ya][k],T_old3[i][yb][k]);
					T_zmin=min(T_old3[i][j][za],T_old3[i][j][zb]);
					float a[3]={T_xmin,T_ymin,T_zmin};
					BubbleSort(a, 3);
					float W=a[0];float V=a[1];float U=a[2];
					T3[i][j][k]=W+s3[i][j][k]*dx;
					if(T3[i][j][k]>V) 
					{
						T3[i][j][k]=((V+W+sqrt(2.0*pow(s3[i][j][k]*dx,2)-pow(V-W,2))))/2.0;
						//T3[i][j][k]=((V+W+sqrt(-pow(V,2)-pow(W,2)+2.0*V*W))/(2.0*s3[i][j][k]*dx*s3[i][j][k]*dx))/2.0;
					}
					if(T3[i][j][k]>U)
					{
						T3[i][j][k]=(V+W+U+sqrt(3.0*pow(s3[i][j][k]*dx,2)-pow(V-W,2)-pow(V-U,2)-pow(U-W,2)))/3.0;
						float tssp=T3[xb][ya][zb]+s3[xb][ya][zb]*dx*sqrt(3);
						T3[i][j][k]=min(T3[i][j][k],tssp);
						//float b=-2.0*(W+V+U);
						//T3[i][j][k]=(2.0*(W+V+U)+sqrt(b*b-12*(W*W+V*V+U*U-pow(s3[i][j][k]*dx,2))))/6.0;
						//T3[i][j][k]=((2.0*pow(V+W+U,2)+sqrt(4.0*pow(V+W+U,2)))/(12.0*pow(W*W+V*V+U*U-s3[i][j][k]*dx,2)))/2.0;
					}
					T_old3[i][j][k]=min(T_old3[i][j][k],T3[i][j][k]);
				}

		for(i=sx;i>=0;i--)
			for(j=sy;j>=0;j--)
				for(k=sz;k<nz;k++)
				{
					int xa=i+1;if(xa==nx) xa=nx-1;
					int xb=i-1;if(xb==-1) xb=0;
					int ya=j+1;if(ya==ny) ya=ny-1;
					int yb=j-1;if(yb==-1) yb=0;
					int za=k+1;if(za==nz) za=nz-1;
					int zb=k-1;if(zb==-1) zb=0;
					T_xmin=min(T_old3[xa][j][k],T_old3[xb][j][k]);
					T_ymin=min(T_old3[i][ya][k],T_old3[i][yb][k]);
					T_zmin=min(T_old3[i][j][za],T_old3[i][j][zb]);
					float a[3]={T_xmin,T_ymin,T_zmin};
					BubbleSort(a, 3);
					float W=a[0];float V=a[1];float U=a[2];
					T3[i][j][k]=W+s3[i][j][k]*dx;
					if(T3[i][j][k]>V) 
					{
						T3[i][j][k]=((V+W+sqrt(2.0*pow(s3[i][j][k]*dx,2)-pow(V-W,2))))/2.0;
						//T3[i][j][k]=((V+W+sqrt(-pow(V,2)-pow(W,2)+2.0*V*W))/(2.0*s3[i][j][k]*dx*s3[i][j][k]*dx))/2.0;
					}
					if(T3[i][j][k]>U)
					{
						T3[i][j][k]=(V+W+U+sqrt(3.0*pow(s3[i][j][k]*dx,2)-pow(V-W,2)-pow(V-U,2)-pow(U-W,2)))/3.0;
						float tssp=T3[xa][ya][zb]+s3[xa][ya][zb]*dx*sqrt(3);
						T3[i][j][k]=min(T3[i][j][k],tssp);
						//float b=-2.0*(W+V+U);
						//T3[i][j][k]=(2.0*(W+V+U)+sqrt(b*b-12*(W*W+V*V+U*U-pow(s3[i][j][k]*dx,2))))/6.0;
						//T3[i][j][k]=((2.0*pow(V+W+U,2)+sqrt(4.0*pow(V+W+U,2)))/(12.0*pow(W*W+V*V+U*U-s3[i][j][k]*dx,2)))/2.0;
					}
					T_old3[i][j][k]=min(T_old3[i][j][k],T3[i][j][k]);
				}

		for(i=sx;i<nx;i++)
			for(j=sy;j<ny;j++)
				for(k=sz;k>=0;k--)
				{
					int xa=i+1;if(xa==nx) xa=nx-1;
					int xb=i-1;if(xb==-1) xb=0;
					int ya=j+1;if(ya==ny) ya=ny-1;
					int yb=j-1;if(yb==-1) yb=0;
					int za=k+1;if(za==nz) za=nz-1;
					int zb=k-1;if(zb==-1) zb=0;
					T_xmin=min(T_old3[xa][j][k],T_old3[xb][j][k]);
					T_ymin=min(T_old3[i][ya][k],T_old3[i][yb][k]);
					T_zmin=min(T_old3[i][j][za],T_old3[i][j][zb]);
					float a[3]={T_xmin,T_ymin,T_zmin};
					BubbleSort(a, 3);
					float W=a[0];float V=a[1];float U=a[2];
					T3[i][j][k]=W+s3[i][j][k]*dx;
					if(T3[i][j][k]>V) 
					{
						T3[i][j][k]=((V+W+sqrt(2.0*pow(s3[i][j][k]*dx,2)-pow(V-W,2))))/2.0;
						//T3[i][j][k]=((V+W+sqrt(-pow(V,2)-pow(W,2)+2.0*V*W))/(2.0*s3[i][j][k]*dx*s3[i][j][k]*dx))/2.0;
					}
					if(T3[i][j][k]>U)
					{
						T3[i][j][k]=(V+W+U+sqrt(3.0*pow(s3[i][j][k]*dx,2)-pow(V-W,2)-pow(V-U,2)-pow(U-W,2)))/3.0;
						float tssp=T3[xb][yb][za]+s3[xb][yb][za]*dx*sqrt(3);
						T3[i][j][k]=min(T3[i][j][k],tssp);
						//float b=-2.0*(W+V+U);
						//T3[i][j][k]=(2.0*(W+V+U)+sqrt(b*b-12*(W*W+V*V+U*U-pow(s3[i][j][k]*dx,2))))/6.0;
						//T3[i][j][k]=((2.0*pow(V+W+U,2)+sqrt(4.0*pow(V+W+U,2)))/(12.0*pow(W*W+V*V+U*U-s3[i][j][k]*dx,2)))/2.0;
					}
					T_old3[i][j][k]=min(T_old3[i][j][k],T3[i][j][k]);
				}

		for(i=sx;i>=0;i--)
			for(j=sy;j<ny;j++)
				for(k=sz;k>=0;k--)
				{
					int xa=i+1;if(xa==nx) xa=nx-1;
					int xb=i-1;if(xb==-1) xb=0;
					int ya=j+1;if(ya==ny) ya=ny-1;
					int yb=j-1;if(yb==-1) yb=0;
					int za=k+1;if(za==nz) za=nz-1;
					int zb=k-1;if(zb==-1) zb=0;
					T_xmin=min(T_old3[xa][j][k],T_old3[xb][j][k]);
					T_ymin=min(T_old3[i][ya][k],T_old3[i][yb][k]);
					T_zmin=min(T_old3[i][j][za],T_old3[i][j][zb]);
					float a[3]={T_xmin,T_ymin,T_zmin};
					BubbleSort(a, 3);
					float W=a[0];float V=a[1];float U=a[2];
					T3[i][j][k]=W+s3[i][j][k]*dx;
					if(T3[i][j][k]>V) 
					{
						T3[i][j][k]=((V+W+sqrt(2.0*pow(s3[i][j][k]*dx,2)-pow(V-W,2))))/2.0;
						//T3[i][j][k]=((V+W+sqrt(-pow(V,2)-pow(W,2)+2.0*V*W))/(2.0*s3[i][j][k]*dx*s3[i][j][k]*dx))/2.0;
					}
					if(T3[i][j][k]>U)
					{
						T3[i][j][k]=(V+W+U+sqrt(3.0*pow(s3[i][j][k]*dx,2)-pow(V-W,2)-pow(V-U,2)-pow(U-W,2)))/3.0;
						float tssp=T3[xa][yb][za]+s3[xa][yb][za]*dx*sqrt(3);
						T3[i][j][k]=min(T3[i][j][k],tssp);
						//float b=-2.0*(W+V+U);
						//T3[i][j][k]=(2.0*(W+V+U)+sqrt(b*b-12*(W*W+V*V+U*U-pow(s3[i][j][k]*dx,2))))/6.0;
						//T3[i][j][k]=((2.0*pow(V+W+U,2)+sqrt(4.0*pow(V+W+U,2)))/(12.0*pow(W*W+V*V+U*U-s3[i][j][k]*dx,2)))/2.0;
					}
					T_old3[i][j][k]=min(T_old3[i][j][k],T3[i][j][k]);
				}

		for(i=sx;i<nx;i++)
			for(j=sy;j>=0;j--)
				for(k=sz;k>=0;k--)
				{
					int xa=i+1;if(xa==nx) xa=nx-1;
					int xb=i-1;if(xb==-1) xb=0;
					int ya=j+1;if(ya==ny) ya=ny-1;
					int yb=j-1;if(yb==-1) yb=0;
					int za=k+1;if(za==nz) za=nz-1;
					int zb=k-1;if(zb==-1) zb=0;
					T_xmin=min(T_old3[xa][j][k],T_old3[xb][j][k]);
					T_ymin=min(T_old3[i][ya][k],T_old3[i][yb][k]);
					T_zmin=min(T_old3[i][j][za],T_old3[i][j][zb]);
					float a[3]={T_xmin,T_ymin,T_zmin};
					BubbleSort(a, 3);
					float W=a[0];float V=a[1];float U=a[2];
					T3[i][j][k]=W+s3[i][j][k]*dx;
					if(T3[i][j][k]>V) 
					{
						T3[i][j][k]=((V+W+sqrt(2.0*pow(s3[i][j][k]*dx,2)-pow(V-W,2))))/2.0;
						//T3[i][j][k]=((V+W+sqrt(-pow(V,2)-pow(W,2)+2.0*V*W))/(2.0*s3[i][j][k]*dx*s3[i][j][k]*dx))/2.0;
					}
					if(T3[i][j][k]>U)
					{
						T3[i][j][k]=(V+W+U+sqrt(3.0*pow(s3[i][j][k]*dx,2)-pow(V-W,2)-pow(V-U,2)-pow(U-W,2)))/3.0;
						float tssp=T3[xb][ya][za]+s3[xb][ya][za]*dx*sqrt(3);
						T3[i][j][k]=min(T3[i][j][k],tssp);
						//float b=-2.0*(W+V+U);
						//T3[i][j][k]=(2.0*(W+V+U)+sqrt(b*b-12*(W*W+V*V+U*U-pow(s3[i][j][k]*dx,2))))/6.0;
						//T3[i][j][k]=((2.0*pow(V+W+U,2)+sqrt(4.0*pow(V+W+U,2)))/(12.0*pow(W*W+V*V+U*U-s3[i][j][k]*dx,2)))/2.0;
					}
					T_old3[i][j][k]=min(T_old3[i][j][k],T3[i][j][k]);
				}

		for(i=sx;i>=0;i--)
			for(j=sy;j>=0;j--)
				for(k=sz;k>=0;k--)
				{
					int xa=i+1;if(xa==nx) xa=nx-1;
					int xb=i-1;if(xb==-1) xb=0;
					int ya=j+1;if(ya==ny) ya=ny-1;
					int yb=j-1;if(yb==-1) yb=0;
					int za=k+1;if(za==nz) za=nz-1;
					int zb=k-1;if(zb==-1) zb=0;
					T_xmin=min(T_old3[xa][j][k],T_old3[xb][j][k]);
					T_ymin=min(T_old3[i][ya][k],T_old3[i][yb][k]);
					T_zmin=min(T_old3[i][j][za],T_old3[i][j][zb]);
					float a[3]={T_xmin,T_ymin,T_zmin};
					BubbleSort(a, 3);
					float W=a[0];float V=a[1];float U=a[2];
					T3[i][j][k]=W+s3[i][j][k]*dx;
					if(T3[i][j][k]>V) 
					{
						T3[i][j][k]=((V+W+sqrt(2.0*pow(s3[i][j][k]*dx,2)-pow(V-W,2))))/2.0;
						//T3[i][j][k]=((V+W+sqrt(-pow(V,2)-pow(W,2)+2.0*V*W))/(2.0*s3[i][j][k]*dx*s3[i][j][k]*dx))/2.0;
					}
					if(T3[i][j][k]>U)
					{
						T3[i][j][k]=(V+W+U+sqrt(3.0*pow(s3[i][j][k]*dx,2)-pow(V-W,2)-pow(V-U,2)-pow(U-W,2)))/3.0;
						float tssp=T3[xa][ya][za]+s3[xa][ya][za]*dx*sqrt(3);
						T3[i][j][k]=min(T3[i][j][k],tssp);
						//float b=-2.0*(W+V+U);
						//T3[i][j][k]=(2.0*(W+V+U)+sqrt(b*b-12*(W*W+V*V+U*U-pow(s3[i][j][k]*dx,2))))/6.0;
						//T3[i][j][k]=((2.0*pow(V+W+U,2)+sqrt(4.0*pow(V+W+U,2)))/(12.0*pow(W*W+V*V+U*U-s3[i][j][k]*dx,2)))/2.0;
					}
					T_old3[i][j][k]=min(T_old3[i][j][k],T3[i][j][k]);
				}
	}
	float tt2=clock();
	cout<<"One shot modeling for 3DFSM is "<<(double)(tt2-tt1)/CLOCKS_PER_SEC<<" s."<<endl;
	float *Rdep=new float[nx];


	ofstream T3out("T3.dat");
	for(int i=0;i<nx;i++)
	{
		for(int j=0;j<ny;j++)
		{
			for(int k=0;k<nz;k++)
			{
				//T_old3[i][j][k]=sqrt(pow(i-nx/2,2)+pow(j-ny/2,2)+pow(k-0,2))*dx*1.0/2000.0;
				T_old3[i][j][k]-=sqrt(pow(i-x0,2)+pow(j-y0,2)+pow(k-z0,2))*dx*1.0/1000.0;
				T3out.write((char*)&T_old3[i][j][k],sizeof(float));
			}
		}
	}
	cout<<T_old3[nx-1][ny-1][nz-1]<<endl;;
	T3out.close();

	for(int i=0;i<nx;i++)
	{
		for(int j=0;j<ny;j++)
		{
			delete [] s3[i][j];
			delete [] T_old3[i][j];
			delete [] v3[i][j];
			delete [] T3[i][j];
		}
		delete []s3[i];
		delete [] T_old3[i];
		delete []v3[i];
		delete [] T3[i];
	}
	delete []s3;
	delete [] T_old3;
	delete []v3;
	delete [] T3;
	return 0;
}//end of main
float T_control(float a)
{
	if(a>0) return  a;
	else return 0;

}
float min(float a,float b)
{
	if (a>b) return b;
	else return a;
}
float max(float a,float b)
{
	if (a>b) return a;
	else return b;
}
void BubbleSort(float* h, size_t len)
{
	if(h==NULL) return;
	if(len<=1) return;
	//i是次数，j是具体下标 
	for(int i=0;i<len-1;++i)
		for(int j=0;j<len-1-i;++j)
			if(h[j]>h[j+1])
				Swap(h[j],h[j+1]);               
	return;
} 
void Swap(float& a, float& b)
{
	float t=a;
	a=b;
	b=t;
	return;
}


 

计算实例
 

走时场（震源位于上表面的中心位置）
 

 

整体走时误差
 

 

 

下底面走时误差
 


                

        

        

    




    

      

        

            

              
                
                  张建明0704
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    24
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    21
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  1
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
有向图.rar_bfs_dfs_dfs有向图栈_joinm3k_深度优先

				
			

			

				

					07-14
				

			

		

		

			
				
DFS：使用栈保存未被检测的结点，结点按照深度优先的次序被访问并依次被压入栈中，并以相反的次序出栈进行新的检测。BFS：使用队列保存未被检测的结点。结点按照宽度优先的次序被访问和进出队列。

			
		

	



                

              
                



	

		

			

				
					
basic-program.rar_三维迷宫

				
			

			

				

					09-14
				

			

		

		

			
				
《三维迷宫编程基础》  在计算机科学领域，三维迷宫是一种引人入胜的图形化游戏或模拟，它能够锻炼玩家的空间想象能力和逻辑思维能力。对于初学者来说，掌握三维迷宫的编程技巧不仅可以提升编程技能，还能为后续的...

			
		

	



                


  
              

                


	

		

			

				
					
蛮力法（DFS）解决TSP问题

				
			

			

				

					03-17
				

			

		

		

			
				
**标题解析：** "蛮力法（DFS）解决TSP问题" 指的是使用深度优先搜索（DFS, Depth-First Search）算法来求解旅行商问题（Traveling Salesman Problem, TSP）。旅行商问题是一个经典的组合优化问题，目标是找到一个...

			
		

	





	

		

			

				
					
易语言三维迷宫.rar

				
			

			

				

					02-23
				

			

		

		

			
				
3. **算法设计**：生成和解决三维迷宫需要用到特定的算法。生成算法可能包括深度优先搜索（DFS）或广度优先搜索（BFS）等，而解谜算法可能采用A*搜索或Dijkstra算法。  4. **图形渲染**：为了让用户能直观地看到迷宫...

			
		

	



		

			
		



	

		

			

				
					
3D工艺大师快速生成装配动画，驱动汽车工业装配流程革新

				
			

			

				

					大腾智能的博客
				

				

					07-12
					
					1910
					
				

			

		

		

			
				
3D工艺大师，一款能够颠覆传统装配指导模式、提升装配效率与质量的创新工具，凭借强大的三维可视化与快速生成动画的能力，帮助汽车制造商成功实现了装配指导方式的数字化转型，大幅提升了生产效率和产品质量。

			
		

	





	

		

			

				
					
gltf模型加载 与3d背景贴图

				
			

			

				

					weixin_48433993的博客
				

				

					07-11
					
					402
					
				

			

		

		

			
				
点击右边的jpg，右键将图像另存为，放到public里面。用于3d模型跟贴图下载资源。模型放到public里面。

			
		

	





	

		

			

				
					
qt 图形、图像、3D相关知识

				
			

			

				

					xie__jin__cheng的博客
				

				

					07-11
					
					793
					
				

			

		

		

			
				
qt 图形、图像、3D相关知识

			
		

	





	

		

			

				
					
echarts使用自定义图形实现3D柱状图

				
			

			

				

					Li_na_na01的博客
				

				

					07-10
					
					784
					
				

			

		

		

			
				
echarts使用自定义图形实现3D柱状图。

			
		

	





	

		

			

				
					
3D线上展示技术如何应用到汽车营销中？有哪些优势？

				
			

			

				

					mirrornan的博客
				

				

					07-10
					
					1153
					
				

			

		

		

			
				
近年来，随着互联网的不断发展，线上看车逐渐成为当下年轻消费群体的看车新选择，并且线上看车正在从2D平面转向3D立体体验。51建模网提供汽车行业3D数字化营销解决方案，让用户一站式体验虚拟与现实融合的线上购车体验。

			
		

	





	

		

			

				
					
实战篇(九)：解锁3D魔方的秘密：用Processing编程实现交互式魔方

				
			

			

				

					帅小柏的博客
				

				

					07-13
					
					162
					
				

			

		

		

			
				
通过本教程，我们学习了如何使用 Processing 创建一个 3D 魔方，并实现了旋转和点击交互功能。这不仅展示了 Processing 强大的 3D 绘图能力，也让我们对 3D 编程有了更深入的理解。希望你能通过本教程掌握更多的 Processing 技巧，并创造出更多有趣的 3D 图形项目。如果你有任何问题或建议，欢迎在评论区留言。祝你编码愉快！

			
		

	





	

		

			

				
					
论文研读：ViT-V-Net—用于无监督3D医学图像配准的Vision Transformer

				
			

			

				

					weixin_42937740的博客
				

				

					07-12
					
					909
					
				

			

		

		

			
				
最近，几种基于VIT的图像分割方法被与ConvNets相结合，以提高对详细定位信息的恢复。受它们的启发，我们提出了VIT-V-Net，它连接了VIT和ConvNet，以提供3D医学图像配准。

			
		

	





	

		

			

				
					
基于AI的3D场景重建技术新突破！破局自动驾驶端到端仿真

				
			

			

				

					51WORLD数字孪生
				

				

					07-08
					
					534
					
				

			

		

		

			
				
未来，51Sim 将持续迭代3DGS融合技术，为AI训练提供充足的数据燃料，赋能更广泛的行业应用。在通过3DGS点云建模的基础上，通过优化的AI融合算法，将静态3DGS场景与51Sim此前积累的静态场景库、动态的交通场景库和各类传感器仿真进行了自然融合，确保了。51Sim融合方案具有高质量和实时渲染的能力，高保真的模拟场景不仅提高了自动驾驶系统的训练质量，还显著提升了仿真的真实性，使其几乎可以达到肉眼难辨的程度，大幅。同时，利用先进的全局渲染技术，生成高质量视图，确保多相机视角的一致性和高保真度，实现了。

			
		

	





	

		

			

				
					
Cornerstone3D导致浏览器崩溃的踩坑记录

				
			

			

				

					bug处理进行时
				

				

					07-12
					
					932
					
				

			

		

		

			
				
WebGL: CONTEXT_LOST_WEBGL: Context: context lost；Cornerstone3D渲染Volume时导致windows 浏览器页面崩溃的处理方案及问题复盘记录

			
		

	





	

		

			

				
					
3d为什么删掉模型不能返回？---模大狮模型网

				
			

			

				

					modashi3dmax的博客
				

				

					07-12
					
					459
					
				

			

		

		

			
				
设计中的删除操作不仅是技术性的挑战，更涉及到设计过程中的复杂依赖和数据连接性。3D模型的设计和修改通常依赖于复杂的几何和图形处理技术。实时编辑和反馈：利用实时编辑和反馈工具，例如实时渲染和虚拟现实技术，可以帮助设计师更直观地理解和调整模型，减少错误和删除操作。历史记录和操作栈：大多数建模软件记录操作历史和操作栈，但在删除操作后，这些记录可能会因为依赖关系或者数据损失而无法完整恢复。功能性影响：某些部分的删除可能会影响到模型的功能性，例如机械结构的工作原理或者展览模型的稳定性和外观。三、设计策略和工作流程。

			
		

	





	

		

			

				
					
什么是Web3D？国内有哪些公司可以做？

				
			

			

				

					weixin_50515446的博客
				

				

					07-11
					
					354
					
				

			

		

		

			
				
利用计算机图形学、图像处理、人机交互等技术，将现实世界中的物体、场景或概念以三维立体的方式呈现在网页里。国内常见到的能够制作Web3D的公司，很多都是项目型公司，他们承接各种定制或委托项目，包括但不限于Web3D项目。另一种是研发工具类软件公司（比如 博维数孪），研发的数字孪生工具可让不懂开发和零代码经验的小白也能快速完成一款产品的Web3D交互展示，最贴心的是他家产品永久免费开放给大家使用。

			
		

	





	

		

			

				
					
从3D扫描到CAD模型【逆向工程】

				
			

			

				

					新缸中之脑
				

				

					07-11
					
					1073
					
				

			

		

		

			
				
该过程的第一部分涉及使用 3D 扫描仪快速准确地收集现有零件的几何表面测量值。传统上，人们使用卡尺和手动工具进行测量。然而，当尝试测量具有复杂特征的复杂零件（例如有机表面）时，它们通常被证明是有限的。扫描仪通常以 obj、ply 或 stl 网格格式输出 3D 扫描数据作为密集三角形网格——从几千个到数百万个多边形有了这种智能，你可以使用它来复制零件或基于原始零件创建新设计。3D 扫描数据可作为绘制 CAD 图纸的视觉指南。它基本上是在扫描数据的顶部进行跟踪。

			
		

	





	

		

			

				
					
Matplotlib库学习之mpl_toolkits.mplot3d.Axes3D函数

					
最新发布

				
			

			

				

					qq_46396470的博客
				

				

					07-15
					
					285
					
				

			

		

		

			
				
是 Matplotlib 的工具包中的一个类，用于创建三维坐标轴（3D Axes）。这个类继承自，提供了在三维空间中绘制图形的能力，非常适合于科学计算和工程领域中的三维数据可视化。

			
		

	





	

		

			

				
					
可视化学习：如何用WebGL绘制3D物体

				
			

			

				

					sdgfafg_25的博客
				

				

					07-11
					
					764
					
				

			

		

		

			
				
至此，我们就实现了正立方体的绘制。在3D物体的绘制中，正立方体属于是比较简单的一类，屏幕前的小伙伴们都可以来动手尝试下，感兴趣的小伙伴，还可以尝试去实现圆柱体、正四面体等等这些几何体的绘制。beckyye引迈 - JNPF快速开发平台_低代码开发平台_零代码开发平台_流程设计器_表单引擎_工作流引擎_软件架构。

			
		

	





	

		

			

				
					
红色文化3D虚拟数字展馆搭建意义深远

				
			

			

				

					VRARvrnew3d的博客
				

				

					07-13
					
					271
					
				

			

		

		

			
				
无论是繁华的商业区、迷人的古镇风貌，还是未来感十足的科技园区，web3d开发公司深圳华锐视点都能搭建720全景虚拟展厅三维场景进行逼真、沉浸、完全呈现，以科技的力量，重新定义着房产与土地市场的展示与交互方式，开启沉浸式体验的新篇章!

			
		

	





	

		

			

				
					
两遍扫描法连通域算法

				
			

			

				

					05-12
				

			

		

		

			
				
两遍扫描法是一种用于图像处理中的连通域算法，其主要思想是通过两次扫描来确定连通域的位置和大小。第一次扫描用于确定像素是否属于某个连通域，并给该连通域标记一个唯一的标识符。第二次扫描用于统计每个连通域中...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值