00001 #ifndef VVELIB_FACTORY_GRID_H
00002 #define VVELIB_FACTORY_GRID_H
00003
00009 #include <config.h>
00010 #include <list>
00011
00015 namespace factory
00016 {
00045 template <typename Graph, class Model>
00046 bool square_grid(size_t N, size_t M, Graph& G, Model& model, bool torus = false, bool connect8 = false)
00047 {
00048 typedef typename Graph::vertex_t vertex;
00049 typedef typename Graph::edge_t edge;
00050
00051 G.clear();
00052
00053 std::vector<vertex> vertices(M*N, vertex(0));
00054
00055 for(size_t k = 0 ; k < M*N ; ++k)
00056 {
00057 vertex v;
00058 G.insert(v);
00059 vertices[k] = v;
00060 }
00061
00062 size_t k = 0;
00063 const size_t delta_border_i = M*(N-1);
00064 const size_t delta_border_j = M-1;
00065 const size_t delta_i = M;
00066 const size_t delta_j = 1;
00067 for(size_t i = 0 ; i < N ; ++i)
00068 for(size_t j = 0 ; j < M ; ++j, ++k)
00069 {
00070 vertex v = vertices[k];
00071
00072 if(j == M-1)
00073 {
00074 if(torus)
00075 G.insertEdge(v, vertices[k-delta_border_j]);
00076 }
00077 else
00078 G.insertEdge(v, vertices[k+delta_j]);
00079
00080 if(i == N-1)
00081 {
00082 if(torus)
00083 G.insertEdge(v, vertices[k-delta_border_i]);
00084 }
00085 else
00086 G.insertEdge(v, vertices[k+delta_i]);
00087
00088 if(j == 0)
00089 {
00090 if(torus)
00091 {
00092 if(i==N-1)
00093 G.spliceAfter(v, vertices[k-delta_border_i], vertices[k+delta_border_j]);
00094 else
00095 G.spliceAfter(v, vertices[k+delta_i], vertices[k+delta_border_j]);
00096 }
00097 }
00098 else
00099 {
00100 if(i==N-1)
00101 {
00102 if(j == M-1)
00103 G.insertEdge(v, vertices[k-delta_j]);
00104 else
00105 G.spliceAfter(v, vertices[k+delta_j], vertices[k-delta_j]);
00106 }
00107 else
00108 G.spliceAfter(v, vertices[k+delta_i], vertices[k-delta_j]);
00109 }
00110
00111 if(i == 0)
00112 {
00113 if(torus)
00114 {
00115 if(j==0)
00116 G.spliceAfter(v, vertices[k+delta_border_j], vertices[k+delta_border_i]);
00117 else
00118 G.spliceAfter(v, vertices[k-delta_j], vertices[k+delta_border_i]);
00119 }
00120 }
00121 else
00122 {
00123 if(j==0)
00124 G.spliceBefore(v, vertices[k+delta_j], vertices[k-delta_i]);
00125 else
00126 G.spliceAfter(v, vertices[k-delta_j], vertices[k-delta_i]);
00127 }
00128 }
00129 if(connect8)
00130 {
00131 const size_t delta_ij = M+1;
00132 const size_t delta_mij = M-1;
00133 const size_t bottom_left_corner = 0;
00134 const size_t bottom_right_corner = M-1;
00135 const size_t top_left_corner = M*(N-1);
00136 const size_t top_right_corner = M*N-1;
00137 const size_t delta_border_bottom_ij = M*(N-1)-1;
00138 const size_t delta_border_right_ij = 1;
00139 const size_t delta_border_bottom_mij = M*(N-1)+1;
00140 const size_t delta_border_left_mij = 2*M-1;
00141 k = 0;
00142 for(size_t i = 0 ; i < N ; ++i)
00143 for(size_t j = 0 ; j < M ; ++j, ++k)
00144 {
00145 vertex v = vertices[k];
00146
00147 if(i == 0 && j == 0)
00148 {
00149
00150 if(torus)
00151 G.spliceAfter(v, vertices[bottom_right_corner], vertices[top_right_corner]);
00152 }
00153 else if(i == 0)
00154 {
00155
00156 if(torus)
00157 G.spliceAfter(v, vertices[k-delta_j], vertices[k+delta_border_bottom_ij]);
00158 }
00159 else if(j == 0)
00160 {
00161
00162 if(torus)
00163 G.spliceBefore(v, vertices[k-delta_i], vertices[k-delta_border_right_ij]);
00164 }
00165 else
00166 G.spliceAfter(v, vertices[k-delta_j], vertices[k-delta_ij]);
00167
00168
00169 if(i == 0 && j == M-1)
00170 {
00171
00172 if(torus)
00173 G.spliceAfter(v, vertices[top_right_corner], vertices[top_left_corner]);
00174 }
00175 else if(i == 0)
00176 {
00177
00178 if(torus)
00179 G.spliceBefore(v, vertices[k+delta_j], vertices[k+delta_border_bottom_mij]);
00180 }
00181 else if(j == M-1)
00182 {
00183
00184 if(torus)
00185 G.spliceAfter(v, vertices[k-delta_i], vertices[k-delta_border_left_mij]);
00186 }
00187 else
00188 G.spliceAfter(v, vertices[k-delta_i], vertices[k-delta_mij]);
00189
00190
00191 if(i == N-1 && j == M-1)
00192 {
00193
00194 if(torus)
00195 G.spliceAfter(v, vertices[top_left_corner], vertices[bottom_left_corner]);
00196 }
00197 else if(i == N-1)
00198 {
00199
00200 if(torus)
00201 G.spliceAfter(v, vertices[k+delta_j], vertices[k-delta_border_bottom_ij]);
00202 }
00203 else if(j == M-1)
00204 {
00205
00206 if(torus)
00207 G.spliceBefore(v, vertices[k+delta_i], vertices[k+delta_border_right_ij]);
00208 }
00209 else
00210 G.spliceAfter(v, vertices[k+delta_j], vertices[k+delta_ij]);
00211
00212
00213 if(i == N-1 && j == 0)
00214 {
00215
00216 if(torus)
00217 G.spliceAfter(v, vertices[bottom_left_corner], vertices[bottom_right_corner]);
00218 }
00219 else if(i == N-1)
00220 {
00221
00222 if(torus)
00223 G.spliceBefore(v, vertices[k-delta_j], vertices[k-delta_border_bottom_mij]);
00224 }
00225 else if(j == 0)
00226 {
00227
00228 if(torus)
00229 G.spliceAfter(v, vertices[k+delta_i], vertices[k+delta_border_left_mij]);
00230 }
00231 else
00232 G.spliceBefore(v, vertices[k-delta_j], vertices[k+delta_mij]);
00233 }
00234 }
00235 k = 0;
00236 for(size_t i = 0 ; i < N ; ++i)
00237 for(size_t j = 0 ; j < M ; ++j, ++k)
00238 {
00239 model.initGridVertex(i, j, vertices[k], G);
00240 }
00241 return true;
00242 }
00243
00256 template <typename Graph, class Model>
00257 bool hex_grid(size_t N, size_t M, Graph& G, Model& model, bool torus = false)
00258 {
00259 if(torus and N%2)
00260 return false;
00261 typedef typename Graph::vertex_t vertex;
00262 typedef typename Graph::edge_t edge;
00263
00264 G.clear();
00265
00266 std::vector<vertex> vertices(M*N, vertex(0));
00267
00268 for(size_t k = 0 ; k < M*N ; ++k)
00269 {
00270 vertex v;
00271 G.insert(v);
00272 vertices[k] = v;
00273 }
00274
00275 size_t k = 0;
00276 const size_t delta_right = 1;
00277 const size_t delta_top_right_even = M;
00278 const size_t delta_top_right_odd = M+1;
00279 const size_t delta_top_left_even = M-1;
00280 const size_t delta_top_left_odd = M;
00281 const size_t delta_bottom_border_bottom_right = M*(N-1);
00282 const size_t delta_bottom_border_bottom_left = M*(N-1)-1;
00283 const size_t delta_right_border_top_right = 1;
00284 const size_t delta_left_border_left = M-1;
00285 const size_t delta_left_border_top_left = 2*M-1;
00286 const size_t top_right_corner = M*N-1;
00287 const size_t bottom_left_corner = 0;
00288 for(size_t i = 0 ; i < N ; ++i)
00289 for(size_t j = 0 ; j < M ; ++j, ++k)
00290 {
00291 vertex v = vertices[k];
00292
00293 if(j == M-1)
00294 {
00295 if(torus)
00296 G.insertEdge(v, vertices[k-delta_left_border_left]);
00297 }
00298 else
00299 G.insertEdge(v, vertices[k+delta_right]);
00300
00301 if(j==0)
00302 {
00303 if(torus)
00304 G.insertEdge(v, vertices[k+delta_left_border_left]);
00305 }
00306 else
00307 G.insertEdge(v, vertices[k-delta_right]);
00308
00309 if(k == top_right_corner)
00310 {
00311 if(torus)
00312 G.spliceAfter(v, vertices[k-delta_left_border_left], vertices[bottom_left_corner]);
00313 }
00314 else if(i == N-1)
00315 {
00316 if(torus)
00317 G.spliceAfter(v, vertices[k+delta_right], vertices[k-delta_bottom_border_bottom_left]);
00318 }
00319 else if(i%2)
00320 {
00321 if(j == M-1)
00322 {
00323 if(torus)
00324 G.spliceAfter(v, vertices[k-delta_left_border_left], vertices[k+delta_right_border_top_right]);
00325 }
00326 else
00327 G.spliceAfter(v, vertices[k+delta_right], vertices[k+delta_top_right_odd]);
00328 }
00329 else if(j == M-1)
00330 G.spliceBefore(v, vertices[k-delta_right], vertices[k+delta_top_right_even]);
00331 else
00332 G.spliceAfter(v, vertices[k+delta_right], vertices[k+delta_top_right_even]);
00333
00334 if(k == top_right_corner)
00335 {
00336 if(torus)
00337 G.spliceAfter(v, vertices[bottom_left_corner], vertices[k-delta_bottom_border_bottom_right]);
00338 }
00339 else if(i == N-1)
00340 {
00341 if(torus)
00342 G.spliceBefore(v, vertices[k-delta_right], vertices[k-delta_bottom_border_bottom_right]);
00343 }
00344 else if(i%2)
00345 {
00346 if(j == 0)
00347 G.spliceAfter(v, vertices[k+delta_top_right_odd], vertices[k+delta_top_left_odd]);
00348 else
00349 G.spliceBefore(v, vertices[k-delta_right], vertices[k+delta_top_left_odd]);
00350 }
00351 else
00352 {
00353 if(j == 0)
00354 {
00355 if(torus)
00356 G.spliceAfter(v, vertices[k+delta_top_right_even], vertices[k+delta_left_border_top_left]);
00357 }
00358 else
00359 G.spliceBefore(v, vertices[k-delta_right], vertices[k+delta_top_left_even]);
00360 }
00361
00362 if(k == bottom_left_corner)
00363 {
00364 if(torus)
00365 G.spliceBefore(v, vertices[k+delta_right], vertices[top_right_corner]);
00366 }
00367 else if(i == 0)
00368 {
00369 if(torus)
00370 G.spliceAfter(v, vertices[k-delta_right], vertices[k+delta_bottom_border_bottom_left]);
00371 }
00372 else if(i%2)
00373 {
00374 if(j==0)
00375 G.spliceBefore(v, vertices[k+delta_right], vertices[k-delta_top_right_even]);
00376 else
00377 G.spliceAfter(v, vertices[k-delta_right], vertices[k-delta_top_right_even]);
00378 }
00379 else if(j == 0)
00380 {
00381 if(torus)
00382 G.spliceBefore(v, vertices[k+delta_right], vertices[k-delta_right_border_top_right]);
00383 }
00384 else
00385 G.spliceAfter(v, vertices[k-delta_right], vertices[k-delta_top_right_odd]);
00386
00387 if(k == bottom_left_corner)
00388 {
00389 if(torus)
00390 G.spliceAfter(v, vertices[top_right_corner], vertices[k+delta_bottom_border_bottom_right]);
00391 }
00392 else if(i == 0)
00393 {
00394 if(torus)
00395 G.spliceAfter(v, vertices[k+delta_bottom_border_bottom_left], vertices[k+delta_bottom_border_bottom_right]);
00396 }
00397 else if(i%2)
00398 {
00399 if(j==M-1)
00400 {
00401 if(torus)
00402 G.spliceBefore(v, vertices[k-delta_left_border_left], vertices[k-delta_left_border_top_left]);
00403 }
00404 else
00405 G.spliceBefore(v, vertices[k+delta_right], vertices[k-delta_top_left_even]);
00406 }
00407 else if(j == M-1)
00408 G.spliceAfter(v, vertices[k-delta_top_right_odd], vertices[k-delta_top_left_odd]);
00409 else
00410 G.spliceBefore(v, vertices[k+delta_right], vertices[k-delta_top_left_odd]);
00411 }
00412 k = 0;
00413 for(size_t i = 0 ; i < N ; ++i)
00414 for(size_t j = 0 ; j < M ; ++j, ++k)
00415 {
00416 model.initGridVertex(i, j, vertices[k], G);
00417 }
00418 return true;
00419 }
00420 }
00421
00422 #endif // VVELIB_FACTORY_GRID_H