int main(){
int i;
pt debut = 0;
pt fin = _largeur/2 +1;
double* mesh = init_tab_mesh();
obstacle(mesh);
//double bottom_left[2] = { 10, 10 };
//double top_right[2] = { 15, 15 };
//generate_rectangle(bottom_left, top_right, mesh);
double* dist = tab_distance(mesh, debut, fin);
printf("\n");
for(i=0; i<_largeur*_largeur;i++){
if(i%_largeur == 0) printf("\n");
printf("%d\t", (int)dist[i]);
}
printf("\n");
save_dist(dist, "distance.vtk");
pt* chemin = court_chemin_bis(dist, fin);
save_path(dist, fin, chemin, "path.vtk");
printf("\n");
for(i=0; i< dist[fin]; i++)
printf("%d \t %d \n", chemin[i]/_largeur, chemin[i]%_largeur);
free(mesh);
free(dist);
return 0;
}
static void fit_curves(args_t *args)
{
peakfit_t *pkf = peakfit_init();
peakfit_verbose(pkf,args->verbose);
int i, nmc = 50;
for (i=0; i<args->ndist; i++)
{
dist_t *dist = &args->dist[i];
save_dist(args, &args->dist[i]);
if ( dist->copy_number!=0 )
{
fprintf(args->dat_fp,"CN\t%s\t%.2f\n", dist->chr,(float)dist->copy_number);
continue;
}
if ( args->verbose )
fprintf(stderr,"%s:\n", dist->chr);
int nrr_aa = dist->iaa - dist->irr + 1;
int nrr_ra = dist->ira - dist->irr + 1;
int naa_max = dist->nvals - dist->iaa;
double xrr = dist->xvals[dist->irr], *xrr_vals = &dist->xvals[dist->irr], *yrr_vals = &dist->yvals[dist->irr];
double xaa = dist->xvals[dist->iaa], *xaa_vals = &dist->xvals[dist->iaa], *yaa_vals = &dist->yvals[dist->iaa];
double xra = dist->xvals[dist->ira];
double xmax = dist->xvals[dist->nvals-1];
// CN2
double cn2aa_fit = 0, cn2ra_fit, cn2_fit;
char *cn2aa_func = 0, *cn2ra_func;
double cn2aa_params[3] = {1,1,1} ,cn2ra_params[3];
if ( args->include_aa )
{
peakfit_reset(pkf);
peakfit_add_exp(pkf, 1.0,1.0,0.2, 5);
peakfit_set_mc(pkf, 0.01,0.3,2,nmc);
peakfit_set_mc(pkf, 0.05,1.0,0,nmc);
cn2aa_fit = peakfit_run(pkf, naa_max, xaa_vals, yaa_vals);
cn2aa_func = strdup(peakfit_sprint_func(pkf));
peakfit_get_params(pkf,0,cn2aa_params,3);
}
peakfit_reset(pkf);
peakfit_add_bounded_gaussian(pkf, 1.0,0.5,0.03, 0.45,0.55, 7);
peakfit_set_mc(pkf, 0.01,0.3,2,nmc);
peakfit_set_mc(pkf, 0.05,1.0,0,nmc);
cn2ra_fit = peakfit_run(pkf, nrr_aa,xrr_vals,yrr_vals);
cn2ra_func = strdup(peakfit_sprint_func(pkf));
cn2_fit = cn2ra_fit + cn2aa_fit;
peakfit_get_params(pkf,0,cn2ra_params,3);
// CN3: fit two peaks, then enforce the symmetry and fit again
double cn3rra_params[5], cn3raa_params[5], *cn3aa_params = cn2aa_params;
double cn3aa_fit = cn2aa_fit, cn3ra_fit;
char *cn3aa_func = cn2aa_func, *cn3ra_func;
double min_dx3 = 0.5 - 1./(args->min_fraction+2);
peakfit_reset(pkf);
peakfit_add_bounded_gaussian(pkf, 1.0,1/3.,0.03, xrr,xra-min_dx3, 7);
peakfit_set_mc(pkf, xrr,xra-min_dx3, 1,nmc);
peakfit_add_bounded_gaussian(pkf, 1.0,2/3.,0.03, xra+min_dx3,xaa, 7);
peakfit_set_mc(pkf, xra+min_dx3,xaa, 1,nmc);
peakfit_run(pkf, nrr_aa, xrr_vals, yrr_vals);
// force symmetry around x=0.5
peakfit_get_params(pkf,0,cn3rra_params,5);
peakfit_get_params(pkf,1,cn3raa_params,5);
double cn3_dx = (0.5-cn3rra_params[1] + cn3raa_params[1]-0.5)*0.5;
if ( cn3_dx > 0.5/3 ) cn3_dx = 0.5/3; // CN3 peaks should not be separated by more than 1/3
peakfit_reset(pkf);
peakfit_add_gaussian(pkf, cn3rra_params[0],0.5-cn3_dx,cn3rra_params[2], 5);
peakfit_add_gaussian(pkf, cn3raa_params[0],0.5+cn3_dx,cn3raa_params[2], 5);
cn3ra_fit = peakfit_run(pkf, nrr_aa, xrr_vals, yrr_vals);
cn3ra_func = strdup(peakfit_sprint_func(pkf));
// compare peak sizes
peakfit_get_params(pkf,0,cn3rra_params,3);
peakfit_get_params(pkf,1,cn3raa_params,3);
double cn3rra_size = cn3rra_params[0]*cn3rra_params[0];
double cn3raa_size = cn3raa_params[0]*cn3raa_params[0];
double cn3_dy = cn3rra_size > cn3raa_size ? cn3raa_size/cn3rra_size : cn3rra_size/cn3raa_size;
double cn3_frac = (1 - 2*cn3rra_params[1]) / cn3rra_params[1];
double cn3_fit = cn3ra_fit + cn3aa_fit;
// A very reasonable heuristics: check if the peak's width converged, exclude far too broad or far too narrow peaks
if ( cn3rra_params[2]>0.3 || cn3raa_params[2]>0.3 ) cn3_fit = HUGE_VAL;
if ( cn3rra_params[2]<1e-2 || cn3raa_params[2]<1e-2 ) cn3_fit = HUGE_VAL;
// CN4 (contaminations)
// - first fit only the [0,0.5] part of the data, then enforce the symmetry and fit again
// - min_frac=1 (resp. 0.5) is interpreted as 50:50% (rep. 75:25%) contamination
double cn4AAaa_params[3] = {1,1,1} ,cn4AAra_params[3] = {1,1,1}, cn4RAra_params[3], cn4RArr_params[5], cn4RAaa_params[5];
double cn4aa_fit = 0, cn4ra_fit;
char *cn4aa_func = 0, *cn4ra_func;
double min_dx4 = 0.25*args->min_fraction;
if ( args->include_aa )
{
peakfit_reset(pkf);
peakfit_add_exp(pkf, 0.5,1.0,0.2, 5);
peakfit_set_mc(pkf, 0.01,0.3,2,nmc);
peakfit_add_bounded_gaussian(pkf, 0.4,(xaa+xmax)*0.5,2e-2, xaa,xmax, 7);
peakfit_set_mc(pkf, xaa,xmax, 1,nmc);
cn4aa_fit = peakfit_run(pkf, naa_max, xaa_vals,yaa_vals);
cn4aa_func = strdup(peakfit_sprint_func(pkf));
peakfit_get_params(pkf,0,cn4AAaa_params,3);
peakfit_get_params(pkf,1,cn4AAra_params,5);
}
peakfit_reset(pkf);
// first fit only the [0,0.5] part of the data
peakfit_add_gaussian(pkf, 1.0,0.5,0.03, 5);
peakfit_add_bounded_gaussian(pkf, 0.6,0.3,0.03, xrr,xra-min_dx4, 7);
peakfit_set_mc(pkf, xrr,xra-min_dx4,2,nmc);
peakfit_run(pkf, nrr_ra , xrr_vals, yrr_vals);
// now forcet symmetry around x=0.5
peakfit_get_params(pkf,0,cn4RAra_params,3);
peakfit_get_params(pkf,1,cn4RArr_params,5);
double cn4_dx = 0.5-cn4RArr_params[1];
if ( cn4_dx > 0.25 ) cn4_dx = 0.25; // CN4 peaks should not be separated by more than 0.5
peakfit_reset(pkf);
peakfit_add_gaussian(pkf, cn4RAra_params[0],0.5,cn4RAra_params[2], 5);
peakfit_add_gaussian(pkf, cn4RArr_params[0],0.5-cn4_dx,cn4RArr_params[2], 5);
peakfit_add_gaussian(pkf, cn4RArr_params[0],0.5+cn4_dx,cn4RArr_params[2], 5);
peakfit_set_mc(pkf, 0.1,cn4RAra_params[0],0,nmc);
peakfit_set_mc(pkf, 0.01,0.1,2,nmc);
cn4ra_fit = peakfit_run(pkf, nrr_aa , xrr_vals, yrr_vals);
cn4ra_func = strdup(peakfit_sprint_func(pkf));
peakfit_get_params(pkf,0,cn4RAra_params,3);
peakfit_get_params(pkf,1,cn4RArr_params,3);
peakfit_get_params(pkf,2,cn4RAaa_params,3);
double cn4RAra_size = cn4RAra_params[0]==0 ? HUGE_VAL : cn4RAra_params[0]*cn4RAra_params[0];
double cn4RArr_size = cn4RArr_params[0]*cn4RArr_params[0];
double cn4RAaa_size = cn4RAaa_params[0]*cn4RAaa_params[0];
double cn4RArr_dy = cn4RArr_size < cn4RAra_size ? cn4RArr_size/cn4RAra_size : cn4RAra_size/cn4RArr_size;
double cn4RAaa_dy = cn4RAaa_size < cn4RAra_size ? cn4RAaa_size/cn4RAra_size : cn4RAra_size/cn4RAaa_size;
double cn4_dy = cn4RArr_dy < cn4RAaa_dy ? cn4RArr_dy/cn4RAaa_dy : cn4RAaa_dy/cn4RArr_dy;
double cn4_ymin = cn4RArr_size < cn4RAaa_size ? cn4RArr_size/cn4RAra_size : cn4RAaa_size/cn4RAra_size;
cn4_dx = (cn4RAaa_params[1]-0.5) - (0.5-cn4RArr_params[1]);
double cn4_frac = cn4RAaa_params[1] - cn4RArr_params[1];
double cn4_fit = cn4ra_fit + cn4aa_fit;
// A very reasonable heuristics: check if the peak's width converged, exclude far too broad or far too narrow peaks
if ( cn4RAra_params[2]>0.3 || cn4RArr_params[2]>0.3 || cn4RAaa_params[2]>0.3 ) cn4_fit = HUGE_VAL;
if ( cn4RAra_params[2]<1e-2 || cn4RArr_params[2]<1e-2 || cn4RAaa_params[2]<1e-2 ) cn4_fit = HUGE_VAL;
// Choose the best match
char cn2_fail = '*', cn3_fail = '*', cn4_fail = '*';
if ( cn2_fit > args->fit_th ) cn2_fail = 'f';
if ( cn3_fit > args->fit_th ) cn3_fail = 'f';
else if ( cn3_dy < args->peak_symmetry ) cn3_fail = 'y'; // size difference is too big
if ( cn4_fit > args->fit_th ) cn4_fail = 'f';
else if ( cn4_ymin < args->min_peak_size ) cn4_fail = 'y'; // side peak is too small
else if ( cn4_dy < args->peak_symmetry ) cn4_fail = 'Y'; // size difference is too big
else if ( cn4_dx > 0.1 ) cn4_fail = 'x'; // side peaks placed assymetrically
double cn = -1, fit = cn2_fit;
if ( cn2_fail == '*' ) { cn = 2; fit = cn2_fit; }
if ( cn3_fail == '*' )
{
// Use cn_penalty as a tiebreaker. If set to 0.3, cn3_fit must be 30% smaller than cn2_fit.
if ( cn<0 || cn3_fit < (1-args->cn_penalty) * fit )
{
cn = 2 + cn3_frac;
fit = cn3_fit;
if ( cn2_fail=='*' ) cn2_fail = 'p';
}
else cn3_fail = 'p';
}
if ( cn4_fail == '*' )
{
if ( cn<0 || cn4_fit < (1-args->cn_penalty) * fit )
{
cn = 3 + cn4_frac;
fit = cn4_fit;
if ( cn2_fail=='*' ) cn2_fail = 'p';
if ( cn3_fail=='*' ) cn3_fail = 'p';
}
else cn4_fail = 'p';
}
if ( args->verbose )
{
fprintf(stderr,"\tcn2 %c fit=%e\n", cn2_fail, cn2_fit);
fprintf(stderr,"\t .. %e\n", cn2ra_fit);
fprintf(stderr,"\t RA: %f %f %f\n", cn2ra_params[0],cn2ra_params[1],cn2ra_params[2]);
fprintf(stderr,"\t .. %e\n", cn2aa_fit);
fprintf(stderr,"\t AA: %f %f %f\n", cn2aa_params[0],cn2aa_params[1],cn2aa_params[2]);
fprintf(stderr,"\t func:\n");
fprintf(stderr,"\t %s\n", cn2ra_func);
fprintf(stderr,"\t %s\n", cn2aa_func);
fprintf(stderr,"\n");
fprintf(stderr,"\tcn3 %c fit=%e frac=%f symmetry=%f\n", cn3_fail, cn3_fit, cn3_frac, cn3_dy);
fprintf(stderr,"\t .. %e\n", cn3ra_fit);
fprintf(stderr,"\t RRA: %f %f %f\n", cn3rra_params[0],cn3rra_params[1],cn3rra_params[2]);
fprintf(stderr,"\t RAA: %f %f %f\n", cn3raa_params[0],cn3raa_params[1],cn3raa_params[2]);
fprintf(stderr,"\t .. %e\n", cn3aa_fit);
fprintf(stderr,"\t AAA: %f %f %f\n", cn3aa_params[0],cn3aa_params[1],cn3aa_params[2]);
fprintf(stderr,"\t func:\n");
fprintf(stderr,"\t %s\n", cn3ra_func);
fprintf(stderr,"\t %s\n", cn3aa_func);
fprintf(stderr,"\n");
fprintf(stderr,"\tcn4 %c fit=%e frac=%f symmetry=%f ymin=%f\n", cn4_fail, cn4_fit, cn4_frac, cn4_dy, cn4_ymin);
fprintf(stderr,"\t .. %e\n", cn4ra_fit);
fprintf(stderr,"\t RArr: %f %f %f\n", cn4RArr_params[0],cn4RArr_params[1],cn4RArr_params[2]);
fprintf(stderr,"\t RAra: %f %f %f\n", cn4RAra_params[0],cn4RAra_params[1],cn4RAra_params[2]);
fprintf(stderr,"\t RAaa: %f %f %f\n", cn4RAaa_params[0],cn4RAaa_params[1],cn4RAaa_params[2]);
fprintf(stderr,"\t .. %e\n", cn4aa_fit);
fprintf(stderr,"\t AAaa: %f %f %f\n", cn4AAaa_params[0],cn4AAaa_params[1],cn4AAaa_params[2]);
fprintf(stderr,"\t func:\n");
fprintf(stderr,"\t %s\n", cn4ra_func);
fprintf(stderr,"\t %s\n", cn4aa_func);
fprintf(stderr,"\n");
}
if ( args->force_cn==2 || cn2_fail == '*' )
{
fprintf(args->dat_fp,"FIT\t%s\t%e\t%d\t%d\t%s\n", dist->chr,cn2ra_fit,dist->irr,dist->iaa,cn2ra_func);
if ( cn2aa_func ) fprintf(args->dat_fp,"FIT\t%s\t%e\t%d\t%d\t%s\n", dist->chr,cn2aa_fit,dist->iaa,dist->nvals-1,cn2aa_func);
}
if ( args->force_cn==3 || cn3_fail == '*' )
{
fprintf(args->dat_fp,"FIT\t%s\t%e\t%d\t%d\t%s\n", dist->chr,cn3ra_fit,dist->irr,dist->iaa,cn3ra_func);
if ( cn3aa_func ) fprintf(args->dat_fp,"FIT\t%s\t%e\t%d\t%d\t%s\n", dist->chr,cn3aa_fit,dist->iaa,dist->nvals-1,cn3aa_func);
}
if ( args->force_cn==4 || cn4_fail == '*' )
{
fprintf(args->dat_fp,"FIT\t%s\t%e\t%d\t%d\t%s\n", dist->chr,cn4ra_fit,dist->irr,dist->iaa,cn4ra_func);
if ( cn4aa_func ) fprintf(args->dat_fp,"FIT\t%s\t%e\t%d\t%d\t%s\n", dist->chr,cn4aa_fit,dist->iaa,dist->nvals-1,cn4aa_func);
}
fprintf(args->dat_fp,"CN\t%s\t%.2f\t%f\n", dist->chr, cn, fit);
free(cn2aa_func);
free(cn2ra_func);
free(cn3ra_func);
free(cn4ra_func);
free(cn4aa_func);
}
peakfit_destroy(pkf);
}
static void fit_curves(args_t *args)
{
int i;
for (i=0; i<args->ndist; i++)
{
dist_t *dist = &args->dist[i];
if ( dist->copy_number!=0 )
{
fprintf(args->dat_fp,"CN\t%s\t%.2f\n", dist->chr,(float)dist->copy_number);
save_dist(args, i, 0, NULL);
continue;
}
// Parameters (center,scale,sigma) for gaussian peaks.
double params_cn2[] = { 1/2.,0.5,0.05 };
double params_cn3[] = { 1/3.,0.5,0.05, 2/3.,0.5,0.05 };
double params_cn4[] = { 1/4.,0.5,0.05, 1/2.,0.5,0.05, 3/4.,0.5,0.05 };
double fit_cn2 = best_fit(args,&args->dist[i],1,params_cn2);
double fit_cn3 = best_fit(args,&args->dist[i],2,params_cn3);
double fit_cn4 = best_fit(args,&args->dist[i],3,params_cn4);
double dx_cn3 = fabs(params_cn3[0] - params_cn3[3]);
double dx_cn4 = fabs(params_cn4[0] - params_cn4[6]);
double dy_cn3 = params_cn3[1] > params_cn3[4] ? params_cn3[4]/params_cn3[1] : params_cn3[1]/params_cn3[4];
double dy_cn4a = params_cn4[1] > params_cn4[7] ? params_cn4[7]/params_cn4[1] : params_cn4[1]/params_cn4[7]; // side peaks
double ymax = params_cn4[1] > params_cn4[7] ? params_cn4[1] : params_cn4[7];
double dy_cn4b = ymax > params_cn4[4] ? params_cn4[4]/ymax : ymax/params_cn4[4]; // middle peak
// Three peaks (CN4) are always a better fit than two (CN3) or one (CN2). Therefore
// check that peaks are well separated and that the peak sizes are reasonable
char cn2_fail = 0, cn3_fail = 0, cn4_fail = 0;
if ( fit_cn2 > args->fit_th ) cn2_fail = 'f';
if ( fit_cn3 > args->fit_th ) cn3_fail = 'f';
else if ( dx_cn3 < 0.05 ) cn3_fail = 'x'; // peak separation: at least ~10% of cells
else if ( dy_cn3 < args->peak_symmetry ) cn3_fail = 'y';
if ( fit_cn4 > args->fit_th ) cn4_fail = 'f';
else if ( dx_cn4 < 0.1 ) cn4_fail = 'x'; // peak separation
else if ( dy_cn4a < args->peak_symmetry ) cn4_fail = 'y';
else if ( dy_cn4b < args->peak_symmetry ) cn4_fail = 'Y';
// Estimate fraction of affected cells. For CN4 we estimate
// contamination (the fraction of foreign cells), which is more
// common than CN4; hence the value is from the interval [0,0.5].
// CN3 .. f = 2*dx/(1-dx)
// CN4 .. f = dx
dx_cn3 = 2*dx_cn3 / (1-dx_cn3);
double cn = -1, fit = fit_cn2;
if ( !cn2_fail ) { cn = 2; fit = fit_cn2; }
if ( !cn3_fail && fit_cn3 < args->cn_penalty * fit ) { cn = 3; fit = fit_cn3; }
if ( !cn4_fail && fit_cn4 < args->cn_penalty * fit ) { cn = 4; fit = fit_cn4; }
if ( cn==-1 ) save_dist(args, i, 0, NULL);
else if ( cn==2 ) save_dist(args, i, 1, params_cn2);
else if ( cn==3 ) { save_dist(args, i, 2, params_cn3); cn = 2 + dx_cn3; }
else if ( cn==4 ) { save_dist(args, i, 3, params_cn4); cn = 3 + dx_cn4; }
if ( args->verbose )
{
printf("%s: \n", args->dist[i].chr);
print_params(&args->dist[i].dat, 1, params_cn2, fit_cn2, 1.0, cn2_fail, cn==2 ? '*' : ' ');
print_params(&args->dist[i].dat, 2, params_cn3, fit_cn3, dx_cn3, cn3_fail, cn>2 && cn<=3 ? '*' : ' ');
print_params(&args->dist[i].dat, 3, params_cn4, fit_cn4, dx_cn4, cn4_fail, cn>3 ? '*' : ' ');
printf("\n");
}
fprintf(args->dat_fp,"CN\t%s\t%.2f\t%f\n", dist->chr, cn, fit);
}
}
