bruno/advent-of-code
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

day19: move beacons/distances from arrays to lists

Browse Source
This commit is contained in:
Bruno Raoult
2022-01-21 16:54:15 +01:00
parent 9fd980c71b
commit 1caa102c23
1 changed files with 418 additions and 335 deletions
Download Patch File Download Diff File Expand all files Collapse all files

741
2021/day19/aoc-c.c
View File

@@ -20,50 +20,37 @@
#include "bits.h" #include "bits.h"
#include "list.h" #include "list.h"
/*
typedef struct beacon {
int x, y, z;
struct list_head list_beacons;
} beacon_t;
typedef struct scanner {
struct list_head list_beacons;
} scanner_t;
*/
// #define SQUARE(x) ((x) * (x))
#define MAX_SCANNERS 32 /* I know, I know... */ #define MAX_SCANNERS 32 /* I know, I know... */
#define MAX_BEACONS 32
#define MAX_DISTANCES ((MAX_BEACONS - 1) * MAX_BEACONS)
typedef struct vector { typedef struct vector {
int x, y, z; /* beacon coordinates */ s64 x, y, z;
} vector_t; } vector_t;
typedef struct beacon { typedef struct beacon {
int x, y, z; /* beacon coordinates */ int scanner; /* original scanner for beacon */
int count; int num; /* original # in original scanner */
int common; /* has common distance with 1st scanner */
vector_t vec; /* beacon coordinates */
struct list_head list_beacons;
} beacon_t; } beacon_t;
typedef struct rotmatrix {
vector_t a, b, c;
} rotmatrix_t;
typedef struct dist { typedef struct dist {
uint dist; /* square distance */ u64 dist; /* square distance... */
int beacon1, beacon2; /* beacons */ beacon_t *beacon1, *beacon2; /* ... between these beacons */
struct list_head list_dists;
} dist_t; } dist_t;
typedef struct scanner { typedef struct scanner {
int nbeacons, ndists, adjusted; int nbeacons, ndists;
beacon_t beacons[MAX_BEACONS]; int adjusted;
uint beacons_count[MAX_BEACONS]; /* common scanner distance count */ struct list_head list_beacons;
dist_t dists[MAX_DISTANCES]; /* sorted */ struct list_head list_dists;
int reference[3]; /* reference beacons */ beacon_t *ref[3]; /* reference beacons */
//vector_t ref[3];
} scanner_t; } scanner_t;
static pool_t *pool_beacon; static pool_t *pool_beacon;
static pool_t *pool_dist;
static scanner_t scanners[MAX_SCANNERS]; static scanner_t scanners[MAX_SCANNERS];
static int nscanners; static int nscanners;
@@ -71,132 +58,104 @@ static int nscanners;
static void scanners_print_dists() static void scanners_print_dists()
{ {
dist_t *cur; dist_t *cur;
beacon_t *beacon1, *beacon2;
log_f(1, "nscanners: %d\n", nscanners); log_f(1, "nscanners: %d\n", nscanners);
for (int i = 0; i < nscanners; ++i) { for (int i = 0; i < nscanners; ++i) {
log(1, "scanner %d:\n", i); log(1, "scanner %d: %d dists\n", i, scanners[i].ndists);
for (int j = 0; j < scanners[i].ndists; ++j) { list_for_each_entry(cur, &scanners[i].list_dists, list_dists) {
cur = &scanners[i].dists[j]; beacon1 = cur->beacon1;
log(1, "\t%u : %d,%d\n", cur->dist, cur->beacon1, cur->beacon2); beacon2 = cur->beacon2;
log_i(3, "%lu : %d-%d (%ld,%ld,%ld)-(%ld,%ld,%ld)\n", cur->dist,
beacon1->num, beacon2->num,
beacon1->vec.x, beacon1->vec.y, beacon1->vec.z,
beacon2->vec.x, beacon2->vec.y, beacon2->vec.z);
} }
// log(1, "zobi\n");
} }
} }
static void scanners_print_refs(scanner_t *s1, scanner_t *s2) static void scanners_print_refs(scanner_t *s1, scanner_t *s2)
{ {
log_f(1, "s1:%ld s2:%ld\n", s1 - scanners, s2 - scanners); log_f(1, "s1:%ld s2:%ld\n", s1 - scanners, s2 - scanners);
log(1, "scanner %ld:", s1 - scanners); log_i(2, "scanner %ld:", s1 - scanners);
for (int i = 0; i < 3; ++i) { for (int i = 0; i < 3; ++i) {
beacon_t *beacon = s1->beacons + s1->reference[i]; beacon_t *beacon = s1->ref[i];
log(1, " (%d,%d,%d)", beacon->x, beacon->y, beacon->z); log(1, " (%ld,%ld,%ld)", beacon->vec.x, beacon->vec.y, beacon->vec.z);
} }
log(1, "\nscanner %ld:", s2 - scanners); log(1, "\n");
log_i(2, "\nscanner %ld:", s2 - scanners);
for (int i = 0; i < 3; ++i) { for (int i = 0; i < 3; ++i) {
beacon_t *beacon = s2->beacons + s2->reference[i]; beacon_t *beacon = s2->ref[i];
log(1, " (%d,%d,%d)", beacon->x, beacon->y, beacon->z); log(1, " (%ld,%ld,%ld)", beacon->vec.x, beacon->vec.y, beacon->vec.z);
} }
log(1, "\n"); log(1, "\n");
} }
/*
static void scanners_print() static void scanners_print()
{ {
beacon_t *cur; beacon_t *cur;
log_f(1, "nscanners: %d\n", nscanners); log_f(1, "nscanners: %d\n", nscanners);
for (int i = 0; i < nscanners; ++i) { for (int i = 0; i < nscanners; ++i) {
log(1, "scanner %d:\n\t", i); log(1, "scanner %d: %d beacons\n", i, scanners[i].nbeacons);
for (int j = 0; j < scanners[i].nbeacons; ++j) { log_i(3, " ");
cur = &scanners[i].beacons[j]; list_for_each_entry(cur, &scanners[i].list_beacons, list_beacons) {
log(1, " %d/%d/%d", cur->x, cur->y, cur->z); log(1, " %ld/%ld/%ld", cur->vec.x, cur->vec.y, cur->vec.z);
} }
log(1, "\n"); log(1, "\n");
} }
} }
*/
static void merge(array, left, mid, right)
dist_t *array;
int left, mid, right;
{
dist_t temp[right - left + 1];
int pos = 0, lpos = left, rpos = mid + 1, iter;
while(lpos <= mid && rpos <= right) {
if(array[lpos].dist < array[rpos].dist) {
temp[pos++] = array[lpos++];
}
else {
temp[pos++] = array[rpos++];
}
}
while(lpos <= mid)
temp[pos++] = array[lpos++];
while(rpos <= right)
temp[pos++] = array[rpos++];
for(iter = 0; iter < pos; iter++) {
array[iter+left] = temp[iter];
}
return;
}
static void mergesort(array, left, right)
dist_t *array;
int left, right;
{
int mid = (left + right) / 2;
if(left < right) {
mergesort(array, left, mid);
mergesort(array, mid + 1, right);
merge(array, left, mid, right);
}
}
/* Thanks to: /* Thanks to:
* http://www.euclideanspace.com/maths/algebra/matrix/transforms/examples/index.htm * http://www.euclideanspace.com/maths/algebra/matrix/transforms/examples/index.htm
*/ */
rotmatrix_t rotations[24] = { vector_t rotations[] = {
{{ 1, 0, 0}, { 0, 1, 0}, { 0, 0, 1}}, { 1, 0, 0}, { 0, 1, 0}, { 0, 0, 1},
{{ 0, 0, 1}, { 0, 1, 0}, {-1, 0, 0}}, { 0, 0, 1}, { 0, 1, 0}, {-1, 0, 0},
{{-1, 0, 0}, { 0, 1, 0}, { 0, 0, -1}}, {-1, 0, 0}, { 0, 1, 0}, { 0, 0, -1},
{{ 0, 0, -1}, { 0, 1, 0}, { 1, 0, 0}}, { 0, 0, -1}, { 0, 1, 0}, { 1, 0, 0},
{{ 0, -1, 0}, { 1, 0, 0}, { 0, 0, 1}}, { 0, -1, 0}, { 1, 0, 0}, { 0, 0, 1},
{{ 0, 0, 1}, { 1, 0, 0}, { 0, 1, 0}}, { 0, 0, 1}, { 1, 0, 0}, { 0, 1, 0},
{{ 0, 1, 0}, { 1, 0, 0}, { 0, 0, -1}}, { 0, 1, 0}, { 1, 0, 0}, { 0, 0, -1},
{{ 0, 0, -1}, { 1, 0, 0}, { 0, -1, 0}}, { 0, 0, -1}, { 1, 0, 0}, { 0, -1, 0},
{{ 0, 1, 0}, {-1, 0, 0}, { 0, 0, 1}}, { 0, 1, 0}, {-1, 0, 0}, { 0, 0, 1},
{{ 0, 0, 1}, {-1, 0, 0}, { 0, -1, 0}}, { 0, 0, 1}, {-1, 0, 0}, { 0, -1, 0},
{{ 0, -1, 0}, {-1, 0, 0}, { 0, 0, -1}}, { 0, -1, 0}, {-1, 0, 0}, { 0, 0, -1},
{{ 0, 0, -1}, {-1, 0, 0}, { 0, 1, 0}}, { 0, 0, -1}, {-1, 0, 0}, { 0, 1, 0},
{{ 1, 0, 0}, { 0, 0, -1}, { 0, 1, 0}}, { 1, 0, 0}, { 0, 0, -1}, { 0, 1, 0},
{{ 0, 1, 0}, { 0, 0, -1}, {-1, 0, 0}}, { 0, 1, 0}, { 0, 0, -1}, {-1, 0, 0},
{{-1, 0, 0}, { 0, 0, -1}, { 0, -1, 0}}, {-1, 0, 0}, { 0, 0, -1}, { 0, -1, 0},
{{ 0, -1, 0}, { 0, 0, -1}, { 1, 0, 0}}, { 0, -1, 0}, { 0, 0, -1}, { 1, 0, 0},
{{ 1, 0, 0}, { 0, -1, 0}, { 0, 0, -1}}, { 1, 0, 0}, { 0, -1, 0}, { 0, 0, -1},
{{ 0, 0, -1}, { 0, -1, 0}, {-1, 0, 0}}, { 0, 0, -1}, { 0, -1, 0}, {-1, 0, 0},
{{-1, 0, 0}, { 0, -1, 0}, { 0, 0, 1}}, {-1, 0, 0}, { 0, -1, 0}, { 0, 0, 1},
{{ 0, 0, 1}, { 0, -1, 0}, { 1, 0, 0}}, { 0, 0, 1}, { 0, -1, 0}, { 1, 0, 0},
{{ 1, 0, 0}, { 0, 0, 1}, { 0, -1, 0}}, { 1, 0, 0}, { 0, 0, 1}, { 0, -1, 0},
{{ 0, -1, 0}, { 0, 0, 1}, {-1, 0, 0}}, { 0, -1, 0}, { 0, 0, 1}, {-1, 0, 0},
{{-1, 0, 0}, { 0, 0, 1}, { 0, 1, 0}}, {-1, 0, 0}, { 0, 0, 1}, { 0, 1, 0},
{{ 0, 1, 0}, { 0, 0, 1}, { 1, 0, 0}}, { 0, 1, 0}, { 0, 0, 1}, { 1, 0, 0},
}; };
#define NROTATIONS (sizeof(rotations) / sizeof(*rotations))
#define NROTATIONS (sizeof(rotations) / sizeof(*rotations) / 3)
/* beacon_rotate: rotate beacon "in" with "nrot"th rotations matrix /* beacon_rotate: rotate beacon "in" with "nrot"th rotations matrix
*/ */
static beacon_t *beacon_rotate(const beacon_t *in, beacon_t *res, rotmatrix_t *rot) static beacon_t *beacon_rotate(const beacon_t *in, beacon_t *res, int nrot)
{ {
res->x = in->x * rot->a.x + in->y * rot->a.y + in->z * rot->a.z; vector_t *rot = &rotations[nrot*3];
res->y = in->x * rot->b.x + in->y * rot->b.y + in->z * rot->b.z; //log_f(1, "rot0[%d]=%d,%d,%d\n", nrot, rot[0].x, rot[0].y , rot[0].z);
res->z = in->x * rot->c.x + in->y * rot->c.y + in->z * rot->c.z; //log_f(1, "rot1[%d]=%d,%d,%d\n", nrot, rot[1].x, rot[1].y , rot[1].z);
//log_f(1, "rot2[%d]=%d,%d,%d\n", nrot, rot[2].x, rot[2].y , rot[2].z);
res->vec.x = in->vec.x * rot[0].x + in->vec.y * rot[0].y + in->vec.z * rot[0].z;
res->vec.y = in->vec.x * rot[1].x + in->vec.y * rot[1].y + in->vec.z * rot[1].z;
res->vec.z = in->vec.x * rot[2].x + in->vec.y * rot[2].y + in->vec.z * rot[2].z;
return res; return res;
} }
@@ -204,22 +163,54 @@ static beacon_t *beacon_rotate(const beacon_t *in, beacon_t *res, rotmatrix_t *r
*/ */
static beacon_t *beacon_diff(const beacon_t *b1, beacon_t *b2, beacon_t *res) static beacon_t *beacon_diff(const beacon_t *b1, beacon_t *b2, beacon_t *res)
{ {
res->x = b1->x - b2->x; res->vec.x = b1->vec.x - b2->vec.x;
res->y = b1->y - b2->y; res->vec.y = b1->vec.y - b2->vec.y;
res->z = b1->z - b2->z; res->vec.z = b1->vec.z - b2->vec.z;
return res; return res;
} }
/* insert a new distance in scanner's (sorted) distances list
*/
static int insert_dist(scanner_t *scanner, dist_t *dist)
{
dist_t *cur;
uint newdist = dist->dist;
log_f(7, "dist=%u\n", newdist);
cur = list_first_entry_or_null(&scanner->list_dists, dist_t, list_dists);
/* special case: first distance or new dist lower than first dist */
if (!cur || newdist < cur->dist) {
list_add(&dist->list_dists, &scanner->list_dists);
log_i(7, "first entry\n");
goto end;
}
/* normal case: insert before current when new dist is lower than current dist */
list_for_each_entry(cur, &scanner->list_dists, list_dists) {
log_i(7, "comp=%lu\n", cur->dist);
if (newdist < cur->dist) {
list_add_tail(&dist->list_dists, &cur->list_dists);
log_i(7, "add before\n");
goto end;
}
}
/* special case: we went to end, insert at list's tail */
list_add_tail(&dist->list_dists, &scanner->list_dists);
log_i(7, "add end\n");
end:
return ++scanner->ndists;
}
/* using scanner's reference points, find the correct rotation and translation /* using scanner's reference points, find the correct rotation and translation
*/ */
static int adjust_scanner(scanner_t *ref, scanner_t *s) static int adjust_scanner(scanner_t *ref, scanner_t *s)
{ {
beacon_t *beacon_ref[3], *beacon[3]; beacon_t *beacon_ref[3], *beacon[3], *cur;
//log_f(1, "sizeof(rotations)=%lu\n", NROTATIONS); //log_f(1, "sizeof(rotations)=%lu\n", NROTATIONS);
for (uint i = 0; i < 3; ++i) { for (uint i = 0; i < 3; ++i) {
beacon_ref[i] = ref->beacons + ref->reference[i]; beacon_ref[i] = ref->ref[i];
beacon[i] = s->beacons + s->reference[i]; beacon[i] = s->ref[i];
} }
for (uint i = 0; i < NROTATIONS; ++i) { for (uint i = 0; i < NROTATIONS; ++i) {
@@ -228,31 +219,31 @@ static int adjust_scanner(scanner_t *ref, scanner_t *s)
/* rotate the first beacon and translate to match ref's (x, y, z) /* rotate the first beacon and translate to match ref's (x, y, z)
*/ */
for (int bref = 0; bref < 3; ++bref) { for (int bref = 0; bref < 3; ++bref) {
beacon_rotate(beacon[bref], &rot[bref], rotations + i); beacon_rotate(beacon[bref], &rot[bref], i);
beacon_diff(beacon_ref[bref], &rot[bref], &diff[bref]); beacon_diff(beacon_ref[bref], &rot[bref], &diff[bref]);
log(2, "ref %d diff=(%d,%d,%d)\n", bref, diff[bref].x, diff[bref].y, log(2, "ref %d diff=(%ld,%ld,%ld)\n", bref,
diff[bref].z); diff[bref].vec.x, diff[bref].vec.y, diff[bref].vec.z);
/* check that rotation/translation works for the 3 reference points /* check that rotation/translation works for the 3 reference points
*/ */
if (bref > 0 && (diff[bref].x != diff[0].x || if (bref > 0 && (diff[bref].vec.x != diff[0].vec.x ||
diff[bref].y != diff[0].y || diff[bref].vec.y != diff[0].vec.y ||
diff[bref].z != diff[0].z)) { diff[bref].vec.z != diff[0].vec.z)) {
log(2, "skipping this translation\n"); log(2, "skipping this translation\n");
goto next_rot; goto next_rot;
} }
} }
log(2, "Got it: scanner %lu is (%d,%d,%d) from reference\n", log(2, "Got it: scanner %lu is (%ld,%ld,%ld) from reference\n",
s - scanners, diff[0].x, diff[0].y, diff[0].z); s - scanners, diff[0].vec.x, diff[0].vec.y, diff[0].vec.z);
/* adjust all beacons */ /* adjust all beacons */
for (int b = 0; b < s->nbeacons; ++ b) { list_for_each_entry(cur, &s->list_beacons, list_beacons) {
beacon_rotate(s->beacons + b, rot, rotations + i); log(2, "translating beacon: (%ld,%ld,%ld) ->", cur->vec.x,
s->beacons[b] = *rot; cur->vec.y, cur->vec.z);
s->beacons[b].x += (*diff).x; beacon_rotate(cur, cur, i);
s->beacons[b].y += (*diff).y; cur->vec.x += (*diff).vec.x;
s->beacons[b].z += (*diff).z; cur->vec.y += (*diff).vec.y;
log(2, "translated beacon: (%d,%d,%d)\n", s->beacons[b].x, cur->vec.z += (*diff).vec.z;
s->beacons[b].y, s->beacons[b].z); log(2, " (%ld,%ld,%ld)\n", cur->vec.x,
//beacon_diff(beacon_ref[bref], &rot[bref], &diff[bref]); cur->vec.y, cur->vec.z);
} }
break; break;
next_rot: next_rot:
@@ -261,20 +252,96 @@ static int adjust_scanner(scanner_t *ref, scanner_t *s)
return 1; return 1;
} }
/* add distances between b1 and all following beacons in scanner's list
*/
static int add_beacon_dists(scanner_t *scanner, beacon_t *b1)
{
beacon_t *b2 = b1;
dist_t *dist;
int count = 0;
list_for_each_entry_continue(b2, &scanner->list_beacons, list_beacons) {
dist = pool_get(pool_dist);
dist->dist =
(b1->vec.x - b2->vec.x) * (b1->vec.x - b2->vec.x) +
(b1->vec.y - b2->vec.y) * (b1->vec.y - b2->vec.y) +
(b1->vec.z - b2->vec.z) * (b1->vec.z - b2->vec.z);
dist->beacon1 = b1;
dist->beacon2 = b2;
log_f(1, "scanner %lu new dist : %lu (%ld,%ld,%ld) / (%ld,%ld,%ld)\n",
scanner - scanners,
dist->dist,
b1->vec.x, b1->vec.y, b1->vec.z,
b2->vec.x, b2->vec.y, b2->vec.z);
insert_dist(scanner, dist);
count++;
}
return count;
}
/* merge scanner s2 (already translated) beacons into scanner s1.
* - ignore duplicate beacons
* - recalculate all distances for new beacons
*/
static int merge_scanner(scanner_t *s1, scanner_t *s2)
{
struct list_head *cur, *tmp;
beacon_t *beacon;
dist_t *dist;
int count = 0;
//log_f(1, "merging scanner %lu into %lu\n", s2 - scanners, s1 - scanners);
log_f(3, "before(%lu -> %lu): count1=%d count2=%d dist1=%d dist2=%d\n\n",
s2 - scanners, s1 - scanners,
s1->nbeacons, s2->nbeacons, s1->ndists, s2->ndists);
list_for_each_safe(cur, tmp, &s2->list_beacons) {
beacon = list_entry(cur, beacon_t, list_beacons);
list_del(cur);
s2->nbeacons--;
if (beacon->common) {
log(2, "common beacon ignored (%ld,%ld,%ld)\n",
beacon->vec.x, beacon->vec.y, beacon->vec.z);
pool_add(pool_beacon, beacon);
} else {
log(2, "add new beacon (%ld,%ld,%ld)\n",
beacon->vec.x, beacon->vec.y, beacon->vec.z);
list_add(cur, &s1->list_beacons);
s1->nbeacons++;
add_beacon_dists(s1, beacon);
count++;
}
}
/* free all dists */
list_for_each_safe(cur, tmp, &s2->list_dists) {
dist = list_entry(cur, dist_t, list_dists);
list_del(cur);
s2->ndists--;
pool_add(pool_dist, dist);
}
s2->adjusted = 1;
log_f(3, "after(%lu -> %lu): count1=%d count2=%d dist1=%d dist2=%d added=%d\n",
s2 - scanners, s1 - scanners,
s1->nbeacons, s2->nbeacons, s1->ndists, s2->ndists, count);
return count;
}
/* For each scanner, calculate square distances between every beacon,
* and generate corresponding list.
* For N beacons, we will get (N) * (N-1) / 2 distances.
*
* Note: To find 12 matching beacons between scanners later, we will need
* 66 matching distances (12 * 11 / 2).
*/
static int count_common_distances(scanner_t *s1, scanner_t *s2) static int count_common_distances(scanner_t *s1, scanner_t *s2)
{ {
dist_t *d1 = s1->dists, *d2 = s2->dists; struct list_head *plist1, *plist2;
int cur1 = 0, cur2 = 0, i; dist_t *pdist1, *pdist2;
int ref_triangle = 0; beacon_t *tmpbeacon;
int cur1 = 0, cur2 = 0;
u64 dist1, dist2;
int ref_triangle = 0, nref = 0;
uint count = 0; uint count = 0;
//beacon_t *beacon1 = s1->beacons, *beacon2 = s2->beacons;
/* initialize s1 and s2 beacons count
*/
for (i = 0; i < MAX_BEACONS; ++i) {
s1->beacons_count[i] = 0;
s2->beacons_count[i] = 0;
}
log_f(1, "(%ld, %ld): \n", s1 - scanners, s2 - scanners); log_f(1, "(%ld, %ld): \n", s1 - scanners, s2 - scanners);
/* We need to find common references A, B, C such as: /* We need to find common references A, B, C such as:
@@ -288,175 +355,167 @@ static int count_common_distances(scanner_t *s1, scanner_t *s2)
* To do so, we find common d1 and d2 such as both have * To do so, we find common d1 and d2 such as both have
* a common A point. * a common A point.
*/ */
while (cur1 < s1->ndists && cur2 < s2->ndists) { if (list_empty(&s1->list_dists) || list_empty(&s2->list_dists))
if (d1[cur1].dist == d2[cur2].dist) { return 0;
log(1, " %u: (%d,%d)= %d-%d %d-%d triangle=%d\n", plist1 = s1->list_dists.next;
d1[cur1].dist, cur1, cur2, plist2 = s2->list_dists.next;
d1[cur1].beacon1, d1[cur1].beacon2,
d2[cur2].beacon1, d2[cur2].beacon2,
ref_triangle);
if (ref_triangle == 0) {
/* both s1 s2 refs may be reversed */
s1->reference[0] = d1[cur1].beacon1;
s1->reference[1] = d1[cur1].beacon2;
s2->reference[0] = d2[cur2].beacon1; /* initialize second scanner common beacons
s2->reference[1] = d2[cur2].beacon2; */
ref_triangle = 2; list_for_each_entry(tmpbeacon, &s2->list_beacons, list_beacons) {
log(2, "\ts1_ref=%d,%d,%d s2_ref=%d,%d,%d\n", tmpbeacon->common = 0;
s1->reference[0], s1->reference[1], s1->reference[2], }
s2->reference[0], s2->reference[1], s2->reference[2]);
} else if (ref_triangle == 2) { //while (count < 66 && plist1 != &s1->list_dists && plist2 != &s2->list_dists) {
int beacon1 , beacon2; while (plist1 != &s1->list_dists && plist2 != &s2->list_dists) {
pdist1 = list_entry(plist1, dist_t, list_dists);
pdist2 = list_entry(plist2, dist_t, list_dists);
dist1 = pdist1->dist;
dist2 = pdist2->dist;
if (dist1 == dist2) {
log(1, " %lu: (%d,%d)= %d-%d %d-%d triangle=%d\n",
dist1,
cur1, cur2,
pdist1->beacon1->num, pdist1->beacon2->num,
pdist2->beacon1->num, pdist2->beacon2->num,
ref_triangle);
plist1 = plist1->next;
plist2 = plist2->next;
cur1++;
cur2++;
count++;
pdist2->beacon1->common++; /* mark beacons as common in 2nd scanner */
pdist2->beacon2->common++;
switch (nref) {
case 0: /* first 2 reference points */
s1->ref[0] = pdist1->beacon1;
s1->ref[1] = pdist1->beacon2;
s2->ref[0] = pdist2->beacon1;
s2->ref[1] = pdist2->beacon2;
nref = 2;
log_i(3, "s1_ref=%d,%d,-1 s2_ref=%d,%d,-1\n",
s1->ref[0]->num, s1->ref[1]->num,
s2->ref[0]->num, s2->ref[1]->num);
break;
case 2: /* third reference point */
beacon_t *beacon1 , *beacon2;
scanner_t *scanner;
/* we need to adjust references for the two pairs of /* we need to adjust references for the two pairs of
* 2 beacons having same distance, for scanner 1. * 2 beacons having same distance, for both scanners.
*/ */
beacon1 = d1[cur1].beacon1; for (int i = 0; i < 2; i++) {
beacon2 = d1[cur1].beacon2; if (i == 0) {
log(2, "\ts1 bea1=%d bea2=%d\n\t ref0=%d ref1=%d\n", beacon1 = pdist1->beacon1;
beacon1, beacon2, s1->reference[0], s1->reference[1]); beacon2 = pdist1->beacon2;
scanner = s1;
if (beacon1 == s1->reference[0]) {
/* ref0----------ref1
* ref0----------ref2
*/
s1->reference[2] = beacon2;
ref_triangle++;
} else if (beacon1 == s1->reference[1]) {
/* ref1----------ref0
* ref0----------ref2
* first & second reference beacons must be reversed,
* second is ok
*/
int tmp = s1->reference[0];
s1->reference[0] = s1->reference[1];
s1->reference[1] = tmp;
s1->reference[2] = beacon2;
ref_triangle++;
} else if (beacon2 == s1->reference[0]) {
/* ref0----------ref1
* ref2----------ref0
*/
s1->reference[2] = beacon1;
ref_triangle++;
} else if (beacon2 == s1->reference[1]) {
/* ref1----------ref0
* ref2----------ref0
*/
int tmp = s1->reference[0];
s1->reference[0] = s1->reference[1];
s1->reference[1] = tmp;
s1->reference[2] = beacon1;
ref_triangle++;
}
/* we do the same for second scanner */
beacon1 = d2[cur2].beacon1;
beacon2 = d2[cur2].beacon2;
if (beacon1 == s2->reference[0]) {
/* ref0----------ref1
* ref0----------ref2
*/
s2->reference[2] = beacon2;
ref_triangle++;
} else if (beacon1 == s2->reference[1]) {
/* ref1----------ref0
* ref0----------ref2
* first & second reference beacons must be reversed,
* second is ok
*/
int tmp = s2->reference[0];
s2->reference[0] = s2->reference[1];
s2->reference[1] = tmp;
s2->reference[2] = beacon2;
ref_triangle++;
} else if (beacon2 == s2->reference[0]) {
/* ref0----------ref1
* ref2----------ref0
*/
s2->reference[2] = beacon1;
ref_triangle++;
} else if (beacon2 == s2->reference[1]) {
/* ref1----------ref0
* ref2----------ref0
*/
int tmp = s2->reference[0];
s2->reference[0] = s2->reference[1];
s2->reference[1] = tmp;
s2->reference[2] = beacon1;
ref_triangle++;
}
log(2, "\ttriangle=%d s1_ref=%d,%d,%d s2_ref=%d,%d,%d\n",
ref_triangle,
s1->reference[0], s1->reference[1], s1->reference[2],
s2->reference[0], s2->reference[1], s2->reference[2]);
}
/*
if (ref_triangle == 3) {
if (d1[cur1].beacon1 == s1->reference[0] ||
d1[cur1].beacon1 == s1->reference[1]) {
s1->reference[2] = d2[cur1].beacon2;
ref_triangle++;
} else if (d1[cur1].beacon2 == s1->reference[0] ||
d1[cur1].beacon2 == s1->reference[1]) {
s1->reference[2] = d1[cur1].beacon1;
ref_triangle++;
}
}
*/
++s1->beacons_count[d1[cur1].beacon1];
++s1->beacons_count[d1[cur1].beacon2];
++s2->beacons_count[d2[cur2].beacon1];
++s2->beacons_count[d2[cur2].beacon2];
++count;
++cur1;
++cur2;
}
else if (d1[cur1].dist < d2[cur2].dist) {
++cur1;
} else { } else {
++cur2; beacon1 = pdist2->beacon1;
beacon2 = pdist2->beacon2;
scanner = s2;
}
log(1, "s%c: beacon1=%p beacon2=%p\n",
i + '1', beacon1, beacon2);
log(1, " ref1 =%p ref2 =%p\n",
scanner->ref[0], scanner->ref[1]);
if (beacon1 == scanner->ref[0]) {
/* ref0----------ref1
* ref0----------ref2
*/
scanner->ref[2] = beacon2;
nref++;
} else if (beacon1 == scanner->ref[1]) {
/* ref1----------ref0
* ref0----------ref2
* first & second reference beacons must be reversed,
* second is ok
*/
beacon_t *tmp = scanner->ref[0];
scanner->ref[0] = scanner->ref[1];
scanner->ref[1] = tmp;
scanner->ref[2] = beacon2;
nref++;
} else if (beacon2 == scanner->ref[0]) {
/* ref0----------ref1
* ref2----------ref0
*/
scanner->ref[2] = beacon1;
nref++;
} else if (beacon2 == scanner->ref[1]) {
/* ref1----------ref0
* ref2----------ref0
*/
beacon_t *tmp = scanner->ref[0];
scanner->ref[0] = scanner->ref[1];
scanner->ref[1] = tmp;
scanner->ref[2] = beacon1;
nref++;
} }
} }
log_i(1, "\n");
log_i(3, "nref=%d s1_ref=%d,%d,%d s2_ref=%d,%d,%d\n",
nref,
s1->ref[0]->num,
s1->ref[1]->num,
s1->ref[2]? s1->ref[2]->num: -1,
s2->ref[0]->num,
s2->ref[1]->num,
s2->ref[2]? s2->ref[2]->num: -1);
break;
}
} else if (dist1 < dist2) {
log(7, " dist1=%lu < dist2=%lu : (%d,%d)= %d-%d %d-%d triangle=%d\n",
dist1, dist2,
cur1, cur2,
pdist1->beacon1->num, pdist1->beacon2->num,
pdist2->beacon1->num, pdist2->beacon2->num,
ref_triangle);
plist1 = plist1->next;
cur1++;
} else { /* dist1 > dist2 */
log(7, " dist1=%lu > dist2=%lu : (%d,%d)= %d-%d %d-%d triangle=%d\n",
dist1, dist2,
cur1, cur2,
pdist1->beacon1->num, pdist1->beacon2->num,
pdist2->beacon1->num, pdist2->beacon2->num,
ref_triangle);
plist2 = plist2->next;
cur2++;
}
}
return count; return count;
} }
/* For each scanner, calculate square distances between every beacon,
* and generate corresponding list.
* For N beacons, we will get (N) * (N-1) / 2 distances.
*
* Note: To find 12 matching beacons between scanners later, we will need
* 66 matching distances (= 12 * 11 / 2).
*/
static void calc_square_distances() static void calc_square_distances()
{ {
scanner_t *scanner; scanner_t *scanner;
beacon_t *b1, *b2; beacon_t *beacon;
uint dist;
log_f(1, "nscanners: %d\n", nscanners); log_f(1, "nscanners: %d\n", nscanners);
for (int i = 0; i < nscanners; ++i) { for (int i = 0; i < nscanners; ++i) {
scanner = scanners + i; scanner = scanners + i;
for (int j = 0; j < scanner->nbeacons; ++j) { list_for_each_entry(beacon, &scanner->list_beacons, list_beacons) {
b1 = scanner->beacons + j; add_beacon_dists(scanner, beacon);
for (int k = j + 1; k < scanner->nbeacons; ++k) {
scanner->dists[scanner->ndists].beacon1 = j;
scanner->dists[scanner->ndists].beacon2 = k;
b2 = scanner->beacons + k;
dist = (b1->x - b2->x) * (b1->x - b2->x) +
(b1->y - b2->y) * (b1->y - b2->y) +
(b1->z - b2->z) * (b1->z - b2->z);
scanner->dists[scanner->ndists].dist = dist;
scanner->ndists++;
log(5, "\tdist(%d/%d) = %u\n",
j, k,
dist);
} }
}
//scanners_print_dists();
mergesort(scanner->dists, 0, scanner->ndists - 1);
} }
scanners_print_dists(); scanners_print_dists();
//log(1, "\n");
} }
/* match all scanners /* match all scanners
@@ -466,7 +525,34 @@ static void match_scanners()
int finished = 0; int finished = 0;
scanners[0].adjusted = 1; scanners[0].adjusted = 1;
log_f(1, "nscanners=%d\n", nscanners);
while (!finished) {
finished = 1;
for (int j = 1; j < nscanners; ++j) {
if (scanners[j].adjusted) /* already translated */
continue;
int count = count_common_distances(scanners, scanners + j);
log(1, "common(%d, %d) = %d\n\n", 0, j, count);
if (count >= 66) {
adjust_scanner(scanners, scanners + j);
scanners_print_refs(scanners, scanners + j);
merge_scanner(scanners, scanners + j);
finished = 0;
}
}
}
scanners_print_dists();
//scanners_print_dists(scanners + 2);
}
static void match_scanners1()
{
int finished = 0;
scanners[0].adjusted = 1;
log_f(1, "nscanners=%d\n", nscanners);
while (!finished) { while (!finished) {
finished = 1; finished = 1;
for (int i = 0; i < nscanners - 1; ++i) { for (int i = 0; i < nscanners - 1; ++i) {
@@ -480,69 +566,55 @@ static void match_scanners()
int count = count_common_distances(scanners + i, scanners + j); int count = count_common_distances(scanners + i, scanners + j);
log(1, "common(%d, %d) = %d\n", i, j, count); log(1, "common(%d, %d) = %d\n", i, j, count);
if (count >= 66) { if (count >= 66) {
/*
beacon_t *beacon;
for (int k = 0; k < scanners[i].nbeacons; ++k) {
beacon = scanners[i].beacons + k;
//if (beacon->count >= 11)
log(1, "s1(%d, %d, %d): %d\n", beacon->x, beacon->y,
beacon->z, scanners[i].beacons_count[k]);
}
for (int k = 0; k < scanners[j].nbeacons; ++k) {
beacon = scanners[j].beacons + k;
//if (beacon->count >= 11)
log(1, "s2(%d, %d, %d): %d\n", beacon->x, beacon->y,
beacon->z, scanners[j].beacons_count[k]);
}
*/
adjust_scanner(scanners + i, scanners + j); adjust_scanner(scanners + i, scanners + j);
scanners[j].adjusted = 1; scanners_print_refs(scanners + i, scanners + j);
//merge_scanner(scanners + i, scanners + j);
finished = 0; finished = 0;
//scanners_print_refs(scanners + i, scanners + j);
} }
} }
} }
} }
scanners_print_dists();
//scanners_print_dists(scanners + 2);
} }
/* read input /* read input
*/ */
static int read_lines() static int scanners_read()
{ {
size_t alloc = 0; size_t alloc = 0;
ssize_t buflen; ssize_t buflen;
char *buf = NULL; char *buf = NULL;
beacon_t *beacon; beacon_t *beacon;
scanner_t *scanner = NULL; scanner_t *scanner = NULL;
//int nbeacon = 0;
while ((buflen = getline(&buf, &alloc, stdin)) > 0) { while ((buflen = getline(&buf, &alloc, stdin)) > 0) {
//buf[--buflen] = 0;
switch (buf[1]) { switch (buf[1]) {
case '-': case '-':
scanner = scanners + nscanners; scanner = scanners + nscanners;
log_f(2, "[%c] nscanners = %d %p/%p\n", *buf, nscanners, log_f(9, "[%c] nscanners = %d %p/%p\n", *buf, nscanners,
scanner, scanners); scanner, scanners);
//INIT_LIST_HEAD(&scanner->list_beacons); INIT_LIST_HEAD(&scanner->list_beacons);
INIT_LIST_HEAD(&scanner->list_dists);
nscanners++; nscanners++;
scanner->nbeacons = 0; scanner->nbeacons = 0;
break; break;
case '\0': case '\0':
log_f(2, "NULL line\n"); log_f(9, "NULL line\n");
break; break;
default: default:
//log_f(2, "[%c] beacon = %d\n", *buf, nscanners); //log_f(2, "[%c] beacon = %d\n", *buf, nscanners);
//beacon = pool_get(pool_beacon); beacon = pool_get(pool_beacon);
//list_add_tail(&beacon->list_beacons, &scanner->list_beacons); beacon->scanner = nscanners;
beacon = &scanner->beacons[scanner->nbeacons]; beacon->num = scanner->nbeacons;
sscanf(buf, "%d,%d,%d", &beacon->x, &beacon->y, &beacon->z); list_add_tail(&beacon->list_beacons, &scanner->list_beacons);
//log_f(2, "beacon %d = %d/%d/%d\n", nbeacon, beacon->x, beacon->y, beacon->z); sscanf(buf, "%ld,%ld,%ld", &beacon->vec.x, &beacon->vec.y, &beacon->vec.z);
scanner->nbeacons++; scanner->nbeacons++;
} }
} }
free(buf); free(buf);
calc_square_distances(); scanners_print();
return nscanners; return nscanners;
} }
@@ -583,15 +655,26 @@ int main(int ac, char **av)
if (optind < ac) if (optind < ac)
return usage(*av); return usage(*av);
log_f(1, "sizeof(rotations)=%lu, sizeof2=%lu sizeof3=%lu rot=%lu\n",
sizeof(rotations), sizeof(*rotations),
sizeof(rotations) / sizeof(*rotations),
NROTATIONS);
if (!(pool_beacon = pool_create("beacons", 1024, sizeof(beacon_t)))) { if (!(pool_beacon = pool_create("beacons", 1024, sizeof(beacon_t)))) {
log(1, "pool create error, errno=%d\n", errno); log(1, "pool create error, errno=%d\n", errno);
exit(1); exit(1);
} }
read_lines(); if (!(pool_dist = pool_create("dists", 1024, sizeof(dist_t)))) {
log(1, "pool create error, errno=%d\n", errno);
exit(1);
}
scanners_read();
calc_square_distances();
match_scanners(); match_scanners();
log_f(1, "sizeof(rotations)=%lu, sizeof2=%lu sizeof2=%lu\n", sizeof(rotations), scanners_print();
sizeof(*rotations), sizeof(rotations) / sizeof(*rotations));
printf("%s : res=%ld\n", *av, part == 1? part1(): part2()); printf("%s : res=%ld\n", *av, part == 1? part1(): part2());
pool_stats(pool_beacon);
pool_destroy(pool_beacon); pool_destroy(pool_beacon);
pool_stats(pool_dist);
pool_destroy(pool_dist);
exit(0); exit(0);
} }