Hitmap 1.3
 All Data Structures Namespaces Files Functions Variables Typedefs Friends Macros Groups Pages
hit_cshape.c
Go to the documentation of this file.
1 
10 /*
11  * <license>
12  *
13  * Hitmap v1.2
14  *
15  * This software is provided to enhance knowledge and encourage progress in the scientific
16  * community. It should be used only for research and educational purposes. Any reproduction
17  * or use for commercial purpose, public redistribution, in source or binary forms, with or
18  * without modifications, is NOT ALLOWED without the previous authorization of the copyright
19  * holder. The origin of this software must not be misrepresented; you must not claim that you
20  * wrote the original software. If you use this software for any purpose (e.g. publication),
21  * a reference to the software package and the authors must be included.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS IS" AND ANY
24  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
25  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
26  * THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
27  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  *
33  * Copyright (c) 2007-2015, Trasgo Group, Universidad de Valladolid.
34  * All rights reserved.
35  *
36  * More information on http://trasgo.infor.uva.es/
37  *
38  * </license>
39 */
40 
41 #include <limits.h>
42 #include <hit_allocP.h>
43 #include <hit_cshape.h>
44 #include <hit_funcop.h>
45 
46 
47 HitShape hit_csrShape(int nvertices, int nedges){
48 
50 
51  // Number of vertices.
52  hit_cShapeNvertices(s) = nvertices;
53 
54  // Allocate the arrays.
55  hit_malloc(hit_cShapeXadj(s), idxtype, nvertices+1 );
56  hit_malloc(hit_cShapeAdjncy(s), idxtype, nedges );
57  // @arturo Ago 2015: New allocP interface
58  /*
59  hit_malloc(hit_cShapeXadj(s),(size_t) (nvertices+1)*sizeof(idxtype),idxtype*);
60  hit_malloc(hit_cShapeAdjncy(s),(size_t) nedges*sizeof(idxtype),idxtype*);
61  */
62 
63  hit_nameListCreate(&hit_cShapeNameList(s,0),nvertices);
65 
66  // Return the shape
67  return s;
68 }
69 
70 
71 
72 HitShape hit_csrShapeMatrix(int n, int m, int nz){
73 
75 
76  // Cardinalities.
77  hit_cShapeCard(s,0) = n;
78  hit_cShapeCard(s,1) = m;
79 
80  // Allocate the arrays.
82  if(nz != 0) hit_malloc(hit_cShapeAdjncy(s), idxtype, nz );
83  // @arturo Ago 2015: New allocP interface
84  /*
85  hit_malloc(hit_cShapeXadj(s),(size_t) (n+1)*sizeof(idxtype),idxtype*);
86  if(nz != 0) hit_malloc(hit_cShapeAdjncy(s),(size_t) nz*sizeof(idxtype),idxtype*);
87  */
88 
91 
92  // Return the shape
93  return s;
94 }
95 
96 
97 
98 
100 
101  hit_free(hit_cShapeXadj(shape));
102  hit_free(hit_cShapeAdjncy(shape));
104  if(hit_cShapeNameList(shape,0).names != hit_cShapeNameList(shape,1).names)
106 }
107 
108 
109 HitShape hit_cShapeSelect(HitShape s, int nvertices, int * vertices){
110 
111  // We have to select one vertex at least.
112  if(nvertices < 1) return HIT_SHAPE_NULL;
113 
114  // 1. If vertices is NULL we use the name vector (a.k.a. n first vertices)
115  if(vertices == NULL){
116  vertices = hit_cShapeNameList(s,0).names;
117  }
118 
119  // 2. Create a new graph with edge array as big as the original.
120  HitShape res = hit_csrShape(nvertices, hit_cShapeNedges(s));
121 
122  // 3. Duplicate vertices array as globalNames.
123  memcpy(hit_cShapeNameList(res,0).names, vertices, sizeof(int) * (size_t) nvertices );
124  hit_cShapeNameList(res,0).nNames = nvertices;
125  hit_cShapeNameList(res,0).flagNames = HIT_SHAPE_NAMES_NOARRAY;
126  hit_cShapeNameList(res,1) = hit_cShapeNameList(res,0);
127 
128  // 4. Construct the inverse translation list
129  int vertex_min = INT_MAX;
130  int vertex_max = 0;
131 
132  // 4.1. Get the maximum and minimum values
133  int i;
134  for(i=0;i<nvertices;i++){
135  vertex_min = hit_min(vertex_min,vertices[i]);
136  vertex_max = hit_max(vertex_max,vertices[i]);
137  }
138 
139  int * inv_list_p;
140  hit_malloc(inv_list_p, int, vertex_max-vertex_min+1 );
141  // @arturo Ago 2015: New allocP interface
142  // hit_malloc(inv_list_p,sizeof(int) * (size_t)(vertex_max-vertex_min+1),int*);
143  int * inv_list = inv_list_p - vertex_min;
144 
145  // Init list elements to -1
146  for(i=vertex_min+1;i<vertex_max;i++){
147  inv_list[i] = -1;
148  }
149 
150  for(i=0;i<nvertices;i++){
151  inv_list[vertices[i]] = i;
152  }
153 
154  // 5. Construct the new sparse shape
155  int nedges = 0;
156  hit_cShapeXadj(res)[0] = 0;
157 
158 
159  // 5.1 Traverse all the new vertices
160  int j;
161  for(i=0;i<nvertices;i++){
162 
163  hit_cShapeXadj(res)[i+1] = hit_cShapeXadj(res)[i];
164 
165  int vertex = hit_cShapeVertexToLocal(s,vertices[i]);
166  int actedges = hit_cShapeNEdgesFromVertex(s,vertex);
167 
168  // 5.2 For each edge, check if we have to add it.
169  for(j=0;j<actedges;j++){
170 
171  int dst = hit_cShapeAdjncy(s)[ hit_cShapeXadj(s)[vertex] + j ];
172  int globaldst = hit_cShapeCoordToGlobal(s,0,dst);
173 
174  // 4.2.1 Search the vertices in our list.
175  if(globaldst < vertex_min || globaldst > vertex_max) continue;
176 
177  int new_dst = inv_list[globaldst];
178 
179  if(new_dst == -1) continue;
180 
181  hit_cShapeAdjncy(res)[nedges] = new_dst;
182  nedges ++;
183  hit_cShapeXadj(res)[i+1] ++;
184 
185  }
186  }
187 
188  // 6. Reduce the edge list to the exact size
189  if(nedges == 0){
191  hit_cShapeAdjncy(res) = NULL;
192  } else {
193  // @arturo Ago 2015: New allocP interface
194  // hit_realloc(hit_cShapeAdjncy(res),(size_t) nedges*sizeof(idxtype),idxtype*);
195  hit_realloc(hit_cShapeAdjncy(res), idxtype, nedges );
196  }
197 
198  // 7. Free resources
199  free(inv_list_p);
200 
201  // 8. Return
202  return res;
203 
204 }
205 
206 
207 
209 
210  //@javfres 2015-10-05 Fix for expanding null shapes
211  // 0. Check the shape has vertices
212  int nvertices = hit_cShapeNvertices(shape);
213  if(nvertices == 0){
215  return res;
216  }
217 
218  // 1. Create a vertex list
219  int orig_nvertices = hit_cShapeNvertices(original);
220  int * vertices;
221  // @arturo Ago 2015: New allocP interface
222  // hit_calloc(vertices, (size_t)orig_nvertices, sizeof(int),int*);
223  hit_calloc(vertices, int, orig_nvertices );
224 
225 #define VLOCAL 1 // (....0001)
226 #define VEXPAND 2 // (....0010)
227 
228  // 2. Set the local vertices in the vector.
229  int vertex;
230  for(vertex=0; vertex<nvertices; vertex++){
231 
232  int global_vertex = hit_cShapeVertexToGlobal(shape,vertex);
233  int local_orig_vertex = hit_cShapeVertexToLocal(original,global_vertex);
234 
235  vertices[local_orig_vertex] = VLOCAL;
236  }
237 
238  // 3. Expand the list.
239  int new_vertices = 0;
240  int a;
241  for(a=0; a<amount; a++){
242 
243  // Complete the local vertices and the number of vertices.
244  for(vertex=0; vertex<orig_nvertices; vertex++){
245 
246  // Get first and last links.
247  int first = hit_cShapeXadj(original)[vertex];
248  int last = hit_cShapeXadj(original)[vertex+1];
249  int nlink;
250 
251 
252  for(nlink=first; nlink<last; nlink++){
253 
254  //Get the neighbor.
255  int neighbor = hit_cShapeAdjncy(original)[nlink];
256 
257  // TO
258  if((vertices[vertex] & VLOCAL) && (! vertices[neighbor] & VLOCAL)){
259  vertices[neighbor] = VEXPAND;
260  new_vertices++;
261  }
262 
263  // @javfres @todo The hit_cShapeExpand function expand the shape
264  // following the edges from source to target. I call this TO direction.
265  // It can be interesting to add a FROM option, or maybe several functions
266  // with TO/FROM/TOFROM.
267  }
268 
269  }
270 
271  // Set the expanded vertices as local for the next loop.
272  if(a<amount-1){
273  for(vertex=0; vertex<orig_nvertices; vertex++){
274  if(vertices[vertex] == VEXPAND) vertices[vertex] |= VLOCAL;
275  }
276  }
277 
278  }
279 
280 
281  // 3. Create selection list
282  int * vlist;
283  int nvlist = new_vertices + nvertices;
284  // @arturo Ago 2015: New allocP interface
285  // hit_malloc(vlist,sizeof(int) * (size_t) nvlist,int*);
286  hit_malloc(vlist, int, nvlist );
287 
288  // 4. The first vertices of the old and new shape are the same.
289  memcpy(vlist,hit_cShapeNameList(shape,0).names, sizeof(int) * (size_t) nvertices);
290 
291  // 5. Complete the selection list.
292  int vertex_index = nvertices;
293  for(vertex=0; vertex<orig_nvertices; vertex++){
294 
295  if(vertices[vertex] > VLOCAL){
296  vlist[vertex_index] = hit_cShapeVertexToGlobal(original,vertex);
297  vertex_index++;
298  }
299  }
300 
301  // 6. Select
302  HitShape res = hit_cShapeSelect(original,nvlist,vlist);
303 
304  // 7. Free resources.
305  hit_free(vertices);
306  hit_free(vlist);
307 
308 #undef VLOCAL
309 #undef VEXPAND
310 
311  return res;
312 
313 }
314 
315 
316 
317 
319 
320  // 1. Check the shape type.
321  if(hit_shapeType(*shape) != HIT_CSR_SHAPE){
322  hit_errInternal(__func__, "Incorrect shape Type.", "Expected CSR Shape", __FILE__, __LINE__);
323  }
324 
326  if(hit_cShapeNameList(*shape,0).names == hit_cShapeNameList(*shape,1).names){
327  hit_cShapeNameList(*shape,1) = hit_cShapeNameList(*shape,0);
328  } else {
330  }
331 
332 }
333 
334 
335 
336 
337 
338 
339 
340 
341 
342 
343 
344 
345 
346 
347 
348 
350 
351 #define s (*shape)
352 
353  int local_x, nelems_x;
354 
355  local_x = hit_cShapeCoordToLocal(s,0,x);
356 
357  if( local_x != -1 ) return;
358  local_x = hit_cShapeCard(s, 0);
359 
360  // A. Create the sparse shape.
361  if(local_x == 0){
362 
363  nelems_x = 1;
364 
365  // Allocate memory
366  hit_cShapeCard(s, 0) = nelems_x;
367  // @arturo Ago 2015: New allocP interface
368  // hit_malloc(hit_cShapeXadj(s),(size_t) (nelems_x+1)*sizeof(idxtype),idxtype*);
369  hit_malloc(hit_cShapeXadj(s), idxtype, nelems_x+1 );
370 
371  // Set element 1
372  hit_cShapeXadj(s)[0] = 0;
373  hit_cShapeXadj(s)[1] = 0;
374 
375  // Create the name list
376  HitNameList list = HIT_NAMELIST_NULL;
377  hit_nameListAdd(&list, x);
378  hit_cShapeNameList(s,0) = list;
379 
380  if(mode == HIT_CSHAPE_GRAPH){
381  hit_cShapeNameList(s,1) = list;
382  }
383 
384  // B. The given sparse shape is not empty.
385  } else {
386 
387  nelems_x = hit_cShapeCard(s, 0) + 1;
388  hit_cShapeCard(s, 0) = nelems_x;
389  // @arturo Ago 2015: New allocP interface
390  // hit_realloc(hit_cShapeXadj(s),(size_t) (nelems_x+1)*sizeof(idxtype),idxtype*);
391  hit_realloc(hit_cShapeXadj(s), idxtype, nelems_x+1 );
392  hit_cShapeXadj(s)[local_x+1] = hit_cShapeXadj(s)[local_x];
393 
394  // Set names
396 
397  if(mode == HIT_CSHAPE_GRAPH){
399  }
400  }
401 
402 #undef s
403 
404 }
405 
406 
408 
409  if(hit_nameListName2Index(hit_cShapeNameList(*shape,1),y) == -1){
410  hit_nameListAdd(&hit_cShapeNameList(*shape,1),y);
411  hit_cShapeCard(*shape,1)++;
412  }
413 }
414 
415 
417 
418  int local_x = hit_cShapeCoordToLocal(shape,0,x);
419  int local_y = hit_cShapeCoordToLocal(shape,1,y);
420 
421  int c;
422  hit_cShapeColumnIterator(c,shape,local_x){
423  if(hit_cShapeAdjncy(shape)[c] == local_y){
424  return 1;
425  }
426  }
427  return 0;
428 }
429 
430 
431 
432 void hit_cShapeAddElem_or_Edge(HitShape * shape, int x, int y, int mode){
433 
434  // 1. Add the row or vertices
435  hit_cShapeAddEmptyRow_or_Vertex(shape, x, mode);
436  if(mode == HIT_CSHAPE_GRAPH)
437  hit_cShapeAddEmptyRow_or_Vertex(shape, y, mode);
438  else
439  hit_cShapeAddColumn(shape, y);
440 
441 #define s (*shape)
442 
443  // 2. Get the local coordinates names.
444  int local_x = hit_cShapeCoordToLocal(s,0,x);
445  int local_y = hit_cShapeCoordToLocal(s,1,y);
446 
447 
448  // 3. Checks if element exists
449  int c;
450  hit_cShapeEdgeIterator(c,s,local_x){
451  if(hit_cShapeAdjncy(s)[c] == local_y) return;
452  }
453 
454  // 4. Add the element
455  int nedges = hit_cShapeNedges(s) + 1;
456 
457  if(hit_cShapeAdjncy(s) == NULL){
458  // @arturo Ago 2015: New allocP interface
459  // hit_malloc(hit_cShapeAdjncy(s),(size_t) nedges*sizeof(idxtype),idxtype*);
460  hit_malloc(hit_cShapeAdjncy(s), idxtype, nedges );
461  }else{
462  // @arturo Ago 2015: New allocP interface
463  // hit_realloc(hit_cShapeAdjncy(s),(size_t) nedges*sizeof(idxtype),idxtype*);
465  }
466 
467  // 4.1 Create a space for the element moving the other elements right
468  int i;
469  for(i=nedges-1; i>hit_cShapeLastColumn(s,local_x); i--){
470  hit_cShapeAdjncy(s)[i] = hit_cShapeAdjncy(s)[i-1];
471  }
472 
473  // 4.2 Insert the element
474  hit_cShapeAdjncy(s)[hit_cShapeLastColumn(s,local_x)] = local_y;
475 
476  // 4.3 Update the Xadj's pointers
477  for(i=local_x;i<hit_cShapeNvertices(s);i++){
478  hit_cShapeXadj(s)[i+1] ++ ;
479  }
480 
481 #undef s
482 
483 }
484 
485 
486 
492 
493  int n = hit_cShapeCard(*shape,0);
494  int m = hit_cShapeCard(*shape,1);
495  int * used;
496  // @arturo Ago 2015: New allocP interface
497  // hit_calloc(used,(size_t)m,sizeof(int),int*);
498  hit_calloc(used, int, m );
499 
500  int i;
501 
502  // Count the number of used elements.
503  for(i=0; i<n; i++){
504  int j;
505  for(j=hit_cShapeXadj(*shape)[i]; j<hit_cShapeXadj(*shape)[i+1]; j++){
506  int idx = hit_cShapeAdjncy(*shape)[j];
507  used[idx] = 1;
508  }
509  }
510 
511  // Delete the not used elements from the name list
512  // and use the used list to create a translation list.
513  int nused = 0;
514  for(i=0; i<m; i++){
515  if(used[i]){
516  hit_cShapeNameList(*shape,1).names[nused] = hit_cShapeNameList(*shape,1).names[i];
517  used[i] = nused;
518  nused++;
519  }
520  }
521 
522  // Set the new column number and realloc the name list.
523  hit_cShapeCard(*shape,1) = nused;
524  hit_cShapeNameList(*shape,1).nNames = nused;
525  //hit_cShapeNameList(*shape,1).names = realloc(hit_cShapeNameList(*shape,1).names, (size_t) nused * sizeof(int) );
526  // @arturo Ago 2015: New allocP interface
527  // hit_realloc(hit_cShapeNameList(*shape,1).names,(size_t) nused * sizeof(int),int*);
528  hit_realloc(hit_cShapeNameList(*shape,1).names, int, nused );
529 
530  // Rename the elements.
531  for(i=0; i<hit_cShapeXadj(*shape)[n]; i++){
532  hit_cShapeAdjncy(*shape)[i] = used[hit_cShapeAdjncy(*shape)[i]];
533  }
534 
535  // Free the used list
536  free(used);
537 }
538 
539 
540 
541 
542 HitShape hit_cShapeSelectRows(HitShape shape, int nNames, int * names){
543 
544  // Select cardinalities: matrix of n x m
545  int n = nNames;
546  int m = hit_cShapeCard(shape,1);
547 
548  if(n == 0){
549  return HIT_CSR_SHAPE_NULL;
550  }
551 
552  // Create the matrix
553  HitShape res = hit_csrShapeMatrix(n,m,0);
554 
555  // Loop for copy and update the Xadj array.
556  int i;
557  int acumNCols = 0;
558  hit_cShapeXadj(res)[0] = 0;
559  for(i=0;i<n;i++){
560 
561  // Get the row and its number of cols
562  int row = hit_cShapeCoordToLocal(shape,0,names[i]);
563  int nCols = hit_cShapeNColsRow(shape, row);
564  acumNCols += nCols;
565 
566  // Add size for this new row
567  // @arturo Ago 2015: New allocP interface
568  // hit_realloc(hit_cShapeAdjncy(res),(size_t) acumNCols*sizeof(idxtype),idxtype*);
569  hit_realloc(hit_cShapeAdjncy(res), idxtype, acumNCols );
570 
571  // Copy the values of the column indexes
572  void * dst = &(hit_cShapeAdjncy(res)[hit_cShapeFistColumn(res,i)]);
573  void * src = &(hit_cShapeAdjncy(shape)[hit_cShapeFistColumn(shape,row)]);
574  memcpy(dst,src, (size_t) nCols *sizeof(idxtype));
575 
576  // Update the Xadj array
577  hit_cShapeXadj(res)[i+1] = acumNCols;
578 
579  }
580 
581  // Create the name lists
582  memcpy(hit_cShapeNameList(res,0).names, names, (size_t) n *sizeof(idxtype) );
583  hit_cShapeNameList(res,0).flagNames = HIT_SHAPE_NAMES_NOARRAY;
585 
586  //hit_cShapeNameList(res,1) = hit_cShapeNameList(shape,1);
588 
589  // Compress the columns removing the not used columns
591 
592  return res;
593 
594 }
595 
596 
597 
598 
599 
600 
601 
void hit_nameListCreateInvNames(HitNameList *list)
Definition: hit_shape.c:361
#define hit_cShapeAdjncy(shape)
#define hit_free(ptr)
Definition: hit_allocP.h:152
#define hit_cShapeNEdgesFromVertex(s, vertex)
#define hit_cShapeCoordToLocal(s, dim, elem)
Definition: hit_cshape.h:263
#define hit_cShapeColumnIterator(var, shape, row)
Definition: hit_cshape.h:403
void hit_nameListClone(HitNameList *dst, HitNameList *src)
Definition: hit_shape.c:318
#define hit_cShapeNedges(shape)
void hit_nameListAdd(HitNameList *list, int x)
Definition: hit_shape.c:337
int hit_nameListName2Index(HitNameList list, int name)
Definition: hit_shape.c:262
#define HIT_CSHAPE_GRAPH
Definition: hit_cshape.h:50
HitShape hit_csrShapeMatrix(int n, int m, int nz)
Definition: hit_cshape.c:72
#define y(a, b, c)
#define hit_cShapeNColsRow(s, row)
Definition: hit_cshape.h:210
#define hit_cShapeLastColumn(s, row)
void hit_cShapeCreateInvNames(HitShape *shape)
Definition: hit_cshape.c:318
#define hit_calloc(ptr, type, nmemb)
Definition: hit_allocP.h:114
HitShape hit_csrShape(int nvertices, int nedges)
Definition: hit_cshape.c:47
#define hit_cShapeEdgeIterator(var, shape, vertex)
Definition: hit_cshape.h:416
void hit_nameListFree(HitNameList list)
Definition: hit_shape.c:291
#define hit_cShapeCard(shape, dim)
Definition: hit_cshape.h:108
void hit_cShapeAddColumn(HitShape *shape, int y)
Definition: hit_cshape.c:407
void hit_cShapeSelectRows_compress_columns(HitShape *shape)
Definition: hit_cshape.c:491
int idxtype
Definition: struct.h:19
void hit_nameListCreate(HitNameList *list, int nelems)
Definition: hit_shape.c:301
#define hit_cShapeCoordToGlobal(s, dim, elem)
Definition: hit_cshape.h:253
#define VEXPAND
#define hit_cShapeXadj(shape)
#define x
HitShape hit_cShapeExpand(HitShape shape, HitShape original, int amount)
Definition: hit_cshape.c:208
#define hit_cShapeNvertices(shape)
#define hit_cShapeVertexToLocal(s, vertex)
Definition: hit_cshape.h:243
Hitmap functions to allocate memory.
#define hit_cShapeNameList(shape, dim)
Definition: hit_cshape.h:162
#define VLOCAL
#define hit_malloc(ptr, type, nmemb)
Definition: hit_allocP.h:93
HitShape hit_cShapeSelect(HitShape s, int nvertices, int *vertices)
Definition: hit_cshape.c:109
#define HIT_CSR_SHAPE
Definition: hit_shape.h:177
HitShape HIT_SHAPE_NULL
Definition: hit_shape.c:60
HitShape shape
HitShape HIT_CSR_SHAPE_NULL
Definition: hit_shape.c:70
HitShape hit_cShapeSelectRows(HitShape shape, int n, int *names)
Definition: hit_cshape.c:542
#define s
void hit_cShapeFree(HitShape shape)
Definition: hit_cshape.c:99
HitNameList HIT_NAMELIST_NULL
Definition: hit_shape.c:80
#define m(a, b, c)
#define hit_shapeType(s)
Definition: hit_shape.h:266
#define hit_realloc(ptr, type, nmemb)
Definition: hit_allocP.h:134
#define hit_cShapeVertexToGlobal(s, vertex)
#define hit_cShapeFistColumn(s, row)
#define hit_max(a, b)
Definition: hit_funcop.h:59
void hit_cShapeAddEmptyRow_or_Vertex(HitShape *shape, int x, int mode)
Definition: hit_cshape.c:349
#define hit_min(a, b)
Definition: hit_funcop.h:65
#define hit_errInternal(routine, text, extraParam, file, numLine)
Definition: hit_error.h:63
int hit_cShapeElemExists(HitShape shape, int x, int y)
Definition: hit_cshape.c:416
void hit_cShapeAddElem_or_Edge(HitShape *shape, int x, int y, int mode)
Definition: hit_cshape.c:432