void midus_file::loop(int const n_events) {
// Call default loop method
input_file::loop();
for (int entry_number = 0; entry_number<n_events; ++entry_number) {
trigger_tree_m->GetEntry(entry_number);
if (entry_number%10000 == 0) std::cout << "Entry "<< entry_number<<std::endl;
if (branches_m[err_i].data[0] > 0) {
std::cerr << "error found in entry " << entry_number;
std::cerr << ". Skipping this entry"<< std::endl;
continue;
}
midus_structure::midus_out_branch parallel_branches[midus_structure::n_branches_in_midus_entry];
extract_values_to(parallel_branches);
midus_entry entry(parallel_branches);
// Loop over all the registered algorithms
for (int alg = 0; alg < get_number_algorithms() ; ++alg) {
entry.accept(get_algorithm(alg));
}
}
if(scaler_algs.size()==0) return;
int const n_scaler_entries = scaler_tree_m->GetEntries();
for (int sclr_entry = 0; sclr_entry < n_scaler_entries; ++sclr_entry) {
scaler_tree_m->GetEntry();
scaler_entry s_entry(scaler_vals);
for (int s_alg = 0; s_alg < scaler_algs.size(); ++s_alg) {
s_entry.accept(scaler_algs[s_alg]);
}
}
}
entity *test_adaptation(population *pop, entity *child){
entity *adult; /* Adapted solution. */
double * img;
Image * fc;
int i;
/*
* We must generate a new solution by copying the original solution.
* This function copys all genomic, and if appropriate, phenomic data.
* It is never safe to adapt the solution in place.
*/
adult = ga_entity_clone(pop, child);
img = (double *)adult->chromosome[0];
for(i = 0;i<TSIZE(amp);i++){
real_in->r[i] = img[i];
real_in->c[i] = img[i+TSIZE(amp)];
real_in->image[i] = norm(real_in,i);
}
freeimg(real_out);
if(get_algorithm(opts,&my_log) == HIO){
real_out = basic_hio_iteration(amp, real_in, support,opts,&my_log);
}else if(get_algorithm(opts,&my_log) == RAAR){
real_out = basic_raar_iteration(amp,exp_sigma, real_in, support,opts,&my_log);
}else if(get_algorithm(opts,&my_log) == HPR){
real_out = basic_hpr_iteration(amp, real_in, support,opts,&my_log);
}
adult->fitness = 0;
fc = image_fft(real_out);
for(i = 0;i<TSIZE(amp);i++){
img[i] = real_out->r[i];
img[i+TSIZE(amp)] = real_out->c[i];
adult->fitness -= fabs(fc->image[i] - amp->image[i]);
}
freeimg(fc);
return adult;
}
void dummy_midus::loop(){
for (int i = 0; i < n_loops_m; ++i) {
midus_out_branch b [2];
for (int j =0 ; j<2; ++j) {
b[j].n_entries = 4;
for (int k= 0; k < 4; ++k) {
b[j].data[k] = k + i + j;
}
}
midus_entry entry(b);
for (int alg = 0; alg < get_number_algorithms() ; ++alg) {
entry.accept(get_algorithm(alg));
}
}
}
int main(int argc, char* argv[]) {
char* name_in = NULL;
char* name_out = NULL;
char* w_argv = NULL;
wrapper* w;
int bsize = B_SIZE_DEFAULT;
int opt, ret;
uint8_t w_mode = WRAPPER_MODE_COMPRESS;
uint8_t w_type = LZ78_ALGORITHM;
while ((opt = getopt(argc, argv, "i:o:dt:b:a:h")) != -1) {
switch (opt) {
case 'i': /* Input */
name_in = optarg;
break;
case 'o': /* Output */
name_out = optarg;
break;
case 'd': /* Decompress */
w_mode = WRAPPER_MODE_DECOMPRESS;
break;
case 't': /* Type */
if (!(w_type = get_algorithm(optarg))) {
fprintf(stderr, "Invalid algorithm type: %s\n", optarg);
exit(EXIT_FAILURE);
}
break;
case 'b': /* Buffer size */
bsize = byte_size(optarg);
break;
case 'a': /* Additional parameter */
w_argv = optarg;
break;
case 'h': /* Compressor help */
default:
help(argv);
exit(EXIT_FAILURE);
}
}
if (bsize <= 0) {
help(argv);
exit(EXIT_FAILURE);
}
/* Creates a wrapper instance */
w = wrapper_new(w_mode, w_type, w_argv);
if (w == NULL) {
fprintf(stderr, "Unable to create wrapper\n");
exit(EXIT_FAILURE);
}
/* Executes the wrapper function */
ret = wrapper_exec(w, name_in, name_out);
if (ret != WRAPPER_SUCCESS)
wrapper_perror();
/* Destroyes the wrapper instance */
wrapper_destroy(w);
return ret;
}
gpg_error_t
_ksba_keyinfo_to_sexp (const unsigned char *der, size_t derlen,
ksba_sexp_t *r_string)
{
gpg_error_t err;
int c;
size_t nread, off, len, parm_off, parm_len;
int parm_type;
char *parm_oid = NULL;
int algoidx;
int is_bitstr;
const unsigned char *parmder = NULL;
size_t parmderlen = 0;
const unsigned char *ctrl;
const char *elem;
struct stringbuf sb;
*r_string = NULL;
/* check the outer sequence */
if (!derlen)
return gpg_error (GPG_ERR_INV_KEYINFO);
c = *der++; derlen--;
if ( c != 0x30 )
return gpg_error (GPG_ERR_UNEXPECTED_TAG); /* not a SEQUENCE */
TLV_LENGTH(der);
/* and now the inner part */
err = get_algorithm (1, der, derlen, &nread, &off, &len, &is_bitstr,
&parm_off, &parm_len, &parm_type);
if (err)
return err;
/* look into our table of supported algorithms */
for (algoidx=0; pk_algo_table[algoidx].oid; algoidx++)
{
if ( len == pk_algo_table[algoidx].oidlen
&& !memcmp (der+off, pk_algo_table[algoidx].oid, len))
break;
}
if (!pk_algo_table[algoidx].oid)
return gpg_error (GPG_ERR_UNKNOWN_ALGORITHM);
if (!pk_algo_table[algoidx].supported)
return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
if (parm_off && parm_len && parm_type == TYPE_OBJECT_ID)
parm_oid = ksba_oid_to_str (der+parm_off, parm_len);
else if (parm_off && parm_len)
{
parmder = der + parm_off;
parmderlen = parm_len;
}
der += nread;
derlen -= nread;
if (is_bitstr)
{ /* Funny: X.509 defines the signature value as a bit string but
CMS as an octet string - for ease of implementation we always
allow both */
if (!derlen)
{
xfree (parm_oid);
return gpg_error (GPG_ERR_INV_KEYINFO);
}
c = *der++; derlen--;
if (c)
fprintf (stderr, "warning: number of unused bits is not zero\n");
}
/* fixme: we should calculate the initial length form the size of the
sequence, so that we don't need a realloc later */
init_stringbuf (&sb, 100);
put_stringbuf (&sb, "(10:public-key(");
/* fixme: we can also use the oidstring here and prefix it with
"oid." - this way we can pass more information into Libgcrypt or
whatever library is used */
put_stringbuf_sexp (&sb, pk_algo_table[algoidx].algo_string);
/* Insert the curve name for ECC. */
if (pk_algo_table[algoidx].pkalgo == PKALGO_ECC && parm_oid)
{
put_stringbuf (&sb, "(");
put_stringbuf_sexp (&sb, "curve");
put_stringbuf_sexp (&sb, parm_oid);
put_stringbuf (&sb, ")");
}
/* If parameters are given and we have a description for them, parse
them. */
if (parmder && parmderlen
&& pk_algo_table[algoidx].parmelem_string
&& pk_algo_table[algoidx].parmctrl_string)
{
elem = pk_algo_table[algoidx].parmelem_string;
ctrl = pk_algo_table[algoidx].parmctrl_string;
for (; *elem; ctrl++, elem++)
{
int is_int;
if ( (*ctrl & 0x80) && !elem[1] )
{
/* Hack to allow reading a raw value. */
is_int = 1;
len = parmderlen;
}
else
{
if (!parmderlen)
{
xfree (parm_oid);
return gpg_error (GPG_ERR_INV_KEYINFO);
}
c = *parmder++; parmderlen--;
if ( c != *ctrl )
{
xfree (parm_oid);
return gpg_error (GPG_ERR_UNEXPECTED_TAG);
}
is_int = c == 0x02;
TLV_LENGTH (parmder);
}
if (is_int && *elem != '-') /* Take this integer. */
{
char tmp[2];
put_stringbuf (&sb, "(");
tmp[0] = *elem; tmp[1] = 0;
put_stringbuf_sexp (&sb, tmp);
put_stringbuf_mem_sexp (&sb, parmder, len);
parmder += len;
parmderlen -= len;
put_stringbuf (&sb, ")");
}
}
}
/* FIXME: We don't release the stringbuf in case of error
better let the macro jump to a label */
elem = pk_algo_table[algoidx].elem_string;
ctrl = pk_algo_table[algoidx].ctrl_string;
for (; *elem; ctrl++, elem++)
{
int is_int;
if ( (*ctrl & 0x80) && !elem[1] )
{
/* Hack to allow reading a raw value. */
is_int = 1;
len = derlen;
}
else
{
if (!derlen)
{
xfree (parm_oid);
return gpg_error (GPG_ERR_INV_KEYINFO);
}
c = *der++; derlen--;
if ( c != *ctrl )
{
xfree (parm_oid);
return gpg_error (GPG_ERR_UNEXPECTED_TAG);
}
is_int = c == 0x02;
TLV_LENGTH (der);
}
if (is_int && *elem != '-') /* Take this integer. */
{
char tmp[2];
put_stringbuf (&sb, "(");
tmp[0] = *elem; tmp[1] = 0;
put_stringbuf_sexp (&sb, tmp);
put_stringbuf_mem_sexp (&sb, der, len);
der += len;
derlen -= len;
put_stringbuf (&sb, ")");
}
}
put_stringbuf (&sb, "))");
xfree (parm_oid);
*r_string = get_stringbuf (&sb);
if (!*r_string)
return gpg_error (GPG_ERR_ENOMEM);
return 0;
}
gpg_error_t
_ksba_parse_algorithm_identifier2 (const unsigned char *der, size_t derlen,
size_t *r_nread, char **r_oid,
char **r_parm, size_t *r_parmlen)
{
gpg_error_t err;
int is_bitstr;
size_t nread, off, len, off2, len2;
int parm_type;
/* fixme: get_algorithm might return the error invalid keyinfo -
this should be invalid algorithm identifier */
*r_oid = NULL;
*r_nread = 0;
off2 = len2 = 0;
err = get_algorithm (0, der, derlen, &nread, &off, &len, &is_bitstr,
&off2, &len2, &parm_type);
if (err)
return err;
*r_nread = nread;
*r_oid = ksba_oid_to_str (der+off, len);
if (!*r_oid)
return gpg_error (GPG_ERR_ENOMEM);
/* Special hack for ecdsaWithSpecified. We replace the returned OID
by the one in the parameter. */
if (off2 && len2 && parm_type == TYPE_SEQUENCE
&& !strcmp (*r_oid, "1.2.840.10045.4.3"))
{
xfree (*r_oid);
*r_oid = NULL;
err = get_algorithm (0, der+off2, len2, &nread, &off, &len, &is_bitstr,
NULL, NULL, NULL);
if (err)
{
*r_nread = 0;
return err;
}
*r_oid = ksba_oid_to_str (der+off2+off, len);
if (!*r_oid)
{
*r_nread = 0;
return gpg_error (GPG_ERR_ENOMEM);
}
off2 = len2 = 0; /* So that R_PARM is set to NULL. */
}
if (r_parm && r_parmlen)
{
if (off2 && len2)
{
*r_parm = xtrymalloc (len2);
if (!*r_parm)
{
xfree (*r_oid);
*r_oid = NULL;
return gpg_error (GPG_ERR_ENOMEM);
}
memcpy (*r_parm, der+off2, len2);
*r_parmlen = len2;
}
else
{
*r_parm = NULL;
*r_parmlen = 0;
}
}
return 0;
}
/* Mode 0: work as described under _ksba_sigval_to_sexp
mode 1: work as described under _ksba_encval_to_sexp */
static gpg_error_t
cryptval_to_sexp (int mode, const unsigned char *der, size_t derlen,
ksba_sexp_t *r_string)
{
gpg_error_t err;
const struct algo_table_s *algo_table;
int c;
size_t nread, off, len;
int algoidx;
int is_bitstr;
const unsigned char *ctrl;
const char *elem;
struct stringbuf sb;
/* FIXME: The entire function is very similar to keyinfo_to_sexp */
*r_string = NULL;
if (!mode)
algo_table = sig_algo_table;
else
algo_table = enc_algo_table;
err = get_algorithm (1, der, derlen, &nread, &off, &len, &is_bitstr,
NULL, NULL, NULL);
if (err)
return err;
/* look into our table of supported algorithms */
for (algoidx=0; algo_table[algoidx].oid; algoidx++)
{
if ( len == algo_table[algoidx].oidlen
&& !memcmp (der+off, algo_table[algoidx].oid, len))
break;
}
if (!algo_table[algoidx].oid)
return gpg_error (GPG_ERR_UNKNOWN_ALGORITHM);
if (!algo_table[algoidx].supported)
return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
der += nread;
derlen -= nread;
if (is_bitstr)
{ /* Funny: X.509 defines the signature value as a bit string but
CMS as an octet string - for ease of implementation we always
allow both */
if (!derlen)
return gpg_error (GPG_ERR_INV_KEYINFO);
c = *der++; derlen--;
if (c)
fprintf (stderr, "warning: number of unused bits is not zero\n");
}
/* fixme: we should calculate the initial length form the size of the
sequence, so that we don't neen a realloc later */
init_stringbuf (&sb, 100);
put_stringbuf (&sb, mode? "(7:enc-val(":"(7:sig-val(");
put_stringbuf_sexp (&sb, algo_table[algoidx].algo_string);
/* FIXME: We don't release the stringbuf in case of error
better let the macro jump to a label */
elem = algo_table[algoidx].elem_string;
ctrl = algo_table[algoidx].ctrl_string;
for (; *elem; ctrl++, elem++)
{
int is_int;
if ( (*ctrl & 0x80) && !elem[1] )
{ /* Hack to allow a raw value */
is_int = 1;
len = derlen;
}
else
{
if (!derlen)
return gpg_error (GPG_ERR_INV_KEYINFO);
c = *der++; derlen--;
if ( c != *ctrl )
return gpg_error (GPG_ERR_UNEXPECTED_TAG);
is_int = c == 0x02;
TLV_LENGTH (der);
}
if (is_int && *elem != '-')
{ /* take this integer */
char tmp[2];
put_stringbuf (&sb, "(");
tmp[0] = *elem; tmp[1] = 0;
put_stringbuf_sexp (&sb, tmp);
put_stringbuf_mem_sexp (&sb, der, len);
der += len;
derlen -= len;
put_stringbuf (&sb, ")");
}
}
put_stringbuf (&sb, ")");
if (!mode && algo_table[algoidx].digest_string)
{
/* Insert the hash algorithm if included in the OID. */
put_stringbuf (&sb, "(4:hash");
put_stringbuf_sexp (&sb, algo_table[algoidx].digest_string);
put_stringbuf (&sb, ")");
}
put_stringbuf (&sb, ")");
*r_string = get_stringbuf (&sb);
if (!*r_string)
return gpg_error (GPG_ERR_ENOMEM);
return 0;
}
void experiment::run_experiment()
{
parameter pdebug = get_param("debugprint");
parameter pdebug_f = get_param("debugprint_file");
pdebug.strvalue=pdebug_f.strvalue;
std::string sverbfile=get_param_s("verbose_file");
bool bverbose=(get_param_i("verbose_mode")==1);
std::ofstream fverbose;
if (sverbfile.compare("cout")==0)
gout=&std::cout;
else
{
fverbose.open(sverbfile.c_str());
gout=&fverbose;
};
//used algorithms
std::string sexp_type=get_param_s("exp_type");
std::string salgo_match=get_param_s("algo");
std::istrstream istr(salgo_match.c_str());
std::vector<std::string>v_salgo_match;
std::string stemp;
while (istr>>stemp)
v_salgo_match.push_back(stemp);
//used initialization algorithms
std::string salgo_init=get_param_s("algo_init_sol");
std::istrstream istrinit(salgo_init.c_str());
std::vector<std::string>v_salgo_init;
while (istrinit>>stemp)
v_salgo_init.push_back(stemp);
if (v_salgo_init.size()!=v_salgo_match.size())
{
printf("Error: algo and algo_init_sol do not have the same size\n");
exit(0);
};
double dalpha_ldh=get_param_d("alpha_ldh");
if ((dalpha_ldh<0) ||(dalpha_ldh>1))
{
printf("Error:alpha_ldh should be between 0 and 1 \n");
exit(0);
};
graph g(get_config());
graph h(get_config());
char cformat1='D',cformat2='D';
if (bverbose) *gout<<"Data loading"<<std::endl;
g.load_graph(get_param_s("graph_1"),'A',cformat1);
h.load_graph(get_param_s("graph_2"),'A',cformat2);
if (get_param_i("graph_dot_print")==1){ g.printdot("g.dot");h.printdot("h.dot");};
// Matrix of local similarities between graph vertices
std::string strfile=get_param_s("C_matrix");
int N1 =g.get_adjmatrix()->size1;
int N2 =h.get_adjmatrix()->size1;
gsl_matrix* gm_ldh=gsl_matrix_alloc(N1,N2);
FILE *f=fopen(strfile.c_str(),"r");
if (f!=NULL){
gsl_set_error_handler_off();
int ierror=gsl_matrix_fscanf(f,gm_ldh);
fclose(f);
gsl_set_error_handler(NULL);
if (ierror!=0){ printf("Error: C_matrix is not correctly defined \n"); exit(0);};
}
else
{
if (bverbose) *gout<<"C matrix is set to constant"<<std::endl;
dalpha_ldh=0;
gsl_matrix_set_all(gm_ldh,1.0/(N1*N2));
};
//inverse the sign if C is a distance matrix
if (get_param_i("C_matrix_dist")==1)
gsl_matrix_scale(gm_ldh,-1);
if (bverbose) *gout<<"Graph synhronization"<<std::endl;
synchronize(g,h,&gm_ldh);
//Cycle over all algoirthms
for (int a=0;a<v_salgo_match.size();a++)
{
//initialization
algorithm* algo_i=get_algorithm(v_salgo_init[a]);
algo_i->read_config(get_config_string());
algo_i->set_ldhmatrix(gm_ldh);
match_result mres_i=algo_i->gmatch(g,h,NULL,NULL,dalpha_ldh);
delete algo_i;
//main algorithm
algorithm* algo=get_algorithm(v_salgo_match[a]);
algo->read_config(get_config_string());
algo->set_ldhmatrix(gm_ldh);
match_result mres_a=algo->gmatch(g,h,(mres_i.gm_P_exact!=NULL)?mres_i.gm_P_exact:mres_i.gm_P, NULL,dalpha_ldh);
mres_a.vd_trace.clear();
mres_a.salgo=v_salgo_match[a];
v_mres.push_back(mres_a);
delete algo;
};
gsl_matrix_free(gm_ldh);
printout();
}
void genetic_reconstruction(Image * _amp, Image * initial_support, Image * _exp_sigma,
Options * _opts, char * dir){
char prev_dir[1024];
real support_threshold = _opts->new_level;
population *pop; /* Population of solutions. */
random_seed(23091975);
stop_threshold = 10;
stop = 0;
support_size = -support_threshold;
opts = _opts;
amp = _amp;
exp_sigma = _exp_sigma;
init_log(&my_log);
my_log.threshold = support_threshold;
opts->cur_iteration = 0;
opts->flog = NULL;
if(opts->automatic){
opts->algorithm = HIO;
}
support = imgcpy(initial_support);
prev_support = imgcpy(initial_support);
/* Set the initial guess */
if(opts->image_guess){
real_in = imgcpy(opts->image_guess);
}else{
real_in = imgcpy(support);
}
/* make sure we make the input complex */
rephase(real_in);
/* Set random phases if needed */
if(opts->rand_phases){
/* set_rand_phases(real_in,img);*/
set_rand_ints(real_in,amp);
}
getcwd(prev_dir,1024);
mkdir(dir,0755);
chdir(dir);
write_png(support,"support.png",COLOR_JET);
write_png(real_in,"initial_guess.png",COLOR_JET);
write_png(initial_support,"initial_support.png",COLOR_JET);
if(get_algorithm(opts,&my_log) == HIO){
real_out = basic_hio_iteration(amp, real_in, support,opts,&my_log);
}else if(get_algorithm(opts,&my_log) == RAAR){
real_out = basic_raar_iteration(amp,exp_sigma, real_in, support,opts,&my_log);
}else if(get_algorithm(opts,&my_log) == HPR){
real_out = basic_hpr_iteration(amp, real_in, support,opts,&my_log);
}else{
fprintf(stderr,"Error: Undefined algorithm!\n");
exit(-1);
}
radius = opts->max_blur_radius;
pop = ga_genesis_double(
3, /* const int population_size */
1, /* const int num_chromo */
TSIZE(amp)*2, /* const int len_chromo */
test_generation_callback,/* GAgeneration_hook generation_hook */
NULL, /* GAiteration_hook iteration_hook */
NULL, /* GAdata_destructor data_destructor */
NULL, /* GAdata_ref_incrementor data_ref_incrementor */
test_score, /* GAevaluate evaluate */
test_seed, /* GAseed seed */
test_adaptation, /* GAadapt adapt */
ga_select_one_bestof2, /* GAselect_one select_one */
ga_select_two_bestof2, /* GAselect_two select_two */
ga_mutate_double_singlepoint_drift, /* GAmutate mutate */
ga_crossover_double_doublepoints, /* GAcrossover crossover */
NULL, /* GAreplace replace */
NULL /* vpointer User data */
);
ga_population_set_parameters(
pop, /* population *pop */
GA_SCHEME_LAMARCK_ALL, /* const ga_scheme_type scheme */
GA_ELITISM_PARENTS_SURVIVE, /* const ga_elitism_type elitism */
0.8, /* double crossover */
0.2, /* double mutation */
0.0 /* double migration */
);
ga_evolution(
pop, /* population *pop */
500 /* const int max_generations */
);
ga_extinction(pop);
exit(EXIT_SUCCESS);
}
void complete_reconstruction(Image * amp, Image * initial_support, Image * exp_sigma,
Options * opts, char * dir){
Image * support = NULL;
Image * prev_support = NULL;
Image * real_in = NULL;
Image * real_space = NULL;
Image * tmp = NULL;
Image * tmp2;
Image * real_space_sum = sp_image_alloc(sp_image_x(initial_support),sp_image_y(initial_support),sp_image_z(initial_support));
int real_space_sum_n = 0;
global_options.current_support = &support;
global_options.current_real_space_image = &real_space;
char buffer[1024];
Log log;
real radius;
char prev_dir[1024];
int stop = 0;
real support_threshold = opts->new_level;
real support_size = -support_threshold;
const int stop_threshold = 10;
int i;
#if defined(_MSC_VER) || defined(__MINGW32__)
_getcwd(prev_dir,1024);
_chdir(dir);
#else
getcwd(prev_dir,1024);
chdir(dir);
#endif
if((get_algorithm(opts,&log) == HIO || get_algorithm(opts,&log) == RAAR || get_algorithm(opts,&log) == DIFF_MAP) &&
(opts->support_update_algorithm == FIXED ||
opts->support_update_algorithm == DECREASING_AREA ||
opts->support_update_algorithm == TEMPLATE_AREA ||
opts->support_update_algorithm == STATIC) && opts->support_image_averaging == 1){
/* use new libspimage backend */
// printf("use clean reconstruction\n");
return complete_reconstruction_clean(amp,initial_support,opts);
}else if(sp_cuda_get_device_type() == SpCUDAHardwareDevice ||
sp_cuda_get_device_type() == SpCUDAEmulatedDevice){
hawk_warning("Cannot use CUDA for this particular configuration.");
}
init_log(&log);
log.threshold = support_threshold;
opts->cur_iteration = 0;
opts->reconstruction_finished = 0;
opts->flog = NULL;
if(opts->automatic){
opts->algorithm = HIO;
}
/* clear real_space_sum */
real_space_sum_n = 0;
for(int i = 0;i<sp_image_size(real_space_sum);i++){
sp_real(real_space_sum->image->data[i]) = 0;
sp_imag(real_space_sum->image->data[i]) = 0;
}
support = sp_image_duplicate(initial_support,SP_COPY_DATA|SP_COPY_MASK);
/* Initialize support size. Necessary for difference map to work reliably */
log.SupSize = 0;
for(int i = 0;i<sp_image_size(support);i++){
if(sp_real(support->image->data[i])){
log.SupSize +=1;
}
}
log.SupSize /=sp_image_size(support);
log.SupSize *=100;
hawk_image_write(initial_support,"support.vtk",SP_3D);
prev_support = sp_image_duplicate(initial_support,SP_COPY_DATA|SP_COPY_MASK);
real_in = sp_image_duplicate(opts->image_guess,SP_COPY_DATA|SP_COPY_MASK);
hawk_image_write(real_in,"initial_guess.vtk",SP_3D);
if(amp->num_dimensions == SP_2D){
tmp2 = sp_image_shift(amp);
hawk_image_write(tmp2,"initial_support.png",SpColormapJet);
sp_image_free(tmp2);
}
hawk_image_write(initial_support,"initial_support.h5",0);
/* make sure we make the input complex */
sp_image_rephase(real_in,SP_ZERO_PHASE);
if(real_in->num_dimensions == SP_2D){
hawk_image_write(support,"support.png",SpColormapGrayScale);
hawk_image_write(real_in,"initial_guess.png",SpColormapJet);
hawk_image_write(real_in,"initial_guess.h5",sizeof(real));
hawk_image_write(initial_support,"initial_support.png",SpColormapGrayScale);
}else if(real_in->num_dimensions == SP_3D){
hawk_image_write(support,"support.vtk",0);
}
if(get_algorithm(opts,&log) == HIO){
real_space = basic_hio_iteration(amp, real_in, support,opts,&log);
}else if(get_algorithm(opts,&log) == RAAR){
real_space = basic_raar_iteration(amp,opts->intensities_std_dev, real_in, support,opts,&log);
}else if(get_algorithm(opts,&log) == HPR){
real_space = basic_hpr_iteration(amp, real_in, support,opts,&log);
}else if(get_algorithm(opts,&log) == CFLIP){
real_space = basic_cflip_iteration(amp, real_in, support,opts,&log);
}else if(get_algorithm(opts,&log) == ESPRESSO) {
real_space = basic_espresso_iteration(amp, real_in, support, opts, &log);
}else if(get_algorithm(opts,&log) == HAAR){
real_space = basic_haar_iteration(amp, NULL, real_in, support,opts,&log);
}else if(get_algorithm(opts,&log) == SO2D){
real_space = basic_so2d_iteration(amp, NULL, real_in, support,opts,&log);
}else if(get_algorithm(opts,&log) == RAAR_PROJ){
real_space = basic_raar_proj_iteration(amp, opts->intensities_std_dev, real_in, support,opts,&log);
}else if(get_algorithm(opts,&log) == HIO_PROJ){
real_space = basic_hio_proj_iteration(amp, opts->intensities_std_dev, real_in, support, opts, &log);
}else if(get_algorithm(opts,&log) == DIFF_MAP){
real_space = serial_difference_map_iteration(amp,real_in, support,opts,&log);
}else{
hawk_fatal("Error: Undefined algorithm!");
}
radius = opts->max_blur_radius;
/* Change the status to running */
opts->is_running = 1;
for(;!opts->reconstruction_finished && (!opts->max_iterations || opts->cur_iteration < opts->max_iterations);opts->cur_iteration++){
/* I'm only going to allow changes to images in the beggining of each iteration */
synchronize_image_data(&real_space,&support);
/* Add current real_space to the average real_space*/
if(opts->iterations-opts->cur_iteration%opts->iterations <= opts->support_image_averaging){
sp_image_add(real_space_sum,real_space);
real_space_sum_n++;
}
if(opts->image_blur_period && opts->cur_iteration%opts->image_blur_period == opts->image_blur_period-1){
sp_image_free(real_in);
real_in = sp_gaussian_blur(real_space,opts->image_blur_radius);
sp_image_memcpy(real_space,real_in);
}
if(opts->iterations && opts->cur_iteration%opts->iterations == opts->iterations-1){
sp_image_scale(real_space_sum,1.0/real_space_sum_n);
sp_image_free(real_in);
for(i = 0;i<opts->error_reduction_iterations_in_support_update;i++){
real_in = real_space_sum;
real_space_sum = basic_error_reduction_iteration(amp, real_in, support,opts,&log);
sp_image_free(real_in);
}
if(get_phases_blur_radius(opts)){
phase_smoothening_iteration(real_space,opts,&log);
}
sp_image_free(prev_support);
prev_support = sp_image_duplicate(support,SP_COPY_DATA|SP_COPY_MASK);
sp_image_free(support);
if (opts->support_update_algorithm == TEMPLATE_AREA) {
support = get_support_from_initial_support(opts);
} else {
support_threshold = get_support_level(real_space_sum,&support_size,radius,&log,opts);
log.threshold = support_threshold;
if(support_threshold > 0){
support = get_updated_support(real_space_sum,support_threshold, radius,opts);
}else{
if(opts->support_update_algorithm == REAL_ERROR_CAPPED){
exit(0);
}else{
abort();
}
}
}
if(opts->filter_intensities){
filter_intensities_with_support(amp,real_space_sum,support,opts);
}
if(opts->cur_iteration <= opts->iterations_to_min_blur){
radius = get_blur_radius(opts);
}
/* clear real_space_sum */
real_space_sum_n = 0;
for(int i = 0;i<sp_image_size(real_space_sum);i++){
sp_real(real_space_sum->image->data[i]) = 0;
sp_imag(real_space_sum->image->data[i]) = 0;
}
if(/*opts->cur_iteration > 50 ||*/ (opts->automatic && opts->algorithm == RAAR && log.Ereal < 0.2)){
stop++;
}
if(stop > stop_threshold){
break;
}
}
if(opts->cur_iteration%opts->output_period == opts->output_period-1){
Image * rs = apply_output_projection(real_space,opts->output_projection,amp);
if(real_in->num_dimensions == SP_2D){
sprintf(buffer,"real_space-%07d.png",opts->cur_iteration);
hawk_image_write(rs,buffer,SpColormapJet);
sprintf(buffer,"real_space_phase-%07d.png",opts->cur_iteration);
// hawk_image_write(real_space,buffer,SpColormapWheel|COLOR_WEIGHTED_PHASE);
hawk_image_write(rs,buffer,SpColormapWheel|SpColormapPhase);
sprintf(buffer,"support-%07d.png",opts->cur_iteration);
hawk_image_write(support,buffer,SpColormapGrayScale);
}
if(real_in->num_dimensions == SP_3D){
sprintf(buffer,"real_space-%07d.vtk",opts->cur_iteration);
// hawk_image_write(real_space,buffer,0);
hawk_image_write(rs,buffer,0);
sprintf(buffer,"support-%07d.vtk",opts->cur_iteration);
hawk_image_write(support,buffer,0);
}
sprintf(buffer,"real_space-%07d.h5",opts->cur_iteration);
// hawk_image_write(real_space,buffer,opts->output_precision);
hawk_image_write(rs,buffer,opts->output_precision);
sprintf(buffer,"support-%07d.h5",opts->cur_iteration);
hawk_image_write(support,buffer,opts->output_precision);
sp_image_free(rs);
tmp = sp_image_duplicate(real_space,SP_COPY_DATA|SP_COPY_MASK);
for(i = 0;i<sp_c3matrix_size(tmp->image);i++){
if(sp_real(support->image->data[i])){
;
}else{
tmp->image->data[i] = sp_cinit(0,0);
}
}
sprintf(buffer,"pre_fourier_space-%07d.h5",opts->cur_iteration);
tmp2 = sp_image_fft(tmp);
sp_image_free(tmp);
tmp = tmp2;
for(i = 0;i<sp_c3matrix_size(tmp->image);i++){
tmp->mask->data[i] = 1;
}
sprintf(buffer,"fourier_space-%07d.h5",opts->cur_iteration);
hawk_image_write(tmp,buffer,opts->output_precision);
tmp2 = sp_image_shift(tmp);
if(tmp2->num_dimensions == SP_2D){
sprintf(buffer,"fourier_space-%07d.png",opts->cur_iteration);
hawk_image_write(tmp2,buffer,SpColormapJet);
sp_image_free(tmp2);
}
/* sprintf(buffer,"fourier_space-%07d.vtk",opts->cur_iteration);
hawk_image_write(tmp,buffer,SP_3D);
sp_image_free(tmp);*/
}
if(opts->break_centrosym_period &&
opts->cur_iteration%opts->break_centrosym_period == opts->break_centrosym_period-1){
centrosym_break_attempt(real_space);
}
sp_image_free(real_in);
real_in = real_space;
if(get_algorithm(opts,&log) == HIO){
real_space = basic_hio_iteration(amp, real_in, support,opts,&log);
}else if(get_algorithm(opts,&log) == RAAR){
real_space = basic_raar_iteration(amp,exp_sigma, real_in, support,opts,&log);
}else if(get_algorithm(opts,&log) == HPR){
real_space = basic_hpr_iteration(amp, real_in, support,opts,&log);
}else if(get_algorithm(opts,&log) == CFLIP){
real_space = basic_cflip_iteration(amp, real_in, support,opts,&log);
}else if(get_algorithm(opts,&log) == ESPRESSO){
real_space = basic_espresso_iteration(amp, real_in, support, opts, &log);
}else if(get_algorithm(opts,&log) == HAAR){
real_space = basic_haar_iteration(amp, exp_sigma,real_in, support,opts,&log);
}else if(get_algorithm(opts,&log) == SO2D){
real_space = basic_so2d_iteration(amp, exp_sigma,real_in, support,opts,&log);
}else if(get_algorithm(opts,&log) == RAAR_PROJ){
real_space = basic_raar_proj_iteration(amp, opts->intensities_std_dev,real_in, support,opts,&log);
}else if(get_algorithm(opts,&log) == HIO_PROJ){
real_space = basic_hio_proj_iteration(amp, opts->intensities_std_dev, real_in, support, opts, &log);
}else if(get_algorithm(opts,&log) == DIFF_MAP){
real_space = serial_difference_map_iteration(amp,real_in, support,opts,&log);
}
}
//hawk_image_write(real_space,"real_space_final.h5",opts->output_precision|SP_2D);
//hawk_image_write(real_space,"real_space_final.png",SpColormapJet|SP_2D);
// hawk_image_write(real_space,"real_space_final.vtk",0);
Image * rs = apply_output_projection(real_space,opts->output_projection,amp);
// hawk_image_write(real_space,"real_space-final.h5",0);
hawk_image_write(rs,"real_space-final.h5",0);
sp_image_free(rs);
//sprintf(buffer,"support-final.png");
//hawk_image_write(support,buffer,SpColormapJet|SP_2D);
//sprintf(buffer,"support-final.h5");
hawk_image_write(support,"support-final.h5",0);
//sprintf(buffer,"support-final.vtk");
// hawk_image_write(support,buffer,opts->output_precision);
tmp = sp_image_fft(real_space);
for(i = 0;i<sp_c3matrix_size(tmp->image);i++){
tmp->mask->data[i] = 1;
}
sprintf(buffer,"fourier_space-final.h5");
//hawk_image_write(tmp,buffer,opts->output_precision);
// sprintf(buffer,"fourier_space-final.png");
//hawk_image_write(tmp,buffer,SpColormapJet);
// sprintf(buffer,"fourier_space-final.vtk");
hawk_image_write(tmp,buffer,0);
sp_image_free(tmp);
//hawk_image_write(real_space,"phases_out_final.png",SpColormapPhase|SpColormapJet);
sp_image_free(support);
sp_image_free(prev_support);
sp_image_free(real_in);
sp_image_free(real_space);
#if defined(_MSC_VER) || defined(__MINGW32__)
_chdir(dir);
#else
chdir(dir);
#endif
if(opts->flog){
fclose(opts->flog);
}
if(log.cumulative_fluctuation){
sp_image_free(log.cumulative_fluctuation);
}
}
void complete_reconstruction_clean(Image * amp, Image * initial_support,Options * opts){
SpPhasingAlgorithm * alg = NULL;
Log log;
init_log(&log);
opts->flog = NULL;
opts->cur_iteration = 0;
SpPhasingConstraints phasing_constraints = SpNoConstraints;
if(opts->enforce_real && opts->enforce_positivity){
phasing_constraints |= SpPositiveRealObject;
}else if(opts->enforce_real){
phasing_constraints |= SpRealObject;
}else if(opts->enforce_positivity){
phasing_constraints |= SpPositiveComplexObject;
}
if(opts->enforce_centrosymmetry){
phasing_constraints |= SpCentrosymmetricObject;
}
// if (opts->enforce_ramp) {
// phasing_constraints |= SpRampObject;
// }
if(get_algorithm(opts,&log) == HIO){
alg = sp_phasing_hio_alloc(opts->beta_evolution,phasing_constraints);
}
if(get_algorithm(opts,&log) == RAAR){
alg = sp_phasing_raar_alloc(opts->beta_evolution,phasing_constraints);
}
if(get_algorithm(opts,&log) == DIFF_MAP){
alg = sp_phasing_diff_map_alloc(opts->beta_evolution,get_gamma1(opts),get_gamma2(opts),phasing_constraints);
}
SpSupportArray * sup_alg = NULL;
if(opts->support_update_algorithm == FIXED){
sup_alg = sp_support_array_init(sp_support_threshold_alloc(opts->support_blur_evolution,opts->threshold_evolution),
opts->iterations);
}
if(opts->support_update_algorithm == DECREASING_AREA){
sup_alg = sp_support_array_init(sp_support_area_alloc(opts->support_blur_evolution,opts->object_area_evolution),
opts->iterations);;
}
if (opts->support_update_algorithm == TEMPLATE_AREA){
sup_alg = sp_support_array_init(sp_support_template_alloc(opts->init_support,opts->template_blur_radius,
opts->template_area_evolution),opts->iterations);
}
if (opts->support_update_algorithm == STATIC){
sup_alg = sp_support_array_init(sp_support_static_alloc(),opts->iterations);
}
if(!alg || !sup_alg){
hawk_fatal("Algorithm is NULL!\nBlame the programmer!");
}
if (opts->support_closure_radius > 0) {
sp_support_array_append(sup_alg,sp_support_close_alloc(opts->support_closure_radius));
}
// !CHANGE!
if (opts->center_image){
sp_support_array_append(sup_alg,sp_support_centre_image_alloc());
}
SpPhaser * ph = sp_phaser_alloc();
sp_phaser_init(ph,alg,sup_alg,opts->phasing_engine);
sp_phaser_set_amplitudes(ph,amp);
sp_phaser_init_model(ph,opts->image_guess,0);
//sp_phaser_init_support(ph,initial_support,0,0);
if (opts->init_support == NULL) {
sp_phaser_init_support(ph,initial_support,SpSupportFromPatterson,opts->init_level);
} else {
sp_phaser_init_support(ph,initial_support,0,0);
}
output_initial_images(sp_phaser_model(ph),initial_support);
while(opts->max_iterations == 0 || opts->cur_iteration < opts->max_iterations){
char buffer[1024];
int to_output = opts->output_period-(ph->iteration)%opts->output_period;
int to_log = opts->log_output_period-(ph->iteration)%opts->log_output_period;
int to_iterate = sp_min(to_output,to_log);
// int timer = sp_timer_start();
sp_phaser_iterate(ph,to_iterate);
// printf("hawk - %d iterations in %d ms\n",to_iterate,(int)sp_timer_stop(timer));
opts->cur_iteration = ph->iteration;
if(to_iterate == to_log){
output_from_phaser(ph,opts,&log);
}
if(to_iterate == to_output){
sprintf(buffer,"real_space-%07d.h5",ph->iteration-1);
//hawk_image_write(sp_phaser_model(ph),buffer,opts->output_precision);
Image * rs = apply_output_projection(sp_phaser_model_with_support(ph),
opts->output_projection,
sp_phaser_amplitudes(ph));
hawk_image_write(rs,buffer,opts->output_precision);
sprintf(buffer,"support-%07d.h5",ph->iteration-1);
hawk_image_write(sp_phaser_support(ph),buffer,opts->output_precision);
sprintf(buffer,"fourier_space-%07d.h5",ph->iteration-1);
hawk_image_write(sp_phaser_fmodel_with_mask(ph),buffer,opts->output_precision);
// appending in cxidb file format is currently only implemented for 2D images
if (amp->num_dimensions == SP_2D) {
// initialize flag to include iteration number with the last 32 bits
long long flag = ph->iteration;
flag = (flag << 32) | 8;
// copy support to data Image
for (unsigned i = 0; i < sp_image_size(sp_phaser_support(ph)); i++) {
rs->mask->data[i] = (int) sp_real(sp_phaser_support(ph)->image->data[i]);
}
// append data to cxidb file
hawk_image_write(rs, "reconstruction.cxi", flag);
}
sp_image_free(rs);
}
}
}
