Contains predefined ways to initialize a graph. More...
Functions | |
template<typename Graph , class Model > | |
bool | hex_grid (size_t N, size_t M, Graph &G, Model &model, bool torus=false) |
Build a hexagonal grid with N lines and M columns. | |
template<typename Graph , class Model > | |
bool | square_grid (size_t N, size_t M, Graph &G, Model &model, bool torus=false, bool connect8=false) |
Create a square grid with N lines and M columns. |
Contains predefined ways to initialize a graph.
bool factory::hex_grid | ( | size_t | N, | |
size_t | M, | |||
Graph & | G, | |||
Model & | model, | |||
bool | torus = false | |||
) | [inline] |
Build a hexagonal grid with N lines and M columns.
N | Number of lines of the grid | |
M | Number of columns of the grid | |
G | Graph to fill in | |
model | Model containing initialisation method | |
torus | True to connect the top cells to the bottom ones and the left cells to the right ones. Requires an even number of lines. |
Definition at line 257 of file grid.h.
Referenced by complex_factory::hex_grid().
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 // First, clear the graph 00264 G.clear(); 00265 // Array of vertices by position 00266 std::vector<vertex> vertices(M*N, vertex(0)); 00267 // Create the vertices and insert them 00268 for(size_t k = 0 ; k < M*N ; ++k) 00269 { 00270 vertex v; 00271 G.insert(v); 00272 vertices[k] = v; 00273 } 00274 // Create the edges 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 // ** Connect to the right 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 // ** Connect to the left 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 // ** Connect to the top-right 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 // ** Connect to the top-left 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 // ** Connect to the bottom-left 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 // ** Connect to the bottom-right 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 }
bool factory::square_grid | ( | size_t | N, | |
size_t | M, | |||
Graph & | G, | |||
Model & | model, | |||
bool | torus = false , |
|||
bool | connect8 = false | |||
) | [inline] |
Create a square grid with N lines and M columns.
N | Number of lines | |
M | Number of columns | |
G | Graph to initialize as a grid | |
m | Model containing the initialization functions | |
torus | Connect the top cells to the bottom ones and the left cells to the right ones if true. | |
connect8 | Set to true to get a 8-connected grid, false to get a 4-connected grid. |
The model should contain this method:
void initGridVertex(size_t i, size_t j, const vertex&, Graph&)
Initialize a newly created vertex at line i and column j
The neighbors are oriented in that order: bottom -> right -> top -> left
With the bottom-left corner being the one of coordinate (0,0).
The graph is cleared at the beginning of the process
Definition at line 46 of file grid.h.
Referenced by complex_factory::square_grid().
00047 { 00048 typedef typename Graph::vertex_t vertex; 00049 typedef typename Graph::edge_t edge; 00050 // First, clear the graph 00051 G.clear(); 00052 // Array of vertices by position 00053 std::vector<vertex> vertices(M*N, vertex(0)); 00054 // Create the vertices and insert them 00055 for(size_t k = 0 ; k < M*N ; ++k) 00056 { 00057 vertex v; 00058 G.insert(v); 00059 vertices[k] = v; 00060 } 00061 // Create the edges 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 // Connect to the right 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 // Connect to the top 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 // Connect to the left 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 // Connect to the bottom 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 // ** Connect to the bottom-left 00147 if(i == 0 && j == 0) 00148 { 00149 // If in the corner 00150 if(torus) 00151 G.spliceAfter(v, vertices[bottom_right_corner], vertices[top_right_corner]); 00152 } 00153 else if(i == 0) 00154 { 00155 // If on the bottom line 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 // If on the left border 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 // ** Connect the bottom-right 00169 if(i == 0 && j == M-1) 00170 { 00171 // If in the corner 00172 if(torus) 00173 G.spliceAfter(v, vertices[top_right_corner], vertices[top_left_corner]); 00174 } 00175 else if(i == 0) 00176 { 00177 // If on the bottom line 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 // If on the right line 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 // ** Connect to the top-right 00191 if(i == N-1 && j == M-1) 00192 { 00193 // If on the corner 00194 if(torus) 00195 G.spliceAfter(v, vertices[top_left_corner], vertices[bottom_left_corner]); 00196 } 00197 else if(i == N-1) 00198 { 00199 // If on the top line 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 // If on the right line 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 // ** Connect to the top-left 00213 if(i == N-1 && j == 0) 00214 { 00215 // If on the bottom-left corner 00216 if(torus) 00217 G.spliceAfter(v, vertices[bottom_left_corner], vertices[bottom_right_corner]); 00218 } 00219 else if(i == N-1) 00220 { 00221 // If on the top line 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 // If on the left line 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 }