static int add_rule(const char *func, const char *file, int line, int off)
{
mrp_htbl_t *ht;
char *rule, *r, buf[PATH_MAX * 2];
if (rules_on == NULL)
if (!init_rules())
return FALSE;
r = rule = NULL;
if (!off)
ht = rules_on;
else
ht = rules_off;
if (func != NULL && file == NULL && line == 0) {
r = mrp_htbl_lookup(ht, (void *)func);
rule = (char *)func;
}
else if (func != NULL && file != NULL && line == 0) {
snprintf(buf, sizeof(buf), "%s@%s", func, file);
r = mrp_htbl_lookup(ht, (void *)buf);
rule = buf;
}
else if (func == NULL && file != NULL && line == 0) {
snprintf(buf, sizeof(buf), "@%s", file);
r = mrp_htbl_lookup(ht, (void *)buf);
rule = buf;
}
else if (func == NULL && file != NULL && line > 0) {
snprintf(buf, sizeof(buf), "%s:%d", file, line);
r = mrp_htbl_lookup(ht, (void *)buf);
rule = buf;
}
if (r != NULL)
return FALSE;
rule = mrp_strdup(rule);
if (rule == NULL)
return FALSE;
if (mrp_htbl_insert(ht, rule, rule)) {
mrp_debug_stamp++;
return TRUE;
}
else {
mrp_free(rule);
return FALSE;
}
}
/**************************************************************************
Edit the currenty selected rule
**************************************************************************/
static void filter_edit(void)
{
#if 0
if (!rules_wnd) init_rules();
if (rules_wnd)
{
struct filter *f;
DoMethod(filter_listview, MUIM_NList_GetEntry, MUIV_NList_GetEntry_Active, &f);
set_rules(f);
set(rules_wnd,MUIA_Window_Open,TRUE);
}
#endif
}
static int del_rule(const char *func, const char *file, int line, int off)
{
mrp_htbl_t *ht;
char *r, buf[PATH_MAX * 2];
if (rules_on == NULL)
if (!init_rules())
return FALSE;
r = NULL;
if (!off)
ht = rules_on;
else
ht = rules_off;
if (func != NULL && file == NULL && line == 0) {
r = mrp_htbl_remove(ht, (void *)func, TRUE);
}
else if (func != NULL && file != NULL && line == 0) {
snprintf(buf, sizeof(buf), "%s@%s", func, file);
r = mrp_htbl_remove(ht, (void *)buf, TRUE);
}
else if (func == NULL && file != NULL && line == 0) {
snprintf(buf, sizeof(buf), "@%s", file);
r = mrp_htbl_remove(ht, (void *)buf, TRUE);
}
else if (func == NULL && file != NULL && line > 0) {
snprintf(buf, sizeof(buf), "%s:%d", file, line);
r = mrp_htbl_remove(ht, (void *)buf, TRUE);
}
if (r != NULL) {
mrp_debug_stamp++;
return TRUE;
}
else
return FALSE;
}
int main(int argc, char **argv) {
//
// local vars
//
GifFileType *GIFfile;
GifRecordType GIFtype;
GifByteType *GIFextension;
GifPixelType *GIFline;
uint32_t w[8],**lower_array,**upper_array;
int x,y,z,i,j,k,n,p,imin,imax;
int image_width,image_height,image_count,color_resolution,GIFcode,ret;
float threshold,voxel_size;
char comment[256],rules[255][20];
struct fab_vars v;
init_vars(&v);
//
// command line args
//
if (!((argc == 3) || (argc == 4) || (argc == 5) || (argc == 6))) {
printf("command line: gif_stl in.gif out.stl [threshold [size [points [angle]]]]\n");
printf(" in.gif = input GIF section file\n");
printf(" out.stl = output STL file\n");
printf(" threshold: surface intensity threshold (0 = min, 1 = max, default 0.5))\n");
printf(" size = voxel size (mm, default from file))\n");
printf(" points = points to interpolate per point (default 0)\n");
printf(" to be implemented: angle = minimum relative face angle to decimate vertices (default 0)\n");
exit(-1);
}
p = 0;
threshold = 0.5;
voxel_size = -1;
image_width = -1;
image_height = -1;
image_count = -1;
if (argc >= 4)
sscanf(argv[3],"%f",&threshold);
if (argc >= 5)
sscanf(argv[4],"%f",&voxel_size);
if (argc >= 6)
sscanf(argv[5],"%d",&p);
//
// initialize the rule table
//
init_rules(rules);
//
// scan the file
//
printf("read %s\n",argv[1]);
color_resolution = -1;
#if GIFLIB_MAJOR >= 5
GIFfile = DGifOpenFileName(argv[1], NULL);
#else
GIFfile = DGifOpenFileName(argv[1]);
#endif
if (GIFfile == NULL) {
printf("gif_stl: oops -- can not open %s\n",argv[1]);
exit(-1);
}
GIFline = malloc(MAX_LINE*sizeof(GifPixelType));
imin = 256;
imax = 0;
do {
DGifGetRecordType(GIFfile,&GIFtype);
switch (GIFtype) {
case IMAGE_DESC_RECORD_TYPE:
DGifGetImageDesc(GIFfile);
image_width = GIFfile->SWidth;
image_height = GIFfile->SHeight;
image_count = GIFfile->ImageCount;
color_resolution = GIFfile->SColorResolution;
for (y = 0; y < GIFfile->SHeight; ++y) {
ret = DGifGetLine(GIFfile,GIFline,GIFfile->SWidth);
if (ret != GIF_OK) {
printf("gif_stl: oops -- error reading line\n");
exit(-1);
}
for (x = 0; x < GIFfile->SWidth; ++x) {
if (GIFline[x] < imin) imin = GIFline[x];
if (GIFline[x] > imax) imax = GIFline[x];
}
}
break;
case EXTENSION_RECORD_TYPE:
DGifGetExtension(GIFfile,&GIFcode,&GIFextension);
if (GIFcode == COMMENT_EXT_FUNC_CODE) {
n = GIFextension[0];
for (i = 1; i <= n; ++i)
comment[i-1] = GIFextension[i];
comment[n] = 0;
if (voxel_size == -1)
sscanf(comment,"mm per pixel: %f;",&voxel_size);
}
while (GIFextension != NULL)
DGifGetExtensionNext(GIFfile,&GIFextension);
break;
case SCREEN_DESC_RECORD_TYPE:
DGifGetScreenDesc(GIFfile);
break;
case TERMINATE_RECORD_TYPE:
break;
case UNDEFINED_RECORD_TYPE:
printf("gif_stl: oops -- undefined GIF record type\n");
exit(-1);
break;
}
} while (GIFtype != TERMINATE_RECORD_TYPE);
if (GIFfile == NULL) {
printf("gif_stl: oops -- can not open %s\n",argv[1]);
exit(-1);
}
if (voxel_size == -1) {
voxel_size = 1.0;
printf(" no pixel size found, assuming 1 mm\n");
}
printf(" voxel size (mm): %f, color resolution (bits): %d\n",voxel_size,color_resolution);
printf(" intensity min: %d max: %d\n",imin,imax);
printf(" number of images: %d, image width %d, image height %d\n",image_count,image_width,image_height);
//
// set threshold
//
threshold = imin + threshold*(imax-imin);
//
// add empty border
//
image_width += 2;
image_height += 2;
image_count += 2;
//
// allocate arrays
//
lower_array = malloc(image_height*sizeof(uint32_t *));
for (y = 0; y < image_height; ++y) {
lower_array[y] = malloc(image_width*sizeof(uint32_t));
for (x = 0; x < image_width; ++x)
lower_array[y][x] = 0;
}
upper_array = malloc(image_height*sizeof(uint32_t *));
for (y = 0; y < image_height; ++y) {
upper_array[y] = malloc(image_width*sizeof(uint32_t));
for (x = 0; x < image_width; ++x)
upper_array[y][x] = 0;
}
//
// read the file
//
DGifCloseFile(GIFfile);
#if GIFLIB_MAJOR >= 5
GIFfile = DGifOpenFileName(argv[1], NULL);
#else
GIFfile = DGifOpenFileName(argv[1]);
#endif
if (GIFfile == NULL) {
printf("gif_stl: oops -- can not open %s\n",argv[1]);
exit(-1);
}
z = 0;
v.mesh = malloc(sizeof(struct fab_mesh_type));
v.mesh->triangle = malloc(sizeof(struct fab_mesh_triangle_type));
v.mesh->first = v.mesh->triangle;
v.mesh->last = v.mesh->triangle;
v.mesh->triangle->previous = v.mesh->triangle->next = 0;
do {
DGifGetRecordType(GIFfile,&GIFtype);
switch (GIFtype) {
case IMAGE_DESC_RECORD_TYPE:
//
// read image
//
DGifGetImageDesc(GIFfile);
printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b layer = %d",z);
//
// read layer
//
for (y = 0; y < (image_height-2); ++y) {
ret = DGifGetLine(GIFfile,GIFline,GIFfile->SWidth);
if (ret != GIF_OK) {
printf("gif_stl: oops -- error reading line\n");
exit(-1);
}
for (x = 0; x < (image_width-2); ++x) {
lower_array[y+1][x+1] = upper_array[y+1][x+1];
upper_array[y+1][x+1] = GIFline[x];
}
}
if (p == 0) {
//
// no interpolation, loop over layer voxels
//
for (x = 0; x < (image_width-1); ++x) {
for (y = 0; y < (image_height-1); ++y) {
w[0] = lower_array[y][x];
w[1] = lower_array[y][x+1];
w[2] = lower_array[y+1][x];
w[3] = lower_array[y+1][x+1];
w[4] = upper_array[y][x];
w[5] = upper_array[y][x+1];
w[6] = upper_array[y+1][x];
w[7] = upper_array[y+1][x+1];
triangulate(x,y,z,voxel_size,threshold,w,rules,&v);
}
}
}
else {
//
// yes interpolation, loop over layer sub-voxels
//
for (x = 0; x < (image_width-1); ++x) {
for (y = 0; y < (image_height-1); ++y) {
for (i = 0; i <= p; ++i) {
for (j = 0; j <= p; ++j) {
for (k = 0; k <= p; ++k) {
w[0] = interp(x,y,i,j,k,lower_array,upper_array,p);
w[1] = interp(x,y,i+1,j,k,lower_array,upper_array,p);
w[2] = interp(x,y,i,j+1,k,lower_array,upper_array,p);
w[3] = interp(x,y,i+1,j+1,k,lower_array,upper_array,p);
w[4] = interp(x,y,i,j,k+1,lower_array,upper_array,p);
w[5] = interp(x,y,i+1,j,k+1,lower_array,upper_array,p);
w[6] = interp(x,y,i,j+1,k+1,lower_array,upper_array,p);
w[7] = interp(x,y,i+1,j+1,k+1,lower_array,upper_array,p);
triangulate((1+p)*x+i,(1+p)*y+j,(1+p)*z+k,voxel_size,threshold,w,rules,&v);
}
}
}
}
}
}
z += 1;
break;
case EXTENSION_RECORD_TYPE:
DGifGetExtension(GIFfile,&GIFcode,&GIFextension);
while (GIFextension != NULL)
DGifGetExtensionNext(GIFfile,&GIFextension);
break;
case SCREEN_DESC_RECORD_TYPE:
DGifGetScreenDesc(GIFfile);
break;
case TERMINATE_RECORD_TYPE:
break;
case UNDEFINED_RECORD_TYPE:
printf("gif_stl: oops -- undefined GIF record type\n");
exit(-1);
break;
}
} while (GIFtype != TERMINATE_RECORD_TYPE);
//
// add empty top layer
//
printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b layer = %d",z);
for (y = 0; y < (image_height-2); ++y) {
for (x = 0; x < (image_width-2); ++x) {
lower_array[y+1][x+1] = upper_array[y+1][x+1];
upper_array[y+1][x+1] = 0;
}
}
if (p == 0) {
//
// no interpolation, loop over layer voxels
//
for (x = 0; x < (image_width-1); ++x) {
for (y = 0; y < (image_height-1); ++y) {
w[0] = lower_array[y][x];
w[1] = lower_array[y][x+1];
w[2] = lower_array[y+1][x];
w[3] = lower_array[y+1][x+1];
w[4] = upper_array[y][x];
w[5] = upper_array[y][x+1];
w[6] = upper_array[y+1][x];
w[7] = upper_array[y+1][x+1];
triangulate(x,y,z,voxel_size,threshold,w,rules,&v);
}
}
}
else {
//
// yes interpolation, loop over layer sub-voxels
//
for (x = 0; x < (image_width-1); ++x) {
for (y = 0; y < (image_height-1); ++y) {
for (i = 0; i <= p; ++i) {
for (j = 0; j <= p; ++j) {
for (k = 0; k <= p; ++k) {
w[0] = interp(x,y,i,j,k,lower_array,upper_array,p);
w[1] = interp(x,y,i+1,j,k,lower_array,upper_array,p);
w[2] = interp(x,y,i,j+1,k,lower_array,upper_array,p);
w[3] = interp(x,y,i+1,j+1,k,lower_array,upper_array,p);
w[4] = interp(x,y,i,j,k+1,lower_array,upper_array,p);
w[5] = interp(x,y,i+1,j,k+1,lower_array,upper_array,p);
w[6] = interp(x,y,i,j+1,k+1,lower_array,upper_array,p);
w[7] = interp(x,y,i+1,j+1,k+1,lower_array,upper_array,p);
triangulate((1+p)*x+i,(1+p)*y+j,(1+p)*z+k,voxel_size,threshold,w,rules,&v);
}
}
}
}
}
}
printf("\n");
//
// write STL
//
fab_write_stl(&v,argv[2]);
//
// exit
//
DGifCloseFile(GIFfile);
exit(0);
}
int run(int argc, char **argv)
{
char *trio_samples = NULL, *trio_file = NULL, *rules_fname = NULL, *rules_string = NULL;
memset(&args,0,sizeof(args_t));
args.mode = 0;
args.output_fname = "-";
static struct option loptions[] =
{
{"trio",1,0,'t'},
{"trio-file",1,0,'T'},
{"delete",0,0,'d'},
{"list",1,0,'l'},
{"count",0,0,'c'},
{"rules",1,0,'r'},
{"rules-file",1,0,'R'},
{"output",required_argument,NULL,'o'},
{"output-type",required_argument,NULL,'O'},
{0,0,0,0}
};
int c;
while ((c = getopt_long(argc, argv, "?ht:T:l:cdr:R:o:O:",loptions,NULL)) >= 0)
{
switch (c)
{
case 'o': args.output_fname = optarg; break;
case 'O':
switch (optarg[0]) {
case 'b': args.output_type = FT_BCF_GZ; break;
case 'u': args.output_type = FT_BCF; break;
case 'z': args.output_type = FT_VCF_GZ; break;
case 'v': args.output_type = FT_VCF; break;
default: error("The output type \"%s\" not recognised\n", optarg);
};
break;
case 'R': rules_fname = optarg; break;
case 'r': rules_string = optarg; break;
case 'd': args.mode |= MODE_DELETE; break;
case 'c': args.mode |= MODE_COUNT; break;
case 'l':
if ( !strcmp("+",optarg) ) args.mode |= MODE_LIST_GOOD;
else if ( !strcmp("x",optarg) ) args.mode |= MODE_LIST_BAD;
else error("The argument not recognised: --list %s\n", optarg);
break;
case 't': trio_samples = optarg; break;
case 'T': trio_file = optarg; break;
case 'h':
case '?':
default: error("%s",usage()); break;
}
}
if ( rules_fname )
args.rules = regidx_init(rules_fname, parse_rules, NULL, sizeof(rule_t), &args);
else
args.rules = init_rules(&args, rules_string);
if ( !args.rules ) return -1;
args.itr = regitr_init(args.rules);
args.itr_ori = regitr_init(args.rules);
char *fname = NULL;
if ( optind>=argc || argv[optind][0]=='-' )
{
if ( !isatty(fileno((FILE *)stdin)) ) fname = "-"; // reading from stdin
else error("%s",usage());
}
else
fname = argv[optind];
if ( !trio_samples && !trio_file ) error("Expected the -t/T option\n");
if ( !args.mode ) error("Expected one of the -c, -d or -l options\n");
if ( args.mode&MODE_DELETE && !(args.mode&(MODE_LIST_GOOD|MODE_LIST_BAD)) ) args.mode |= MODE_LIST_GOOD|MODE_LIST_BAD;
args.sr = bcf_sr_init();
if ( !bcf_sr_add_reader(args.sr, fname) ) error("Failed to open %s: %s\n", fname,bcf_sr_strerror(args.sr->errnum));
args.hdr = bcf_sr_get_header(args.sr, 0);
args.out_fh = hts_open(args.output_fname,hts_bcf_wmode(args.output_type));
if ( args.out_fh == NULL ) error("Can't write to \"%s\": %s\n", args.output_fname, strerror(errno));
bcf_hdr_write(args.out_fh, args.hdr);
int i, n = 0;
char **list;
if ( trio_samples )
{
args.ntrios = 1;
args.trios = (trio_t*) calloc(1,sizeof(trio_t));
list = hts_readlist(trio_samples, 0, &n);
if ( n!=3 ) error("Expected three sample names with -t\n");
args.trios[0].imother = bcf_hdr_id2int(args.hdr, BCF_DT_SAMPLE, list[0]);
args.trios[0].ifather = bcf_hdr_id2int(args.hdr, BCF_DT_SAMPLE, list[1]);
args.trios[0].ichild = bcf_hdr_id2int(args.hdr, BCF_DT_SAMPLE, list[2]);
for (i=0; i<n; i++) free(list[i]);
free(list);
}
if ( trio_file )
{
list = hts_readlist(trio_file, 1, &n);
args.ntrios = n;
args.trios = (trio_t*) calloc(n,sizeof(trio_t));
for (i=0; i<n; i++)
{
char *ss = list[i], *se;
se = strchr(ss, ',');
if ( !se ) error("Could not parse %s: %s\n",trio_file, ss);
*se = 0;
args.trios[i].imother = bcf_hdr_id2int(args.hdr, BCF_DT_SAMPLE, ss);
if ( args.trios[i].imother<0 ) error("No such sample: \"%s\"\n", ss);
ss = ++se;
se = strchr(ss, ',');
if ( !se ) error("Could not parse %s\n",trio_file);
*se = 0;
args.trios[i].ifather = bcf_hdr_id2int(args.hdr, BCF_DT_SAMPLE, ss);
if ( args.trios[i].ifather<0 ) error("No such sample: \"%s\"\n", ss);
ss = ++se;
if ( *ss=='\0' ) error("Could not parse %s\n",trio_file);
args.trios[i].ichild = bcf_hdr_id2int(args.hdr, BCF_DT_SAMPLE, ss);
if ( args.trios[i].ichild<0 ) error("No such sample: \"%s\"\n", ss);
free(list[i]);
}
free(list);
}
while ( bcf_sr_next_line(args.sr) )
{
bcf1_t *line = bcf_sr_get_line(args.sr,0);
line = process(line);
if ( line )
{
if ( line->errcode ) error("TODO: Unchecked error (%d), exiting\n",line->errcode);
bcf_write1(args.out_fh, args.hdr, line);
}
}
fprintf(stderr,"# [1]nOK\t[2]nBad\t[3]nSkipped\t[4]Trio\n");
for (i=0; i<args.ntrios; i++)
{
trio_t *trio = &args.trios[i];
fprintf(stderr,"%d\t%d\t%d\t%s,%s,%s\n",
trio->nok,trio->nbad,args.nrec-(trio->nok+trio->nbad),
bcf_hdr_int2id(args.hdr, BCF_DT_SAMPLE, trio->imother),
bcf_hdr_int2id(args.hdr, BCF_DT_SAMPLE, trio->ifather),
bcf_hdr_int2id(args.hdr, BCF_DT_SAMPLE, trio->ichild)
);
}
free(args.gt_arr);
free(args.trios);
regitr_destroy(args.itr);
regitr_destroy(args.itr_ori);
regidx_destroy(args.rules);
bcf_sr_destroy(args.sr);
if ( hts_close(args.out_fh)!=0 ) error("Error: close failed\n");
return 0;
}
int
main(int argc, char **argv)
{
int ch, argi;
while ((ch = getopt(argc, argv, options)) != -1) {
switch (ch) {
case '1':
first_match_only = 1;
break;
case 'f':
follow_flag = 1;
break;
case 'F':
report_from = optarg;
if (*report_from == '\0')
report_from = NULL;
break;
case 'v':
debug++;
break;
case 'd':
db_path = optarg;
break;
case 'D':
db_delete = 1;
break;
case 'r':
report_to = optarg;
break;
case 'R':
db_reset = 1;
break;
case 's':
smtp_host = optarg;
break;
case 'y':
assumed_year = strtol(optarg, NULL, 10);
break;
case 'z':
assumed_tz = strtol(optarg, NULL, 10);
break;
default:
(void) printf(usage);
return EX_USAGE;
}
}
if (argc <= optind || (follow_flag && optind+2 < argc)) {
(void) printf(usage);
return EX_USAGE;
}
if (1 < debug)
LogOpen(NULL);
if (db_path == NULL) {
(void) snprintf(db_user, sizeof (db_user), DB_PATH_FMT, getuid());
db_path = db_user;
}
if (db_delete)
(void) unlink(db_path);
init_today();
if (atexit(at_exit_cleanup) || init_db(db_path) || init_rules(argv[optind]))
return EX_SOFTWARE;
if ((report = TextSplit(report_to, ", ", 0)) == NULL)
return EX_SOFTWARE;
if (optind+1 == argc) {
follow_flag = 0;
process_file("-");
} else {
for (argi = optind+1; argi < argc; argi++)
process_file(argv[argi]);
}
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
int error, cntrlsfd, remotesfd;
struct event cntrlev, remoteev;
pid_t pid, sid;
RHashTable *workers;
error = 0;
info("Starting the reactor...");
dbg("...freeing Mars.", NULL);
// TODO root user check
// TODO change ruid to euid (root)
// TODO help
// TODO version
// TODO daemon lock file (?)
// TODO trap signals
/* daemonize */
#ifndef DEBUG
pid = fork();
switch(pid) {
case 0:
/* child */
dbg("Forked child running.", NULL);
break;
case -1:
err("Unable to daemonize");
fprintf(stderr, "Unable to daemonize\n");
default:
/* parent */
goto exit;
}
#endif
/* redirect standard files to /dev/null */
freopen( "/dev/null", "r", stdin);
freopen( "/dev/null", "w", stdout);
freopen( "/dev/null", "w", stderr);
// TODO cancel child signals ?
// sid = setsid();
// if (sid < 0) {
// error = 1;
// dbg_e("setsid() returned with errors.", NULL);
// err("Unable to create a new session.");
// goto exit;
// }
/* change current directory */
if ((chdir("/")) < 0) {
error = 1;
err("Unable to change current directory to '/'.");
goto exit;
}
reactor.eventnotices = reactor_hash_table_new((RHashFunc) reactor_str_hash, (REqualFunc) str_eq);
reactor.states = reactor_hash_table_new((RHashFunc) reactor_str_hash, (REqualFunc) str_eq);
workers = reactor_hash_table_new((RHashFunc) reactor_str_hash, (REqualFunc) str_eq);
init_rules();
/* sockets setup and poll */
event_init();
if((cntrlsfd = listen_cntrl()) == -1) {
err("Unable to create the control socket and bind it to '%s'. Probably a permissions issue.", SOCK_PATH);
goto exit;
}
if((remotesfd = listen_remote()) == -1) {
err("Unable to create the remote socket.");
goto exit;
}
load_all_modules(REACTORPLUGINDIR, workers);
event_set(&cntrlev, cntrlsfd, EV_READ | EV_PERSIST, &attend_cntrl_msg, NULL);
event_add(&cntrlev, NULL);
event_set(&remoteev, remotesfd, EV_READ | EV_PERSIST, &attend_remote_events, NULL);
event_add(&remoteev, NULL);
event_dispatch();
exit:
close_cntrl(cntrlsfd);
close(remotesfd);
return error;
}
