static void
refresh (PsppireDialog *dialog, const struct comment_dialog *cd)
{
gint i;
GtkWidget *tv = get_widget_assert (cd->xml, "comments-textview1");
GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tv));
gtk_text_buffer_set_text (buffer, "", 0);
for ( i = 0 ; i < dict_get_document_line_cnt (cd->dict->dict); ++i )
add_line_to_buffer (buffer, dict_get_document_line (cd->dict->dict, i));
}
/* Reads any base64-encoded certificates present in fp and adds them to store.
* Returns TRUE if any certificates were successfully imported.
*/
static BOOL import_base64_certs_from_fp(FILE *fp, HCERTSTORE store)
{
char line[1024];
BOOL in_cert = FALSE;
struct DynamicBuffer saved_cert = { 0, 0, NULL };
int num_certs = 0;
TRACE("\n");
while (fgets(line, sizeof(line), fp))
{
static const char header[] = "-----BEGIN CERTIFICATE-----";
static const char trailer[] = "-----END CERTIFICATE-----";
if (!strncmp(line, header, strlen(header)))
{
TRACE("begin new certificate\n");
in_cert = TRUE;
reset_buffer(&saved_cert);
}
else if (!strncmp(line, trailer, strlen(trailer)))
{
DWORD size;
TRACE("end of certificate, adding cert\n");
in_cert = FALSE;
if (CryptStringToBinaryA((char *)saved_cert.data, saved_cert.used,
CRYPT_STRING_BASE64, NULL, &size, NULL, NULL))
{
LPBYTE buf = CryptMemAlloc(size);
if (buf)
{
CryptStringToBinaryA((char *)saved_cert.data,
saved_cert.used, CRYPT_STRING_BASE64, buf, &size, NULL,
NULL);
if (CertAddEncodedCertificateToStore(store,
X509_ASN_ENCODING, buf, size, CERT_STORE_ADD_NEW, NULL))
num_certs++;
CryptMemFree(buf);
}
}
}
else if (in_cert)
add_line_to_buffer(&saved_cert, line);
}
CryptMemFree(saved_cert.data);
TRACE("Read %d certs\n", num_certs);
return num_certs > 0;
}
// returns the 35 points associated to the test chart in [x1,y1,x2,y2]
// format if there are more than 35 points will return NULL
matd_t* build_homography(image_u32_t* im, vx_buffer_t* buf, metrics_t met)
{
frame_t frame = {{0,0}, {im->width-1, im->height-1},
{0,0}, {1,1}};
int good_size = 0;
zarray_t* blobs = zarray_create(sizeof(node_t));
hsv_find_balls_blob_detector(im, frame, met, blobs, buf);
// remove unqualified blobs
if(met.qualify) {
for(int i = 0; i < zarray_size(blobs); i++) {
node_t n;
zarray_get(blobs, i, &n);
if(!blob_qualifies(im, &n, met, buf))
zarray_remove_index(blobs, i, 0);
}
}
if(zarray_size(blobs) == NUM_TARGETS ||zarray_size(blobs) == NUM_CHART_BLOBS) good_size = 1;
zarray_sort(blobs, compare);
int pix_array[zarray_size(blobs)*2];
// iterate through
int idx = 0;
double size = 2.0;
for(int i = 0; i < zarray_size(blobs); i++) {
node_t n;
zarray_get(blobs, i, &n);
loc_t center = { .x = n.ave_loc.x/n.num_children,
.y = n.ave_loc.y/n.num_children};
loc_t parent = { .x = n.id % im->stride,
.y = n.id / im->stride};
if(buf != NULL) {
add_circle_to_buffer(buf, size, center, vx_maroon);
// add_circle_to_buffer(buf, size, parent, vx_olive);
// add_sides_to_buffer(im, buf, 1.0, &n, vx_orange, met);
loc_t* lp = fit_lines(im, &n, buf, met, NULL);
if(lp != NULL) {
// printf("(%d, %d) (%d, %d) (%d, %d) (%d, %d) \n",
// lp[0].x, lp[0].y, lp[1].x, lp[1].y, lp[2].x, lp[2].y, lp[3].x, lp[3].y);
loc_t intersect = get_line_intersection(lp[0], lp[1], lp[2], lp[3]);
if(in_range(im, intersect.x, intersect.y)) {
loc_t ext_lines[2];
extend_lines_to_edge_of_image(im, intersect, center, ext_lines);
add_line_to_buffer(im, buf, 2.0, ext_lines[0], ext_lines[1], vx_blue);
}
for(int i = 0; i < 4; i++) {
pix_array[i*2] = lp[i].x;
pix_array[i*2+1] = lp[i].y;
add_circle_to_buffer(buf, 3.0, lp[i], vx_orange);
}
}
free(n.sides);
// loc_t corners[4] = {{n.box.right, n.box.top},
// {n.box.right, n.box.bottom},
// {n.box.left, n.box.bottom},
// {n.box.left, n.box.top}};
// print extremes of box
// if(1) {
// add_circle_to_buffer(buf, size, corners[0], vx_green);
// add_circle_to_buffer(buf, size, corners[1], vx_yellow);
// add_circle_to_buffer(buf, size, corners[2], vx_red);
// add_circle_to_buffer(buf, size, corners[3], vx_blue);
// for(int j = 0; j < 4; j++) {
// // add_circle_to_buffer(buf, size, corners[j], vx_maroon);
// }
// }
}
}
matd_t* H;
H = dist_homography(pix_array, NUM_TARGETS);
// if(0) {//zarray_size(blobs) == NUM_CHART_BLOBS){
// H = dist_homography(pix_array, NUM_CHART_BLOBS);
// }
// else if(zarray_size(blobs) == NUM_TARGETS){
// H = dist_homography(pix_array, NUM_TARGETS);
// if(met.add_lines) connect_lines(blobs, buf);
// }
// else {
// if(met.dothis)
// printf("num figures: %d\n", zarray_size(blobs));
// return(NULL);
// }
// make projected points
// project_measurements_through_homography(H, buf, blobs, zarray_size(blobs));
zarray_destroy(blobs);
return(H);
}
/*
{ R00, R01, R02, TX,
R10, R11, R12, TY,
R20, R21, R22, TZ,
0, 0, 0, 1 });
*/
double get_rotation(const char* axis, matd_t* H)
{
double cosine, sine, theta;
if(strncmp(axis,"x", 1)) {
cosine = MATD_EL(H, 1, 1);
sine = MATD_EL(H, 2, 1);
}
else if(strncmp(axis,"y", 1)) {
cosine = MATD_EL(H, 0, 0);
sine = MATD_EL(H, 0, 2);
}
else if(strncmp(axis,"z", 1)) {
cosine = MATD_EL(H, 0, 0);
sine = MATD_EL(H, 1, 0);
}
else assert(0);
theta = atan2(sine, cosine);
return(theta);
}
// if buf is NULL, will not fill with points of the homography
void take_measurements(image_u32_t* im, vx_buffer_t* buf, metrics_t met)
{
// form homography
matd_t* H = build_homography(im, buf, met);
if(H == NULL) return;
// get model view from homography
matd_t* Model = homography_to_pose(H, 654, 655, 334, 224);
// printf("\n");
// matd_print(H, matrix_format);
// printf("\n\n");
// printf("model:\n");
// matd_print(Model, "%15f");
// printf("\n\n");
// matd_print(matd_op("M^-1",Model), matrix_format);
// printf("\n");
// extrapolate metrics from model view
double TX = MATD_EL(Model, 0, 3);
double TY = MATD_EL(Model, 1, 3);
double TZ = MATD_EL(Model, 2, 3);
// double rot_x = get_rotation("x", H);
// double rot_y = get_rotation("y", H);
// double rot_z = get_rotation("z", H);
double cosine = MATD_EL(Model, 0, 0);
double rot_z = acos(cosine) * 180/1.5 - 180;
cosine = MATD_EL(Model, 2, 2);
double rot_x = asin(cosine) * 90/1.3 + 90;
cosine = MATD_EL(Model, 1, 1);
double rot_y = asin(cosine);
char str[200];
sprintf(str, "<<#00ffff,serif-30>> DIST:%lf Offset:(%lf, %lf)\n rot: (%lf, %lf, %lf)\n",
TZ, TX, TY, rot_x, rot_y, rot_z);
vx_object_t *text = vxo_text_create(VXO_TEXT_ANCHOR_BOTTOM_LEFT, str);
vx_buffer_add_back(buf, vxo_pix_coords(VX_ORIGIN_BOTTOM_LEFT, text));
// printf("dist: %lf cos:%lf angle: %lf\n", TZ, cosine, theta);
}
loc_t* fit_lines(image_u32_t* im, node_t* n, vx_buffer_t* buf, metrics_t met, loc_t* out)
{
// usleep(2000000);
srand(time(NULL));
// isolate valid entries
zarray_t* loc_arr = zarray_create(sizeof(loc_t*));
for(int i = 0; i < im->height; i++) {
if(n->sides[i].leftmost.x == im->width) continue; // not apart of blob
loc_t* loc = malloc(sizeof(loc_t));
loc->x = n->sides[i].leftmost.x;
loc->y = n->sides[i].leftmost.y;
loc->valid = 0;
zarray_add(loc_arr, &loc);
}
for(int i = 0; i < im->height; i++) {
if(n->sides[i].rightmost.x == -1) continue;
loc_t* loc = malloc(sizeof(loc_t));
loc->x = n->sides[i].rightmost.x;
loc->y = n->sides[i].rightmost.y;
loc->valid = 0;
zarray_add(loc_arr, &loc);
}
// printf("\n\nall\n");
// for(int i = 0; i < zarray_size(loc_arr); i++)
// {
// loc_t* p1;
// zarray_get(loc_arr, i, &p1);
// printf("(%d, %d)\n", p1->x, p1->y);
// }
// printf("\n\n");
int iterations = 0;
int best_score = 0;
int lines_found = 0;
loc_t line_match[8];
int max_iterations = 500;
while(lines_found < 2 && zarray_size(loc_arr) > met.num_outliers) // still a lot of points left
{
if(iterations > max_iterations) break;
// reset image and array
// vx_object_t *vim = vxo_image_from_u32(im, 0, 0);
// vx_buffer_add_back(buf, vxo_pix_coords(VX_ORIGIN_BOTTOM_LEFT, vim));
add_arr_of_locs_to_buffer(loc_arr, buf, 1.0, vx_black, met);
int num_outliers = met.num_outliers/met.consensus_accuracy;
while(best_score < ((zarray_size(loc_arr) - num_outliers)/(4 - lines_found)))
{
reset_locs(loc_arr);
// pick random sample (2 points)
loc_t* p1;
loc_t* p2;
zarray_get(loc_arr, (rand()%zarray_size(loc_arr)), &p1);
p2 = p1;
while(p1 == p2)
zarray_get(loc_arr, (rand()%zarray_size(loc_arr)), &p2); // don't get same point
// find consensus score of line from other points
// if inside consensus range add 1
int tmp_score = 0;
for(int j = 0; j < zarray_size(loc_arr); j++) {
loc_t* tmp;
zarray_get(loc_arr, j, &tmp);
if(fabs(dist_from_point_to_line(p1, p2, tmp)) < (double)met.consensus_accuracy)
{
tmp->valid = 1;
// printf("dist: (%d, %d, %d) %lf\n", tmp->x, tmp->y, tmp->valid,
// fabs(dist_from_point_to_line(p1, p2, tmp)));
tmp_score++;
}
}
// keep best line so far
if(tmp_score > best_score) {
if(lines_found != 0) { // if 2nd line intersects, throw it out and find another
loc_t intersect = get_line_intersection(line_match[0], line_match[1], *p1, *p2);
if(in_range(im, intersect.x, intersect.y)) continue;
}
best_score = tmp_score;
// printf(" score:%d, %d, %d %lf\n", best_score, ((zarray_size(loc_arr)-1)/(4-lines_found)),
// zarray_size(loc_arr), 10/met.std_dev_from_square);
line_match[lines_found*2] = *p1;
line_match[lines_found*2+1] = *p2;
}
iterations++;
if(iterations > max_iterations) break;
}
// loc_t ext_lines[2];
// extend_lines_to_edge_of_image(im, line_match[lines_found*2], line_match[lines_found*2+1], ext_lines);
// add_line_to_buffer(im, buf, 2.0, ext_lines[0], ext_lines[1], vx_yellow);
// delete all points associated with the found line
zarray_t* endpoints_arr = zarray_create(sizeof(loc_t*));
for(int i = 0; i < zarray_size(loc_arr); i++) {
loc_t* tmp;
zarray_get(loc_arr, i, &tmp);
// printf("removed: (%d, %d, %d) \n", tmp->x, tmp->y, tmp->valid);
if(tmp->valid)
{
// add_circle_to_buffer(buf, 1.0, *tmp, vx_red);
zarray_add(endpoints_arr, &tmp);
zarray_remove_index(loc_arr, i, 0);
i--;
}
}
// find endpoints of line
loc_t ext_lines[2];
extend_lines_to_edge_of_image(im, line_match[lines_found*2], line_match[lines_found*2+1], ext_lines);
line_t endpoints = find_line_endpoints(endpoints_arr, &ext_lines[0], &ext_lines[1]);
add_circle_to_buffer(buf, 2.0, endpoints.start, vx_red);
add_circle_to_buffer(buf, 2.0, endpoints.end, vx_red);
line_match[lines_found*2] = endpoints.start;
line_match[lines_found*2+1] = endpoints.end;
lines_found++;
best_score = 0;
// vx_buffer_swap(buf);
// usleep(500000);
}
loc_t* ret = calloc(lines_found*2, sizeof(loc_t));
for(int i = 0; i < lines_found; i++) {
ret[i*2] = line_match[i*2];
ret[i*2+1] = line_match[i*2+1];
loc_t ext_lines[2];
extend_lines_to_edge_of_image(im, line_match[i*2], line_match[i*2+1], ext_lines);
add_line_to_buffer(im, buf, 2.0, ext_lines[0], ext_lines[1], vx_blue);
}
zarray_vmap(loc_arr, free);
zarray_destroy(loc_arr);
return(ret);
// int corners_found = 0;
// loc_t corners[4];
// find_corners_from_lines(im,line_match, 4, &corners_found, corners);
// for(int i = 0; i < corners_found; i++) {
// printf("(%d, %d)\n", corners[i].x, corners[i].y);
// add_circle_to_buffer(buf, 3.0, corners[i], vx_blue);
// }
// printf("(%d, %d) (%d, %d) %lf\n", line_match[0].x, line_match[0].y,
// line_match[1].x, line_match[1].y,
// (double)best_score/N);
}
