递进网格算法绘制等高线

简介:
/* generates contours using marching squares */

/* region size */

#define X_MAX 1.0 
#define Y_MAX 1.0 
#define X_MIN -1.0 
#define Y_MIN -1.0

/* number of cells */

#define N_X 50 
#define N_Y 50

/* contour value */

#define THRESHOLD 0.0

#include <GL/glut.h>

void display()
{
   double f(double,double);
   int cell(double, double, double, double);
   void lines(int, int, int, double, double, double, double);

   double data[N_X][N_Y];
   int i,j;
   int c;

   glClear(GL_COLOR_BUFFER_BIT);
/* form data array from function */

    for(i=0;i<N_X;i++) for (j=0;j<N_Y;j++)
       data[i][j]=f(X_MIN+i*(X_MAX-(X_MIN))/(N_X-1.0), Y_MIN+j*(Y_MAX-(Y_MIN))/(N_Y-1.0));

    /* process each cell */

    for(i=0;i<N_X;i++) for (j=0;j<N_Y;j++)
    {
       c=cell(data[i][j], data[i+1][j], data[i+1][j+1], data[i][j+1]);
       lines(c,i,j,data[i][j], data[i+1][j], data[i+1][j+1], data[i][j+1]);
    }
    glFlush();
}

/* define function f(x,y)      */

double f(double x, double y)
{

   double a=0.49, b=0.5;

   /* Ovals of Cassini  */

   return (x*x+y*y+a*a)*(x*x+y*y+a*a)-4*a*a*x*x-b*b*b*b;
}


/* define cell vertices */

int cell(double a, double b, double c , double d)
{
    int n=0;
    if(a>THRESHOLD) n+=1;
    if(b>THRESHOLD) n+=8;
    if(c>THRESHOLD) n+=4;
    if(d>THRESHOLD) n+=2;
    return n;
}


/* draw line segments for each case */

void lines(int num, int i, int j, double a, double b, double c, double d)
{
     void draw_one(int, int, int, double, double, double, double);
     void draw_adjacent(int, int, int, double, double, double, double);
     void draw_opposite(int, int, int, double, double, double, double);
     switch(num)
     {
     case 1: case 2: case 4: case 7: case 8: case 11: case 13: case 14:
        draw_one(num, i,j,a,b,c,d);
        break;
     case 3: case 6: case 9: case 12:
        draw_adjacent(num,i,j,a,b,c,d);
        break;
     case 5: case 10:
        draw_opposite(num, i,j,a,b,c,d);
        break;
     case 0: case 15: break;
     }
}

void draw_one(int num, int i, int j, double a, double b, double c, double d)
{
  double x1, y1, x2, y2;
  double ox, oy;
  double dx, dy;
  dx=(X_MAX-(X_MIN))/(N_X-1.0);
  dy=(Y_MAX-(Y_MIN))/(N_Y-1.0);
  ox=X_MIN+i*(X_MAX-(X_MIN))/(N_X-1.0);
  oy=Y_MIN+j*(Y_MAX-(Y_MIN))/(N_Y-1.0);
    switch(num)
    {
    case 1: case 14:
      x1=ox;
      y1=oy+dy*(THRESHOLD-a)/(d-a);
      x2=ox+dx*(THRESHOLD-a)/(b-a);
      y2=oy;
      break;
    case 2: case 13:
      x1=ox;
      y1=oy+dy*(THRESHOLD-a)/(d-a);
      x2=ox+dx*(THRESHOLD-d)/(c-d);
      y2=oy+dy;
      break;
    case 4: case 11:
      x1=ox+dx*(THRESHOLD-d)/(c-d);
      y1=oy+dy;
      x2=ox+dx;
      y2=oy+dy*(THRESHOLD-b)/(c-b);
      break;
    case 7: case 8:
      x1=ox+dx*(THRESHOLD-a)/(b-a);
      y1=oy;
      x2=ox+dx;
      y2=oy+dy*(THRESHOLD-b)/(c-b);
      break;
    }
  glBegin(GL_LINES);
    glVertex2d(x1, y1);
    glVertex2d(x2, y2);
  glEnd();
}

void draw_adjacent(int num, int i, int j, double a, double b,
double c, double d)
{
  double x1, y1, x2, y2;
  double ox, oy;
  double dx, dy;
  dx=(X_MAX-(X_MIN))/(N_X-1.0);
  dy=(Y_MAX-(Y_MIN))/(N_Y-1.0);
  ox=X_MIN+i*(X_MAX-(X_MIN))/(N_X-1.0);
  oy=Y_MIN+j*(Y_MAX-(Y_MIN))/(N_Y-1.0);
  switch(num)
  {
    case 3: case 12:
      x1=ox+dx*(THRESHOLD-a)/(b-a);
      y1=oy;
      x2=ox+dx*(THRESHOLD-d)/(c-d);
      y2=oy+dy;
      break;
    case 6: case 9:
      x1=ox;
      y1=oy+dy*(THRESHOLD-a)/(d-a);
      x2=ox+dx;
      y2=oy+dy*(THRESHOLD-b)/(c-b);
      break;
  }
  glBegin(GL_LINES);
    glVertex2d(x1, y1);
    glVertex2d(x2, y2);
  glEnd();

}

void draw_opposite(int num, int i, int j, double a, double b,
double c, double d)
{
  double x1,y1,x2,y2,x3,y3,x4,y4;
  double ox, oy;
  double dx, dy;
  dx=(X_MAX-(X_MIN))/(N_X-1.0);
  dy=(Y_MAX-(Y_MIN))/(N_Y-1.0);
  ox=X_MIN+i*(X_MAX-(X_MIN))/(N_X-1.0);
  oy=Y_MIN+j*(Y_MAX-(Y_MIN))/(N_Y-1.0);
  switch(num)
  {
    case5:
      x1=ox;
      y1=oy+dy*(THRESHOLD-a)/(d-a);
      x2=ox+dx*(THRESHOLD-a)/(b-a);
      y2=oy;
      x3=ox+dx*(THRESHOLD-d)/(c-d);
      y3=oy+dy;
      x4=ox+dx;
      y4=oy+dy*(THRESHOLD-b)/(c-b);
      break;
    case 10:
      x1=ox;
      y1=oy+dy*(THRESHOLD-a)/(d-a);
      x2=ox+dx*(THRESHOLD-d)/(c-d);
      y2=oy+dy;
      x3=ox+dy*(THRESHOLD-a)/(b-a);
      y3=oy;
      x4=ox+dx;
      y4=oy+dy*(THRESHOLD-b)/(c-b);
      break;
  }
  glBegin(GL_LINES);
    glVertex2d(x1, y1);
    glVertex2d(x2, y2);
    glVertex2d(x3, y3);
    glVertex2d(x4, y4);
  glEnd();
}

void myReshape(int w, int h)
{
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    if (w <= h) gluOrtho2D(X_MIN, X_MAX, Y_MIN * (GLfloat) h / (GLfloat) w, Y_MAX* (GLfloat) h / (GLfloat) w);
    else gluOrtho2D(X_MIN * (GLfloat) w / (GLfloat) h, X_MAX * (GLfloat) w / (GLfloat) h, Y_MIN, Y_MAX);
    glMatrixMode(GL_MODELVIEW);
}

int main(int argc, char **argv)
{
   glutInit(&argc, argv);
   glutInitWindowSize(500, 500);
   glutCreateWindow("contour plot");
   glutReshapeFunc(myReshape);
   glutDisplayFunc(display);
   glClearColor(0.0,0.0,0.0,1.0);
   glColor3f(1.0,1.0,1.0);
   glutMainLoop();
}

200792701.jpg


本文转自Phinecos(洞庭散人)博客园博客,原文链接:http://www.cnblogs.com/phinecos/archive/2007/09/27/907891.html,如需转载请自行联系原作者
目录
相关文章
|
5月前
|
机器学习/深度学习 数据采集 算法
Python实现GBDT(梯度提升树)分类模型(GradientBoostingClassifier算法)并应用网格搜索算法寻找最优参数项目实战
Python实现GBDT(梯度提升树)分类模型(GradientBoostingClassifier算法)并应用网格搜索算法寻找最优参数项目实战
|
5月前
|
机器学习/深度学习 人工智能 分布式计算
算法金 | 最难的来了:超参数网格搜索、贝叶斯优化、遗传算法、模型特异化、Hyperopt、Optuna、多目标优化、异步并行优化
机器学习中的超参数调优是提升模型性能的关键步骤,包括网格搜索、随机搜索、贝叶斯优化和遗传算法等方法。网格搜索通过穷举所有可能的超参数组合找到最优,但计算成本高;随机搜索则在预设范围内随机采样,降低计算成本;贝叶斯优化使用代理模型智能选择超参数,效率高且适应性强;遗传算法模拟生物进化,全局搜索能力强。此外,还有多目标优化、异步并行优化等高级技术,以及Hyperopt、Optuna等优化库来提升调优效率。实践中,应结合模型类型、数据规模和计算资源选择合适的调优策略。
213 0
算法金 | 最难的来了:超参数网格搜索、贝叶斯优化、遗传算法、模型特异化、Hyperopt、Optuna、多目标优化、异步并行优化
|
5月前
|
机器学习/深度学习 数据采集 自然语言处理
Python实现支持向量机SVM分类模型(SVC算法)并应用网格搜索算法调优项目实战
Python实现支持向量机SVM分类模型(SVC算法)并应用网格搜索算法调优项目实战
|
5月前
|
机器学习/深度学习 数据采集 算法
Python实现人工神经网络回归模型(MLPRegressor算法)并基于网格搜索(GridSearchCV)进行优化项目实战
Python实现人工神经网络回归模型(MLPRegressor算法)并基于网格搜索(GridSearchCV)进行优化项目实战
|
6月前
|
机器学习/深度学习 算法
机器学习中的超参数优化涉及手动尝试、网格搜索、随机搜索、贝叶斯优化、梯度优化、进化算法等策略
【6月更文挑战第28天】**机器学习中的超参数优化涉及手动尝试、网格搜索、随机搜索、贝叶斯优化、梯度优化、进化算法等策略。工具如scikit-optimize、Optuna助力优化,迁移学习和元学习提供起点,集成方法则通过多模型融合提升性能。资源与时间考虑至关重要,交叉验证和提前停止能有效防止过拟合。**
82 0
|
7月前
|
机器学习/深度学习 数据采集 算法
Python中基于网格搜索算法优化的深度学习模型分析糖尿病数据
Python中基于网格搜索算法优化的深度学习模型分析糖尿病数据
|
7月前
|
机器学习/深度学习 算法 C++
【算法 | 实验6-1】n*n的网格,从左上角开始到右下角结束遍历所有的方块仅一次,总共有多少种不同的遍历路径
前言 思路介绍中省略了关于如何进行回溯搜索的细节,而主要讨论回溯中所使用的剪枝策略。
159 0
|
算法
网格算法和穷举法
网格算法和穷举法
159 0
|
机器学习/深度学习 算法 Python
【数学建模】机器学习预测算法(KNN、随机森林、网格搜索对决策树、支持向量机)(Python代码实现)【2021华为杯】
【数学建模】机器学习预测算法(KNN、随机森林、网格搜索对决策树、支持向量机)(Python代码实现)【2021华为杯】
328 0
|
机器学习/深度学习 算法
【MATLAB第42期】基于MATLAB的贝叶斯优化决策树分类算法与网格搜索、随机搜索对比,含对机器学习模型的评估度量介绍
【MATLAB第42期】基于MATLAB的贝叶斯优化决策树分类算法与网格搜索、随机搜索对比,含对机器学习模型的评估度量介绍