cv::Mat atfz::getThinnedImage() {
cv::imshow("step_imageZ34_1", this->image); cv::waitKey(1000);
thin();
cv::imshow("step_imageZ34_2", this->image); cv::waitKey(1000);
updateImage();
cv::imshow("step_imageZ34_3", this->image); cv::waitKey(1000);
return this->image;
}
int main(int argc, char *argv[])
{
double ne0, ne, ne1, ne2, ne3, ne4, ne5, ne6, ne7, ne8, ne9, ne10;
double gl, gb, dordm, dist, xx, yy, zz, r, sl, cl, sb, cb, ll, hh;
double nstep, dstep, dmstep;
static double dd, dtest, dmpsr, rr;
double dmm=0;
double dm=0;
double DM_MC=0;
double DM_Gal=0;
double DM_Host=0;
double DDM;
double tau_sc=0;
double tau_Gal=0;
double tau_MC=0;
double tau_MC_sc=0;
double R_g=0;
double gd=0;
//The localtion of Sun relative to GP and Warp
double z_warp, zz_w, R_warp, theta_warp, theta_max;
R_warp=8400;//pc
theta_max=0.0; //In +x direction
int WGN=0;
int WLB=0;
int WLI=0;
int WFB=0;
int np, ndir,vbs, nk, uu, nn;
char str[5];
char dirname[64]="NULL",text[64]="";
char *p;
static int i, ncount;
int w_lmc=0;
int w_smc=0;
int umc=1;
char *s;
struct Warp_Sun t0;
struct Thick t1;
struct Thin t2;
struct Spiral t3;
struct GC t4;
struct Gum t5;
struct LB t6;
struct LI t7;
struct FB t8;
struct LMC t9;
struct Dora t10;
struct SMC t11;
vbs=0;
argc--; argv++;
if(argc < 5)usage(1);
while(argc > 5){ /* Get command line inputs */
if((*argv)[0] == '-'){
s=argv[0]+1;
argc--; argv++;
switch(*s){
case 'h':
case '?':
usage(0);
case 't':
if(sscanf(*argv,"%s",text) != 1)usage(1);
argc--; argv++;
break;
case 'd':
if(sscanf(*argv,"%s",dirname) != 1)usage(1);
argc--; argv++;
break;
case 'v':
vbs=1;
break;
case 'V':
vbs=2;
break;
default:
usage(1);
}
}
else{
if(argc>6){
printf("Extra parameters exist in input\n");
usage(1);
}
else break;
}
}
if(argc==5){
if(sscanf(*argv,"%s",str) != 1){
printf("Incorrect arguments\n");
usage(1);
}
argc--; argv++;
if(sscanf(*argv,"%lf",&gl) != 1){
printf("Incorrect arguments\n");
usage(1);
}
argc--; argv++;
if(sscanf(*argv,"%lf",&gb) != 1){
printf("Incorrect arguments\n");
usage(1);
}
argc--; argv++;
if(sscanf(*argv,"%lf",&dordm) != 1){
printf("Incorrect arguments\n");
usage(1);
}
argc--; argv++;
if(sscanf(*argv,"%d",&ndir) != 1){
printf("Incorrect arguments\n");
usage(1);
}
DM_Host=100;//default
}
if(argc==6){
if(sscanf(*argv,"%s",str) != 1){
printf("Incorrect arguments\n");
usage(1);
}
argc--; argv++;
if(sscanf(*argv,"%lf",&gl) != 1){
printf("Incorrect arguments\n");
usage(1);
}
argc--; argv++;
if(sscanf(*argv,"%lf",&gb) != 1){
printf("Incorrect arguments\n");
usage(1);
}
argc--; argv++;
if(sscanf(*argv,"%lf",&dordm) != 1){
printf("Incorrect arguments\n");
usage(1);
}
argc--; argv++;
if(sscanf(*argv,"%lf",&DM_Host) != 1){
printf("Incorrect arguments\n");
usage(1);
}
argc--; argv++;
if(sscanf(*argv,"%d",&ndir) != 1){
printf("Incorrect arguments\n");
usage(1);
}
}
//convert to upper case
p=strupr(str);
if(strcmp(p,"IGM") == 0) np=-1; // IGM
else if(strcmp(p,"MC") == 0) np=0; // Mag Clouds
else if(strcmp(p,"GAL") == 0){ // Galaxy
np=1;
p="Gal";
}
else{
printf("please input correct model\n");
usage(1);
exit(1);
}
if(ndir!=1&&ndir!=2){
printf("please input correct ndir\n");
usage(1);
}
if(!strcmp(dirname,"NULL")){
if(getenv("YMW16_DIR")==NULL){
printf("Warning: YMW16_DIR set to local directory\n");
strcpy(dirname,"./");
}else{
strcpy(dirname,getenv("YMW16_DIR"));
}
}
if(vbs>=1)printf("File directory: %s\n",dirname);
ymw16par(&t0, &t1, &t2, &t3, &t4, &t5, &t6, &t7, &t8, &t9, &t10, &t11, dirname);
if(ndir==1)printf("%s: gl=%8.3f gb=%8.3f DM=%8.2f", p, gl, gb, dordm);
else printf("%s: gl=%8.3f gb=%8.3f Dist=%9.1f", p, gl, gb, dordm);
ll=gl;
gl=gl/RAD;
gb=gb/RAD;
sl=sin(gl);
sb=sin(gb);
cl=cos(gl);
cb=cos(gb);
dstep=5.0;
if(np==-1){ // FRBs
if(ndir==1)uu=0;//dm---dist
else uu=1;//dist---dm
ndir=2;
DDM=dordm;
dordm=100000;
nk=20000;
}
if(np==0){ // Magellanic Cloud
nk=20000;
}
if(np==1){ //Galactic pulsars
nk=5000;
}
if(ndir==1){
dm=dordm;
if(np==1)tau_sc=tsc(dm);
dtest=dm/N0;
nstep=dtest/dstep;
if(nstep<200) dstep=dtest/200;
if(vbs>=1){
printf("\ndtest=%lf, nstep=%lf, dstep=%lf\n", dtest, nstep, dstep);
}
}
if(ndir==2){
dist=dordm;
dtest=dist;
nstep=dtest/dstep;
if(nstep<200) dstep=dtest/200;
if(vbs>=1){
printf("\ndtest=%lf, nstep=%lf, dstep=%lf\n", dtest, nstep, dstep);
}
}
dd=-0.5*dstep;
ncount=0;
for(i=1;i<=nk;i++){
ncount++;
if(vbs>=2){
printf("ncount=%d, dstep=%lf\n", ncount,dstep);
}
dd+=dstep;
r=dd*cb; /* r is different from rr */
xx=r*sl;
yy=R0*1000-r*cl;
zz=dd*sb+t0.z_Sun;
rr=sqrt(xx*xx+yy*yy);
/* Definition of warp */
if(rr<R_warp){
zz_w=zz;
}else{
theta_warp=atan2(yy,xx);
z_warp=t0.Gamma_w*(rr-R_warp)*cos(theta_warp-theta_max);
zz_w=zz-z_warp;
}
if(vbs>=2)
{
printf("dd=%lf, xx=%lf, yy=%lf, zz=%lf, rr=%lf\n", dd, xx, yy, zz, rr);
printf("theta_warp=%lf, z_warp=%lf, zz_w=%lf\n",theta_warp,z_warp,zz_w);
}
R_g=sqrt(xx*xx+yy*yy+zz_w*zz_w);
/* DM to Distance */
if(ndir==1){
if(dmm<=dm){
if(R_g<=35000){
thick(xx, yy, zz_w, &gd, &ne1, rr, t1);
thin(xx, yy, zz_w, gd, &ne2, rr, t2);
spiral(xx, yy, zz_w, gd, &ne3, rr, t3, dirname);
galcen(xx, yy, zz, &ne4, t4);
gum(xx, yy, zz, &ll, &ne5, t5);
localbubble(xx, yy, zz, &ll, &ne6, &hh, t6);
nps(xx, yy, zz, &ne7, &WLI, t7);
fermibubble(xx, yy, zz, &WFB);
}else{
if(np==1){
dstep=5;
}else{
dstep=200;
if(w_lmc>=1||w_smc>=1) dstep=5;
lmc(gl,gb,dd,&w_lmc,&ne8,t9);
dora(gl,gb,dd,&ne9,t10);
smc(xx, yy, zz,&w_smc, &ne10, t11);
}
}
if(WFB==1){
ne1=t8.J_FB*ne1;
}
ne0=ne1+max(ne2,ne3);
if(hh>110){ /* Outside LB */
if(ne6>ne0 && ne6>ne5){
WLB=1;
}else{
WLB=0;
}
}else{ /* Inside LB */
if(ne6>ne0){
WLB=1;
}else{
ne1=t6.J_LB*ne1;
ne0=ne1+max(ne2,ne3);
WLB=0;
}
}
if(ne7>ne0){ /* Loop I */
WLI=1;
}else{
WLI=0;
}
if(ne5>ne0){ /* Gum Nebula */
WGN=1;
}else{
WGN=0;
}
/* Galactic ne */
ne=(1-WLB)*((1-WGN)*((1-WLI)*(ne0+ne4+ne8+ne9+ne10)+WLI*ne7)+WGN*ne5)+WLB*ne6;
if(vbs>=2){
printf("ne=%lf, ne1=%lf, ne2=%lf, ne3=%lf, ne4=%lf, ne5=%lf, ne6=%lf, ne7=%lf, ne8=%lf, ne9=%lf, ne10=%lf\n", ne, ne1, ne2, ne3, ne4, ne5, ne6, ne7, ne8, ne9, ne10);
}
dmstep=ne*dstep;
if(dmstep<=0.000001)dmstep=0;
if(vbs>=2){
printf("dmstep=%lf, dstep=%lf\n", dmstep, dstep);
}
dmm+=dmstep;
dist=dd;
if(np==0&&umc==1){
if(R_g>35000){
DM_Gal=dmm;
tau_Gal=0.5*tsc(dmm);
printf(" DM_Gal:%8.2f",DM_Gal);
umc++;
}
}
if(i==nk){
dist+=0.5*dstep;
if(dist>100000)dist=100000;
if(np==0){
DM_MC=dmm-DM_Gal;
tau_MC=0.5*tsc(DM_MC);
tau_MC_sc=max(tau_Gal, tau_MC);
printf(" DM_MC:%8.2f",DM_MC);
}
if(np==0)printf(" Dist:%9.1f log(tau_sc):%7.3f %s\n",dist, log10(tau_MC_sc),text);
if(np==1)printf(" DM_Gal:%8.2f Dist:%9.1f log(tau_sc):%7.3f %s\n", dmm, dist,log10(tau_sc),text);
}
if(vbs>=2){
printf("dmm=%lf\n", dmm);
}
}
else{
dist=dd-0.5*dstep-(dstep*(dmm-dm))/dmstep;
if(np==0){
DM_MC=dm-DM_Gal;
if(DM_Gal==0){
DM_MC=0;
DM_Gal=dm;
tau_MC_sc=tsc(dm);
printf(" DM_Gal:%8.2f ", DM_Gal);
}
else{
tau_MC=0.5*tsc(DM_MC);
tau_MC_sc=max(tau_MC, tau_Gal);
}
printf(" DM_MC:%8.2f", DM_MC);
}
if(np==0)printf(" Dist:%9.1f log(tau_sc):%7.3f %s\n",dist,log10(tau_MC_sc),text);
if(np==1)printf(" DM_Gal:%8.2f Dist:%9.1f log(tau_sc):%7.3f %s\n", dm, dist,log10(tau_sc),text);
break;
}
}
/* Distance to DM */
if(ndir==2){
if(dd<=dtest){
if(R_g<=35000){
thick(xx, yy, zz_w, &gd, &ne1, rr, t1);
thin(xx, yy, zz_w, gd, &ne2, rr, t2);
spiral(xx, yy, zz_w, gd, &ne3, rr, t3, dirname);
galcen(xx, yy, zz, &ne4, t4);
gum(xx, yy, zz, &ll, &ne5, t5);
localbubble(xx, yy, zz, &ll, &ne6, &hh, t6);
nps(xx, yy, zz, &ne7, &WLI, t7);
fermibubble(xx, yy, zz, &WFB);
}else{
if(np==1)dstep=5;
else{
dstep=200;
if(np==-1)dstep=5;
if(w_lmc>=1||w_smc>=1) dstep=5;
lmc(gl,gb,dd,&w_lmc,&ne8,t9);
dora(gl,gb,dd,&ne9,t10);
smc(xx, yy, zz,&w_smc, &ne10, t11);
}
}
if(WFB==1){
ne1=t8.J_FB*ne1;
}
ne0=ne1+max(ne2,ne3);
if(hh>110){ /* Outside LB */
if(ne6>ne0 && ne6>ne5){
WLB=1;
}else{
WLB=0;
}
}else{ /* Inside LB */
if(ne6>ne0){
WLB=1;
}else{
ne1=t6.J_LB*ne1;
ne0=ne1+max(ne2,ne3);
WLB=0;
}
}
if(ne7>ne0){ /* Loop I */
WLI=1;
}else{
WLI=0;
}
if(ne5>ne0){ /* Gum Nebula */
WGN=1;
}else{
WGN=0;
}
/* Galactic ne */
ne=(1-WLB)*((1-WGN)*((1-WLI)*(ne0+ne4+ne8+ne9+ne10)+WLI*ne7)+WGN*ne5)+WLB*ne6;
if(vbs>=2){
printf("ne=%lf, ne1=%lf, ne2=%lf, ne3=%lf, ne4=%lf, ne5=%lf, ne6=%lf, ne7=%lf, ne8=%lf, ne9=%lf, ne10=%lf\n", ne, ne1, ne2, ne3, ne4, ne5, ne6, ne7, ne8, ne9, ne10);
}
dmstep=ne*dstep;
if(dmstep<=0.000001)dmstep=0;
dm+=dmstep;
if(np!=1&&umc==1){
if(R_g>35000){
DM_Gal=dm;
tau_Gal=0.5*tsc(dm);
printf(" DM_Gal:%8.2f",dm);
umc++;
}
}
if(i==nk&&np!=-1){
dmpsr=dm;
if(np==0){
DM_MC=dm-DM_Gal;
tau_MC=0.5*tsc(DM_MC);
printf(" DM_MC:%8.2f", DM_MC);
}
tau_sc=tsc(dmpsr);
tau_MC_sc=max(tau_Gal, tau_MC);
if(np==0)printf(" DM:%8.2f log(tau_sc):%7.3f %s\n", dmpsr,log10(tau_MC_sc),text);
if(np==1)printf(" DM:%8.2f log(tau_sc):%7.3f %s\n", dmpsr, log10(tau_sc),text);
}
if(i==nk&&np==-1){
if(dordm==100000){
DM_MC=dm-DM_Gal;
printf(" DM_MC:%8.2f",DM_MC);
}
frb_d(DDM, DM_Gal, DM_MC, DM_Host, uu, vbs, text);
break;
}
}
else{
dmpsr=dm+(dmstep*(dtest-(dd-0.5*dstep)))/dstep;
if(np==0){
DM_MC=dmpsr-DM_Gal;
if(DM_Gal==0){
DM_MC=0;
DM_Gal=dmpsr;
tau_MC_sc=tsc(dmpsr);
printf(" DM_Gal:%8.2f", DM_Gal);
}
else{
tau_MC=0.5*tsc(DM_MC);
tau_MC_sc=max(tau_Gal, tau_MC);
}
printf(" DM_MC:%8.2f", DM_MC);
}
tau_sc=tsc(dmpsr);
if(np==0)printf(" DM:%8.2f log(tau_sc):%7.3f %s\n", dmpsr,log10(tau_MC_sc),text);
if(np==1)printf(" DM:%8.2f log(tau_sc):%7.3f %s\n", dmpsr, log10(tau_sc),text);
break;
}
}
}
}
/**
* The Stan print function.
*
* @param argc Number of arguments
* @param argv Arguments
*
* @return 0 for success,
* non-zero otherwise
*/
int main(int argc, const char* argv[]) {
if (argc == 1) {
print_usage();
return 0;
}
// Parse any arguments specifying filenames
std::ifstream ifstream;
std::vector<std::string> filenames;
for (int i = 1; i < argc; i++) {
if (std::string(argv[i]).find("--autocorr=") != std::string::npos)
continue;
if (std::string(argv[i]).find("--sig_figs=") != std::string::npos)
continue;
if (std::string("--help") == std::string(argv[i])) {
print_usage();
return 0;
}
ifstream.open(argv[i]);
if (ifstream.good()) {
filenames.push_back(argv[i]);
ifstream.close();
} else {
std::cout << "File " << argv[i] << " not found" << std::endl;
}
}
if (!filenames.size()) {
std::cout << "No valid input files, exiting." << std::endl;
return 0;
}
// Parse specified files
Eigen::VectorXd warmup_times(filenames.size());
Eigen::VectorXd sampling_times(filenames.size());
Eigen::VectorXi thin(filenames.size());
ifstream.open(filenames[0].c_str());
stan::io::stan_csv stan_csv = stan::io::stan_csv_reader::parse(ifstream);
warmup_times(0) = stan_csv.timing.warmup;
sampling_times(0) = stan_csv.timing.sampling;
stan::mcmc::chains<> chains(stan_csv);
ifstream.close();
thin(0) = stan_csv.metadata.thin;
for (std::vector<std::string>::size_type chain = 1;
chain < filenames.size(); chain++) {
ifstream.open(filenames[chain].c_str());
stan_csv = stan::io::stan_csv_reader::parse(ifstream);
chains.add(stan_csv);
ifstream.close();
thin(chain) = stan_csv.metadata.thin;
warmup_times(chain) = stan_csv.timing.warmup;
sampling_times(chain) = stan_csv.timing.sampling;
}
double total_warmup_time = warmup_times.sum();
double total_sampling_time = sampling_times.sum();
// Compute largest variable name length
const int skip = 0;
std::string model_name = stan_csv.metadata.model;
size_t max_name_length = 0;
for (int i = skip; i < chains.num_params(); i++)
if (chains.param_name(i).length() > max_name_length)
max_name_length = chains.param_name(i).length();
for (int i = 0; i < 2; i++)
if (chains.param_name(i).length() > max_name_length)
max_name_length = chains.param_name(i).length();
// Prepare values
int n = 9;
Eigen::MatrixXd values(chains.num_params(), n);
values.setZero();
Eigen::VectorXd probs(3);
probs << 0.05, 0.5, 0.95;
for (int i = 0; i < chains.num_params(); i++) {
double sd = chains.sd(i);
double n_eff = chains.effective_sample_size(i);
values(i,0) = chains.mean(i);
values(i,1) = sd / sqrt(n_eff);
values(i,2) = sd;
Eigen::VectorXd quantiles = chains.quantiles(i,probs);
for (int j = 0; j < 3; j++)
values(i,3+j) = quantiles(j);
values(i,6) = n_eff;
values(i,7) = n_eff / total_sampling_time;
values(i,8) = chains.split_potential_scale_reduction(i);
}
// Prepare header
Eigen::Matrix<std::string, Eigen::Dynamic, 1> headers(n);
headers <<
"Mean", "MCSE", "StdDev",
"5%", "50%", "95%",
"N_Eff", "N_Eff/s", "R_hat";
// Set sig figs
Eigen::VectorXi column_sig_figs(n);
int sig_figs = 2;
for (int k = 1; k < argc; k++)
if (std::string(argv[k]).find("--sig_figs=") != std::string::npos)
sig_figs = atoi(std::string(argv[k]).substr(11).c_str());
// Compute column widths
Eigen::VectorXi column_widths(n);
Eigen::Matrix<std::ios_base::fmtflags, Eigen::Dynamic, 1> formats(n);
column_widths = calculate_column_widths(values, headers, sig_figs, formats);
// Initial output
std::cout << "Inference for Stan model: " << model_name << std::endl
<< chains.num_chains() << " chains: each with iter=(" << chains.num_kept_samples(0);
for (int chain = 1; chain < chains.num_chains(); chain++)
std::cout << "," << chains.num_kept_samples(chain);
std::cout << ")";
// Timing output
std::cout << "; warmup=(" << chains.warmup(0);
for (int chain = 1; chain < chains.num_chains(); chain++)
std::cout << "," << chains.warmup(chain);
std::cout << ")";
std::cout << "; thin=(" << thin(0);
for (int chain = 1; chain < chains.num_chains(); chain++)
std::cout << "," << thin(chain);
std::cout << ")";
std::cout << "; " << chains.num_samples() << " iterations saved."
<< std::endl << std::endl;
std::string warmup_unit = "seconds";
if (total_warmup_time / 3600 > 1) {
total_warmup_time /= 3600;
warmup_unit = "hours";
} else if (total_warmup_time / 60 > 1) {
total_warmup_time /= 60;
warmup_unit = "minutes";
}
std::cout << "Warmup took ("
<< std::fixed
<< std::setprecision(compute_precision(warmup_times(0), sig_figs, false))
<< warmup_times(0);
for (int chain = 1; chain < chains.num_chains(); chain++)
std::cout << ", " << std::fixed
<< std::setprecision(compute_precision(warmup_times(chain), sig_figs, false))
<< warmup_times(chain);
std::cout << ") seconds, ";
std::cout << std::fixed
<< std::setprecision(compute_precision(total_warmup_time, sig_figs, false))
<< total_warmup_time << " " << warmup_unit << " total" << std::endl;
std::string sampling_unit = "seconds";
if (total_sampling_time / 3600 > 1) {
total_sampling_time /= 3600;
sampling_unit = "hours";
} else if (total_sampling_time / 60 > 1) {
total_sampling_time /= 60;
sampling_unit = "minutes";
}
std::cout << "Sampling took ("
<< std::fixed
<< std::setprecision(compute_precision(sampling_times(0), sig_figs, false))
<< sampling_times(0);
for (int chain = 1; chain < chains.num_chains(); chain++)
std::cout << ", " << std::fixed
<< std::setprecision(compute_precision(sampling_times(chain), sig_figs, false))
<< sampling_times(chain);
std::cout << ") seconds, ";
std::cout << std::fixed
<< std::setprecision(compute_precision(total_sampling_time, sig_figs, false))
<< total_sampling_time << " " << sampling_unit << " total" << std::endl;
std::cout << std::endl;
// Header output
std::cout << std::setw(max_name_length + 1) << "";
for (int i = 0; i < n; i++) {
std::cout << std::setw(column_widths(i)) << headers(i);
}
std::cout << std::endl;
// Value output
for (int i = skip; i < chains.num_params(); i++) {
if (!is_matrix(chains.param_name(i))) {
std::cout << std::setw(max_name_length + 1) << std::left << chains.param_name(i);
std::cout << std::right;
for (int j = 0; j < n; j++) {
std::cout.setf(formats(j), std::ios::floatfield);
std::cout << std::setprecision(
compute_precision(values(i,j), sig_figs, formats(j) == std::ios_base::scientific))
<< std::setw(column_widths(j)) << values(i, j);
}
std::cout << std::endl;
} else {
std::vector<int> dims = dimensions(chains, i);
std::vector<int> index(dims.size(), 1);
int max = 1;
for (int j = 0; j < dims.size(); j++)
max *= dims[j];
for (int k = 0; k < max; k++) {
int param_index = i + matrix_index(index, dims);
std::cout << std::setw(max_name_length + 1) << std::left
<< chains.param_name(param_index);
std::cout << std::right;
for (int j = 0; j < n; j++) {
std::cout.setf(formats(j), std::ios::floatfield);
std::cout
<< std::setprecision(compute_precision(values(param_index,j),
sig_figs,
formats(j) == std::ios_base::scientific))
<< std::setw(column_widths(j)) << values(param_index, j);
}
std::cout << std::endl;
next_index(index, dims);
}
i += max-1;
}
}
/// Footer output
std::cout << std::endl;
std::cout << "Samples were drawn using " << stan_csv.metadata.algorithm
<< " with " << stan_csv.metadata.engine << "." << std::endl
<< "For each parameter, N_Eff is a crude measure of effective sample size," << std::endl
<< "and R_hat is the potential scale reduction factor on split chains (at " << std::endl
<< "convergence, R_hat=1)." << std::endl
<< std::endl;
// Print autocorrelation, if desired
for (int k = 1; k < argc; k++) {
if (std::string(argv[k]).find("--autocorr=") != std::string::npos) {
const int c = atoi(std::string(argv[k]).substr(11).c_str());
if (c < 0 || c >= chains.num_chains()) {
std::cout << "Bad chain index " << c << ", aborting autocorrelation display." << std::endl;
break;
}
Eigen::MatrixXd autocorr(chains.num_params(), chains.num_samples(c));
for (int i = 0; i < chains.num_params(); i++) {
autocorr.row(i) = chains.autocorrelation(c, i);
}
// Format and print header
std::cout << "Displaying the autocorrelations for chain " << c << ":" << std::endl;
std::cout << std::endl;
const int n_autocorr = autocorr.row(0).size();
int lag_width = 1;
int number = n_autocorr;
while ( number != 0) { number /= 10; lag_width++; }
std::cout << std::setw(lag_width > 4 ? lag_width : 4) << "Lag";
for (int i = 0; i < chains.num_params(); ++i) {
std::cout << std::setw(max_name_length + 1) << std::right << chains.param_name(i);
}
std::cout << std::endl;
// Print body
for (int n = 0; n < n_autocorr; ++n) {
std::cout << std::setw(lag_width) << std::right << n;
for (int i = 0; i < chains.num_params(); ++i) {
std::cout << std::setw(max_name_length + 1) << std::right << autocorr(i, n);
}
std::cout << std::endl;
}
}
}
return 0;
}
Limbs::Limbs(Encoding &g)
:genome(g)
{
//create Traits
Trait spindly(1, -3, 3, "spindly");
Trait thin(1, -2, 1, "thin");
Trait thick(-2, 3, 0, "thick");
Trait round(3, -1, -1, "round");
Trait zero(0, 0, 3, "0");
Trait one(1, 1, 3, "1");
Trait two(3, 1, -3, "2");
Trait three(-1, 1, 3, "3");
Trait four(3, 1, -3, "4");
Trait five(-1, 1, 3, "5");
Trait six(2, 1, -3, "6");
Trait seven(-2, 2, 3, "7");
Trait eight(0, 3, 2, "8");
Trait nine(-3, 2, 3, "9");
Trait ten(-2, 3, 2, "10");
Trait eleven(-3, 2, 3, "11");
Trait twelve(-3, 3, 2, "12");
Trait thirteen(-3, 2, 3, "13");
Trait fourteen(-3, 3, 3, "14");
Trait fifteen(-3, 2, 3, "15");
//create all maps
if (thicknessK.empty() ) {
thicknessK["spindly"] = 0;
thicknessK["thin"] = 1;
thicknessK["thick"] = 2;
thicknessK["round"] = 3;
thicknessM[0] = spindly;
thicknessM[1] = thin;
thicknessM[2] = thick;
thicknessM[3] = round;
numM[0] = zero;
numM[1] = one;
numM[2] = two;
numM[3] = three;
numM[4] = four;
numM[5] = five;
numM[6] = six;
numM[7] = seven;
numM[8] = eight;
numM[9] = nine;
numM[10] = ten;
numM[11] = eleven;
numM[12] = twelve;
numM[13] = thirteen;
numM[14] = fourteen;
numM[15] = fifteen;
}
//decode the number of limbs so that there can
//only be a non-zero even number of them
number = decodeNumber();
int numValue = std::stoi(number);
if (numValue % 2 != 0) {
encodeNumber(numValue + 1);
number = decodeNumber();
}
if (numValue == 0) {
encodeNumber(2);
number = decodeNumber();
}
thickness = decodeThickness();
}
int main( int ac, char** av )
{
try
{
comma::command_line_options options( ac, av );
verbose = options.exists( "--verbose,-v" );
if( options.exists( "--help,-h" ) ) { usage( verbose ); }
csv = comma::csv::options( options );
csv.full_xpath = true;
ascii = comma::csv::ascii< Eigen::Vector3d >( "x,y,z", csv.delimiter );
const std::vector< std::string >& operations = options.unnamed( "--verbose,-v,--trace,--no-antialiasing,--next,--unit", "-.*" );
if( operations.size() != 1 ) { std::cerr << "points-calc: expected one operation, got " << operations.size() << ": " << comma::join( operations, ' ' ) << std::endl; return 1; }
const std::string& operation = operations[0];
if (vector_calc::has_operation(operation))
{
vector_calc::process(operation, options, csv);
return 0;
}
if( operation == "plane-intersection" )
{
plane_intersection::process(options, csv);
return 0;
}
if( operation == "distance" )
{
if( csv.has_field( "first" ) || csv.has_field( "second" )
|| csv.has_field( "first/x" ) || csv.has_field( "second/x" )
|| csv.has_field( "first/y" ) || csv.has_field( "second/y" )
|| csv.has_field( "first/z" ) || csv.has_field( "second/z" ) )
{
calculate_distance_for_pairs();
return 0;
}
if ( options.exists( "--next" ) ) { calculate_distance_next(); }
else { calculate_distance( false ); }
return 0;
}
if( operation == "cumulative-distance" )
{
calculate_distance( true );
return 0;
}
if( operation == "nearest" )
{
if( options.exists( "--point,--to" ) )
{
Eigen::Vector3d point = comma::csv::ascii< Eigen::Vector3d >().get( options.value< std::string >( "--point,--to" ) );
comma::csv::input_stream< Eigen::Vector3d > istream( std::cin, csv );
std::string record;
double min_distance = std::numeric_limits< double >::max();
while( istream.ready() || ( std::cin.good() && !std::cin.eof() ) )
{
const Eigen::Vector3d* p = istream.read();
if( !p ) { break; }
double d = ( *p - point ).norm();
if( d >= min_distance ) { continue; }
min_distance = d;
record = csv.binary() ? std::string( istream.binary().last(), csv.format().size() ) : comma::join( istream.ascii().last(), csv.delimiter );
}
if( !record.empty() ) { std::cout << record; }
if( csv.binary() ) { std::cout.write( reinterpret_cast< const char* >( &min_distance ), sizeof( double ) ); }
else { std::cout << csv.delimiter << min_distance << std::endl; }
return 0;
}
else
{
return 0;
}
}
if( operation == "thin" )
{
if( !options.exists( "--resolution" ) ) { std::cerr << "points-calc: --resolution is not specified " << std::endl; return 1; }
double resolution = options.value( "--resolution" , 0.0 );
thin( resolution );
return 0;
}
if( operation == "discretise" || operation == "discretize" )
{
if( !options.exists( "--step" ) ) { std::cerr << "points-calc: --step is not specified " << std::endl; return 1; }
double step = options.value( "--step" , 0.0 );
if( step <= 0 ) { std::cerr << "points-calc: expected positive step, got " << step << std::endl; return 1; }
// the last discretised point can be very close to the end of the interval, in which case the last two points can be identical in the output since ascii.put uses 12 digits by default
// setting --tolerance=1e-12 will not allow the last discretised point to be too close to the end of the interval and therefore the output will have two distinct points at the end
double tolerance = options.value( "--tolerance" , 0.0 );
if( tolerance < 0 ) { std::cerr << "points-calc: expected non-negative tolerance, got " << tolerance << std::endl; return 1; }
discretise( step, tolerance );
return 0;
}
if( operation == "local-max" || operation == "local-min" ) // todo: if( operation == "local-calc" ? )
{
double sign = operation == "local-max" ? 1 : -1;
if( csv.fields.empty() ) { csv.fields = "x,y,z,scalar"; }
csv.full_xpath = false;
bool has_id = csv.has_field( "id" );
comma::csv::input_stream< local_operation::point > istream( std::cin, csv );
std::deque< local_operation::record > records;
double radius = options.value< double >( "--radius" );
bool trace = options.exists( "--trace" );
Eigen::Vector3d resolution( radius, radius, radius );
snark::math::closed_interval< double, 3 > extents;
comma::uint32 id = 0;
if( verbose ) { std::cerr << "points-calc: reading input points..." << std::endl; }
while( istream.ready() || ( std::cin.good() && !std::cin.eof() ) )
{
const local_operation::point* p = istream.read();
if( !p ) { break; }
std::string line;
if( csv.binary() ) // quick and dirty
{
line.resize( csv.format().size() );
::memcpy( &line[0], istream.binary().last(), csv.format().size() );
}
else
{
line = comma::join( istream.ascii().last(), csv.delimiter );
}
local_operation::point q = *p;
if( !has_id ) { q.id = id++; }
records.push_back( local_operation::record( q, line ) );
records.back().reference_record = &records.back();
extents.set_hull( p->coordinates );
}
if( verbose ) { std::cerr << "points-calc: loading " << records.size() << " points into grid..." << std::endl; }
typedef std::vector< local_operation::record* > voxel_t; // todo: is vector a good container? use deque
typedef snark::voxel_map< voxel_t, 3 > grid_t;
grid_t grid( extents.min(), resolution );
for( std::size_t i = 0; i < records.size(); ++i ) { ( grid.touch_at( records[i].point.coordinates ) )->second.push_back( &records[i] ); }
if( verbose ) { std::cerr << "points-calc: searching for local extrema..." << std::endl; }
for( grid_t::iterator it = grid.begin(); it != grid.end(); ++it )
{
grid_t::index_type i;
for( i[0] = it->first[0] - 1; i[0] < it->first[0] + 2; ++i[0] )
{
for( i[1] = it->first[1] - 1; i[1] < it->first[1] + 2; ++i[1] )
{
for( i[2] = it->first[2] - 1; i[2] < it->first[2] + 2; ++i[2] )
{
grid_t::iterator git = grid.find( i );
if( git == grid.end() ) { continue; }
for( voxel_t::iterator vit = it->second.begin(); vit != it->second.end(); ++vit )
{
for( std::size_t k = 0; k < git->second.size() && ( *vit )->is_extremum; ++k )
{
local_operation::evaluate_local_extremum( *vit, git->second[k], radius, sign );
}
}
}
}
}
}
#ifdef WIN32
_setmode( _fileno( stdout ), _O_BINARY );
#endif
if( verbose ) { std::cerr << "points-calc: filling extrema grid..." << std::endl; }
grid_t extrema( extents.min(), resolution );
for( std::size_t i = 0; i < records.size(); ++i )
{
if( records[i].is_extremum )
{
( extrema.touch_at( records[i].point.coordinates ) )->second.push_back( &records[i] );
}
else
{
records[i].extremum_id = local_operation::record::invalid_id; // quick and dirty for now
// if( records[i].extremum_id == local_operation::record::invalid_id ) { continue; }
// while( records[i].reference_record->point.id != records[i].reference_record->reference_record->point.id )
// {
// records[i].reference_record = records[i].reference_record->reference_record;
// }
// records[i].extremum_id = records[i].reference_record->point.id;
}
}
if( verbose ) { std::cerr << "points-calc: calculating distances to " << extrema.size() << " local extrema..." << std::endl; }
for( grid_t::iterator it = grid.begin(); it != grid.end(); ++it )
{
grid_t::index_type i;
for( i[0] = it->first[0] - 1; i[0] < it->first[0] + 2; ++i[0] )
{
for( i[1] = it->first[1] - 1; i[1] < it->first[1] + 2; ++i[1] )
{
for( i[2] = it->first[2] - 1; i[2] < it->first[2] + 2; ++i[2] )
{
grid_t::iterator git = extrema.find( i );
if( git == extrema.end() ) { continue; }
for( std::size_t n = 0; n < it->second.size(); ++n )
{
for( std::size_t k = 0; k < git->second.size(); ++k )
{
local_operation::update_nearest_extremum( it->second[n], git->second[k], radius );
}
}
}
}
}
}
if( trace )
{
if( verbose ) { std::cerr << "points-calc: tracing extrema..." << std::endl; }
for( std::size_t i = 0; i < records.size(); ++i )
{
if( records[i].extremum_id == local_operation::record::invalid_id ) { continue; }
while( records[i].reference_record->point.id != records[i].reference_record->reference_record->point.id )
{
records[i].reference_record = records[i].reference_record->reference_record;
}
}
}
if( verbose ) { std::cerr << "points-calc: outputting..." << std::endl; }
std::string endl = csv.binary() ? "" : "\n";
std::string delimiter = csv.binary() ? "" : std::string( 1, csv.delimiter );
comma::csv::options output_csv;
if( csv.binary() ) { output_csv.format( "ui,d" ); }
comma::csv::output_stream< local_operation::output > ostream( std::cout, output_csv );
for( std::size_t i = 0; i < records.size(); ++i )
{
std::cout.write( &records[i].line[0], records[i].line.size() );
std::cout.write( &delimiter[0], delimiter.size() );
ostream.write( records[i].output( false ) ); // quick and dirty
}
if( verbose ) { std::cerr << "points-calc: done!" << std::endl; }
return 0;
}
if( operation == "nearest-max" || operation == "nearest-min" || operation == "nearest-any" )
{
double sign = operation == "nearest-max" ? 1 : -1;
bool any = operation == "nearest-any";
if( csv.fields.empty() ) { csv.fields = "x,y,z,scalar"; }
csv.full_xpath = false;
bool has_id = csv.has_field( "id" );
comma::csv::input_stream< local_operation::point > istream( std::cin, csv );
std::deque< local_operation::record > records;
double radius = options.value< double >( "--radius" );
Eigen::Vector3d resolution( radius, radius, radius );
snark::math::closed_interval< double, 3 > extents;
comma::uint32 id = 0;
if( verbose ) { std::cerr << "points-calc: reading input points..." << std::endl; }
while( istream.ready() || ( std::cin.good() && !std::cin.eof() ) )
{
const local_operation::point* p = istream.read();
if( !p ) { break; }
std::string line;
if( csv.binary() ) // quick and dirty
{
line.resize( csv.format().size() );
::memcpy( &line[0], istream.binary().last(), csv.format().size() );
}
else
{
line = comma::join( istream.ascii().last(), csv.delimiter );
}
local_operation::point q = *p;
if( !has_id ) { q.id = id++; }
records.push_back( local_operation::record( q, line ) );
records.back().reference_record = &records.back();
extents.set_hull( p->coordinates );
}
if( verbose ) { std::cerr << "points-calc: loading " << records.size() << " points into grid..." << std::endl; }
typedef std::vector< local_operation::record* > voxel_t; // todo: is vector a good container? use deque
typedef snark::voxel_map< voxel_t, 3 > grid_t;
grid_t grid( extents.min(), resolution );
for( std::size_t i = 0; i < records.size(); ++i ) { ( grid.touch_at( records[i].point.coordinates ) )->second.push_back( &records[i] ); }
if( verbose ) { std::cerr << "points-calc: searching for " << operation << "..." << std::endl; }
for( grid_t::iterator it = grid.begin(); it != grid.end(); ++it )
{
grid_t::index_type i;
for( i[0] = it->first[0] - 1; i[0] < it->first[0] + 2; ++i[0] )
{
for( i[1] = it->first[1] - 1; i[1] < it->first[1] + 2; ++i[1] )
{
for( i[2] = it->first[2] - 1; i[2] < it->first[2] + 2; ++i[2] )
{
grid_t::iterator git = grid.find( i );
if( git == grid.end() ) { continue; }
for( std::size_t n = 0; n < it->second.size(); ++n )
{
for( std::size_t k = 0; k < git->second.size(); ++k )
{
local_operation::update_nearest( it->second[n], git->second[k], radius, sign, any );
}
}
}
}
}
}
#ifdef WIN32
_setmode( _fileno( stdout ), _O_BINARY );
#endif
if( verbose ) { std::cerr << "points-calc: outputting..." << std::endl; }
std::string endl = csv.binary() ? "" : "\n";
std::string delimiter = csv.binary() ? "" : std::string( 1, csv.delimiter );
comma::csv::options output_csv;
if( csv.binary() ) { output_csv.format( "ui,d" ); }
comma::csv::output_stream< local_operation::output > ostream( std::cout, output_csv );
for( std::size_t i = 0; i < records.size(); ++i )
{
std::cout.write( &records[i].line[0], records[i].line.size() );
std::cout.write( &delimiter[0], delimiter.size() );
ostream.write( records[i].output() );
}
if( verbose ) { std::cerr << "points-calc: done!" << std::endl; }
return 0;
}
if( operation == "find-outliers" )
{
unsigned int size = options.value< unsigned int >( "--min-number-of-points-per-voxel,--size" );
double r = options.value< double >( "--resolution" );
Eigen::Vector3d resolution( r, r, r );
bool no_antialiasing = options.exists( "--no-antialiasing" );
comma::csv::input_stream< Eigen::Vector3d > istream( std::cin, csv );
std::deque< remove_outliers::record > records;
snark::math::closed_interval< double, 3 > extents;
if( verbose ) { std::cerr << "points-calc: reading input points..." << std::endl; }
while( istream.ready() || ( std::cin.good() && !std::cin.eof() ) )
{
const Eigen::Vector3d* p = istream.read();
if( !p ) { break; }
std::string line;
if( csv.binary() ) // quick and dirty
{
line.resize( csv.format().size() );
::memcpy( &line[0], istream.binary().last(), csv.format().size() );
}
else
{
line = comma::join( istream.ascii().last(), csv.delimiter );
}
records.push_back( remove_outliers::record( *p, line ) );
extents.set_hull( *p );
}
if( verbose ) { std::cerr << "points-calc: loading " << records.size() << " points into grid..." << std::endl; }
typedef std::vector< remove_outliers::record* > voxel_t; // todo: is vector a good container? use deque
typedef snark::voxel_map< voxel_t, 3 > grid_t;
grid_t grid( extents.min(), resolution );
for( std::size_t i = 0; i < records.size(); ++i ) { ( grid.touch_at( records[i].point ) )->second.push_back( &records[i] ); }
if( verbose ) { std::cerr << "points-calc: removing outliers..." << std::endl; }
for( grid_t::iterator it = grid.begin(); it != grid.end(); ++it )
{
bool rejected = true;
if( no_antialiasing )
{
rejected = it->second.size() < size;
}
else
{
grid_t::index_type i;
for( i[0] = it->first[0] - 1; i[0] < it->first[0] + 2 && rejected; ++i[0] )
{
for( i[1] = it->first[1] - 1; i[1] < it->first[1] + 2 && rejected; ++i[1] )
{
for( i[2] = it->first[2] - 1; i[2] < it->first[2] + 2 && rejected; ++i[2] )
{
grid_t::iterator git = grid.find( i );
rejected = git == grid.end() || git->second.size() < size;
}
}
}
}
if( rejected ) { for( std::size_t i = 0; i < it->second.size(); ++i ) { it->second[i]->rejected = true; } }
}
#ifdef WIN32
_setmode( _fileno( stdout ), _O_BINARY );
#endif
if( verbose ) { std::cerr << "points-calc: outputting..." << std::endl; }
std::string endl = csv.binary() ? "" : "\n";
std::string delimiter = csv.binary() ? "" : std::string( 1, csv.delimiter );
for( std::size_t i = 0; i < records.size(); ++i )
{
char valid = records[i].rejected ? 0 : 1;
std::cout.write( &records[i].line[0], records[i].line.size() );
std::cout.write( &delimiter[0], delimiter.size() );
std::cout.write( &valid, 1 );
std::cout.write( &endl[0], endl.size() );
}
if( verbose ) { std::cerr << "points-calc: done!" << std::endl; }
return 0;
}
std::cerr << "points-calc: please specify an operation" << std::endl;
return 1;
}
catch( std::exception& ex )
{
std::cerr << "points-calc: " << ex.what() << std::endl;
}
catch( ... )
{
std::cerr << "points-calc: unknown exception" << std::endl;
}
return 1;
}
