string str_event(const event_t event) {
// Parse event
const section_t section = parse_section(event);
const auto block = parse_block(event);
const uint8_t dimensions = parse_dimensions(event);
// Parse kind
switch (event&ekind_mask) {
case unevent:
return "unevent";
case block_ekind:
return format("s%s b%d,%d,%d,%d",str(section),block[0],block[1],block[2],block[3]);
case line_ekind: {
string b[4];
for (int i=0;i<4;i++)
b[i] = i==dimensions?"_":str(int(block[i-(i>=dimensions)]));
return format("s%s d%d b%s,%s,%s,%s",str(section),dimensions,b[0],b[1],b[2],b[3]); }
case block_line_ekind:
return format("s%s d%d b%d,%d,%d,%d",str(section),dimensions,block[0],block[1],block[2],block[3]);
case block_lines_ekind:
return format("s%s ss%d cd%d b%d,%d,%d,%d",str(section),dimensions>>2,dimensions&3,block[0],block[1],block[2],block[3]);
default:
return "<error>";
}
}
int main(void)
{
if (!check_junk())
err("bad junk");
printf("Welcome to the super awesome OCR engine! Enter your input to have it OCR'd\n");
int infd = STDIN;
#define LINE_SIZE 32
char line[LINE_SIZE];
memset(line, 0, LINE_SIZE);
if (read_until(infd, LINE_SIZE, '\n', line) < 0)
err("bad line");
else
dbg("good line");
if (strlen(line) != strlen(magic) || strncmp(line, magic, strlen(line)) != 0)
err("bad magic");
else
dbg("good magic");
memset(line, 0, LINE_SIZE);
if (read_until(infd, LINE_SIZE, '\n', line) < 0)
err("bad line");
else
dbg("good line");
u32 w, h;
if (parse_dimensions(line, strlen(line), &w, &h) != 0)
err("bad dimensions");
else
dbg("good dimensions, %dx%d", w, h);
u8 *image;
u32 read_height = read_image(infd, w, h, &image);
if (read_height != h || !image)
err("bad image");
else
dbg("good image");
#define MATCH_THRESHOLD .90
char* output = perform_ocr(image, w, h, MATCH_THRESHOLD);
if (output)
printf("Result: %s\n", output);
else
printf("No characters recognized\n");
}
static int
processor_set_request_size (zbarProcessor *self,
PyObject *value,
void *closure)
{
if(!value) {
zbar_processor_request_size(self->zproc, 0, 0);
return(0);
}
int dims[2];
if(parse_dimensions(value, dims, 2) ||
dims[0] < 0 || dims[1] < 0) {
PyErr_SetString(PyExc_ValueError,
"request_size must be a sequence of two positive ints");
return(-1);
}
zbar_processor_request_size(self->zproc, dims[0], dims[1]);
return(0);
}
static void dopts(int ac, char *av[]) {
int c;
char *p;
int i, j, r;
dim_t dim, dimx, dimy;
int matches, bestmatch;
/* defaults */
backend_lookup("eps", &info.backend);
info.debug = 0;
info.width_d.x = UNDEF;
info.height_d.x = UNDEF;
info.rx = UNDEF;
info.ry = UNDEF;
info.sx = UNDEF;
info.sy = UNDEF;
info.stretch = 1;
info.lmar_d.x = UNDEF;
info.rmar_d.x = UNDEF;
info.tmar_d.x = UNDEF;
info.bmar_d.x = UNDEF;
info.angle = 0;
info.paperwidth = DEFAULT_PAPERWIDTH;
info.paperheight = DEFAULT_PAPERHEIGHT;
info.tight = 0;
info.unit = 10;
info.compress = 1;
info.pslevel = 2;
info.color = 0x000000;
info.gamma = 2.2;
info.param = potrace_param_default();
if (!info.param) {
fprintf(stderr, ""POTRACE": %s\n", strerror(errno));
exit(1);
}
info.longcoding = 0;
info.outfile = NULL;
info.blacklevel = 0.5;
info.invert = 0;
info.opaque = 0;
info.grouping = 1;
info.fillcolor = 0xffffff;
info.progress = 0;
info.progress_bar = DEFAULT_PROGRESS_BAR;
while ((c = getopt_long(ac, av, shortopts, longopts, NULL)) != -1) {
switch (c) {
case 'h':
fprintf(stdout, ""POTRACE" "VERSION". Transforms bitmaps into vector graphics.\n\n");
usage(stdout);
exit(0);
break;
case 'v':
case 'V':
fprintf(stdout, ""POTRACE" "VERSION". Copyright (C) 2001-2015 Peter Selinger.\n");
fprintf(stdout, "Library version: %s\n", potrace_version());
show_defaults(stdout);
exit(0);
break;
case 'l':
fprintf(stdout, ""POTRACE" "VERSION". Copyright (C) 2001-2015 Peter Selinger.\n\n");
license(stdout);
exit(0);
break;
case 'W':
info.width_d = parse_dimension(optarg, &p);
if (*p) {
fprintf(stderr, ""POTRACE": invalid dimension -- %s\n", optarg);
exit(1);
}
break;
case 'H':
info.height_d = parse_dimension(optarg, &p);
if (*p) {
fprintf(stderr, ""POTRACE": invalid dimension -- %s\n", optarg);
exit(1);
}
break;
case 'r':
parse_dimensions(optarg, &p, &dimx, &dimy);
if (*p == 0 && dimx.d == 0 && dimy.d == 0 && dimx.x != 0.0 && dimy.x != 0.0) {
info.rx = dimx.x;
info.ry = dimy.x;
break;
}
dim = parse_dimension(optarg, &p);
if (*p == 0 && dim.d == 0 && dim.x != 0.0) {
info.rx = info.ry = dim.x;
break;
}
fprintf(stderr, ""POTRACE": invalid resolution -- %s\n", optarg);
exit(1);
break;
case 'x':
parse_dimensions(optarg, &p, &dimx, &dimy);
if (*p == 0 && dimx.d == 0 && dimy.d == 0) {
info.sx = dimx.x;
info.sy = dimy.x;
break;
}
dim = parse_dimension(optarg, &p);
if (*p == 0 && dim.d == 0) {
info.sx = info.sy = dim.x;
break;
}
fprintf(stderr, ""POTRACE": invalid scaling factor -- %s\n", optarg);
exit(1);
break;
case 'S':
info.stretch = atof(optarg);
break;
case 'M':
info.lmar_d = parse_dimension(optarg, &p);
if (*p) {
fprintf(stderr, ""POTRACE": invalid dimension -- %s\n", optarg);
exit(1);
}
info.rmar_d = info.tmar_d = info.bmar_d = info.lmar_d;
break;
case 'L':
info.lmar_d = parse_dimension(optarg, &p);
if (*p) {
fprintf(stderr, ""POTRACE": invalid dimension -- %s\n", optarg);
exit(1);
}
break;
case 'R':
info.rmar_d = parse_dimension(optarg, &p);
if (*p) {
fprintf(stderr, ""POTRACE": invalid dimension -- %s\n", optarg);
exit(1);
}
break;
case 'T':
info.tmar_d = parse_dimension(optarg, &p);
if (*p) {
fprintf(stderr, ""POTRACE": invalid dimension -- %s\n", optarg);
exit(1);
}
break;
case 'B':
info.bmar_d = parse_dimension(optarg, &p);
if (*p) {
fprintf(stderr, ""POTRACE": invalid dimension -- %s\n", optarg);
exit(1);
}
break;
case OPT_TIGHT:
info.tight = 1;
break;
case 'A':
info.angle = strtod(optarg, &p);
if (*p) {
fprintf(stderr, ""POTRACE": invalid angle -- %s\n", optarg);
exit(1);
}
break;
case 'P':
matches = 0;
bestmatch = 0;
for (i=0; pageformat[i].name!=NULL; i++) {
if (strcasecmp(pageformat[i].name, optarg)==0) {
matches = 1;
bestmatch = i;
break;
} else if (strncasecmp(pageformat[i].name, optarg, strlen(optarg))==0) {
/* don't allow partial match on "10x14" */
if (optarg[0] != '1') {
matches++;
bestmatch = i;
}
}
}
if (matches == 1) {
info.paperwidth = pageformat[bestmatch].w;
info.paperheight = pageformat[bestmatch].h;
break;
}
parse_dimensions(optarg, &p, &dimx, &dimy);
if (*p == 0) {
info.paperwidth = (int)rint(double_of_dim(dimx, DEFAULT_DIM));
info.paperheight = (int)rint(double_of_dim(dimy, DEFAULT_DIM));
break;
}
if (matches == 0) {
fprintf(stderr, ""POTRACE": unrecognized page format -- %s\n", optarg);
} else {
fprintf(stderr, ""POTRACE": ambiguous page format -- %s\n", optarg);
}
j = fprintf(stderr, "Use one of: ");
for (i=0; pageformat[i].name!=NULL; i++) {
if (j + strlen(pageformat[i].name) > 75) {
fprintf(stderr, "\n");
j = 0;
}
j += fprintf(stderr, "%s, ", pageformat[i].name);
}
fprintf(stderr, "or specify <dim>x<dim>.\n");
exit(1);
break;
case 't':
info.param->turdsize = atoi(optarg);
break;
case 'u':
info.unit = strtod(optarg, &p);
if (*p) {
fprintf(stderr, ""POTRACE": invalid unit -- %s\n", optarg);
exit(1);
}
break;
case 'c':
info.pslevel = 2;
info.compress = 0;
break;
case '2':
info.pslevel = 2;
info.compress = 1;
break;
case '3':
#ifdef HAVE_ZLIB
info.pslevel = 3;
info.compress = 1;
#else
fprintf(stderr, ""POTRACE": option -3 not supported, using -2 instead.\n");
fflush(stderr);
info.pslevel = 2;
info.compress = 1;
#endif
break;
case 'e':
backend_lookup("eps", &info.backend);
break;
case 'p':
backend_lookup("postscript", &info.backend);
break;
case 's':
backend_lookup("svg", &info.backend);
break;
case 'g':
backend_lookup("pgm", &info.backend);
break;
case 'b':
r = backend_lookup(optarg, &info.backend);
if (r==1 || r==2) {
if (r==1) {
fprintf(stderr, ""POTRACE": unrecognized backend -- %s\n", optarg);
} else {
fprintf(stderr, ""POTRACE": ambiguous backend -- %s\n", optarg);
}
j = fprintf(stderr, "Use one of: ");
backend_list(stderr, j, 70);
fprintf(stderr, ".\n");
exit(1);
}
break;
case 'd':
info.debug = atoi(optarg);
break;
case 'C':
info.color = parse_color(optarg);
if (info.color == -1) {
fprintf(stderr, ""POTRACE": invalid color -- %s\n", optarg);
exit(1);
}
break;
case OPT_FILLCOLOR:
info.fillcolor = parse_color(optarg);
if (info.fillcolor == -1) {
fprintf(stderr, ""POTRACE": invalid color -- %s\n", optarg);
exit(1);
}
info.opaque = 1;
break;
case 'z':
matches = 0;
bestmatch = 0;
for (i=0; turnpolicy[i].name!=NULL; i++) {
if (strcasecmp(turnpolicy[i].name, optarg)==0) {
matches = 1;
bestmatch = i;
break;
} else if (strncasecmp(turnpolicy[i].name, optarg, strlen(optarg))==0) {
matches++;
bestmatch = i;
}
}
if (matches == 1) {
info.param->turnpolicy = turnpolicy[bestmatch].n;
break;
}
if (matches == 0) {
fprintf(stderr, ""POTRACE": unrecognized turnpolicy -- %s\n", optarg);
} else {
fprintf(stderr, ""POTRACE": ambiguous turnpolicy -- %s\n", optarg);
}
j = fprintf(stderr, "Use one of: ");
for (i=0; turnpolicy[i].name!=NULL; i++) {
if (j + strlen(turnpolicy[i].name) > 75) {
fprintf(stderr, "\n");
j = 0;
}
j += fprintf(stderr, "%s%s", turnpolicy[i].name, turnpolicy[i+1].name ? ", " : "");
}
fprintf(stderr, ".\n");
exit(1);
break;
case 'G':
info.gamma = atof(optarg);
break;
case 'n':
info.param->opticurve = 0;
break;
case 'q':
info.longcoding = 1;
break;
case 'a':
info.param->alphamax = strtod(optarg, &p);
if (*p) {
fprintf(stderr, ""POTRACE": invalid alphamax -- %s\n", optarg);
exit(1);
}
break;
case 'O':
info.param->opttolerance = strtod(optarg, &p);
if (*p) {
fprintf(stderr, ""POTRACE": invalid opttolerance -- %s\n", optarg);
exit(1);
}
break;
case 'o':
free(info.outfile);
info.outfile = strdup(optarg);
if (!info.outfile) {
fprintf(stderr, ""POTRACE": %s\n", strerror(errno));
exit(2);
}
break;
case 'k':
info.blacklevel = strtod(optarg, &p);
if (*p) {
fprintf(stderr, ""POTRACE": invalid blacklevel -- %s\n", optarg);
exit(1);
}
break;
case 'i':
info.invert = 1;
break;
case OPT_OPAQUE:
info.opaque = 1;
break;
case OPT_GROUP:
info.grouping = 2;
break;
case OPT_FLAT:
info.grouping = 0;
break;
case OPT_PROGRESS:
info.progress = 1;
break;
case OPT_TTY:
if (strcmp(optarg, "dumb") == 0) {
info.progress_bar = progress_bar_simplified;
} else if (strcmp(optarg, "vt100") == 0) {
info.progress_bar = progress_bar_vt100;
} else {
fprintf(stderr, ""POTRACE": invalid tty mode -- %s. Try --help for more info\n", optarg);
exit(1);
}
break;
case '?':
fprintf(stderr, "Try --help for more info\n");
exit(1);
break;
default:
fprintf(stderr, ""POTRACE": Unimplemented option -- %c\n", c);
exit(1);
}
}
info.infiles = &av[optind];
info.infilecount = ac-optind;
info.some_infiles = info.infilecount ? 1 : 0;
/* if "--" was used, even an empty list of filenames is considered
"some" filenames. */
if (strcmp(av[optind-1], "--") == 0) {
info.some_infiles = 1;
}
}
static Array<Tuple<time_kind_t,event_t>> dependencies(const int direction, const time_kind_t kind, const event_t event) {
GEODE_ASSERT(abs(direction)==1);
static_assert(compress_kind==0,"Verify that -kind != kind for kinds we care about");
// Parse event
const section_t section = parse_section(event);
const auto block = parse_block(event);
const uint8_t dimensions = parse_dimensions(event),
parent_to_child_symmetry = dimensions>>2,
dimension = dimensions&3;
const auto ekind = event&ekind_mask;
// See mpi/graph for summarized explanation
Array<Tuple<time_kind_t,event_t>> deps;
switch (direction*kind) {
case -allocate_line_kind: {
GEODE_ASSERT(ekind==line_ekind);
break; }
case response_recv_kind:
case -request_send_kind: {
GEODE_ASSERT(ekind==block_lines_ekind);
const auto other_kind = kind==response_recv_kind ? schedule_kind : allocate_line_kind;
const auto parent_section = section.parent(dimension).transform(symmetry_t::invert_global(parent_to_child_symmetry));
const auto permutation = section_t::quadrant_permutation(parent_to_child_symmetry);
const uint8_t parent_dimension = permutation.find(dimension);
const auto block_base = Vector<uint8_t,4>(block.subset(permutation)).remove_index(parent_dimension);
deps.append(tuple(other_kind,line_event(parent_section,parent_dimension,block_base)));
break; }
case request_send_kind: {
GEODE_ASSERT(ekind==block_lines_ekind);
deps.append(tuple(response_send_kind,event));
break; }
case -response_send_kind:
case response_send_kind: {
GEODE_ASSERT(ekind==block_lines_ekind);
deps.append(tuple(direction<0?request_send_kind:response_recv_kind,event));
break; }
case -response_recv_kind: {
GEODE_ASSERT(ekind==block_lines_ekind);
deps.append(tuple(response_send_kind,event));
break; }
case allocate_line_kind:
case -schedule_kind: {
GEODE_ASSERT(ekind==line_ekind);
if (section.sum()!=35) {
const auto other_kind = kind==allocate_line_kind ? request_send_kind : response_recv_kind;
const auto child_section = section.child(dimension).standardize<8>();
const auto permutation = section_t::quadrant_permutation(symmetry_t::invert_global(child_section.y));
const uint8_t child_dimension = permutation.find(dimension);
const dimensions_t dimensions(child_section.y,child_dimension);
auto child_block = Vector<uint8_t,4>(block.slice<0,3>().insert(0,dimension).subset(permutation));
for (const uint8_t b : range(section_blocks(child_section.x)[child_dimension])) {
child_block[child_dimension] = b;
deps.append(tuple(other_kind,block_lines_event(child_section.x,dimensions,child_block)));
}
}
break; }
case schedule_kind: {
GEODE_ASSERT(ekind==line_ekind);
deps.append(tuple(compute_kind,event)); // Corresponds to many different microline compute events
break; }
case -compute_kind: // Note: all microline compute events have the same line event
case compute_kind: {
GEODE_ASSERT(ekind==line_ekind);
deps.append(tuple(direction<0?schedule_kind:wakeup_kind,event));
break; }
case -wakeup_kind: {
GEODE_ASSERT(ekind==line_ekind);
deps.append(tuple(compute_kind,event)); // Corresponds to many different microline compute events
break; }
case wakeup_kind: {
GEODE_ASSERT(ekind==line_ekind);
const auto block_base = block.slice<0,3>();
for (const uint8_t b : range(section_blocks(section)[dimension]))
deps.append(tuple(output_send_kind,block_line_event(section,dimension,block_base.insert(b,dimension))));
break; }
case -output_send_kind:
case output_send_kind: {
GEODE_ASSERT(ekind==block_line_ekind);
if (direction<0)
deps.append(tuple(wakeup_kind,line_event(section,dimension,block.remove_index(dimension))));
else
deps.append(tuple(output_recv_kind,event));
break; }
case -output_recv_kind:
case output_recv_kind: {
GEODE_ASSERT(ekind==block_line_ekind);
deps.append(tuple(direction<0?output_send_kind:snappy_kind,event));
break; }
case -snappy_kind:
case snappy_kind: {
GEODE_ASSERT(ekind==block_line_ekind);
if (direction<0)
deps.append(tuple(output_recv_kind,event));
break; }
default:
break;
}
return deps;
}
