void trace_flash (DNATrace *t) {
int x0, i;
Display *d = t->display;
Window w = Tk_WindowId(t->tkwin);
Pixmap tmp;
if (!Tk_IsMapped(t->tkwin) || Tk_WindowId(t->tkwin) == 0)
return;
x0 = point_to_pixel(t, trace_get_pos(t, t->cursor_pos));
tmp = Tk_GetPixmap(d, w, 24, t->pos[TRACEP_T].h, Tk_Depth(t->tkwin));
XCopyArea(d, w, tmp, t->CursorGC,
x0-12, t->pos[TRACEP_T].y, 24, t->pos[TRACEP_T].h, 0, 0);
for (i=12; i > 0; i-=3) {
XCopyArea(d, tmp, w, t->CursorGC,
0, 0, 24, t->pos[TRACEP_T].h, x0-12, t->pos[TRACEP_T].y);
XFillRectangle(d, w,
t->CursorGC,
x0 - i, t->pos[TRACEP_T].y,
i, t->pos[TRACEP_T].h);
XSync(d, False);
myusleep(20000);
}
XCopyArea(d, tmp, w, t->CursorGC,
0, 0, 24, t->pos[TRACEP_T].h, x0-12, t->pos[TRACEP_T].y);
Tk_FreePixmap(d, tmp);
}
/*
* Draw the numbers from pixel coordinates (x,y) to (x+width, y+height).
*/
void trace_draw_numbers(DNATrace *t, Display *d, Pixmap p,
int x0, int xn, int yoff, int height) {
int ind, pos, x1, fh, i;
float fwid, fw;
char number[10];
double xoff;
if (!p)
return;
x1 = x0 + xn < t->read->NPoints ? x0+xn : t->read->NPoints - 1;
x1 = t->tracePos[x1] + 1;
if (x1 >= t->read->NBases) x1--;
x1 = t->read->basePos[x1];
fw = t->font_width/2 + 1;
x0 -= 2*fw;
if (x0 < 0) x0 = 0;
ind = t->tracePos[x0]; /* Index of first base on screen */
if (ind < 1) ind = 1;
fwid = t->font_width;
fh = t->fm.ascent + yoff;
while (ind < t->read->NBases && (pos = t->read->basePos[ind-1]) <= x1) {
int cind = t->comp ? t->read->NBases - ind + 1: ind;
if (cind % 10 == 0) {
/* Base numbers are right aligned */
i = ABS(cind);
if (i >= 1000) {
fw = fwid * 3.5;
} else if (i >= 100) {
fw = fwid * 2.5;
} else if (i >= 10) {
fw = fwid * 1.5;
} else {
fw = fwid * .5;
}
/* Stick plots have A,C,G,T separated out, so move the number */
xoff = 0;
if (t->style == STYLE_STICK) {
switch (t->read->base[ind-1]) {
case 'A': case 'a': xoff = 0.00; break;
case 'C': case 'c': xoff = 0.15; break;
case 'G': case 'g': xoff = 0.30; break;
case 'T': case 't': xoff = 0.45; break;
}
}
sprintf(number, "%d", cind);
Tk_DrawChars(d, p, t->CursorGC, t->font, number, strlen(number),
point_to_pixel(t, pos + xoff) - fw, fh);
}
ind++;
}
}
/*
* Draw the sequence from pixel coordinates (x,y) to (x+width, y+height).
*/
void trace_draw_sequence(DNATrace *t, Display *d, Pixmap p,
int x0, int xn, int yoff, int height) {
int ind, pos, x1, fw, fh;
if( !p || !t || !t->read || (t->read->NBases==0) )
return;
x1 = x0 + xn < t->read->NPoints ? x0+xn : t->read->NPoints - 1;
x1 = t->tracePos[x1] + 1;
if (x1 >= t->read->NBases) x1--;
x1 = t->read->basePos[x1];
ind = t->tracePos[x0]; /* Index of first base on screen */
fw = t->font_width/2 + 1;
fh = t->fm.ascent + yoff;
while (ind < t->read->NBases && (pos = t->read->basePos[ind]) <= x1) {
char base = t->read->base[ind];
GC gc;
double xoff = 0;
switch (base) {
case 'A':
case 'a':
gc = t->Agc;
break;
case 'C':
case 'c':
gc = t->Cgc;
xoff = 0.15;
break;
case 'G':
case 'g':
gc = t->Ggc;
xoff = 0.3;
break;
case 'T':
case 't':
gc = t->Tgc;
xoff = 0.45;
break;
default:
gc = t->CursorGC;
}
/* XDrawString(d, p, gc, point_to_pixel(t, pos) - fw, fh, &base, 1); */
if (t->style != STYLE_STICK)
xoff = 0;
pos = point_to_pixel(t, (double)pos + xoff) - fw;
Tk_DrawChars(d, p, gc, t->font, &base, 1, pos, fh);
ind++;
}
}
void trace_update_extents(DNATrace *t, int *x0p, int *xnp) {
int ind, pos, x1, fw, cfw, new_x1;
int min = 999999;
int max = -999999;
int x0 = *x0p, xn = *xnp;
int new_x0, new_xn;
if (t->Ned <= 0)
return;
if (x0 < 0) x0 = 0;
if (x0 >= t->read->NPoints) x0 = t->read->NPoints-1;
x1 = x0 + xn < t->read->NPoints ? x0+xn : t->read->NPoints - 1;
x1 = t->tracePos[x1] + 1;
if (x1 >= t->read->NBases) x1--;
x1 = t->read->basePos[x1];
ind = t->tracePosE[x0]; /* Index of first base on screen */
fw = t->font_width/2 + 1;
cfw = t->conf_font_width;
while (ind < t->read->NBases && (pos = trace_get_pos(t, ind)) <= x1) {
pos = point_to_pixel(t, pos) - fw;
if (pos < min)
min = pos;
if (pos + cfw > max)
max = pos + cfw;
ind++;
}
new_x0 = (int)pixel_to_point(t, min-cfw/2-1);
new_xn = (int)pixel_to_point(t, max+cfw/2+1) - new_x0;
x1 = x0 + xn;
new_x1 = new_x0 + new_xn;
x0 = MIN(x0, new_x0);
x1 = MAX(x1, new_x1);
xn = x1 - x0;
if (x0 < 0) {
xn += x0;
x0 = 0;
}
if (x0 + xn > t->read->NPoints)
xn = t->read->NPoints - x0;
*x0p = x0;
*xnp = xn;
}
void gui_theme::ui_float::compute(const float& size) {
switch(type) {
case VALUE_TYPE::PIXEL:
// just clamp to size
value = std::min(ui_value, size);
break;
case VALUE_TYPE::PERCENTAGE:
// scale by size
value = ui_value * size;
break;
case VALUE_TYPE::POINT:
// convert point to pixel (-> multiply by dpi / 72)
value = point_to_pixel(ui_value);
break;
case VALUE_TYPE::CENTER:
// scale by size
value = 0.5f * size;
break;
}
}
/* asses_new_position() determines the nearest target on each camera around a
* search position and prepares the data structures accordingly with the
* determined target info or the unused flag value.
*
* Arguments:
* vec3d pos - the position around which to search.
* vec2d targ_pos[] - the determined targets' respective positions.
* int cand_inds[][MAX_CANDS] - output buffer, the determined targets' index in
* the respective camera's target list
* frame *frm - the frame holdin target data for the search position.
* tracking_run *run - scene information struct.
*
* Returns:
* the number of cameras where a suitable target was found.
*/
int assess_new_position(vec3d pos, vec2d targ_pos[],
int cand_inds[][MAX_CANDS], frame *frm, tracking_run *run)
{
int cam, num_cands, valid_cams, _ix;
vec2d pixel;
double right, left, down, up; /* search rectangle limits */
left = right = up = down = ADD_PART;
for (cam = 0; cam < run->cpar->num_cams; cam++) {
point_to_pixel(pixel, pos, run->cal[cam], run->cpar);
targ_pos[cam][0] = targ_pos[cam][1] = COORD_UNUSED;
/* here we shall use only the 1st neigbhour */
num_cands = candsearch_in_pix (frm->targets[cam], frm->num_targets[cam],
pixel[0], pixel[1], left, right, up, down,
cand_inds[cam], run->cpar);
if (num_cands > 0) {
_ix = cand_inds[cam][0]; // first nearest neighbour
targ_pos[cam][0] = frm->targets[cam][_ix].x;
targ_pos[cam][1] = frm->targets[cam][_ix].y;
}
}
valid_cams = 0;
for (cam = 0; cam < run->cpar->num_cams; cam++) {
if ((targ_pos[cam][0] != COORD_UNUSED) && \
(targ_pos[cam][1] != COORD_UNUSED))
{
pixel_to_metric(&(targ_pos[cam][0]), &(targ_pos[cam][1]),
targ_pos[cam][0], targ_pos[cam][1], run->cpar);
dist_to_flat(targ_pos[cam][0], targ_pos[cam][1], run->cal[cam],
&(targ_pos[cam][0]), &(targ_pos[cam][1]), run->flatten_tol);
valid_cams++;
}
}
return valid_cams;
}
void trace_draw_confidence(DNATrace *t, Display *d, Pixmap p,
int x0, int xn, int height) {
int ind, pos, x1, fw, cfw, cfh;
char b[5];
if (!p || t->Ned <= 0)
return;
x1 = x0 + xn < t->read->NPoints ? x0+xn : t->read->NPoints - 1;
x1 = t->tracePos[x1] + 1;
if (x1 >= t->read->NBases) x1--;
x1 = t->read->basePos[x1];
ind = t->tracePosE[x0]; /* Index of first base on screen */
fw = t->font_width/2 + 1;
cfh = t->conf_font_height;
cfw = t->conf_font_width;
while (ind < t->read->NBases && (pos = trace_get_pos(t, ind)) <= x1) {
int conf;
conf = t->edConf[ind];
if (conf < 100)
sprintf(b, "%02d", conf);
else
strcpy(b, "XX");
pos = point_to_pixel(t, pos) - fw;
XFillRectangle(d, p, t->ConfGC, pos, cfh,
cfw, (int)(conf * t->scale_conf));
Tk_DrawChars(d, p, t->ConfGC, t->conf_font, b, 2,
pos, cfh);
ind++;
}
}
/* track backwards */
double trackback_c (tracking_run *run_info, int step)
{
int i, j, h, in_volume = 0;
int philf[4][MAX_CANDS];
int count1 = 0, count2 = 0, num_added = 0;
int quali = 0;
double angle, acc, dl;
vec3d diff_pos, X[6]; /* 6 reference points used in the algorithm */
vec2d n[4], v2[4]; // replaces xn,yn, x2[4], y2[4],
double rr, Ymin = 0, Ymax = 0;
double npart = 0, nlinks = 0;
foundpix *w;
sequence_par *seq_par;
track_par *tpar;
volume_par *vpar;
control_par *cpar;
framebuf *fb;
Calibration **cal;
/* Shortcuts to inside current frame */
P *curr_path_inf, *ref_path_inf;
/* shortcuts */
cal = run_info->cal;
seq_par = run_info->seq_par;
tpar = run_info->tpar;
vpar = run_info->vpar;
cpar = run_info->cpar;
fb = run_info->fb;
/* Prime the buffer with first frames */
for (step = seq_par->last; step > seq_par->last - 4; step--) {
fb_read_frame_at_end(fb, step, 1);
fb_next(fb);
}
fb_prev(fb);
/* sequence loop */
for (step = seq_par->last - 1; step > seq_par->first; step--) {
printf ("Time step: %d, seqnr: %d:\n",
step - seq_par->first, step);
for (h = 0; h < fb->buf[1]->num_parts; h++) {
curr_path_inf = &(fb->buf[1]->path_info[h]);
/* We try to find link only if the forward search failed to. */
if ((curr_path_inf->next < 0) || (curr_path_inf->prev != -1)) continue;
for (j = 0; j < 6; j++) vec_init(X[j]);
curr_path_inf->inlist = 0;
/* 3D-position of current particle */
vec_copy(X[1], curr_path_inf->x);
/* use information from previous to locate new search position
and to calculate values for search area */
ref_path_inf = &(fb->buf[0]->path_info[curr_path_inf->next]);
vec_copy(X[0], ref_path_inf->x);
search_volume_center_moving(ref_path_inf->x, curr_path_inf->x, X[2]);
for (j = 0; j < fb->num_cams; j++) {
point_to_pixel (n[j], X[2], cal[j], cpar);
}
/* calculate searchquader and reprojection in image space */
w = sorted_candidates_in_volume(X[2], n, fb->buf[2], run_info);
if (w != NULL) {
count2++;
i = 0;
while (w[i].ftnr != TR_UNUSED) {
ref_path_inf = &(fb->buf[2]->path_info[w[i].ftnr]);
vec_copy(X[3], ref_path_inf->x);
vec_subt(X[1], X[3], diff_pos);
if (pos3d_in_bounds(diff_pos, tpar)) {
angle_acc(X[1], X[2], X[3], &angle, &acc);
/* *********************check link *****************************/
if ((acc < tpar->dacc && angle < tpar->dangle) || \
(acc < tpar->dacc/10))
{
dl = (vec_diff_norm(X[1], X[3]) +
vec_diff_norm(X[0], X[1]) )/2;
quali = w[i].freq;
rr = (dl/run_info->lmax + acc/tpar->dacc + \
angle/tpar->dangle)/quali;
register_link_candidate(curr_path_inf, rr, w[i].ftnr);
}
}
i++;
}
}
free(w);
/* if old wasn't found try to create new particle position from rest */
if (tpar->add) {
if ( curr_path_inf->inlist == 0) {
quali = assess_new_position(X[2], v2, philf, fb->buf[2], run_info);
if (quali>=2) {
//vec_copy(X[3], X[2]);
in_volume = 0;
point_position(v2, fb->num_cams, cpar->mm, cal, X[3]);
/* volume check */
if ( vpar->X_lay[0] < X[3][0] && X[3][0] < vpar->X_lay[1] &&
Ymin < X[3][1] && X[3][1] < Ymax &&
vpar->Zmin_lay[0] < X[3][2] && X[3][2] < vpar->Zmax_lay[1])
{in_volume = 1;}
vec_subt(X[1], X[3], diff_pos);
if (in_volume == 1 && pos3d_in_bounds(diff_pos, tpar)) {
angle_acc(X[1], X[2], X[3], &angle, &acc);
if ( (acc<tpar->dacc && angle<tpar->dangle) || \
(acc<tpar->dacc/10) )
{
dl = (vec_diff_norm(X[1], X[3]) +
vec_diff_norm(X[0], X[1]) )/2;
rr = (dl/run_info->lmax+acc/tpar->dacc + angle/tpar->dangle)/(quali);
register_link_candidate(curr_path_inf, rr, fb->buf[2]->num_parts);
add_particle(fb->buf[2], X[3], philf);
}
}
in_volume = 0;
}
}
} /* end of if old wasn't found try to create new particle position from rest */
} /* end of h-loop */
for (h = 0; h < fb->buf[1]->num_parts; h++) {
curr_path_inf = &(fb->buf[1]->path_info[h]);
if(curr_path_inf->inlist > 0 ) {
sort(curr_path_inf->inlist, (float *)curr_path_inf->decis,
curr_path_inf->linkdecis);
}
}
/* create links with decision check */
count1 = 0; num_added = 0;
for (h = 0; h < fb->buf[1]->num_parts; h++) {
curr_path_inf = &(fb->buf[1]->path_info[h]);
if (curr_path_inf->inlist > 0 ) {
/* if old/new and unused prev == -1 and next == -2 link is created */
ref_path_inf = &(fb->buf[2]->path_info[curr_path_inf->linkdecis[0]]);
if ( ref_path_inf->prev == PREV_NONE && \
ref_path_inf->next == NEXT_NONE )
{
curr_path_inf->finaldecis = curr_path_inf->decis[0];
curr_path_inf->prev = curr_path_inf->linkdecis[0];
fb->buf[2]->path_info[curr_path_inf->prev].next = h;
num_added++;
}
/* old which link to prev has to be checked */
if ((ref_path_inf->prev != PREV_NONE) && \
(ref_path_inf->next == NEXT_NONE) )
{
vec_copy(X[0], fb->buf[0]->path_info[curr_path_inf->next].x);
vec_copy(X[1], curr_path_inf->x);
vec_copy(X[3], ref_path_inf->x);
vec_copy(X[4], fb->buf[3]->path_info[ref_path_inf->prev].x);
for (j = 0; j < 3; j++)
X[5][j] = 0.5*(5.0*X[3][j] - 4.0*X[1][j] + X[0][j]);
angle_acc(X[3], X[4], X[5], &angle, &acc);
if ( (acc<tpar->dacc && angle<tpar->dangle) || (acc<tpar->dacc/10) ) {
curr_path_inf->finaldecis = curr_path_inf->decis[0];
curr_path_inf->prev = curr_path_inf->linkdecis[0];
fb->buf[2]->path_info[curr_path_inf->prev].next = h;
num_added++;
}
}
}
if (curr_path_inf->prev != PREV_NONE ) count1++;
} /* end of creation of links with decision check */
printf ("step: %d, curr: %d, next: %d, links: %d, lost: %d, add: %d",
step, fb->buf[1]->num_parts, fb->buf[2]->num_parts, count1,
fb->buf[1]->num_parts - count1, num_added);
/* for the average of particles and links */
npart = npart + fb->buf[1]->num_parts;
nlinks = nlinks + count1;
fb_next(fb);
fb_write_frame_from_start(fb, step);
if(step > seq_par->first + 2) { fb_read_frame_at_end(fb, step - 3, 1); }
} /* end of sequence loop */
/* average of all steps */
npart /= (seq_par->last - seq_par->first - 1);
nlinks /= (seq_par->last - seq_par->first - 1);
printf ("Average over sequence, particles: %5.1f, links: %5.1f, lost: %5.1f\n",
npart, nlinks, npart-nlinks);
fb_next(fb);
fb_write_frame_from_start(fb, step);
fb_free(fb);
free(fb);
free(tpar);
return nlinks;
}
/* trackcorr_c_loop is the main tracking subroutine that scans the 3D particle position
* data from rt_is.* files and the 2D particle positions in image space in _targets and
* constructs trajectories (links) of the particles in 3D in time.
* the basic concepts of the tracking procedure are from the following publication by
* Jochen Willneff: "A New Spatio-Temporal Matching Algorithm For 3D-Particle Tracking Velocimetry"
* https://www.mendeley.com/catalog/new-spatiotemporal-matching-algorithm-3dparticle-tracking-velocimetry/
* or http://e-collection.library.ethz.ch/view/eth:26978
* this method is an extension of the previously used tracking method described in details in
* Malik et al. 1993: "Particle tracking velocimetry in three-dimensional flows: Particle tracking"
* http://mnd.ly/2dCt3um
*
* Arguments:
* tracking_run *run_info pointer to the (sliding) frame dataset of 4 frames of particle positions
* and all the needed parameters underneath: control, volume, etc.
* integer step number or the frame number from the sequence
* Note: step is not really setting up the step to track, the buffer provided to the trackcoor_c_loop
* is already preset by 4 frames buf[0] to buf[3] and we track particles in buf[1], i.e. one "previous"
* one present and two future frames.
*
* Returns: function does not return an argument, the tracks are updated within the run_info dataset
*/
void trackcorr_c_loop (tracking_run *run_info, int step) {
/* sequence loop */
int j, h, mm, kk, in_volume = 0;
int philf[4][MAX_CANDS];
int count1 = 0, count2 = 0, count3 = 0, num_added = 0;
int quali = 0;
vec3d diff_pos, X[6]; /* 7 reference points used in the algorithm, TODO: check if can reuse some */
double angle, acc, angle0, acc0, dl;
double angle1, acc1;
vec2d v1[4], v2[4]; /* volume center projection on cameras */
double rr;
/* Shortcuts to inside current frame */
P *curr_path_inf, *ref_path_inf;
corres *curr_corres;
target **curr_targets;
int _ix; /* For use in any of the complex index expressions below */
int orig_parts; /* avoid infinite loop with particle addition set */
/* Shortcuts into the tracking_run struct */
Calibration **cal;
framebuf *fb;
track_par *tpar;
volume_par *vpar;
control_par *cpar;
foundpix *w, *wn;
count1 = 0; num_added = 0;
fb = run_info->fb;
cal = run_info->cal;
tpar = run_info->tpar;
vpar = run_info->vpar;
cpar = run_info->cpar;
curr_targets = fb->buf[1]->targets;
/* try to track correspondences from previous 0 - corp, variable h */
orig_parts = fb->buf[1]->num_parts;
for (h = 0; h < orig_parts; h++) {
for (j = 0; j < 6; j++) vec_init(X[j]);
curr_path_inf = &(fb->buf[1]->path_info[h]);
curr_corres = &(fb->buf[1]->correspond[h]);
curr_path_inf->inlist = 0;
/* 3D-position */
vec_copy(X[1], curr_path_inf->x);
/* use information from previous to locate new search position
and to calculate values for search area */
if (curr_path_inf->prev >= 0) {
ref_path_inf = &(fb->buf[0]->path_info[curr_path_inf->prev]);
vec_copy(X[0], ref_path_inf->x);
search_volume_center_moving(ref_path_inf->x, curr_path_inf->x, X[2]);
for (j = 0; j < fb->num_cams; j++) {
point_to_pixel (v1[j], X[2], cal[j], cpar);
}
} else {
vec_copy(X[2], X[1]);
for (j = 0; j < fb->num_cams; j++) {
if (curr_corres->p[j] == -1) {
point_to_pixel (v1[j], X[2], cal[j], cpar);
} else {
_ix = curr_corres->p[j];
v1[j][0] = curr_targets[j][_ix].x;
v1[j][1] = curr_targets[j][_ix].y;
}
}
}
/* calculate search cuboid and reproject it to the image space */
w = sorted_candidates_in_volume(X[2], v1, fb->buf[2], run_info);
if (w == NULL) continue;
/* Continue to find candidates for the candidates. */
count2++;
mm = 0;
while (w[mm].ftnr != TR_UNUSED) { /* counter1-loop */
/* search for found corr of current the corr in next
with predicted location */
/* found 3D-position */
ref_path_inf = &(fb->buf[2]->path_info[w[mm].ftnr]);
vec_copy(X[3], ref_path_inf->x);
if (curr_path_inf->prev >= 0) {
for (j = 0; j < 3; j++)
X[5][j] = 0.5*(5.0*X[3][j] - 4.0*X[1][j] + X[0][j]);
} else {
search_volume_center_moving(X[1], X[3], X[5]);
}
for (j = 0; j < fb->num_cams; j++) {
point_to_pixel (v1[j], X[5], cal[j], cpar);
}
/* end of search in pix */
wn = sorted_candidates_in_volume(X[5], v1, fb->buf[3], run_info);
if (wn != NULL) {
count3++;
kk = 0;
while (wn[kk].ftnr != TR_UNUSED) {
ref_path_inf = &(fb->buf[3]->path_info[wn[kk].ftnr]);
vec_copy(X[4], ref_path_inf->x);
vec_subt(X[4], X[3], diff_pos);
if ( pos3d_in_bounds(diff_pos, tpar)) {
angle_acc(X[3], X[4], X[5], &angle1, &acc1);
if (curr_path_inf->prev >= 0) {
angle_acc(X[1], X[2], X[3], &angle0, &acc0);
} else {
acc0 = acc1; angle0 = angle1;
}
acc = (acc0+acc1)/2; angle = (angle0+angle1)/2;
quali = wn[kk].freq+w[mm].freq;
if ((acc < tpar->dacc && angle < tpar->dangle) || \
(acc < tpar->dacc/10))
{
dl = (vec_diff_norm(X[1], X[3]) +
vec_diff_norm(X[4], X[3]) )/2;
rr = (dl/run_info->lmax + acc/tpar->dacc + \
angle/tpar->dangle)/(quali);
register_link_candidate(
curr_path_inf, rr, w[mm].ftnr);
}
}
kk++;
} /* End of searching 2nd-frame candidates. */
}
/* creating new particle position,
* reset img coord because of num_cams < 4
* fix distance of 3 pixels to define xl,xr,yu,yd instead of searchquader
* and search for unused candidates in next time step
*/
quali = assess_new_position(X[5], v2, philf, fb->buf[3], run_info);
/* quali >=2 means at least in two cameras
* we found a candidate
*/
if ( quali >= 2) {
in_volume = 0; //inside volume
dl = point_position(v2, cpar->num_cams, cpar->mm, cal, X[4]);
/* volume check */
if ( vpar->X_lay[0] < X[4][0] && X[4][0] < vpar->X_lay[1] &&
run_info->ymin < X[4][1] && X[4][1] < run_info->ymax &&
vpar->Zmin_lay[0] < X[4][2] && X[4][2] < vpar->Zmax_lay[1])
{
in_volume = 1;
}
vec_subt(X[3], X[4], diff_pos);
if ( in_volume == 1 && pos3d_in_bounds(diff_pos, tpar) ) {
angle_acc(X[3], X[4], X[5], &angle, &acc);
if ((acc < tpar->dacc && angle < tpar->dangle) || \
(acc < tpar->dacc/10))
{
dl = (vec_diff_norm(X[1], X[3]) +
vec_diff_norm(X[4], X[3]) )/2;
rr = (dl/run_info->lmax + acc/tpar->dacc + angle/tpar->dangle) /
(quali+w[mm].freq);
register_link_candidate(curr_path_inf, rr, w[mm].ftnr);
if (tpar->add) {
add_particle(fb->buf[3], X[4], philf);
num_added++;
}
}
}
in_volume = 0;
}
quali = 0;
/* end of creating new particle position */
/* *************************************************************** */
/* try to link if kk is not found/good enough and prev exist */
if ( curr_path_inf->inlist == 0 && curr_path_inf->prev >= 0 ) {
vec_subt(X[3], X[1], diff_pos);
if (pos3d_in_bounds(diff_pos, tpar)) {
angle_acc(X[1], X[2], X[3], &angle, &acc);
if ( (acc < tpar->dacc && angle < tpar->dangle) || \
(acc < tpar->dacc/10) )
{
quali = w[mm].freq;
dl = (vec_diff_norm(X[1], X[3]) +
vec_diff_norm(X[0], X[1]) )/2;
rr = (dl/run_info->lmax + acc/tpar->dacc + angle/tpar->dangle)/(quali);
register_link_candidate(curr_path_inf, rr, w[mm].ftnr);
}
}
}
free(wn);
mm++;
} /* end of loop over first-frame candidates. */
/* begin of inlist still zero */
if (tpar->add) {
if ( curr_path_inf->inlist == 0 && curr_path_inf->prev >= 0 ) {
quali = assess_new_position(X[2], v2, philf, fb->buf[2], run_info);
if (quali>=2) {
vec_copy(X[3], X[2]);
in_volume = 0;
dl = point_position(v2, fb->num_cams, cpar->mm, cal, X[3]);
/* in volume check */
if ( vpar->X_lay[0] < X[3][0] && X[3][0] < vpar->X_lay[1] &&
run_info->ymin < X[3][1] && X[3][1] < run_info->ymax &&
vpar->Zmin_lay[0] < X[3][2] &&
X[3][2] < vpar->Zmax_lay[1])
{
in_volume = 1;
}
vec_subt(X[2], X[3], diff_pos);
if ( in_volume == 1 && pos3d_in_bounds(diff_pos, tpar) ) {
angle_acc(X[1], X[2], X[3], &angle, &acc);
if ( (acc < tpar->dacc && angle < tpar->dangle) || \
(acc < tpar->dacc/10) )
{
dl = (vec_diff_norm(X[1], X[3]) +
vec_diff_norm(X[0], X[1]) )/2;
rr = (dl/run_info->lmax + acc/tpar->dacc + angle/tpar->dangle)/(quali);
register_link_candidate(curr_path_inf, rr, fb->buf[2]->num_parts);
add_particle(fb->buf[2], X[3], philf);
num_added++;
}
}
in_volume = 0;
} // if quali >= 2
}
}
/* end of inlist still zero */
/***********************************/
free(w);
} /* end of h-loop */
/* sort decis and give preliminary "finaldecis" */
for (h = 0; h < fb->buf[1]->num_parts; h++) {
curr_path_inf = &(fb->buf[1]->path_info[h]);
if(curr_path_inf->inlist > 0 ) {
sort(curr_path_inf->inlist, (float *) curr_path_inf->decis,
curr_path_inf->linkdecis);
curr_path_inf->finaldecis = curr_path_inf->decis[0];
curr_path_inf->next = curr_path_inf->linkdecis[0];
}
}
/* create links with decision check */
for (h = 0; h < fb->buf[1]->num_parts; h++) {
curr_path_inf = &(fb->buf[1]->path_info[h]);
if(curr_path_inf->inlist > 0 ) {
ref_path_inf = &(fb->buf[2]->path_info[curr_path_inf->next]);
if (ref_path_inf->prev == PREV_NONE) {
/* best choice wasn't used yet, so link is created */
ref_path_inf->prev = h;
} else {
/* best choice was already used by mega[2][mega[1][h].next].prev */
/* check which is the better choice */
if ( fb->buf[1]->path_info[ref_path_inf->prev].finaldecis > \
curr_path_inf->finaldecis)
{
/* remove link with prev */
fb->buf[1]->path_info[ref_path_inf->prev].next = NEXT_NONE;
ref_path_inf->prev = h;
} else {
curr_path_inf->next = NEXT_NONE;
}
}
}
if (curr_path_inf->next != NEXT_NONE ) count1++;
}
/* end of creation of links with decision check */
printf ("step: %d, curr: %d, next: %d, links: %d, lost: %d, add: %d\n",
step, fb->buf[1]->num_parts, fb->buf[2]->num_parts, count1,
fb->buf[1]->num_parts - count1, num_added);
/* for the average of particles and links */
run_info->npart = run_info->npart + fb->buf[1]->num_parts;
run_info->nlinks = run_info->nlinks + count1;
fb_next(fb);
fb_write_frame_from_start(fb, step);
if(step < run_info->seq_par->last - 2) {
fb_read_frame_at_end(fb, step + 3, 0);
}
} /* end of sequence loop */
/* searchquader defines the search region, using tracking parameters
* dvxmin, ... dvzmax (but within the image boundaries), per camera
* Its primary objective is to provide a safe search region in each camera
* to the following candidate search in pixels (candsearch_in_pix).
* We project a position of a center of search from 3D to the image space (pixels)
* and project also 8 corners in 3D of a cuboid on the image space
* The searchquader returns the distances from the center of search to the
* left, right, up and down, in any case not crossing the image size limits
* (0,0) and (cpar->imx, cpar->imy). If the point is on the border, the search
* region is only in the allowed directions.
* Arguments:
* vec3d point position in physical space
* track_par *tpar set of tracking parameters
* control_par *cpar set of control parameters for the num_cams
* Calibration *cal calibration per camera to find a projection of a 3D vertex
* of a cuboid in the image space.
* Returns the arrays xr,xl,yd,yu (right, left, down, up) per camera
* for the search of a quader (cuboid), given in pixel distances, relative to the
* point of search.
*/
void searchquader(vec3d point, double xr[4], double xl[4], double yd[4], \
double yu[4], track_par *tpar, control_par *cpar, Calibration **cal){
int i, pt, dim;
vec3d mins, maxes;
vec2d corner, center;
vec3d quader[8];
vec_set(mins, tpar->dvxmin, tpar->dvymin, tpar->dvzmin);
vec_set(maxes, tpar->dvxmax, tpar->dvymax, tpar->dvzmax);
/* 3D positions of search volume - eight corners of a box */
for (pt = 0; pt < 8; pt++) {
vec_copy(quader[pt], point);
for (dim = 0; dim < 3; dim++) {
if (pt & 1<<dim) {
quader[pt][dim] += maxes[dim];
} else {
quader[pt][dim] += mins[dim];
}
}
}
/* calculation of search area in each camera */
for (i = 0; i < cpar->num_cams; i++) {
/* initially large or small values */
xr[i] = 0;
xl[i] = cpar->imx;
yd[i] = 0;
yu[i] = cpar->imy;
/* pixel position of a search center */
point_to_pixel (center, point, cal[i], cpar);
/* mark 4 corners of the search region in pixels */
for (pt = 0; pt < 8; pt++) {
point_to_pixel (corner, quader[pt], cal[i], cpar);
if (corner[0] < xl[i] ) xl[i] = corner[0];
if (corner[1] < yu[i] ) yu[i] = corner[1];
if (corner[0] > xr[i] ) xr[i] = corner[0];
if (corner[1] > yd[i] ) yd[i] = corner[1];
}
if (xl[i] < 0 ) xl[i] = 0;
if (yu[i] < 0 ) yu[i] = 0;
if (xr[i] > cpar->imx)
xr[i] = cpar->imx;
if (yd[i] > cpar->imy)
yd[i] = cpar->imy;
/* eventually xr,xl,yd,yu are pixel distances relative to the point */
xr[i] = xr[i] - center[0];
xl[i] = center[0] - xl[i];
yd[i] = yd[i] - center[1];
yu[i] = center[1] - yu[i];
}
}
/*******************************************************************************
* GdipCreateFont [GDIPLUS.@]
*
* Create a new font based off of a FontFamily
*
* PARAMS
* *fontFamily [I] Family to base the font off of
* emSize [I] Size of the font
* style [I] Bitwise OR of FontStyle enumeration
* unit [I] Unit emSize is measured in
* **font [I] the resulting Font object
*
* RETURNS
* SUCCESS: Ok
* FAILURE: InvalidParameter if fontfamily or font is NULL.
* FAILURE: FontFamilyNotFound if an invalid FontFamily is given
*
* NOTES
* UnitDisplay is unsupported.
* emSize is stored separately from lfHeight, to hold the fraction.
*/
GpStatus WINGDIPAPI GdipCreateFont(GDIPCONST GpFontFamily *fontFamily,
REAL emSize, INT style, Unit unit, GpFont **font)
{
WCHAR facename[LF_FACESIZE];
LOGFONTW* lfw;
const NEWTEXTMETRICW* tmw;
GpStatus stat;
if (!fontFamily || !font)
return InvalidParameter;
TRACE("%p (%s), %f, %d, %d, %p\n", fontFamily,
debugstr_w(fontFamily->FamilyName), emSize, style, unit, font);
stat = GdipGetFamilyName (fontFamily, facename, 0);
if (stat != Ok) return stat;
*font = GdipAlloc(sizeof(GpFont));
tmw = &fontFamily->tmw;
lfw = &((*font)->lfw);
ZeroMemory(&(*lfw), sizeof(*lfw));
lfw->lfWeight = tmw->tmWeight;
lfw->lfItalic = tmw->tmItalic;
lfw->lfUnderline = tmw->tmUnderlined;
lfw->lfStrikeOut = tmw->tmStruckOut;
lfw->lfCharSet = tmw->tmCharSet;
lfw->lfPitchAndFamily = tmw->tmPitchAndFamily;
lstrcpynW(lfw->lfFaceName, facename, LF_FACESIZE);
switch (unit)
{
case UnitWorld:
/* FIXME: Figure out when World != Pixel */
lfw->lfHeight = emSize; break;
case UnitDisplay:
FIXME("Unknown behavior for UnitDisplay! Please report!\n");
/* FIXME: Figure out how this works...
* MSDN says that if "DISPLAY" is a monitor, then pixel should be
* used. That's not what I got. Tests on Windows revealed no output,
* and the tests in tests/font crash windows */
lfw->lfHeight = 0; break;
case UnitPixel:
lfw->lfHeight = emSize; break;
case UnitPoint:
lfw->lfHeight = point_to_pixel(emSize); break;
case UnitInch:
lfw->lfHeight = inch_to_pixel(emSize); break;
case UnitDocument:
lfw->lfHeight = document_to_pixel(emSize); break;
case UnitMillimeter:
lfw->lfHeight = mm_to_pixel(emSize); break;
}
lfw->lfHeight *= -1;
lfw->lfWeight = style & FontStyleBold ? 700 : 400;
lfw->lfItalic = style & FontStyleItalic;
lfw->lfUnderline = style & FontStyleUnderline;
lfw->lfStrikeOut = style & FontStyleStrikeout;
(*font)->unit = unit;
(*font)->emSize = emSize;
(*font)->height = tmw->ntmSizeEM;
(*font)->line_spacing = tmw->tmAscent + tmw->tmDescent + tmw->tmExternalLeading;
TRACE("<-- %p\n", *font);
return Ok;
}
/*
* Draw the edited seq. from pixel coordinates (x,y) to (x+width, y+height).
*/
void trace_draw_edits(DNATrace *t, Display *d, Pixmap p,
int x0, int xn, int yoff, int height) {
int ind, pos, x1, fw, fh;
if( !p || !t || !t->read || (t->read->NBases==0) )
return;
x0 -= 4;
if (x0 < 0) x0 = 0;
xn += 8;
x1 = x0 + xn < t->read->NPoints ? x0+xn : t->read->NPoints - 1;
x1 = t->tracePos[x1] + 1;
if (x1 >= t->read->NBases) x1--;
x1 = t->read->basePos[x1];
ind = t->tracePosE[x0]; /* Index of first base on screen */
fw = t->font_width/2 + 1;
fh = t->fm.ascent + yoff;
while (ind < t->Ned && (pos = trace_get_pos(t, ind)) <= x1) {
char base;
GC gc;
base = t->edBases[ind];
switch (base) {
case 'A':
case 'a':
gc = t->Agc;
break;
case 'C':
case 'c':
gc = t->Cgc;
break;
case 'G':
case 'g':
gc = t->Ggc;
break;
case 'T':
case 't':
gc = t->Tgc;
break;
default:
gc = t->CursorGC;
}
/* XDrawString(d, p, gc, point_to_pixel(t, pos) - fw, fh, &base, 1); */
Tk_DrawChars(d, p, gc, t->font, &base, 1,
point_to_pixel(t, pos) - fw, fh);
ind++;
}
/* Cursor */
if (t->cursor_pos > 0)
pos = trace_get_pos(t, t->cursor_pos-1);
else
pos = 0;
XFillRectangle(d, p, t->CursorGC, point_to_pixel(t, pos)+4,
t->fm.linespace-3, 8, 3);
}
/*
* Draw a trace from pixel coordinates (x0,0) to (x0+xn, height).
*/
void trace_draw_trace(DNATrace *t, Display *d, Pixmap p,
int x0, int xn, int yoff, int height) {
double yscale;
int m = t->read->maxTraceVal;
if (x0 < 0) {
xn += x0;
x0 = 0;
if (xn <= 0)
return;
}
if (x0 + xn > t->read->NPoints)
xn = t->read->NPoints - x0;
trace_update_extents(t, &x0, &xn);
if (xn <= 0)
return;
if (t->show_conf) {
if (t->style == STYLE_STICK)
trace_draw_confidence4(t, d, p, x0, xn, height);
else
trace_draw_confidence(t, d, p, x0, xn, height);
}
if (t->read->traceA == 0 || p == 0)
return;
if (t->read->maxTraceVal) {
int c = (t->show_conf && t->style == STYLE_STICK) ? 20 : 0;
yscale = (double)(t->scale_y * (height-1-c)) /
(double)(t->trace_scale ? t->trace_scale : t->read->maxTraceVal);
} else {
yscale = 0;
}
switch (t->style) {
case STYLE_CHROMA:
trace_draw2(t, &t->read->traceA[x0], d, p, m,
t->Agc, x0, xn, yoff, height, yscale,
t->read->baseline, 1);
trace_draw2(t, &t->read->traceC[x0], d, p, m,
t->Cgc, x0, xn, yoff, height, yscale,
t->read->baseline, 1);
trace_draw2(t, &t->read->traceG[x0], d, p, m,
t->Ggc, x0, xn, yoff, height, yscale,
t->read->baseline, 1);
trace_draw2(t, &t->read->traceT[x0], d, p, m,
t->Tgc, x0, xn, yoff, height, yscale,
t->read->baseline, 1);
break;
#if 0
case STYLE_FILLED:
trace_draw2filled(t, d, p, m, x0, xn, height, yscale,
t->read->baseline);
break;
#endif
case STYLE_PYRO:
trace_draw_hist(t, &t->read->traceA[x0], d, p, m,
t->Agc, x0, xn, yoff, height, yscale,
t->read->baseline);
trace_draw_hist(t, &t->read->traceC[x0], d, p, m,
t->Cgc, x0, xn, yoff, height, yscale,
t->read->baseline);
trace_draw_hist(t, &t->read->traceG[x0], d, p, m,
t->Ggc, x0, xn, yoff, height, yscale,
t->read->baseline);
trace_draw_hist(t, &t->read->traceT[x0], d, p, m,
t->Tgc, x0, xn, yoff, height, yscale,
t->read->baseline);
break;
case STYLE_STICK:
trace_draw_hist(t, &t->read->traceA[x0], d, p, m,
t->Agc, x0, xn, yoff, height, yscale,
t->read->baseline);
trace_draw_hist(t, &t->read->traceC[x0], d, p, m,
t->Cgc, x0+.15, xn, yoff, height, yscale,
t->read->baseline);
trace_draw_hist(t, &t->read->traceG[x0], d, p, m,
t->Ggc, x0+.3, xn, yoff, height, yscale,
t->read->baseline);
trace_draw_hist(t, &t->read->traceT[x0], d, p, m,
t->Tgc, x0+.45, xn, yoff, height, yscale,
t->read->baseline);
/* trace_draw_pyro(t, d, p, x0, xn, yoff, height, yscale); */
break;
}
if (t->yticks)
trace_draw_yticks(t, d, p, t->CursorGC, x0, xn, yoff, height,
yscale, t->read->baseline);
if (t->show_edits == 0) {
int pos;
pos = point_to_pixel(t, trace_get_pos(t, t->cursor_pos));
XFillRectangle(d, p, t->CursorGC, pos-1, yoff, 1, height);
}
}
/*
* Draws the 4 confidence values produced by Solexa in their +/- log-odds
* encoding.
*
* NB: Only works when trace editing hasn't been performed
*/
void trace_draw_confidence4(DNATrace *t, Display *d, Pixmap p,
int x0, int xn, int height) {
int ind, x1, fw, cfh, cfw;
char b[5];
double pos;
if (!p || t->Ned <= 0)
return;
x1 = x0 + xn < t->read->NPoints ? x0+xn : t->read->NPoints - 1;
x1 = t->tracePos[x1] + 1;
if (x1 >= t->read->NBases) x1--;
x1 = t->read->basePos[x1];
ind = t->tracePosE[x0]; /* Index of first base on screen */
fw = t->font_width/2 + 1;
cfh = t->conf_font_height;
cfw = t->conf_font_width;
while (ind < t->read->NBases && (pos = trace_get_pos(t, ind)) <= x1) {
int conf;
int edind;
double xoff;
/* Called confidence value */
conf = (signed char)(t->edConf[ind]);
if (conf < 100)
sprintf(b, "%02d", conf);
else
strcpy(b, "XX");
xoff = 0;
switch (t->read->base[ind]) {
case 'A': case 'a': xoff = 0.00; break;
case 'C': case 'c': xoff = 0.15; break;
case 'G': case 'g': xoff = 0.30; break;
case 'T': case 't': xoff = 0.45; break;
}
Tk_DrawChars(d, p, t->ConfGC, t->conf_font, b, 2,
point_to_pixel(t, pos + xoff)-fw, cfh);
/* Graphics bars for 4 confidence values */
edind = t->edPos[ind];
pos = point_to_pixel(t, pos);
if (edind) {
int i;
for (i = 0; i < 4; i++, pos += .15 * t->scale_x) {
int v;
switch(i) {
case 0: v = t->read->prob_A[ind]; break;
case 1: v = t->read->prob_C[ind]; break;
case 2: v = t->read->prob_G[ind]; break;
case 3: v = t->read->prob_T[ind]; break;
}
if (v >= 0)
XFillRectangle(d, p, t->ConfGC, pos-fw, cfh+30-v, cfw, v);
else
XFillRectangle(d, p, t->ConfNegGC, pos, cfh+30, 3, -v);
/*
if (v >= 0)
XFillRectangle(d, p, t->ConfGC, pos-1, cfh, 5, v);
else
XFillRectangle(d, p, t->ConfNegGC, pos, cfh, 3, -v);
*/
}
}
ind++;
}
}
