[Bf-blender-cvs] [259436afefa] temp-D5423-update: Rename struct members
Campbell Barton
noreply at git.blender.org
Fri Aug 9 09:13:26 CEST 2019
Commit: 259436afefa2f22e3bc328996746b83ef34167f3
Author: Campbell Barton
Date: Fri Aug 9 16:48:00 2019 +1000
Branches: temp-D5423-update
https://developer.blender.org/rB259436afefa2f22e3bc328996746b83ef34167f3
Rename struct members
Opinionated changes for struct names.
- Use plural for faces/edges/verts.
- Was using len / num in a confusing way.
Now lookup tables use a `_table` suffix, so we can have.
- faces_len (length of the array).
- faces_len_table (length of each face).
===================================================================
M source/blender/blenlib/BLI_delaunay_2d.h
M source/blender/blenlib/intern/delaunay_2d.c
M tests/gtests/blenlib/BLI_delaunay_2d_test.cc
===================================================================
diff --git a/source/blender/blenlib/BLI_delaunay_2d.h b/source/blender/blenlib/BLI_delaunay_2d.h
index 77483807793..9c4c2b4d978 100644
--- a/source/blender/blenlib/BLI_delaunay_2d.h
+++ b/source/blender/blenlib/BLI_delaunay_2d.h
@@ -56,7 +56,7 @@
/**
* Input to Constrained Delaunay Triangulation.
- * There are num_vertex vertices, whose coordinates
+ * There are verts_len vertices, whose coordinates
* are given by vert_coords. For the rest of the input,
* vertices are referred to by indices into that array.
* Edges and Faces are optional. If provided, they will
@@ -65,10 +65,10 @@
* implied by the faces will be inferred.
*
* The edges are given by pairs of vertex indices.
- * The faces are given in a triple `(faces, face_start, face_len)`
+ * The faces are given in a triple `(faces, faces_start_table, faces_len_table)`
* to represent a list-of-lists as follows:
* the vertex indices for a counterclockwise traversal of
- * face number `i` starts at `face_start[i]` and has `face_len[i]`
+ * face number `i` starts at `faces_start_table[i]` and has `faces_len_table[i]`
* elements.
*
* The edges implied by the faces are automatically added
@@ -78,14 +78,14 @@
* Epsilon is used for "is it near enough" distance calculations.
*/
typedef struct CDT_input {
- int num_verts;
- int num_edges;
- int num_faces;
+ int verts_len;
+ int edges_len;
+ int faces_len;
float (*vert_coords)[2];
int (*edges)[2];
int *faces;
- int *face_start;
- int *face_len;
+ int *faces_start_table;
+ int *faces_len_table;
float epsilon;
} CDT_input;
@@ -108,37 +108,37 @@ typedef struct CDT_input {
* mapping of vertices, edges, and faces.
*
* Those triples are:
- * - vert_orig, vert_orig_start, vert_orig_len
- * - edge_eorig, edge_orig_start, edge_orig_len
- * - face_orig, face_orig_start, face_orig_len
+ * - verts_orig, verts_orig_start_table, verts_orig_len_table
+ * - edges_orig, edges_orig_start_table, edges_orig_len_table
+ * - faces_orig, faces_orig_start_table, faces_orig_len_table
*
- * For edges, the edge_orig triple can also say which original face
- * edge is part of a given output edge. If an index in edge_orig
- * is greater than the input's num_edges, then subtract input's num_edges
+ * For edges, the edges_orig triple can also say which original face
+ * edge is part of a given output edge. If an index in edges_orig
+ * is greater than the input's edges_len, then subtract input's edges_len
* from it to some number i: then the face edge that starts from the
* input vertex at input's faces[i] is the corresponding face edge.
* for convenience, face_edge_offset in the result will be the input's
- * num_edges, so that this conversion can be easily done by the caller.
+ * edges_len, so that this conversion can be easily done by the caller.
*/
typedef struct CDT_result {
- int num_verts;
- int num_edges;
- int num_faces;
+ int verts_len;
+ int edges_len;
+ int faces_len;
int face_edge_offset;
float (*vert_coords)[2];
int (*edges)[2];
int *faces;
- int *face_start;
- int *face_len;
- int *vert_orig;
- int *vert_orig_start;
- int *vert_orig_len;
- int *edge_orig;
- int *edge_orig_start;
- int *edge_orig_len;
- int *face_orig;
- int *face_orig_start;
- int *face_orig_len;
+ int *faces_start_table;
+ int *faces_len_table;
+ int *verts_orig;
+ int *verts_orig_start_table;
+ int *verts_orig_len_table;
+ int *edges_orig;
+ int *edges_orig_start_table;
+ int *edges_orig_len_table;
+ int *faces_orig;
+ int *faces_orig_start_table;
+ int *faces_orig_len_table;
} CDT_result;
/** What triangles and edges of CDT are desired when getting output? */
diff --git a/source/blender/blenlib/intern/delaunay_2d.c b/source/blender/blenlib/intern/delaunay_2d.c
index 3bf81692172..57a1872357a 100644
--- a/source/blender/blenlib/intern/delaunay_2d.c
+++ b/source/blender/blenlib/intern/delaunay_2d.c
@@ -74,7 +74,7 @@ typedef struct CDT_state {
CDTFace *outer_face;
CDTVert **vert_array;
int vert_array_len;
- int vert_array_allocated;
+ int vert_array_len_alloc;
double minx;
double miny;
double maxx;
@@ -278,14 +278,14 @@ static CDTVert *add_cdtvert(CDT_state *cdt, double x, double y)
v->co[1] = y;
v->input_ids = NULL;
v->symedge = NULL;
- if (cdt->vert_array_len == cdt->vert_array_allocated) {
+ if (cdt->vert_array_len == cdt->vert_array_len_alloc) {
CDTVert **old_array = cdt->vert_array;
- cdt->vert_array_allocated *= 4;
+ cdt->vert_array_len_alloc *= 4;
cdt->vert_array = BLI_memarena_alloc(cdt->arena,
- cdt->vert_array_allocated * sizeof(cdt->vert_array[0]));
+ cdt->vert_array_len_alloc * sizeof(cdt->vert_array[0]));
memmove(cdt->vert_array, old_array, cdt->vert_array_len * sizeof(cdt->vert_array[0]));
}
- BLI_assert(cdt->vert_array_len < cdt->vert_array_allocated);
+ BLI_assert(cdt->vert_array_len < cdt->vert_array_len_alloc);
v->index = cdt->vert_array_len;
cdt->vert_array[cdt->vert_array_len++] = v;
return v;
@@ -622,9 +622,9 @@ static CDT_state *cdt_init(double minx, double maxx, double miny, double maxy, d
cdt->edges = NULL;
cdt->faces = NULL;
cdt->vert_array_len = 0;
- cdt->vert_array_allocated = 32;
+ cdt->vert_array_len_alloc = 32;
cdt->vert_array = BLI_memarena_alloc(arena,
- cdt->vert_array_allocated * sizeof(*cdt->vert_array));
+ cdt->vert_array_len_alloc * sizeof(*cdt->vert_array));
cdt->minx = minx;
cdt->miny = miny;
cdt->maxx = maxx;
@@ -2155,7 +2155,7 @@ static void prepare_cdt_for_output(CDT_state *cdt, const CDT_output_type output_
static CDT_result *cdt_get_output(CDT_state *cdt, const CDT_output_type output_type)
{
- int i, j, nv, ne, nf, tot_face_len;
+ int i, j, nv, ne, nf, faces_len_total;
int orig_map_size, orig_map_index;
CDT_result *result;
LinkNode *lne, *lnf, *ln;
@@ -2173,7 +2173,7 @@ static CDT_result *cdt_get_output(CDT_state *cdt, const CDT_output_type output_t
return result;
}
- result->num_verts = nv;
+ result->verts_len = nv;
result->vert_coords = MEM_malloc_arrayN(nv, sizeof(result->vert_coords[0]), __func__);
/* Make the vertex "orig" map arrays, mapping output verts to lists of input ones. */
@@ -2181,20 +2181,20 @@ static CDT_result *cdt_get_output(CDT_state *cdt, const CDT_output_type output_t
for (i = 0; i < nv; i++) {
orig_map_size += BLI_linklist_count(cdt->vert_array[i + 4]->input_ids);
}
- result->vert_orig_len = MEM_malloc_arrayN(nv, sizeof(int), __func__);
- result->vert_orig_start = MEM_malloc_arrayN(nv, sizeof(int), __func__);
- result->vert_orig = MEM_malloc_arrayN(orig_map_size, sizeof(int), __func__);
+ result->verts_orig_len_table = MEM_malloc_arrayN(nv, sizeof(int), __func__);
+ result->verts_orig_start_table = MEM_malloc_arrayN(nv, sizeof(int), __func__);
+ result->verts_orig = MEM_malloc_arrayN(orig_map_size, sizeof(int), __func__);
orig_map_index = 0;
for (i = 0; i < nv; i++) {
j = i + NUM_BOUND_VERTS;
result->vert_coords[i][0] = (float)cdt->vert_array[j]->co[0];
result->vert_coords[i][1] = (float)cdt->vert_array[j]->co[1];
- result->vert_orig_start[i] = orig_map_index;
+ result->verts_orig_start_table[i] = orig_map_index;
for (ln = cdt->vert_array[j]->input_ids; ln; ln = ln->next) {
- result->vert_orig[orig_map_index++] = POINTER_AS_INT(ln->link);
+ result->verts_orig[orig_map_index++] = POINTER_AS_INT(ln->link);
}
- result->vert_orig_len[i] = orig_map_index - result->vert_orig_start[i];
+ result->verts_orig_len_table[i] = orig_map_index - result->verts_orig_start_table[i];
}
ne = 0;
@@ -2209,13 +2209,13 @@ static CDT_result *cdt_get_output(CDT_state *cdt, const CDT_output_type output_t
}
}
if (ne != 0) {
- result->num_edges = ne;
+ result->edges_len = ne;
result->face_edge_offset = cdt->face_edge_offset;
result->edges = MEM_malloc_arrayN(ne, sizeof(result->edges[0]), __func__);
- result->edge_orig_len = MEM_malloc_arrayN(ne, sizeof(int), __func__);
- result->edge_orig_start = MEM_malloc_arrayN(ne, sizeof(int), __func__);
+ result->edges_orig_len_table = MEM_malloc_arrayN(ne, sizeof(int), __func__);
+ result->edges_orig_start_table = MEM_malloc_arrayN(ne, sizeof(int), __func__);
if (orig_map_size > 0) {
- result->edge_orig = MEM_malloc_arrayN(orig_map_size, sizeof(int), __func__);
+ result->edges_orig = MEM_malloc_arrayN(orig_map_size, sizeof(int), __func__);
}
orig_map_index = 0;
i = 0;
@@ -2224,18 +2224,18 @@ static CDT_result *cdt_get_output(CDT_state *cdt, const CDT_output_type output_t
if (!is_deleted_edge(e)) {
result->edges[i][0] = VERT_OUT_INDEX(e->symedges[0].vert);
result->edges[i][1] = VERT_OUT_INDEX(e->symedges[1].vert);
- result->edge_orig_start[i] = orig_map_index;
+ result->edges_orig_start_table[i] = orig_map_index;
for (ln = e->input_ids; ln; ln = ln->next) {
- result->edge_orig[orig_map_index++] = POINTER_AS_INT(ln->link);
+ result->edges_orig[orig_map_index++] = POINTER_AS_INT(ln->link);
}
- result->edge_orig_len[i] = orig_map_index - result->edge_orig_start[i];
+ result->edges_orig_len_table[i] = orig_map_index - result->edges_orig_start_table[i];
i++;
}
}
}
nf = 0;
- tot_face_len = 0;
+ faces_len_total = 0;
orig_map_size = 0;
for (ln = cdt->faces; ln; ln = ln->next) {
f = (CDTFace *)ln->link;
@@ -2244,7 +2244,7 @@ static CDT_result *cdt_get_output(CDT_state *cdt, const CDT_output_type output_t
se = se_start = f->symedge;
BLI_assert(se != NULL);
do {
- tot_face_len++;
+ faces_len_total++;
se = se->next;
} while (se != se_start);
if (f->input_ids) {
@@ -2254,14 +2254,14 @@ static CDT_result *cdt_get_output(CDT_state *cdt, const CDT_output_type output_t
}
if (nf != 0) {
- result->num_faces = nf;
- result->face_len = MEM_malloc_arrayN(nf, sizeof(int), __func__);
- result->face_start = MEM_mal
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list