开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 查看源码
polyhedron.c
资源名称：leda.tar.gz　[点击查看]
上传用户：gzelex
上传日期：2007-01-07
资源大小：707k
文件大小：6k
源码类别：

数值算法/人工智能

开发平台：

MultiPlatform

polyhedron.c：源码内容
  1. #include <LEDA/graph.h>
  2. #include <LEDA/graph_alg.h>
  3. #include <LEDA/array.h>
  4. #include <LEDA/stream.h>
  5. #include <LEDA/array.h>
  6. #include <LEDA/window.h>
  7. #include <math.h>
  11. typedef GRAPH<vector,int> polyhedron;
  13. void rotate(float alpha1,float alpha2, vector& p)
  14. { 
  15.   // rotate 3d-point p about the origin
  16.   // by alpha2 in yz-plane and alpha1 in xy-plane
  18.     double R  = hypot(p[1],p[2]);
  19.     double phi = asin(p[1]/R);
  20.   
  21.     if (p[2] < 0) phi = LEDA_PI - phi;
  22.   
  23.     p[1]  = ((R != 0) ? R*sin(phi+alpha2) : 0);
  24.     p[2]  = ((R != 0) ? R*cos(phi+alpha2) : 0);
  26.     R   = hypot(p[0],p[2]);
  27.     phi = asin(p[0]/R);
  29.     if (p[2] < 0) phi = LEDA_PI - phi;
  30.   
  31.     p[0]  = ((R != 0) ? R*sin(phi+alpha1) : 0);
  32.     p[2]  = ((R != 0) ? R*cos(phi+alpha1) : 0);
  33. }
  36. point project(vector p)   // project p into xy-plane
  37. {
  38.   return point(p[0],p[1]); 
  39.  }
  43. void draw_poly(window& W, polyhedron& poly, vector& trans)
  44. { node v,w;
  45.   node_array<bool> marked(poly,false);
  46.   forall_nodes(v,poly) 
  47.   { forall_adj_nodes(w,v)
  48.       if (!marked[w])
  49.       { point a = project(poly[v]+trans);
  50.         point b = project(poly[w]+trans);
  51.         W.draw_segment(a,b,blue);
  52.        }
  53.     marked[v] = true;
  54.    }
  55.  }
  57. /*
  58. void draw_poly(window& W, polyhedron& poly, vector& trans)
  59. { edge e;
  60.   forall_edges(e,poly) 
  61.   { point a = project(poly[source(e)]+trans);
  62.     point b = project(poly[target(e)]+trans);
  63.     W.draw_segment(a,b,blue);
  64.    }
  65.  }
  66. */
  69. void make_poly(polyhedron& poly, int N)
  70. { 
  71.   
  72.     node* L = new node[N];
  73.     node* R = new node[N];
  74.   
  75.     float d = 2*LEDA_PI/N;
  77.     node v;
  79.     poly.clear();
  80.   
  81.     int i;
  82.     for(i=0; i<N; i++)
  83.     { point origin(0,0);
  84.       point p = origin.translate(i*d,100);
  85.       L[i] = poly.new_node(vector(p.xcoord(),p.ycoord(), 120));
  86.       R[i] = poly.new_node(vector(p.xcoord(),p.ycoord(),-120));
  87.      }
  89.     node v0 = poly.new_node(vector(0,0,-30));
  90.   
  91.     for(i=1; i<N; i++)
  92.     { poly.new_edge(L[i],L[i-1]);
  93.       poly.new_edge(L[i-1],L[i]);
  94.       poly.new_edge(R[i],R[i-1]);
  95.       poly.new_edge(R[i-1],R[i]);
  96.       poly.new_edge(L[i],R[i]);
  97.       poly.new_edge(R[i],L[i]);
  98.       poly.new_edge(v0,R[i]);
  99.       poly.new_edge(R[i],v0);
  100.      }
  101.   
  102.     poly.new_edge(L[0],L[N-1]);
  103.     poly.new_edge(L[N-1],L[0]);
  104.     poly.new_edge(R[0],R[N-1]);
  105.     poly.new_edge(R[N-1],R[0]);
  106.     poly.new_edge(L[0],R[0]);
  107.     poly.new_edge(R[0],L[0]);
  108.     poly.new_edge(v0,R[0]);
  109.     poly.new_edge(R[0],v0);
  111.     if (!PLANAR(poly,true)) error_handler(1,"graph not planar !");
  113.     // compute an interior point M and move the origin to this point
  114.   
  115.     vector M(3);
  116.   
  117.     forall_nodes(v,poly)
  118.     {  M[0] += poly[v][0];
  119.        M[1] += poly[v][1];
  120.        M[2] += poly[v][2];
  121.      }
  122.   
  123.   
  124.     M[0] /= poly.number_of_nodes();
  125.     M[1] /= poly.number_of_nodes();
  126.     M[2] /= poly.number_of_nodes();
  127.   
  128.   
  129.     forall_nodes(v,poly)
  130.     { poly[v][0] -= M[0];
  131.       poly[v][1] -= M[1];
  132.       poly[v][2] -= M[2];
  133.      }
  134.   
  135. }
  139. void make_sphere(GRAPH<vector,int>& G, int n)
  140. {
  141.   int m = 2*n;
  143.   array<node>  V(m);
  145.   node north = G.new_node(vector(0,0, 1));
  147.   int i;
  148.   int j;
  149.   double phi1 = 0;
  150.   double phi2 = 0;
  151.   double d1 = LEDA_PI/n;
  152.   double d2 = LEDA_PI/n;
  154.   for(i=0; i<m; i++) V[i] = north;
  156.   for(phi1=d1, j=1; j<n; phi1+=d1, j++)
  157.   { double z = cos(phi1);
  158.     double r = sin(phi1);
  160.     for(phi2=0, i=0; i<m; phi2+=d2, i++)
  161.     {
  162.       double x = r*cos(phi2);
  163.       double y = r*sin(phi2);
  165.       node v = G.new_node(vector(x,y,z));
  167.       if(i==0) 
  168.       { G.new_edge(v,V[i]);
  169.         G.new_edge(V[i],v);
  170.         if (j > 1)  
  171.         { G.new_edge(V[0],V[m-1]);
  172.           G.new_edge(V[m-1],V[0]);
  173.          }
  174.        }
  175.       else
  176.        { G.new_edge(v,V[i-1]);
  177.          G.new_edge(V[i-1],v);
  178.          G.new_edge(v,V[i]);
  179.          G.new_edge(V[i],v);
  180.         }
  181.       V[i] = v;
  182.      }
  184.    }
  186.   node south = G.new_node(vector(0,0,-1));
  188.   G.new_edge(V[m-1],V[0]);
  189.   G.new_edge(V[0],V[m-1]);
  191.   for (i=0;i<m;i++) 
  192.   { G.new_edge(south,V[i]);
  193.     G.new_edge(V[i],south);
  194.    }
  197.   node v;
  199.   forall_nodes(v,G) G[v] = G[v]*100;
  201.   if (!PLANAR(G,true)) error_handler(1," G not planar !");
  203. }
  209. void read_poly(polyhedron& poly, string fname)
  210. {
  211.   poly.clear();
  213.   file_istream IN(fname);
  215.   int N;
  216.   int i;
  218.   IN >> N;
  221.   array<node> V(N);
  223.   vector v(3);
  225.   for(i = 0; i<N; i++) 
  226.   { IN >> v;
  227.     V[i] = poly.new_node(v);
  228.    }
  230. /*
  231.   for(i = 0; i<N; i++) 
  232.   { int d;
  233.     IN >> d;
  234.     while(d--)
  235.     { IN >> j;
  236.       poly.new_edge(V[i], V[j])
  237.      }
  238.    }
  239. */
  241.   for(i = 0; i<N; i++) 
  242.   { int u,v,w;
  243.     IN >> u >> v >> w;
  244.     poly.new_edge(V[u], V[v]);
  245.     poly.new_edge(V[v], V[w]);
  246.     poly.new_edge(V[w], V[u]);
  247.   }
  249. }
  254. main()
  255. { 
  256.   window W(700,700);
  258.   W.init(-250,250,-250);
  259.   W.set_node_width(4);
  260.   W.set_mode(xor_mode);
  262.   node v;
  264.   int     N = 5;
  265.   int speed = 40;
  266.   bool  ran = false;
  268.  panel P("Rotate Polyhedron");
  270.  P.text_item("");
  271.  P.text_item("This program creates and rotates a 3-dimensional polyhedron.");
  272.  P.text_item("Direction and duration of the rotation is controled by the");
  273.  P.text_item("left mouse button.");
  274.  P.text_item("");
  275.  P.bool_item("random",ran);
  276.  P.int_item("speed",speed,1,80);
  277.  P.int_item("# vertices",N,3,32);
  281.  for(;;)
  282.  {
  283.     P.open(W);
  285.     W.clear();
  287.     // define a polyhedron in 3d space
  288.   
  289.     polyhedron poly;
  291.     //make_poly(poly,N);
  292.     make_sphere(poly,N);
  293.   
  294.   
  295.   
  296.     forall_nodes(v,poly) rotate(1.5,0.7,poly[v]);
  298.     W.draw_point(0,0);
  299.   
  300.   
  301.     polyhedron poly0 = poly;
  303.     vector dir(2);   // direction and duration of rotation
  304.     //vector trans(50,50,50);  // translation
  305.     vector trans(0,0,0);  // translation
  306.     int steps;
  308.     draw_poly(W,poly,trans);
  309.   
  310.     for(;;)
  311.     {
  312.       if (ran)
  313.       { dir[0] += rand_int(-10000,10000)/(5000000.0);
  314.         dir[1] += rand_int(-10000,10000)/(5000000.0);
  315.         dir = dir.norm()*(speed/500.0);
  316.         steps = 1;
  317.         if (W.get_button() != 0) break;
  318.        }
  319.       else
  320.       { int but = W.read_mouse(dir[0],dir[1]);
  321.         steps = int(dir.length()*W.scale())/8;
  322.         if (but == 3) break;
  323.         dir = dir.norm()*(speed/500.0);
  324.        }
  326.   
  328.       while (steps--)
  329.       {  
  330.         forall_nodes(v,poly) rotate(dir[0],dir[1],poly[v]);
  331.    
  332.         draw_poly(W,poly,trans);   // draw new position
  333.         draw_poly(W,poly0,trans);  // erase old position  (xor_mode !!)
  334.   
  335.         // poly0 = poly;
  336.   
  337.         node w = poly.first_node();
  338.         forall_nodes(v,poly0) 
  339.         { poly0[v] = poly[w];
  340.           w = poly.succ_node(w);
  341.          }
  342.       }
  343.     }
  345.   }
  347.  return 0;
  348. }