int main(int argc, char *argv[])
{
if (Show_Version(argc, argv, "1.0") == 1) {
return 0;
}
static char *Spec[] = {
"[-R<string> -T<string> -M<string>] -D<string> [-minlen <double>]",
"[-root <double> <double> <double>] [-trans <double> <double> <double>]",
"[-rtlist <string>] [-sup_root] [-dist <double>]",
"[-C<string>] [-I<string>] [-z <double>] -o <string> [-b] [-res <string>]",
"[-screen] [-sp] [-intp] [-sl] [-rb] [-rz] [-rs] [-ct] [-al <double>]",
"[-screenz <double>] [-force_merge <double>] [-ct_break <double>]",
"[-jumpz <double>] [-single_break]",
NULL};
Print_Arguments(argc, argv);
Process_Arguments(argc, argv, Spec, 1);
char *dir = Get_String_Arg("-D");
Stack_Document *stack_doc = NULL;
if (Is_Arg_Matched("-I")) {
if (!fexist(Get_String_Arg("-I"))) {
PRINT_EXCEPTION("File does not exist", "");
fprintf(stderr, "%s cannot be found.\n", Get_String_Arg("-I"));
return 1;
}
if (fhasext(Get_String_Arg("-I"), "xml")) {
stack_doc = Xml_Read_Stack_Document(Get_String_Arg("-I"));
}
}
/* Get number of chains */
int chain_number2 = dir_fnum_p(dir, "^chain.*\\.tb");
if (chain_number2 == 0) {
printf("No tube found.\n");
printf("Quit reconstruction.\n");
return 1;
}
int i;
int *chain_map = iarray_malloc(chain_number2);
int chain_number;
Locseg_Chain **chain_array =
Dir_Locseg_Chain_Nd(dir, "chain.*\\.tb", &chain_number, chain_map);
if (Is_Arg_Matched("-screenz")) {
Locseg_Chain_Array_Screen_Z(chain_array, chain_number,
Get_Double_Arg("-screenz"));
}
if (Is_Arg_Matched("-single_break")) {
int i;
for (i = 0; i < chain_number; i++) {
if (Locseg_Chain_Length(chain_array[i]) == 1) {
/* break the segment into two parts */
Locseg_Chain_Break_Node(chain_array[i], 0, 0.5);
}
}
}
if (Is_Arg_Matched("-ct_break")) {
int tmp_chain_number;
Locseg_Chain **tmp_chain_array =
Locseg_Chain_Array_Break_Jump(chain_array, chain_number,
Get_Double_Arg("-ct_break"), &tmp_chain_number);
kill_locseg_chain_array(chain_array, chain_number);
chain_array = tmp_chain_array;
chain_number = tmp_chain_number;
}
Connection_Test_Workspace *ctw = New_Connection_Test_Workspace();
if (Is_Arg_Matched("-res")) {
FILE *fp = fopen(Get_String_Arg("-res"), "r");
if (fp != NULL) {
if (darray_fscanf(fp, ctw->resolution, 3) != 3) {
fprintf(stderr, "Failed to load %s\n", Get_String_Arg("-res"));
ctw->resolution[0] = 1.0;
ctw->resolution[1] = 1.0;
ctw->resolution[2] = 1.0;
} else {
ctw->unit = 'u';
}
fclose(fp);
} else {
fprintf(stderr, "Failed to load %s. The file may not exist.\n",
Get_String_Arg("-res"));
}
} else if (stack_doc != NULL) {
ctw->resolution[0] = stack_doc->resolution[0];
ctw->resolution[1] = stack_doc->resolution[1];
ctw->resolution[2] = stack_doc->resolution[2];
}
if (Is_Arg_Matched("-force_merge")) {
Connection_Test_Workspace *ws = New_Connection_Test_Workspace();
ws->dist_thre = Get_Double_Arg("-force_merge");
ws->interpolate = FALSE;
ws->resolution[2] = ctw->resolution[2] / ctw->resolution[0];
for (i = 0; i < chain_number; i++) {
//Locseg_Chain_Correct_Ends(chain_array[i]);
}
Locseg_Chain_Array_Force_Merge(chain_array, chain_number, ws);
Kill_Connection_Test_Workspace(ws);
}
chain_number2 = 0;
Neuron_Component *chain_array2;
GUARDED_MALLOC_ARRAY(chain_array2, chain_number, Neuron_Component);
for (i = 0; i < chain_number; i++) {
if (Locseg_Chain_Is_Empty(chain_array[i]) == FALSE) {
chain_map[chain_number2] = chain_map[i];
Set_Neuron_Component(chain_array2+(chain_number2++),
NEUROCOMP_TYPE_LOCSEG_CHAIN, chain_array[i]);
} else {
printf("chain_%d is empty.\n", chain_map[i]);
}
}
/*
Dir_Locseg_Chain_Nc(dir, "^chain.*\\.tb", &chain_number2, chain_map);
*/
Stack *signal = NULL;
//Stack *canvas = NULL;
if (Is_Arg_Matched("-I")) {
signal = Read_Stack_U(Get_String_Arg("-I"));
//canvas = Translate_Stack(signal, COLOR, 0);
} else {
if (Is_Arg_Matched("-screen")) {
perror("The -screen option requires -I option to be supplied.\n");
return 1;
}
}
/* Minimal tube length. */
double minlen = 25.0;
if (Is_Arg_Matched("-minlen")) {
minlen = Get_Double_Arg("-minlen");
}
chain_number = 0;
//int i;
if (signal != NULL) {
ctw->mask = Make_Stack(GREY, signal->width, signal->height, signal->depth);
One_Stack(ctw->mask);
}
FILE *result_file = fopen(full_path(dir, Get_String_Arg("-o")), "w");
double z_scale = 1.0;
if (Is_Arg_Matched("-z")) {
z_scale = Get_Double_Arg("-z");
}
/* Array to store corrected chains */
Neuron_Component *chain_array_c = Make_Neuron_Component_Array(chain_number2);
int screen = 0;
double average_intensity = 0.0;
if (Is_Arg_Matched("-screen")) {
int good_chain_number = 0;
int bad_chain_number = 0;
for (i = 0; i < chain_number2; i++) {
Locseg_Chain *chain = NEUROCOMP_LOCSEG_CHAIN(chain_array2 + i);
average_intensity += Locseg_Chain_Average_Score(chain, signal, z_scale,
STACK_FIT_MEAN_SIGNAL);
if ((Locseg_Chain_Geolen(chain) > 55) ||
(Locseg_Chain_Average_Score(chain, signal, z_scale,
STACK_FIT_CORRCOEF) > 0.6)) {
good_chain_number++;
} else {
bad_chain_number++;
}
}
printf("good %d bad %d\n", good_chain_number, bad_chain_number);
if (good_chain_number + bad_chain_number > 50) {
if (bad_chain_number > good_chain_number) {
screen = 1;
}
} else {
screen = 3;
/*
if (bad_chain_number > good_chain_number * 2) {
screen = 2;
}
*/
}
}
average_intensity /= chain_number2;
/* build chain map */
for (i = 0; i < chain_number2; i++) {
Locseg_Chain *chain = NEUROCOMP_LOCSEG_CHAIN(chain_array2 + i);
BOOL good = FALSE;
switch (screen) {
case 1:
case 2:
if ((Locseg_Chain_Geolen(chain) > 100) ||
(Locseg_Chain_Average_Score(chain, signal, z_scale,
STACK_FIT_CORRCOEF)
> 0.6)) {
good = TRUE;
} else {
if (Locseg_Chain_Geolen(chain) < 100) {
if ((Locseg_Chain_Average_Score(chain, signal, z_scale,
STACK_FIT_CORRCOEF) > 0.5) ||
(Locseg_Chain_Average_Score(chain, signal, z_scale,
STACK_FIT_MEAN_SIGNAL) >
average_intensity)) {
good = TRUE;
}
}
}
break;
case 3:
if ((Locseg_Chain_Average_Score(chain, signal, z_scale,
STACK_FIT_CORRCOEF) > 0.50) ||
(Locseg_Chain_Average_Score(chain, signal, z_scale,
STACK_FIT_MEAN_SIGNAL) >
average_intensity)) {
good = TRUE;
}
break;
default:
good = TRUE;
}
if (good == TRUE) {
if (Locseg_Chain_Geolen(chain) < minlen) {
good = FALSE;
}
}
if (good == TRUE) {
Locseg_Chain *tmpchain = chain;
if (signal != NULL) {
//Locseg_Chain_Trace_Np(signal, 1.0, tmpchain, tw);
Locseg_Chain_Erase(chain, ctw->mask, 1.0);
}
fprintf(result_file, "%d %d\n", chain_number, chain_map[i]);
chain_map[chain_number] = chain_map[i];
if (z_scale != 1.0) {
Locseg_Chain_Scale_Z(chain, z_scale);
}
Set_Neuron_Component(chain_array_c + chain_number,
NEUROCOMP_TYPE_LOCSEG_CHAIN, tmpchain);
chain_number++;
} else {
#ifdef _DEBUG_
printf("chain%d is excluded.\n", i);
/*
char tmpfile[500];
sprintf(tmpfile, "../data/diadem_c1/bad_chain/chain%d.tb", i);
Write_Locseg_Chain(tmpfile, chain);
*/
#endif
}
}
z_scale = 1.0;
fprintf(result_file, "#\n");
//Int_Arraylist *hit_spots = Int_Arraylist_New(0, chain_number);
/* reconstruct neuron */
if (Is_Arg_Matched("-res")) {
FILE *fp = fopen(Get_String_Arg("-res"), "r");
if (fp != NULL) {
if (darray_fscanf(fp, ctw->resolution, 3) != 3) {
fprintf(stderr, "Failed to load %s\n", Get_String_Arg("-res"));
ctw->resolution[0] = 1.0;
ctw->resolution[1] = 1.0;
ctw->resolution[2] = 1.0;
} else {
ctw->unit = 'u';
}
fclose(fp);
} else {
fprintf(stderr, "Failed to load %s. The file may not exist.\n",
Get_String_Arg("-res"));
}
} else if (stack_doc != NULL) {
ctw->resolution[0] = stack_doc->resolution[0];
ctw->resolution[1] = stack_doc->resolution[1];
ctw->resolution[2] = stack_doc->resolution[2];
}
if (!Is_Arg_Matched("-sp")) {
ctw->sp_test = FALSE;
if (ctw->sp_test == FALSE) {
ctw->dist_thre = NEUROSEG_DEFAULT_H / 2.0;
}
} else {
ctw->dist_thre = NEUROSEG_DEFAULT_H * 1.5;
}
if (Is_Arg_Matched("-dist")) {
ctw->dist_thre = Get_Double_Arg("-dist");
}
if (!Is_Arg_Matched("-intp")) {
ctw->interpolate = FALSE;
}
//ctw->dist_thre = 100.0;
double *tube_offset = NULL;
if (Is_Arg_Matched("-trans")) {
tube_offset = darray_malloc(3);
tube_offset[0] = Get_Double_Arg("-trans", 1);
tube_offset[1] = Get_Double_Arg("-trans", 2);
tube_offset[2] = Get_Double_Arg("-trans", 3);
} else {
if (stack_doc != NULL) {
tube_offset = darray_malloc(3);
tube_offset[0] = stack_doc->offset[0];
tube_offset[1] = stack_doc->offset[1];
tube_offset[2] = stack_doc->offset[2];
}
}
Neuron_Structure *ns = New_Neuron_Structure();
ns->comp = chain_array_c;
ns->graph = New_Graph();
ns->graph->nvertex = chain_number;
if (Is_Arg_Matched("-rtlist")) {
int m, n;
double *d = darray_load_matrix(Get_String_Arg("-rtlist"), NULL, &m, &n);
if (n > 0) {
coordinate_3d_t *roots = GUARDED_MALLOC_ARRAY(roots, n, coordinate_3d_t);
int i;
for (i = 0; i < n; i++) {
if (Is_Arg_Matched("-trans")) {
roots[i][0] = d[i*3] - tube_offset[0];
roots[i][1] = d[i*3 + 1] - tube_offset[1];
roots[i][2] = d[i*3 + 2] - tube_offset[2];
} else {
roots[i][0] = d[i*3];
roots[i][1] = d[i*3 + 1];
roots[i][2] = d[i*3 + 2];
}
}
Neuron_Structure_Break_Root(ns, roots, n);
Neuron_Structure_Load_Root(ns, roots, n);
}
}
Locseg_Chain_Comp_Neurostruct_W(ns, signal, z_scale, ctw);
if (tube_offset != NULL) {
for (i = 0; i < chain_number; i++) {
Locseg_Chain_Translate(NEUROCOMP_LOCSEG_CHAIN(chain_array_c + i),
tube_offset);
}
}
/*
Neuron_Structure *ns = Locseg_Chain_Comp_Neurostruct(chain_array,
chain_number,
signal, z_scale, ctw);
*/
FILE *tube_fp = fopen(full_path(dir, "tube.swc"), "w");
int start_id = 1;
for (i = 0; i < chain_number; i++) {
int node_type = i % 10;
int n = Locseg_Chain_Swc_Fprint_T(tube_fp,
NEUROCOMP_LOCSEG_CHAIN(chain_array_c + i),
node_type, start_id,
-1, DL_FORWARD, 1.0, NULL);
start_id += n;
}
fclose(tube_fp);
//Neuron_Structure_To_Swc_File(ns, full_path(dir, "tube.swc"));
/*
Graph *testgraph = New_Graph(0, 0, FALSE);
Int_Arraylist *cidx = Make_Int_Arraylist(0, 2);
Int_Arraylist *sidx = Make_Int_Arraylist(0, 2);
Locseg_Chain_Network_Simlify(&net, testgraph, cidx, sidx);
*/
/* Find branch points */
//Locseg_Chain *branches = Locseg_Chain_Network_Find_Branch(ns);
//Graph *graph = Locseg_Chain_Graph(chain_array, chain_number, hit_spots);
//Graph *graph = ns->graph;
if (Is_Arg_Matched("-sup_root")) {
if (Is_Arg_Matched("-rtlist")) {
int m, n;
double *d = darray_load_matrix(Get_String_Arg("-rtlist"), NULL, &m, &n);
if (n > 0) {
coordinate_3d_t *roots =
GUARDED_MALLOC_ARRAY(roots, n, coordinate_3d_t);
int i;
for (i = 0; i < n; i++) {
roots[i][0] = d[i*3];
roots[i][1] = d[i*3 + 1];
roots[i][2] = d[i*3 + 2];
/*
if (tube_offset != NULL) {
roots[i][0] += tube_offset[0];
roots[i][1] += tube_offset[1];
roots[i][2] += tube_offset[2];
}
*/
}
neuron_structure_suppress(ns, roots, n);
free(roots);
}
}
}
Process_Neuron_Structure(ns);
Print_Neuron_Structure(ns);
#ifdef _DEBUG_
for (i = 0; i < NEURON_STRUCTURE_LINK_NUMBER(ns); i++) {
printf("chain_%d (%d) -- chain_%d (%d) ",
chain_map[ns->graph->edges[i][0]],
ns->graph->edges[i][0],
chain_map[ns->graph->edges[i][1]],
ns->graph->edges[i][1]);
Print_Neurocomp_Conn(ns->conn + i);
}
#endif
if (Is_Arg_Matched("-ct")) {
Neuron_Structure_Crossover_Test(ns,
ctw->resolution[0] / ctw->resolution[2]);
}
if (Is_Arg_Matched("-al")) {
Neuron_Structure_Adjust_Link(ns, Get_Double_Arg("-al"));
}
Neuron_Structure_To_Tree(ns);
Neuron_Structure_Remove_Negative_Conn(ns);
#ifdef _DEBUG_
printf("\nTree:\n");
for (i = 0; i < NEURON_STRUCTURE_LINK_NUMBER(ns); i++) {
printf("chain_%d (%d) -- chain_%d (%d) ",
chain_map[ns->graph->edges[i][0]],
ns->graph->edges[i][0],
chain_map[ns->graph->edges[i][1]],
ns->graph->edges[i][1]);
Print_Neurocomp_Conn(ns->conn + i);
}
#endif
/*
printf("\ncross over changed: \n");
Print_Neuron_Structure(ns);
*/
#ifdef _DEBUG_2
ns->graph->nedge = 0;
Neuron_Structure_To_Swc_File(ns, "../data/test.swc");
return 1;
#endif
//Print_Neuron_Structure(ns);
Neuron_Structure* ns2= NULL;
if (Is_Arg_Matched("-intp")) {
ns2 = Neuron_Structure_Locseg_Chain_To_Circle_S(ns, 1.0, 1.0);
} else {
ns2 = Neuron_Structure_Locseg_Chain_To_Circle(ns);
}
/*
Neuron_Structure* ns2=
Neuron_Structure_Locseg_Chain_To_Circle_S(ns, 1.0, 1.0);
*/
Graph_To_Dot_File(ns2->graph, full_path(dir, "graph_d.dot"));
//Neuron_Structure_Main_Graph(ns2);
Neuron_Structure_To_Tree(ns2);
double root[3];
if (Is_Arg_Matched("-root")) {
root[0] = Get_Double_Arg("-root", 1);
root[1] = Get_Double_Arg("-root", 2);
root[2] = Get_Double_Arg("-root", 3);
}
Swc_Tree *tree = NULL;
if (Is_Arg_Matched("-root")) {
/*
int root_index = Neuron_Structure_Find_Root_Circle(ns2, root);
Graph_Workspace *gw2 = New_Graph_Workspace();
Graph_Clean_Root(ns2->graph, root_index, gw2);
Neuron_Structure_To_Swc_File_Circle_Z(ns2, full_path(dir, "graph_d.swc"),
z_scale, root);
*/
tree = Neuron_Structure_To_Swc_Tree_Circle_Z(ns2, z_scale, root);
if (Swc_Tree_Node_Is_Virtual(tree->root) == TRUE) {
tree->root->first_child->next_sibling = NULL;
}
Swc_Tree_Clean_Root(tree);
} else {
/*
Neuron_Structure_To_Swc_File_Circle_Z(ns2, full_path(dir, "graph_d.swc"),
z_scale, NULL);
*/
tree = Neuron_Structure_To_Swc_Tree_Circle_Z(ns2, z_scale, NULL);
}
ns->graph->nedge = 0;
//Neuron_Structure_To_Swc_File(ns, full_path(dir, "tube.swc"));
if (Is_Arg_Matched("-rb")) {
//Swc_Tree_Tune_Branch(tree);
Swc_Tree_Tune_Fork(tree);
}
if (Is_Arg_Matched("-sl")) {
Swc_Tree_Leaf_Shrink(tree);
}
if (Is_Arg_Matched("-rz")) {
Swc_Tree_Remove_Zigzag(tree);
}
if (Is_Arg_Matched("-rs")) {
Swc_Tree_Remove_Spur(tree);
}
Swc_Tree_Resort_Id(tree);
Write_Swc_Tree(full_path(dir, "graph_d.swc"), tree);
if (Is_Arg_Matched("-rtlist")) {
int m, n;
double *d = darray_load_matrix(Get_String_Arg("-rtlist"), NULL, &m, &n);
if (n > 0) {
coordinate_3d_t *roots = GUARDED_MALLOC_ARRAY(roots, n, coordinate_3d_t);
int i;
for (i = 0; i < n; i++) {
roots[i][0] = d[i*3];
roots[i][1] = d[i*3 + 1];
roots[i][2] = d[i*3 + 2];
/*
if (tube_offset != NULL) {
roots[i][0] += tube_offset[0];
roots[i][1] += tube_offset[1];
roots[i][2] += tube_offset[2];
}
*/
Swc_Tree *subtree = Swc_Tree_Pull_R(tree, roots[i]);
char filename[MAX_PATH_LENGTH];
if (subtree->root != NULL) {
//Swc_Tree_Clean_Root(subtree);
Swc_Tree_Clean_Root(subtree);
Swc_Tree_Node_Set_Pos(subtree->root, roots[i]);
if (Is_Arg_Matched("-jumpz")) {
//swc_tree_remove_zjump(subtree, Get_Double_Arg("-jumpz"));
}
Swc_Tree_Resort_Id(subtree);
sprintf(filename, "graph%d.swc", i + 1);
Write_Swc_Tree(full_path(dir, filename), subtree);
}
}
}
}
printf("%d chains\n", chain_number);
return 0;
}
int main(int argc, char* argv[])
{
if (Show_Version(argc, argv, "1.00") == 1) {
return 0;
}
static char *Spec[] = {
" <image:string> -s <string> -o <string> [-e <string>] [-fo <int>] "
"[-z <double> | -res <string>] [-field <int>] [-min_score <double>]",
NULL};
Process_Arguments(argc, argv, Spec, 1);
Geo3d_Scalar_Field *seed = Read_Geo3d_Scalar_Field(Get_String_Arg("-s"));
size_t idx;
double max_r = darray_max(seed->values, seed->size, &idx);
max_r *= 1.5;
//Set_Neuroseg_Max_Radius(max_r);
Stack *signal = Read_Stack_U(Get_String_Arg("image"));
dim_type dim[3];
dim[0] = signal->width;
dim[1] = signal->height;
dim[2] = signal->depth;
Rgb_Color color;
Set_Color(&color, 255, 0, 0);
int seed_offset = -1;
double z_scale = 1.0;
if (Is_Arg_Matched("-res")) {
if (fexist(Get_String_Arg("-res"))) {
double res[3];
int length;
darray_read2(Get_String_Arg("-res"), res, &length);
if (res[0] != res[1]) {
perror("Different X-Y resolutions.");
TZ_ERROR(ERROR_DATA_VALUE);
}
z_scale = res[0] / res[2] * 2.0;
}
}
if (Is_Arg_Matched("-z")) {
z_scale = Get_Double_Arg("-z");
}
printf("z scale: %g\n", z_scale);
tic();
double *values = darray_malloc(seed->size);
int i;
Local_Neuroseg *locseg = (Local_Neuroseg *)
malloc(seed->size * sizeof(Local_Neuroseg));
int index = 0;
//int ncol = LOCAL_NEUROSEG_NPARAM + 1 + 23;
//double *features = darray_malloc(seed->size * ncol);
//double *tmpfeats = features;
Stack *seed_mask = Make_Stack(GREY, signal->width, signal->height,
signal->depth);
Zero_Stack(seed_mask);
Locseg_Fit_Workspace *fws = New_Locseg_Fit_Workspace();
if (Is_Arg_Matched("-field")) {
fws->sws->field_func = Neuroseg_Slice_Field_Func(Get_Int_Arg("-field"));
}
fws->sws->fs.n = 2;
fws->sws->fs.options[0] = STACK_FIT_DOT;
fws->sws->fs.options[1] = STACK_FIT_CORRCOEF;
if (Is_Arg_Matched("-fo")) {
fws->sws->fs.options[1] = Get_Int_Arg("-fo");
}
for (i = 0; i < seed->size; i++) {
printf("-----------------------------> seed: %d / %d\n", i, seed->size);
index = i;
int x = (int) seed->points[index][0];
int y = (int) seed->points[index][1];
int z = (int) seed->points[index][2];
double width = seed->values[index];
seed_offset = Stack_Util_Offset(x, y, z, signal->width, signal->height,
signal->depth);
if (width < 3.0) {
width += 0.5;
}
Set_Neuroseg(&(locseg[i].seg), width, 0.0, NEUROSEG_DEFAULT_H,
0.0, 0.0, 0.0, 0.0, 1.0);
double cpos[3];
cpos[0] = x;
cpos[1] = y;
cpos[2] = z;
cpos[2] /= z_scale;
Set_Neuroseg_Position(&(locseg[i]), cpos, NEUROSEG_CENTER);
if (seed_mask->array[seed_offset] > 0) {
printf("labeled\n");
values[i] = 0.0;
continue;
}
//Local_Neuroseg_Optimize(locseg + i, signal, z_scale, 0);
Local_Neuroseg_Optimize_W(locseg + i, signal, z_scale, 0, fws);
values[i] = fws->sws->fs.scores[1];
/*
Stack_Fit_Score fs;
fs.n = 1;
fs.options[0] = 1;
values[i] = Local_Neuroseg_Score(locseg + i, signal, z_scale, &fs);
*/
//values[i] = Local_Neuroseg_Score_W(locseg + i, signal, z_scale, sws);
printf("%g\n", values[i]);
double min_score = LOCAL_NEUROSEG_MIN_CORRCOEF;
if (Is_Arg_Matched("-min_score")) {
min_score = Get_Double_Arg("-min_score");
}
if (values[i] > min_score) {
Local_Neuroseg_Label_G(locseg + i, seed_mask, -1, 2, z_scale);
} else {
Local_Neuroseg_Label_G(locseg + i, seed_mask, -1, 1, z_scale);
}
/*
tmpfeats += Local_Neuroseg_Param_Array(locseg + i, z_scale, tmpfeats);
tmpfeats += Local_Neuroseg_Stack_Feature(locseg + i, signal, z_scale,
tmpfeats);
*/
}
if (Is_Arg_Matched("-e")) {
Write_Stack(Get_String_Arg("-e"), seed_mask);
}
Write_Local_Neuroseg_Array(Get_String_Arg("-o"), locseg, seed->size);
char file_path[MAX_PATH_LENGTH];
sprintf(file_path, "%s_score", Get_String_Arg("-o"));
darray_write(file_path, values, seed->size);
//sprintf(file_path, "%s_feat", Get_String_Arg("-o"));
//darray_write(file_path, features, seed->size * ncol);
Kill_Geo3d_Scalar_Field(seed);
printf("Time passed: %lld\n", toc());
return 0;
}
/**
* The main() function of ngIRCd.
*
* Here all starts: this function is called by the operating system loader,
* it is the first portion of code executed of ngIRCd.
*
* @param argc The number of arguments passed to ngIRCd on the command line.
* @param argv An array containing all the arguments passed to ngIRCd.
* @return Global exit code of ngIRCd, zero on success.
*/
GLOBAL int
main(int argc, const char *argv[])
{
bool ok, configtest = false;
bool NGIRCd_NoDaemon = false;
int i;
size_t n;
#if defined(DEBUG) && defined(HAVE_MTRACE)
/* enable GNU libc memory tracing when running in debug mode
* and functionality available */
mtrace();
#endif
umask(0077);
NGIRCd_SignalQuit = NGIRCd_SignalRestart = false;
NGIRCd_Passive = false;
#ifdef DEBUG
NGIRCd_Debug = false;
#endif
#ifdef SNIFFER
NGIRCd_Sniffer = false;
#endif
strlcpy(NGIRCd_ConfFile, SYSCONFDIR, sizeof(NGIRCd_ConfFile));
strlcat(NGIRCd_ConfFile, CONFIG_FILE, sizeof(NGIRCd_ConfFile));
Fill_Version();
/* parse conmmand line */
for (i = 1; i < argc; i++) {
ok = false;
if (argv[i][0] == '-' && argv[i][1] == '-') {
/* long option */
if (strcmp(argv[i], "--config") == 0) {
if (i + 1 < argc) {
/* Ok, there's an parameter left */
strlcpy(NGIRCd_ConfFile, argv[i+1],
sizeof(NGIRCd_ConfFile));
/* next parameter */
i++; ok = true;
}
}
if (strcmp(argv[i], "--configtest") == 0) {
configtest = true;
ok = true;
}
#ifdef DEBUG
if (strcmp(argv[i], "--debug") == 0) {
NGIRCd_Debug = true;
ok = true;
}
#endif
if (strcmp(argv[i], "--help") == 0) {
Show_Version();
puts(""); Show_Help( ); puts( "" );
exit(1);
}
if (strcmp(argv[i], "--nodaemon") == 0) {
NGIRCd_NoDaemon = true;
ok = true;
}
if (strcmp(argv[i], "--passive") == 0) {
NGIRCd_Passive = true;
ok = true;
}
#ifdef SNIFFER
if (strcmp(argv[i], "--sniffer") == 0) {
NGIRCd_Sniffer = true;
ok = true;
}
#endif
if (strcmp(argv[i], "--version") == 0) {
Show_Version();
exit(1);
}
}
else if(argv[i][0] == '-' && argv[i][1] != '-') {
/* short option */
for (n = 1; n < strlen(argv[i]); n++) {
ok = false;
#ifdef DEBUG
if (argv[i][n] == 'd') {
NGIRCd_Debug = true;
ok = true;
}
#endif
if (argv[i][n] == 'f') {
if (!argv[i][n+1] && i+1 < argc) {
/* Ok, next character is a blank */
strlcpy(NGIRCd_ConfFile, argv[i+1],
sizeof(NGIRCd_ConfFile));
/* go to the following parameter */
i++;
n = strlen(argv[i]);
ok = true;
}
}
if (argv[i][n] == 'h') {
Show_Version();
puts(""); Show_Help(); puts("");
exit(1);
}
if (argv[i][n] == 'n') {
NGIRCd_NoDaemon = true;
ok = true;
}
if (argv[i][n] == 'p') {
NGIRCd_Passive = true;
ok = true;
}
#ifdef SNIFFER
if (argv[i][n] == 's') {
NGIRCd_Sniffer = true;
ok = true;
}
#endif
if (argv[i][n] == 't') {
configtest = true;
ok = true;
}
if (argv[i][n] == 'V') {
Show_Version();
exit(1);
}
if (!ok) {
printf("%s: invalid option \"-%c\"!\n",
PACKAGE_NAME, argv[i][n]);
printf("Try \"%s --help\" for more information.\n",
PACKAGE_NAME);
exit(1);
}
}
}
if (!ok) {
printf("%s: invalid option \"%s\"!\n",
PACKAGE_NAME, argv[i]);
printf("Try \"%s --help\" for more information.\n",
PACKAGE_NAME);
exit(1);
}
}
/* Debug level for "VERSION" command */
NGIRCd_DebugLevel[0] = '\0';
#ifdef DEBUG
if (NGIRCd_Debug)
strcpy(NGIRCd_DebugLevel, "1");
#endif
#ifdef SNIFFER
if (NGIRCd_Sniffer) {
NGIRCd_Debug = true;
strcpy(NGIRCd_DebugLevel, "2");
}
#endif
if (configtest) {
Show_Version(); puts("");
exit(Conf_Test());
}
while (!NGIRCd_SignalQuit) {
/* Initialize global variables */
NGIRCd_Start = time(NULL);
(void)strftime(NGIRCd_StartStr, 64,
"%a %b %d %Y at %H:%M:%S (%Z)",
localtime(&NGIRCd_Start));
NGIRCd_SignalRestart = false;
NGIRCd_SignalQuit = false;
/* Initialize modules, part I */
Log_Init(!NGIRCd_NoDaemon);
Random_Init();
Conf_Init();
Log_ReInit();
/* Initialize the "main program": chroot environment, user and
* group ID, ... */
if (!NGIRCd_Init(NGIRCd_NoDaemon)) {
Log(LOG_ALERT, "Fatal: Initialization failed");
exit(1);
}
/* Initialize modules, part II: these functions are eventually
* called with already dropped privileges ... */
Channel_Init();
Client_Init();
Conn_Init();
Class_Init();
if (!io_library_init(CONNECTION_POOL)) {
Log(LOG_ALERT,
"Fatal: Could not initialize IO routines: %s",
strerror(errno));
exit(1);
}
if (!Signals_Init()) {
Log(LOG_ALERT,
"Fatal: Could not set up signal handlers: %s",
strerror(errno));
exit(1);
}
/* Create protocol and server identification. The syntax
* used by ngIRCd in PASS commands and the known "extended
* flags" are described in doc/Protocol.txt. */
#ifdef IRCPLUS
snprintf(NGIRCd_ProtoID, sizeof NGIRCd_ProtoID, "%s%s %s|%s:%s",
PROTOVER, PROTOIRCPLUS, PACKAGE_NAME, PACKAGE_VERSION,
IRCPLUSFLAGS);
#ifdef ZLIB
strcat(NGIRCd_ProtoID, "Z");
#endif
if (Conf_OperCanMode)
strcat(NGIRCd_ProtoID, "o");
#else /* IRCPLUS */
snprintf(NGIRCd_ProtoID, sizeof NGIRCd_ProtoID, "%s%s %s|%s",
PROTOVER, PROTOIRC, PACKAGE_NAME, PACKAGE_VERSION);
#endif /* IRCPLUS */
strlcat(NGIRCd_ProtoID, " P", sizeof NGIRCd_ProtoID);
#ifdef ZLIB
strlcat(NGIRCd_ProtoID, "Z", sizeof NGIRCd_ProtoID);
#endif
LogDebug("Protocol and server ID is \"%s\".", NGIRCd_ProtoID);
Channel_InitPredefined();
if (Conn_InitListeners() < 1) {
Log(LOG_ALERT,
"Server isn't listening on a single port!" );
Log(LOG_ALERT,
"%s exiting due to fatal errors!", PACKAGE_NAME);
Pidfile_Delete();
exit(1);
}
/* Main Run Loop */
Conn_Handler();
Conn_Exit();
Client_Exit();
Channel_Exit();
Class_Exit();
Log_Exit();
}
Pidfile_Delete();
return 0;
} /* main */
void Initialize_Test(UNSIGNED argc, VOID *argv)
{
TRACE_ENTRY(Initialize_Test);
STATUS status;
// Allocate memory for callback contexts.
void *p_memory;
NU_Allocate_Memory(&system_memory, &p_memory, MEMORY_FOR_CALLBACKS, NU_NO_SUSPEND);
// Initialize callbacks.
status = Callback_Context::Initialize(p_memory, MEMORY_FOR_CALLBACKS, sizeof(FF_Bat_Context) + 16);
if (status != OK)
{
CT_Log_Error(CT_ERROR_TYPE_FATAL,
"Initialize_Test",
"Callback_Context::Initialize failed",
status,
0);
}
// Allocate memory for buffer for reading and writing pages.
NU_Allocate_Memory(&system_memory, &p_page_buffer, MAX_PAGE_SIZE + 64, NU_NO_SUSPEND);
p_page_buffer = (void *)ALIGN(p_page_buffer, 64);
NU_Allocate_Memory(&system_memory, &p_read_buffer, MAX_PAGE_SIZE + 64, NU_NO_SUSPEND);
p_read_buffer = (void *)ALIGN(p_read_buffer, 64);
NU_Allocate_Memory(&system_memory, &p_write_buffer, MAX_PAGE_SIZE + 64, NU_NO_SUSPEND);
p_write_buffer = (void *)ALIGN(p_write_buffer, 64);
NU_Allocate_Memory(&system_memory, &p_verify_buffer, MAX_PAGE_SIZE + 64, NU_NO_SUSPEND);
p_verify_buffer = (void *)ALIGN(p_verify_buffer, 64);
// Allocate memory for buffer for statistics reporting.
NU_Allocate_Memory(&system_memory, (void **)&p_string_buffer, 8000, NU_NO_SUSPEND);
// Find out how much memory is left.
CHAR pool_name[8];
VOID *start_address;
UNSIGNED pool_size;
UNSIGNED min_allocation;
UNSIGNED memory_available;
OPTION suspend_type;
UNSIGNED tasks_suspended;
NU_TASK *first_task;
NU_Memory_Pool_Information(&system_memory,
pool_name,
&start_address,
&pool_size,
&min_allocation,
&memory_available,
&suspend_type,
&tasks_suspended,
&first_task);
// Allocate the rest of memory for the file system.
status = NU_Allocate_Memory(&system_memory, &FT_p_memory,
memory_available - 100, NU_NO_SUSPEND);
if (status != OK)
{
CT_Log_Error(CT_ERROR_TYPE_FATAL,
"Initialize_Test",
"Allocate memory failed",
status,
0);
}
// How much is left now.
U32 available_now;
NU_Memory_Pool_Information(&system_memory,
pool_name,
&start_address,
&pool_size,
&min_allocation,
&available_now,
&suspend_type,
&tasks_suspended,
&first_task);
// Initialize config structures.
Init_Config(memory_available);
// Create a parent context.
FT_Test_Context *p_test_context =
(FT_Test_Context *)Callback_Context::Allocate(sizeof(FT_Test_Context));
p_test_context->Set_Callback(&Run_Test);
p_test_context->Make_Ready();
Show_Version();
#if 0
Tracef("\nSize of FF_SGL = %d", sizeof(FF_SGL));
Tracef("\nSize of SGE_SIMPLE_ELEMENT = %d", sizeof(SGE_SIMPLE_ELEMENT));
Tracef("\nSize of FF_Controller_Context = %d", sizeof(FF_Controller_Context));
Tracef("\nSize of Flash_Device_Status = %d", sizeof(Flash_Device_Status));
Tracef("\nSize of Flash_Address = %d", sizeof(Flash_Address));
#endif
} // Initialize_Test
