From dec8c284bcb53f2e683d77bfc37dfce9371d76ba Mon Sep 17 00:00:00 2001 From: eddyem Date: Fri, 30 Sep 2016 18:57:41 +0300 Subject: [PATCH] some settings for .dat file processing --- README.md | 6 + wfs_read/Makefile | 24 ++ wfs_read/cmdlnopts.c | 85 +++++++ wfs_read/cmdlnopts.h | 45 ++++ wfs_read/main.c | 95 ++++++++ wfs_read/main.h | 0 wfs_read/parseargs.c | 497 ++++++++++++++++++++++++++++++++++++++ wfs_read/parseargs.h | 124 ++++++++++ wfs_read/readdat.c | 146 +++++++++++ wfs_read/readdat.h | 30 +++ wfs_read/readwfs.c | 257 ++++++++++++++++++++ wfs_read/readwfs.h | 149 ++++++++++++ wfs_read/usefull_macros.c | 371 ++++++++++++++++++++++++++++ wfs_read/usefull_macros.h | 138 +++++++++++ wfs_read/zernike.c | 132 ++++++++++ wfs_read/zernike.h | 43 ++++ 16 files changed, 2142 insertions(+) create mode 100644 wfs_read/Makefile create mode 100644 wfs_read/cmdlnopts.c create mode 100644 wfs_read/cmdlnopts.h create mode 100644 wfs_read/main.c create mode 100644 wfs_read/main.h create mode 100644 wfs_read/parseargs.c create mode 100644 wfs_read/parseargs.h create mode 100644 wfs_read/readdat.c create mode 100644 wfs_read/readdat.h create mode 100644 wfs_read/readwfs.c create mode 100644 wfs_read/readwfs.h create mode 100644 wfs_read/usefull_macros.c create mode 100644 wfs_read/usefull_macros.h create mode 100644 wfs_read/zernike.c create mode 100644 wfs_read/zernike.h diff --git a/README.md b/README.md index 031044b..cefae16 100644 --- a/README.md +++ b/README.md @@ -10,3 +10,9 @@ Allows to stream BTA data over TCP socket ** Stellarium_control Allows to point telescope with help of stellarium +** fits_headers +Process FITS-files with WCS headers and calculate reference angle between plate angle (P2) and parallax angle + +** wfs_read +Read WFS/DAT files got by SHA tool (Shack-Hartmann processing utilite) and get some information from it. + diff --git a/wfs_read/Makefile b/wfs_read/Makefile new file mode 100644 index 0000000..45637de --- /dev/null +++ b/wfs_read/Makefile @@ -0,0 +1,24 @@ +PROGRAM = readwfs +LDFLAGS = +SRCS = $(wildcard *.c) +CC = gcc +DEFINES = -D_XOPEN_SOURCE=1111 +CXX = gcc +CFLAGS = -Wall -Werror -Wextra $(DEFINES) -std=gnu99 +OBJS = $(SRCS:.c=.o) +all : $(PROGRAM) +$(PROGRAM) : $(OBJS) + $(CC) $(CFLAGS) $(OBJS) $(LDFLAGS) -o $(PROGRAM) + +# some addition dependencies +# %.o: %.c +# $(CC) $(LDFLAGS) $(CFLAGS) $< -o $@ +$(SRCS) : %.c : %.h + touch $@ + +%.h: ; + +clean: + /bin/rm -f *.o *~ +depend: + $(CXX) -MM $(CXX.SRCS) diff --git a/wfs_read/cmdlnopts.c b/wfs_read/cmdlnopts.c new file mode 100644 index 0000000..689ab04 --- /dev/null +++ b/wfs_read/cmdlnopts.c @@ -0,0 +1,85 @@ +/* + * cmdlnopts.c - the only function that parse cmdln args and returns glob parameters + * + * Copyright 2013 Edward V. Emelianoff + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ +#include +#include +#include "cmdlnopts.h" +#include "usefull_macros.h" +#include "zernike.h" // for DEFAULT_CRD_STEP & DEFAULT_WF_UNIT + +/* + * here are global parameters initialisation + */ +int help; +static glob_pars G; +// DEFAULTS +// default global parameters +glob_pars const Gdefault = { + .inwfs = NULL // input WFS file name + ,.indat = NULL // input DAT file name + ,.outname = "wavefront_coords.dat" // output file name + ,.step = DEFAULT_CRD_STEP // coordinate step in wavefront map + ,.wfunits = DEFAULT_WF_UNIT // units for wavefront measurement in WF map + ,.wavelength = DEFAULT_WAVELENGTH // default wavelength +}; + +/* + * Define command line options by filling structure: + * name has_arg flag val type argptr help +*/ +myoption cmdlnopts[] = { + // set 1 to param despite of its repeating number: + {"help", NO_ARGS, NULL, 'h', arg_int, APTR(&help), _("show this help")}, + // simple integer parameter with obligatory arg: + {"wfs", NEED_ARG, NULL, 'w', arg_string, APTR(&G.inwfs), _("input WFS file name")}, + {"dat", NEED_ARG, NULL, 'd', arg_string, APTR(&G.indat), _("input DAT file name")}, + {"output", NEED_ARG, NULL, 'o', arg_string, APTR(&G.outname), _("output file name")}, + {"step", NEED_ARG, NULL, 's', arg_double, APTR(&G.step), _("coordinate step in wavefront map (R=1)")}, + {"wfunits", NEED_ARG, NULL, 'u', arg_string, APTR(&G.wfunits), _("units for wavefront measurement in WF map")}, + {"wavelength", NEED_ARG, NULL, 'l', arg_double, APTR(&G.wavelength),_("default wavelength (in meters, microns or nanometers), 101..9999nm")}, + end_option +}; + +/** + * Parse command line options and return dynamically allocated structure + * to global parameters + * @param argc - copy of argc from main + * @param argv - copy of argv from main + * @return allocated structure with global parameters + */ +glob_pars *parse_args(int argc, char **argv){ + void *ptr = memcpy(&G, &Gdefault, sizeof(G)); + if(!ptr) ERR(_("Can't memcpy")); + // format of help: "Usage: progname [args]\n" + change_helpstring(_("Usage: %s [args]\n\n\tWhere args are:\n")); + // parse arguments + parseargs(&argc, &argv, cmdlnopts); + if(help) showhelp(-1, cmdlnopts); +/* + int i; + if(argc > 0){ + G.rest_pars_num = argc; + G.rest_pars = calloc(argc, sizeof(char*)); + for (i = 0; i < argc; i++) + G.rest_pars[i] = strdup(argv[i]); + }*/ + return &G; +} + diff --git a/wfs_read/cmdlnopts.h b/wfs_read/cmdlnopts.h new file mode 100644 index 0000000..2cf33dc --- /dev/null +++ b/wfs_read/cmdlnopts.h @@ -0,0 +1,45 @@ +/* + * cmdlnopts.h - comand line options for parceargs + * + * Copyright 2013 Edward V. Emelianoff + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ + +#pragma once +#ifndef __CMDLNOPTS_H__ +#define __CMDLNOPTS_H__ + +#include "parseargs.h" + +/* + * here are some typedef's for global data + */ +typedef struct{ + char *inwfs; // input WFS file name + char *indat; // input DAT file name + char *outname; // output file name + double step; // coordinate step in wavefront map + char *wfunits; // units for wavefront measurement in WF map + double wavelength; // default wavelength +} glob_pars; + + +// default & global parameters +extern glob_pars const Gdefault; + +glob_pars *parse_args(int argc, char **argv); +#endif // __CMDLNOPTS_H__ diff --git a/wfs_read/main.c b/wfs_read/main.c new file mode 100644 index 0000000..9591a38 --- /dev/null +++ b/wfs_read/main.c @@ -0,0 +1,95 @@ +/* + * main.c + * + * Copyright 2016 Edward V. Emelianov + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ +#include +#include "usefull_macros.h" +#include "cmdlnopts.h" +#include "readwfs.h" +#include "readdat.h" +#include "zernike.h" + + +glob_pars *GP = NULL; + +/** + * Read and dump WFS file + */ +void proc_WFS(){ + int fd = open(GP->inwfs, O_RDONLY); + if(fd < 0){ + WARN(_("open %s"), GP->inwfs); + return; + } + if(!test_wfs_file(fd)){ + WARNX(_("Bad WFS file %s"), GP->inwfs); + return; + } + Zhistory *hist = show_zhistry(fd); + print_table(hist, fd); + hist = show_zhistry(fd); + print_table(hist, fd); + close(fd); +} + +void proc_DAT(){ + int i, Zn; + if(fabs(GP->step - DEFAULT_CRD_STEP) > DBL_EPSILON){ // user change default step + if((i = z_set_step(GP->step))) + WARNX(_("Can't change step to %g, value is too %s"), GP->step, i < 0 ? "small" : "big"); + return; + } + if(fabs(GP->wavelength - DEFAULT_WAVELENGTH) > DBL_EPSILON){ // user want to change wavelength + // WARNING! This option test should be before changing unit because units depends on wavelength + if(z_set_wavelength(GP->wavelength)){ + WARNX(_("Bad wavelength: %g, should be from 100 to 10000um (1e-7 to 1e-5 or 0.1 to 10)"), GP->wavelength); + return; + } + } + if(strcmp(GP->wfunits, DEFAULT_WF_UNIT)){ // user ask to change default unit + if(z_set_wfunit(GP->wfunits)){ + WARNX(_("Bad wavefront unit: %s. Should be one of"), GP->wfunits); + z_print_wfunits(); + return; + } + } + double *zerncoeffs = read_dat_file(GP->indat, &Zn); + if(!zerncoeffs){ + WARNX(_("Bad DAT file %s"), GP->indat); + return; + } + printf("Read coefficients:\n"); + for(i = 0; i < Zn; ++i) printf("%4d\t%g\n", i, zerncoeffs[i]); +} + +/** + * Read DAT file and build table with wavefront coordinates + */ +int main(int argc, char** argv){ + initial_setup(); + GP = parse_args(argc, argv); + if(!GP->inwfs && !GP->indat) ERRX(_("You should give input file name")); + if(GP->inwfs){ + proc_WFS(); + } + if(GP->indat){ + proc_DAT(); + } + return 0; +} diff --git a/wfs_read/main.h b/wfs_read/main.h new file mode 100644 index 0000000..e69de29 diff --git a/wfs_read/parseargs.c b/wfs_read/parseargs.c new file mode 100644 index 0000000..62c3808 --- /dev/null +++ b/wfs_read/parseargs.c @@ -0,0 +1,497 @@ +/* + * parseargs.c - parsing command line arguments & print help + * + * Copyright 2013 Edward V. Emelianoff + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ + +#include // printf +#include // getopt_long +#include // calloc, exit, strtoll +#include // assert +#include // strdup, strchr, strlen +#include // strcasecmp +#include // INT_MAX & so on +#include // gettext +#include // isalpha +#include "parseargs.h" +#include "usefull_macros.h" + +char *helpstring = "%s\n"; + +/** + * Change standard help header + * MAY consist ONE "%s" for progname + * @param str (i) - new format + */ +void change_helpstring(char *s){ + int pcount = 0, scount = 0; + char *str = s; + // check `helpstring` and set it to default in case of error + for(; pcount < 2; str += 2){ + if(!(str = strchr(str, '%'))) break; + if(str[1] != '%') pcount++; // increment '%' counter if it isn't "%%" + else{ + str += 2; // pass next '%' + continue; + } + if(str[1] == 's') scount++; // increment "%s" counter + }; + if(pcount > 1 || pcount != scount){ // amount of pcount and/or scount wrong + /// "Неправильный формат строки помощи" + ERRX(_("Wrong helpstring!")); + } + helpstring = s; +} + +/** + * Carefull atoll/atoi + * @param num (o) - returning value (or NULL if you wish only check number) - allocated by user + * @param str (i) - string with number must not be NULL + * @param t (i) - T_INT for integer or T_LLONG for long long (if argtype would be wided, may add more) + * @return TRUE if conversion sone without errors, FALSE otherwise + */ +static bool myatoll(void *num, char *str, argtype t){ + long long tmp, *llptr; + int *iptr; + char *endptr; + assert(str); + assert(num); + tmp = strtoll(str, &endptr, 0); + if(endptr == str || *str == '\0' || *endptr != '\0') + return FALSE; + switch(t){ + case arg_longlong: + llptr = (long long*) num; + *llptr = tmp; + break; + case arg_int: + default: + if(tmp < INT_MIN || tmp > INT_MAX){ + /// "Целое вне допустимого диапазона" + WARNX(_("Integer out of range")); + return FALSE; + } + iptr = (int*)num; + *iptr = (int)tmp; + } + return TRUE; +} + +// the same as myatoll but for double +// There's no NAN & INF checking here (what if they would be needed?) +static bool myatod(void *num, const char *str, argtype t){ + double tmp, *dptr; + float *fptr; + char *endptr; + assert(str); + tmp = strtod(str, &endptr); + if(endptr == str || *str == '\0' || *endptr != '\0') + return FALSE; + switch(t){ + case arg_double: + dptr = (double *) num; + *dptr = tmp; + break; + case arg_float: + default: + fptr = (float *) num; + *fptr = (float)tmp; + break; + } + return TRUE; +} + +/** + * Get index of current option in array options + * @param opt (i) - returning val of getopt_long + * @param options (i) - array of options + * @return index in array + */ +static int get_optind(int opt, myoption *options){ + int oind; + myoption *opts = options; + assert(opts); + for(oind = 0; opts->name && opts->val != opt; oind++, opts++); + if(!opts->name || opts->val != opt) // no such parameter + showhelp(-1, options); + return oind; +} + +/** + * reallocate new value in array of multiple repeating arguments + * @arg paptr - address of pointer to array (**void) + * @arg type - its type (for realloc) + * @return pointer to new (next) value + */ +void *get_aptr(void *paptr, argtype type){ + int i = 1; + void **aptr = *((void***)paptr); + if(aptr){ // there's something in array + void **p = aptr; + while(*p++) ++i; + } + size_t sz = 0; + switch(type){ + default: + case arg_none: + /// "Не могу использовать несколько параметров без аргументов!" + ERRX("Can't use multiple args with arg_none!"); + break; + case arg_int: + sz = sizeof(int); + break; + case arg_longlong: + sz = sizeof(long long); + break; + case arg_double: + sz = sizeof(double); + break; + case arg_float: + sz = sizeof(float); + break; + case arg_string: + sz = 0; + break; + /* case arg_function: + sz = sizeof(argfn *); + break;*/ + } + aptr = realloc(aptr, (i + 1) * sizeof(void*)); + *((void***)paptr) = aptr; + aptr[i] = NULL; + if(sz){ + aptr[i - 1] = malloc(sz); + }else + aptr[i - 1] = &aptr[i - 1]; + return aptr[i - 1]; +} + + +/** + * Parse command line arguments + * ! If arg is string, then value will be strdup'ed! + * + * @param argc (io) - address of argc of main(), return value of argc stay after `getopt` + * @param argv (io) - address of argv of main(), return pointer to argv stay after `getopt` + * BE CAREFUL! if you wanna use full argc & argv, save their original values before + * calling this function + * @param options (i) - array of `myoption` for arguments parcing + * + * @exit: in case of error this function show help & make `exit(-1)` + */ +void parseargs(int *argc, char ***argv, myoption *options){ + char *short_options, *soptr; + struct option *long_options, *loptr; + size_t optsize, i; + myoption *opts = options; + // check whether there is at least one options + assert(opts); + assert(opts[0].name); + // first we count how much values are in opts + for(optsize = 0; opts->name; optsize++, opts++); + // now we can allocate memory + short_options = calloc(optsize * 3 + 1, 1); // multiply by three for '::' in case of args in opts + long_options = calloc(optsize + 1, sizeof(struct option)); + opts = options; loptr = long_options; soptr = short_options; + // in debug mode check the parameters are not repeated +#ifdef EBUG + char **longlist = MALLOC(char*, optsize); + char *shortlist = MALLOC(char, optsize); +#endif + // fill short/long parameters and make a simple checking + for(i = 0; i < optsize; i++, loptr++, opts++){ + // check + assert(opts->name); // check name +#ifdef EBUG + longlist[i] = strdup(opts->name); +#endif + if(opts->has_arg){ + assert(opts->type != arg_none); // check error with arg type + assert(opts->argptr); // check pointer + } + if(opts->type != arg_none) // if there is a flag without arg, check its pointer + assert(opts->argptr); + // fill long_options + // don't do memcmp: what if there would be different alignment? + loptr->name = opts->name; + loptr->has_arg = (opts->has_arg < MULT_PAR) ? opts->has_arg : 1; + loptr->flag = opts->flag; + loptr->val = opts->val; + // fill short options if they are: + if(!opts->flag && opts->val){ +#ifdef EBUG + shortlist[i] = (char) opts->val; +#endif + *soptr++ = opts->val; + if(loptr->has_arg) // add ':' if option has required argument + *soptr++ = ':'; + if(loptr->has_arg == 2) // add '::' if option has optional argument + *soptr++ = ':'; + } + } + // sort all lists & check for repeating +#ifdef EBUG + int cmpstringp(const void *p1, const void *p2){ + return strcmp(* (char * const *) p1, * (char * const *) p2); + } + int cmpcharp(const void *p1, const void *p2){ + return (int)(*(char * const)p1 - *(char *const)p2); + } + qsort(longlist, optsize, sizeof(char *), cmpstringp); + qsort(shortlist,optsize, sizeof(char), cmpcharp); + char *prevl = longlist[0], prevshrt = shortlist[0]; + for(i = 1; i < optsize; ++i){ + if(longlist[i]){ + if(prevl){ + if(strcmp(prevl, longlist[i]) == 0) ERRX("double long arguments: --%s", prevl); + } + prevl = longlist[i]; + } + if(shortlist[i]){ + if(prevshrt){ + if(prevshrt == shortlist[i]) ERRX("double short arguments: -%c", prevshrt); + } + prevshrt = shortlist[i]; + } + } +#endif + // now we have both long_options & short_options and can parse `getopt_long` + while(1){ + int opt; + int oindex = 0, optind = 0; // oindex - number of option in argv, optind - number in options[] + if((opt = getopt_long(*argc, *argv, short_options, long_options, &oindex)) == -1) break; + if(opt == '?'){ + opt = optopt; + optind = get_optind(opt, options); + if(options[optind].has_arg == NEED_ARG || options[optind].has_arg == MULT_PAR) + showhelp(optind, options); // need argument + } + else{ + if(opt == 0 || oindex > 0) optind = oindex; + else optind = get_optind(opt, options); + } + opts = &options[optind]; + if(opt == 0 && opts->has_arg == NO_ARGS) continue; // only long option changing integer flag + // now check option + if(opts->has_arg == NEED_ARG || opts->has_arg == MULT_PAR) + if(!optarg) showhelp(optind, options); // need argument + void *aptr; + if(opts->has_arg == MULT_PAR){ + aptr = get_aptr(opts->argptr, opts->type); + }else + aptr = opts->argptr; + bool result = TRUE; + // even if there is no argument, but argptr != NULL, think that optarg = "1" + if(!optarg) optarg = "1"; + switch(opts->type){ + default: + case arg_none: + if(opts->argptr) *((int*)aptr) += 1; // increment value + break; + case arg_int: + result = myatoll(aptr, optarg, arg_int); + break; + case arg_longlong: + result = myatoll(aptr, optarg, arg_longlong); + break; + case arg_double: + result = myatod(aptr, optarg, arg_double); + break; + case arg_float: + result = myatod(aptr, optarg, arg_float); + break; + case arg_string: + result = (*((void**)aptr) = (void*)strdup(optarg)); + break; + case arg_function: + result = ((argfn)aptr)(optarg); + break; + } + if(!result){ + showhelp(optind, options); + } + } + *argc -= optind; + *argv += optind; +} + +/** + * compare function for qsort + * first - sort by short options; second - sort arguments without sort opts (by long options) + */ +static int argsort(const void *a1, const void *a2){ + const myoption *o1 = (myoption*)a1, *o2 = (myoption*)a2; + const char *l1 = o1->name, *l2 = o2->name; + int s1 = o1->val, s2 = o2->val; + int *f1 = o1->flag, *f2 = o2->flag; + // check if both options has short arg + if(f1 == NULL && f2 == NULL){ // both have short arg + return (s1 - s2); + }else if(f1 != NULL && f2 != NULL){ // both don't have short arg - sort by long + return strcmp(l1, l2); + }else{ // only one have short arg -- return it + if(f2) return -1; // a1 have short - it is 'lesser' + else return 1; + } +} + +/** + * Show help information based on myoption->help values + * @param oindex (i) - if non-negative, show only help by myoption[oindex].help + * @param options (i) - array of `myoption` + * + * @exit: run `exit(-1)` !!! + */ +void showhelp(int oindex, myoption *options){ + int max_opt_len = 0; // max len of options substring - for right indentation + const int bufsz = 255; + char buf[bufsz+1]; + myoption *opts = options; + assert(opts); + assert(opts[0].name); // check whether there is at least one options + if(oindex > -1){ // print only one message + opts = &options[oindex]; + printf(" "); + if(!opts->flag && isalpha(opts->val)) printf("-%c, ", opts->val); + printf("--%s", opts->name); + if(opts->has_arg == 1) printf("=arg"); + else if(opts->has_arg == 2) printf("[=arg]"); + printf(" %s\n", _(opts->help)); + exit(-1); + } + // header, by default is just "progname\n" + printf("\n"); + if(strstr(helpstring, "%s")) // print progname + printf(helpstring, __progname); + else // only text + printf("%s", helpstring); + printf("\n"); + // count max_opt_len + do{ + int L = strlen(opts->name); + if(max_opt_len < L) max_opt_len = L; + }while((++opts)->name); + max_opt_len += 14; // format: '-S , --long[=arg]' - get addition 13 symbols + opts = options; + // count amount of options + int N; for(N = 0; opts->name; ++N, ++opts); + if(N == 0) exit(-2); + // Now print all help (sorted) + opts = options; + qsort(opts, N, sizeof(myoption), argsort); + do{ + int p = sprintf(buf, " "); // a little indent + if(!opts->flag && opts->val) // .val is short argument + p += snprintf(buf+p, bufsz-p, "-%c, ", opts->val); + p += snprintf(buf+p, bufsz-p, "--%s", opts->name); + if(opts->has_arg == 1) // required argument + p += snprintf(buf+p, bufsz-p, "=arg"); + else if(opts->has_arg == 2) // optional argument + p += snprintf(buf+p, bufsz-p, "[=arg]"); + assert(p < max_opt_len); // there would be magic if p >= max_opt_len + printf("%-*s%s\n", max_opt_len+1, buf, _(opts->help)); // write options & at least 2 spaces after + ++opts; + }while(--N); + printf("\n\n"); + exit(-1); +} + +/** + * get suboptions from parameter string + * @param str - parameter string + * @param opt - pointer to suboptions structure + * @return TRUE if all OK + */ +bool get_suboption(char *str, mysuboption *opt){ + int findsubopt(char *par, mysuboption *so){ + int idx = 0; + if(!par) return -1; + while(so[idx].name){ + if(strcasecmp(par, so[idx].name) == 0) return idx; + ++idx; + } + return -1; // badarg + } + bool opt_setarg(mysuboption *so, int idx, char *val){ + mysuboption *soptr = &so[idx]; + bool result = FALSE; + void *aptr = soptr->argptr; + switch(soptr->type){ + default: + case arg_none: + if(soptr->argptr) *((int*)aptr) += 1; // increment value + result = TRUE; + break; + case arg_int: + result = myatoll(aptr, val, arg_int); + break; + case arg_longlong: + result = myatoll(aptr, val, arg_longlong); + break; + case arg_double: + result = myatod(aptr, val, arg_double); + break; + case arg_float: + result = myatod(aptr, val, arg_float); + break; + case arg_string: + result = (*((void**)aptr) = (void*)strdup(val)); + break; + case arg_function: + result = ((argfn)aptr)(val); + break; + } + return result; + } + char *tok; + bool ret = FALSE; + char *tmpbuf; + tok = strtok_r(str, ":,", &tmpbuf); + do{ + char *val = strchr(tok, '='); + int noarg = 0; + if(val == NULL){ // no args + val = "1"; + noarg = 1; + }else{ + *val++ = '\0'; + if(!*val || *val == ':' || *val == ','){ // no argument - delimeter after = + val = "1"; noarg = 1; + } + } + int idx = findsubopt(tok, opt); + if(idx < 0){ + /// "Неправильный параметр: %s" + WARNX(_("Wrong parameter: %s"), tok); + goto returning; + } + if(noarg && opt[idx].has_arg == NEED_ARG){ + /// "%s: необходим аргумент!" + WARNX(_("%s: argument needed!"), tok); + goto returning; + } + if(!opt_setarg(opt, idx, val)){ + /// "Неправильный аргумент \"%s\" параметра \"%s\"" + WARNX(_("Wrong argument \"%s\" of parameter \"%s\""), val, tok); + goto returning; + } + }while((tok = strtok_r(NULL, ":,", &tmpbuf))); + ret = TRUE; +returning: + return ret; +} diff --git a/wfs_read/parseargs.h b/wfs_read/parseargs.h new file mode 100644 index 0000000..a0ac099 --- /dev/null +++ b/wfs_read/parseargs.h @@ -0,0 +1,124 @@ +/* + * parseargs.h - headers for parsing command line arguments + * + * Copyright 2013 Edward V. Emelianoff + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ +#pragma once +#ifndef __PARSEARGS_H__ +#define __PARSEARGS_H__ + +#include // bool +#include + +#ifndef TRUE + #define TRUE true +#endif + +#ifndef FALSE + #define FALSE false +#endif + +// macro for argptr +#define APTR(x) ((void*)x) + +// if argptr is a function: +typedef bool(*argfn)(void *arg); + +/* + * type of getopt's argument + * WARNING! + * My function change value of flags by pointer, so if you want to use another type + * make a latter conversion, example: + * char charg; + * int iarg; + * myoption opts[] = { + * {"value", 1, NULL, 'v', arg_int, &iarg, "char val"}, ..., end_option}; + * ..(parse args).. + * charg = (char) iarg; + */ +typedef enum { + arg_none = 0, // no arg + arg_int, // integer + arg_longlong, // long long + arg_double, // double + arg_float, // float + arg_string, // char * + arg_function // parse_args will run function `bool (*fn)(char *optarg, int N)` +} argtype; + +/* + * Structure for getopt_long & help + * BE CAREFUL: .argptr is pointer to data or pointer to function, + * conversion depends on .type + * + * ATTENTION: string `help` prints through macro PRNT(), bu default it is gettext, + * but you can redefine it before `#include "parseargs.h"` + * + * if arg is string, then value wil be strdup'ed like that: + * char *str; + * myoption opts[] = {{"string", 1, NULL, 's', arg_string, &str, "string val"}, ..., end_option}; + * *(opts[1].str) = strdup(optarg); + * in other cases argptr should be address of some variable (or pointer to allocated memory) + * + * NON-NULL argptr should be written inside macro APTR(argptr) or directly: (void*)argptr + * + * !!!LAST VALUE OF ARRAY SHOULD BE `end_option` or ZEROS !!! + * + */ +typedef enum{ + NO_ARGS = 0, // first three are the same as in getopt_long + NEED_ARG = 1, + OPT_ARG = 2, + MULT_PAR +} hasarg; + +typedef struct{ + // these are from struct option: + const char *name; // long option's name + hasarg has_arg; // 0 - no args, 1 - nesessary arg, 2 - optionally arg, 4 - need arg & key can repeat (args are stored in null-terminated array) + int *flag; // NULL to return val, pointer to int - to set its value of val (function returns 0) + int val; // short opt name (if flag == NULL) or flag's value + // and these are mine: + argtype type; // type of argument + void *argptr; // pointer to variable to assign optarg value or function `bool (*fn)(char *optarg, int N)` + const char *help; // help string which would be shown in function `showhelp` or NULL +} myoption; + +/* + * Suboptions structure, almost the same like myoption + * used in parse_subopts() + */ +typedef struct{ + const char *name; + hasarg has_arg; + argtype type; + void *argptr; +} mysuboption; + +// last string of array (all zeros) +#define end_option {0,0,0,0,0,0,0} +#define end_suboption {0,0,0,0} + +extern const char *__progname; + +void showhelp(int oindex, myoption *options); +void parseargs(int *argc, char ***argv, myoption *options); +void change_helpstring(char *s); +bool get_suboption(char *str, mysuboption *opt); + +#endif // __PARSEARGS_H__ diff --git a/wfs_read/readdat.c b/wfs_read/readdat.c new file mode 100644 index 0000000..123bf84 --- /dev/null +++ b/wfs_read/readdat.c @@ -0,0 +1,146 @@ +/* + * readdat.c + * + * Copyright 2016 Edward V. Emelianov + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ +#include // isspace +#include // strncasecmp +#include "usefull_macros.h" +#include "readdat.h" + +/** + * Get next text line ending with '\n' or '\n\r' + * @param start (i) - text in current line + * @param end (i) - end of text + * @return pointer to next line first character (spaces are omit) or NULL + */ +char *nextline(char *start, char* end){ + if(!start || !end) return NULL; + while(start < end) // get next newline symbol + if(*start++ == '\n') break; + while(start < end){ // now skip all spaces, '\r' etc + if(isspace(*start)) ++start; + else break; + } + if(start == end) return NULL; + return start; +} + +/** + * Read next double value from .dat file + * @param begin (i) - beginning of data portion + * @param end (i) - data end + * @param num (o) - number read + * @return pointer to next data item if line isn't end after current + * or pointer to next '\n' symbol (or `end`) if this value was last in string; + * NULL if there was an error during strtod + */ +char *read_double(char *begin, char *end, double *num){ + char *nextchar; + if(!num || !begin|| !end || begin >= end) return NULL; + *num = strtod(begin, &nextchar); + if(!nextchar) // end of data + return end; + if(begin == nextchar || !isspace(*nextchar)){ + char buf[10]; + snprintf(buf, 10, "%s", begin); + WARNX(_("Not a number %s..."), buf); + return NULL; + } + while(nextchar < end){ + char c = *nextchar; + if(isspace(c) && c != '\n') ++nextchar; + else break; + } + return nextchar; +} + +/** + * Find in .dat file neader column number named `val` + * @param val (i) - name of column to search + * @param dat (i) - header start + * @param end (i) - data end + * @return number of column found or -1 + */ +int get_hdrval(char *val, char *dat, char *end){ + size_t l = strlen(val); + int i = 0; + while(dat < end){ + char c = 0; + while(dat < end){ // skip spaces + c = *dat; + if(isspace(c) && c != '\n') ++dat; + else break; + } + if(c == '\n' || dat == end) return -1; // end of line or end of data reached + if(!strncasecmp(dat, val, l)) return i; + while(dat < end){ // skip non-spaces + if(!isspace(*dat)) ++dat; + else break; + } + ++i; + } + return -1; +} + +/** + * Read .dat file and get Zernike coefficients from it + * @param fname (i) - .dat file name + * @param sz (o) - size of coefficients' array + * @return dynamically allocated array or NULL in case of error + */ +double *read_dat_file(char *fname, int *sz){ + if(!fname) return NULL; + mmapbuf *dbuf = My_mmap(fname); + if(!dbuf) return NULL; + char *dat = dbuf->data, *eptr = dat + dbuf->len; + if(strncasecmp(dat, "time", 4)){ + WARNX(_("Bad header")); + return NULL; + } + int rd = 0, skipfst = get_hdrval("piston", dat, eptr), L = Z_REALLOC_STEP; + if(skipfst < 0){ + WARNX(_("Dat file don't have OSA Zernike coefficients")); + return NULL; + } + dat = nextline(dat, eptr); + double *zern = MALLOC(double, Z_REALLOC_STEP); + while(dat < eptr){ + double d; + char *next = read_double(dat, eptr, &d); + if(!next) break; + dat = next; + if(skipfst > 0){ // skip this value + --skipfst; + continue; + } + if(++rd > L){ + L += Z_REALLOC_STEP; + double *z_realloc = realloc(zern, L * sizeof(double)); + if(!z_realloc){ + WARN(_("Reallocation of memory failed")); + break; + } + zern = z_realloc; + } + zern[rd - 1] = d; + if(*next == '\n') break; + } + if(sz) *sz = rd; + return zern; +} diff --git a/wfs_read/readdat.h b/wfs_read/readdat.h new file mode 100644 index 0000000..14f300d --- /dev/null +++ b/wfs_read/readdat.h @@ -0,0 +1,30 @@ +/* + * readdat.h + * + * Copyright 2016 Edward V. Emelianov + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ +#pragma once +#ifndef __READDAT_H__ +#define __READDAT_H__ + +// allocate memory with quantum of this +#define Z_REALLOC_STEP (10) + +double *read_dat_file(char *fname, int *sz); + +#endif // __READDAT_H__ diff --git a/wfs_read/readwfs.c b/wfs_read/readwfs.c new file mode 100644 index 0000000..d0f541d --- /dev/null +++ b/wfs_read/readwfs.c @@ -0,0 +1,257 @@ +/* + * readwfs.c + * + * Copyright 2016 Edward V. Emelianov + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ +#include + +#include "usefull_macros.h" +#include "readwfs.h" + +WFS_header hdr; +void hexdump(int fd, int N); + + +void signals(int sig){ + exit(sig); +} + +void gettime(struct tm *tm, SYSTEMTIME *st){ + if(!tm || !st) return; + tm->tm_sec = st->wSecond; + tm->tm_min = st->wMinute; + tm->tm_hour = st->wHour; + tm->tm_mday = st->wDay; + tm->tm_mon = st->wMonth - 1; + tm->tm_year = st->wYear - 1900; + tm->tm_isdst = -1; +} + +/** + * read from file fd maxlen bytes into optr with size optrlen + * return 0 if suxeed + */ +int get_struct(int fd, void *optr, int optrlen, int maxlen){ + if(maxlen < optrlen) return 1; + if(optrlen != read(fd, optr, optrlen)) return 2; + if(optrlen != maxlen){ + //printf("seek to %d", maxlen-optrlen); + lseek(fd, maxlen-optrlen, SEEK_CUR); + } + return 0; +} + +void show_sparam(int fd){ + Sparam *par = &hdr.sparam; + if(get_struct(fd, (void*)par, sizeof(Sparam), hdr.Sparam_sz)) ERRX("read sparam"); + //if(get_struct(fd, (void*)par, sizeof(Sparam), sizeof(Sparam))) ERRX("read sparam"); + printf("\nSPARAM:\nInput pupil: %gmm, wavelength: %gnm\n", par->SystemInputPupilM*1e3, + par->WLength*1e9); + printf("Focus len: %gmm, refraction idx: %g\n", par->SysFocusLength*1e3, + par->SysRefraction); + printf("Pix2WF: %g, pixel size: %gmkm, sensor size(W:H): %d:%d\n", par->Pix2WF, par->Pix2Meter*1e6, + par->W, par->H); + printf("Distance between lenses: %g, %spre-estimate\n", par->LensD, par->bPreEstimate ? "" : "not "); + printf("Pupil shift: %gmm, output pupil: %dm\n", par->dPupilShift*1e3, + par->SystemOutputPupilP); + printf("Xdir: %g, Ydir: %g\n", par->XDir, par->YDir); + printf("Version: %d\n", par->Version); + printf("Using %d polynomials\n", par->NumberOfPolynomials); + printf("Lenslet geometry: %s\n", par->iLensletGeometry == 8 ? "square": + (par->iLensletGeometry == 6 ? "hexagonal" : "rombus")); + if(par->Afocal) printf("Afocal system\n"); + printf("Lenslet F: %gmm\n", par->LensletFocusLength); + printf("Scale factor: %g, Well depth: %de\n\n", par->ScaleFactor, par->WellDepth); +} + +void show_mparam(int fd){ + Mparam *par = &hdr.mparam; + if(get_struct(fd, (void*)par, sizeof(Mparam), hdr.Mparam_sz)) ERRX("read mparam"); + //if(get_struct(fd, (void*)par, sizeof(Mparam), sizeof(Mparam))) ERRX("read mparam"); + struct tm tm; + gettime(&tm, &par->DateTime); + time_t t = mktime(&tm); + printf("\nMPARAM:\nMeasurements date/time: %s\n", ctime(&t)); + int i; + printf("#\tMeasurement id\n"); + for(i = 0; i < 1024; ++i) if(par->MeasurementID[i]) printf("%d\t0x%02X\n", i, par->MeasurementID[i]); +} + +/** + "* Test header of WFS file + */ +int test_wfs_file(int fd){ + if(fd < 1) return 0; + int L = 3*sizeof(uint32_t); + if(read(fd, &hdr, L) != L){ + ERR("read"); + } + if(sizeof(Zhistory) > hdr.Zhistory_sz){ + ERRX("Zhistory size is %d instead of %d\n", hdr.Zhistory_sz, sizeof(Zhistory)); + } + printf("Zhistory: should be: %ld, in file: %d\n", sizeof(Zhistory), hdr.Zhistory_sz); + if(sizeof(Hhistory) > hdr.Hhistory_sz){ + ERRX("Hhistory size is %d instead of %d\n", hdr.Hhistory_sz, sizeof(Hhistory)); + } + printf("Hhistory: should be: %ld, in file: %d\n", sizeof(Hhistory), hdr.Hhistory_sz); + if(sizeof(Sparam) > hdr.Sparam_sz){ + ERRX("Sparam size is %d instead of %d\n", hdr.Sparam_sz, sizeof(Sparam)); + } + printf("Sparam: should be: %ld, in file: %d\n", sizeof(Sparam), hdr.Sparam_sz); + show_sparam(fd); + if(sizeof(uint32_t) != read(fd, &hdr.Mparam_sz, sizeof(uint32_t))){ + ERR("read"); + } + printf("Mparam: should be: %ld, in file: %d\n", sizeof(Mparam), hdr.Mparam_sz); + if(sizeof(Mparam) > hdr.Mparam_sz){ + ERRX("Mparam size is %d instead of %d\n", hdr.Mparam_sz, sizeof(Mparam)); + } + show_mparam(fd); + if(sizeof(uint32_t) != read(fd, &hdr.History_len, sizeof(uint32_t))){ + ERR("read"); + } + printf("\n\n%d records in history\n\n", hdr.History_len); + return 1; +} + +void show_hhistry(Hhistory *h){ + printf("\nHHISTORY:\nN spots: %d\n", h->NSpots); + printf("Unitary circle center: (%d, %d), radius: %d\n", h->C.ux, h->C.uy, h->C.ur); + printf("Measurement area center: (%d, %d), ", h->C.ax, h->C.ay); + if(h->C.ar == 0) printf("rectangle\n"); + else{ + if(h->C.ar < 0) printf("radius: %d (area outside this radius)\n", -h->C.ar); + else printf("radius: %d\n", h->C.ar); + } + printf("Pointers: "); + int i; for(i = 0; i < 6; ++i) printf("%d, ", h->pointers[i]); + printf("\nPdiff: "); + for(i = 1; i < 6; ++i) printf("%d, ", h->pointers[i] - h->pointers[i-1]); + printf("\n"); +} + +static off_t zhstart; +Zhistory *show_zhistry(int fd){ + Zhistory *hist = MALLOC(Zhistory, 1); + zhstart = lseek(fd, 0, SEEK_CUR); + int L = (void*)&hist->h - (void*)hist; + if(get_struct(fd, (void*)hist, L, L)) ERRX("read Zhistory header"); + if(get_struct(fd, (void*)&hist->h, sizeof(Hhistory), hdr.Hhistory_sz)) ERRX("read Hhistory"); + L = (void*)&hist->zhend - (void*)&hist->sx; + int szdiff = (hdr.Zhistory_sz - sizeof(Zhistory)) - (hdr.Hhistory_sz - sizeof(Hhistory)); + // 2 - dirty hack + if(get_struct(fd, (void*)&hist->sx, L, L+szdiff+2)) ERRX("read remain of Zhistory"); + //printf("diff: %d\n", szdiff); + printf("\nZHISTORY:\nCurrent number of poly: %d\n", hist->CurrentNumberOfPolynomials); + if(hist->CurrentNumberOfPolynomials < 37){ + int i; + printf("#\t polynomial value\n"); + for(i = 0; i < 37; ++i) printf("%d\t%g\n", i, hist->loPolynomials[i]); + } + printf("Sphere: %g, Cylinder: %g, Axis: %g\n", hist->Sphere, hist->Cylinder, hist->Axis); + printf("Circle diameter: %gmm\n", hist->ADiameter * 1e3); + printf("Time from measurements start: %dms\n", hist->Time); + printf("Polynomial set: %s\n", hist->PolynomialSet == 0 ? "Fringe" : + (hist->PolynomialSet == 1 ? "Born & Wolf" : + (hist->PolynomialSet == 2 ? "OSA" : "Ring"))); + show_hhistry(&hist->h); + printf("Beam center: (%g, %g)mm, radius: %gmm\n", + hist->sx*1e3, hist->sy*1e3, hist->sr*1e3); + printf("Unitary circle diameter: %gmm\n", hist->UDiameter*1e3); + if(hist->bBad) red("Bad image - not use it!\n"); + if(hist->bZRW) printf("Reconstructed by zonal method\n"); + printf("Chi^2 = %g\n", hist->chi2); + printf("Time from start %Lgmks\n", hist->time_mcsec); + printf("\n\nRESERVED:\nReserved3_1: %g, %g, %g\n", hist->Reserved3_1[0], hist->Reserved3_1[1], hist->Reserved3_1[2]); + printf("Reserved3_2: %g, %g, %g\n", hist->Reserved3_2[0], hist->Reserved3_2[1], hist->Reserved3_2[2]); + printf("pfReserved3: %d, iReserved4: %d\n", hist->pfReserved3, hist->iReserved4); + printf("pdReserved6: %d, pReserved7: %d\n", hist->pdReserved6, hist->pReserved7); + + return hist; +} + +float *getflt(int fd, int sz){ + int L = sizeof(float)*sz; + float *flt = MALLOC(float, sz); + if(L != read(fd, flt, L)) ERR("read"); + return flt; +} +uint8_t *get_uint8(int fd, int sz){ + uint8_t *u = MALLOC(uint8_t, sz); + if(sz != read(fd, u, sz)) ERR("read"); + return u; +} +void hexdump(int fd, int N){ + uint8_t *hx = MALLOC(uint8_t, N); + int i, L = read(fd, hx, N); + for(i = 0; i < L; ++i){ + printf("0x%02X ", hx[i]); + if(i%16 == 15) printf("\n"); + } + printf("\n"); + FREE(hx); +} + +/** + * print table of parameters for given "history" + */ +void print_table(Zhistory *hist, int fd){ + int Nspots = hist->h.NSpots, Npoly = hist->CurrentNumberOfPolynomials, i, zon = hist->bZRW; + float *XR, *YR, *XC, *YC, *W, *D, *poly = NULL, *Z=NULL, *I; + uint8_t *flag; + off_t blkstart = lseek(fd, 0, SEEK_CUR); + XR = getflt(fd, Nspots); + YR = getflt(fd, Nspots); + XC = getflt(fd, Nspots); + YC = getflt(fd, Nspots); + W = getflt(fd, Nspots); + D = getflt(fd, Nspots); + flag = MALLOC(uint8_t, Nspots); + I = getflt(fd, Nspots); + if(Npoly > 37) poly = getflt(fd, Npoly); + printf("\nTable:\n# Arrays of data for frame\n"); + printf("#\tXR\tYR\tXC\tYC\tWeight\tDispersion\tFlag\tIntensity"); + if(zon){ + printf("\tZonal"); + Z = getflt(fd, Nspots); + } + printf("\n"); + for(i = 0; i < Nspots; ++i){ + printf("%d\t%f\t%f\t%f\t%f\t%f\t%f\t%d\t%f", i,XR[i], YR[i], XC[i], YC[i], + W[i], D[i], flag[i], I[i]); + if(zon) printf("\t%f", Z[i]); + printf("\n"); + } + if(poly){ + printf("\nPolynomial coefficients\n#\tcoeff\n"); + for(i = 0; i < Npoly; ++i) printf("%d\t%f\n", i, poly[i]); + } + FREE(XR); FREE(YR); FREE(XC); FREE(YC); FREE(W); FREE(D); FREE(flag); + FREE(I); + FREE(Z); FREE(poly); + //printf("next 4474:\n"); + //hexdump(fd, 4474); + printf("next 1346:\n"); + hexdump(fd, 1346); + off_t blkend = lseek(fd, 0, SEEK_CUR); + printf("Block length: %zd, ZH length: %zd\n", blkend - blkstart, blkend - zhstart); +/* printf("starting of next ZHistory\nzeros: \n"); + hexdump(fd, 37*8); + printf("CurrentNumberOfPolynomials: "); + hexdump(fd, 4);*/ +} diff --git a/wfs_read/readwfs.h b/wfs_read/readwfs.h new file mode 100644 index 0000000..d01d1ad --- /dev/null +++ b/wfs_read/readwfs.h @@ -0,0 +1,149 @@ +/* + * wfsparams.h + * + * Copyright 2016 Edward V. Emelianov + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ +#pragma once +#ifndef __WFSPARAMS_H__ +#define __WFSPARAMS_H__ + +#include + +#pragma pack(push, 4) +typedef struct{ + double SystemInputPupilM; + double WLength; // wavelength in meters + double SysFocusLength; + double SysRefraction; + double Pix2WF; // coefficient of spots' shift reduction into wavefront tilts + double Pix2Meter; // sensor's pixel size in meters + double LensD; // distance between lenses in lenslet (pixels) + int32_t W, H; // sensor's size (pixels) + int32_t bPreEstimate; + double dPupilShift; + int32_t iReserved2; + int32_t SystemOutputPupilP; // in meters + double XDir; // camera mirrored by X? (1 or -1) + uint32_t Version; + double YDir; // camera mirrored by Y? (1 or -1) + int32_t iReserved3_3[3]; + double dReserved4; + int32_t iReserved4_2[2]; + int32_t NumberOfPolynomials; + int32_t iLensletGeometry; // lenslet geometry: 8 - square, 6 - hexagonal, 4 - rombus + int32_t Afocal; // TRUE for afocal system + double LensletFocusLength; // in meters + int32_t iTRelay; // WTF? + double ScaleFactor; + int32_t WellDepth; // in electrons + int8_t reserved_[20]; // added for compatibility with M$W +} Sparam; + +enum eDummy {eDummyNone = 0}; + +typedef struct _SYSTEMTIME { + uint16_t wYear; + uint16_t wMonth; + uint16_t wDayOfWeek; + uint16_t wDay; + uint16_t wHour; + uint16_t wMinute; + uint16_t wSecond; + uint16_t wMilliseconds; +} SYSTEMTIME; + +typedef struct { + int8_t MeasurementID[1024]; + uint8_t Dummy; + double Dummy1; + double Dummy2; + double Dummy3; + int8_t Reserved1[2048]; + double Dummy4; + int8_t Dummy5; + int32_t Reserved2_2[2]; + double Dummy6; + double Reserved3; + int8_t bReserved4; + double Reserved5; + SYSTEMTIME DateTime; + double Dummy7; + double Dummy8; + int8_t Dummy9; + int64_t Reserved6; +} Mparam; + +typedef struct { + int32_t NSpots; + union { + struct { + int32_t ux, uy, ur; // unitary circle center & radius + int32_t ax, ay, ar; // measurement area -//- ar == 0 - rectangle, ar < 0 - inverted (outside this radius) + } C; + struct { + int32_t x, y, a, w, h; // rectangle area center, rotation angle, width and height + } R; + }; + int32_t pointers[6]; //uint8_t *ucpReserved2; + uint32_t ucpReserved2; + int8_t bReserved3; + //int8_t Reserved4[256]; + int8_t Reserved4[258]; +} Hhistory; + +typedef struct{ + double loPolynomials[37]; // if amount of poly <37, they are stored here + int32_t CurrentNumberOfPolynomials; + double Sphere, Cylinder, Axis; // approximate sphere & astigmatism in dptr/degrees + double ADiameter; // measurement circle diameter in meters + int32_t Time; // time from measurement starts (ms) + double Reserved3_1[3]; + uint8_t PolynomialSet; // 0 - Fringe, 1 - Born/Wolf, 2 - OSA , 4 - Ring + double Reserved3_2[3]; + Hhistory h; + double sx, sy, sr; // center & beam radius calculated by S-H (meters) + double UDiameter; // diameter of unitary circle (meters) + int32_t pfReserved3; // float* + int32_t iReserved4; + uint8_t bReserved5_6[6]; + int32_t pdReserved6; // double* + int8_t bBad; // == true if current image bad + int8_t bZRW; // == true if wavefront was reconstructed by zonal method + int32_t pReserved7; // float* + double chi2; + long double time_mcsec; // time from beginning of measurement, mks + int8_t reserved_[74]; // added for compatibility with M$W + uint8_t zhend[0]; +} Zhistory; + +typedef struct{ + uint32_t Zhistory_sz; + uint32_t Hhistory_sz; + uint32_t Sparam_sz; + Sparam sparam; + uint32_t Mparam_sz; + Mparam mparam; + int32_t History_len; +} WFS_header; +#pragma pack(pop) + +int test_wfs_file(int fd); +void print_table(Zhistory *hist, int fd); +Zhistory *show_zhistry(int fd); + +#endif // __WFSPARAMS_H__ diff --git a/wfs_read/usefull_macros.c b/wfs_read/usefull_macros.c new file mode 100644 index 0000000..5eb9e7b --- /dev/null +++ b/wfs_read/usefull_macros.c @@ -0,0 +1,371 @@ +/* + * usefull_macros.h - a set of usefull functions: memory, color etc + * + * Copyright 2013 Edward V. Emelianoff + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ + +#include "usefull_macros.h" + +/** + * function for different purposes that need to know time intervals + * @return double value: time in seconds + */ +double dtime(){ + double t; + struct timeval tv; + gettimeofday(&tv, NULL); + t = tv.tv_sec + ((double)tv.tv_usec)/1e6; + return t; +} + +/******************************************************************************\ + * Coloured terminal +\******************************************************************************/ +int globErr = 0; // errno for WARN/ERR + +// pointers to coloured output printf +int (*red)(const char *fmt, ...); +int (*green)(const char *fmt, ...); +int (*_WARN)(const char *fmt, ...); + +/* + * format red / green messages + * name: r_pr_, g_pr_ + * @param fmt ... - printf-like format + * @return number of printed symbols + */ +int r_pr_(const char *fmt, ...){ + va_list ar; int i; + printf(RED); + va_start(ar, fmt); + i = vprintf(fmt, ar); + va_end(ar); + printf(OLDCOLOR); + return i; +} +int g_pr_(const char *fmt, ...){ + va_list ar; int i; + printf(GREEN); + va_start(ar, fmt); + i = vprintf(fmt, ar); + va_end(ar); + printf(OLDCOLOR); + return i; +} +/* + * print red error/warning messages (if output is a tty) + * @param fmt ... - printf-like format + * @return number of printed symbols + */ +int r_WARN(const char *fmt, ...){ + va_list ar; int i = 1; + fprintf(stderr, RED); + va_start(ar, fmt); + if(globErr){ + errno = globErr; + vwarn(fmt, ar); + errno = 0; + globErr = 0; + }else + i = vfprintf(stderr, fmt, ar); + va_end(ar); + i++; + fprintf(stderr, OLDCOLOR "\n"); + return i; +} + +static const char stars[] = "****************************************"; +/* + * notty variants of coloured printf + * name: s_WARN, r_pr_notty + * @param fmt ... - printf-like format + * @return number of printed symbols + */ +int s_WARN(const char *fmt, ...){ + va_list ar; int i; + i = fprintf(stderr, "\n%s\n", stars); + va_start(ar, fmt); + if(globErr){ + errno = globErr; + vwarn(fmt, ar); + errno = 0; + globErr = 0; + }else + i = +vfprintf(stderr, fmt, ar); + va_end(ar); + i += fprintf(stderr, "\n%s\n", stars); + i += fprintf(stderr, "\n"); + return i; +} +int r_pr_notty(const char *fmt, ...){ + va_list ar; int i; + i = printf("\n%s\n", stars); + va_start(ar, fmt); + i += vprintf(fmt, ar); + va_end(ar); + i += printf("\n%s\n", stars); + return i; +} + +/** + * Run this function in the beginning of main() to setup locale & coloured output + */ +void initial_setup(){ + // setup coloured output + if(isatty(STDOUT_FILENO)){ // make color output in tty + red = r_pr_; green = g_pr_; + }else{ // no colors in case of pipe + red = r_pr_notty; green = printf; + } + if(isatty(STDERR_FILENO)) _WARN = r_WARN; + else _WARN = s_WARN; + // Setup locale + setlocale(LC_ALL, ""); + setlocale(LC_NUMERIC, "C"); +#if defined GETTEXT_PACKAGE && defined LOCALEDIR + bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR); + textdomain(GETTEXT_PACKAGE); +#endif +} + +/******************************************************************************\ + * Memory +\******************************************************************************/ +/* + * safe memory allocation for macro ALLOC + * @param N - number of elements to allocate + * @param S - size of single element (typically sizeof) + * @return pointer to allocated memory area + */ +void *my_alloc(size_t N, size_t S){ + void *p = calloc(N, S); + if(!p) ERR("malloc"); + //assert(p); + return p; +} + +/** + * Mmap file to a memory area + * + * @param filename (i) - name of file to mmap + * @return stuct with mmap'ed file or die + */ +mmapbuf *My_mmap(char *filename){ + int fd; + char *ptr; + size_t Mlen; + struct stat statbuf; + /// "Не задано имя файла!" + if(!filename){ + WARNX(_("No filename given!")); + return NULL; + } + if((fd = open(filename, O_RDONLY)) < 0){ + /// "Не могу открыть %s для чтения" + WARN(_("Can't open %s for reading"), filename); + return NULL; + } + if(fstat (fd, &statbuf) < 0){ + /// "Не могу выполнить stat %s" + WARN(_("Can't stat %s"), filename); + close(fd); + return NULL; + } + Mlen = statbuf.st_size; + if((ptr = mmap (0, Mlen, PROT_READ, MAP_PRIVATE, fd, 0)) == MAP_FAILED){ + /// "Ошибка mmap" + WARN(_("Mmap error for input")); + close(fd); + return NULL; + } + /// "Не могу закрыть mmap'нутый файл" + if(close(fd)) WARN(_("Can't close mmap'ed file")); + mmapbuf *ret = MALLOC(mmapbuf, 1); + ret->data = ptr; + ret->len = Mlen; + return ret; +} + +void My_munmap(mmapbuf *b){ + if(munmap(b->data, b->len)){ + /// "Не могу munmap" + ERR(_("Can't munmap")); + } + FREE(b); +} + + +/******************************************************************************\ + * Terminal in no-echo mode +\******************************************************************************/ +static struct termios oldt, newt; // terminal flags +static int console_changed = 0; +// run on exit: +void restore_console(){ + if(console_changed) + tcsetattr(STDIN_FILENO, TCSANOW, &oldt); // return terminal to previous state + console_changed = 0; +} + +// initial setup: +void setup_con(){ + if(console_changed) return; + tcgetattr(STDIN_FILENO, &oldt); + newt = oldt; + newt.c_lflag &= ~(ICANON | ECHO); + if(tcsetattr(STDIN_FILENO, TCSANOW, &newt) < 0){ + /// "Не могу настроить консоль" + WARN(_("Can't setup console")); + tcsetattr(STDIN_FILENO, TCSANOW, &oldt); + signals(0); //quit? + } + console_changed = 1; +} + +/** + * Read character from console without echo + * @return char readed + */ +int read_console(){ + int rb; + struct timeval tv; + int retval; + fd_set rfds; + FD_ZERO(&rfds); + FD_SET(STDIN_FILENO, &rfds); + tv.tv_sec = 0; tv.tv_usec = 10000; + retval = select(1, &rfds, NULL, NULL, &tv); + if(!retval) rb = 0; + else { + if(FD_ISSET(STDIN_FILENO, &rfds)) rb = getchar(); + else rb = 0; + } + return rb; +} + +/** + * getchar() without echo + * wait until at least one character pressed + * @return character readed + */ +int mygetchar(){ // getchar() without need of pressing ENTER + int ret; + do ret = read_console(); + while(ret == 0); + return ret; +} + + +/******************************************************************************\ + * TTY with select() +\******************************************************************************/ +static struct termio oldtty, tty; // TTY flags +static int comfd = -1; // TTY fd + +// run on exit: +void restore_tty(){ + if(comfd == -1) return; + ioctl(comfd, TCSANOW, &oldtty ); // return TTY to previous state + close(comfd); + comfd = -1; +} + +#ifndef BAUD_RATE +#define BAUD_RATE B9600 +#endif +// init: +void tty_init(char *comdev){ + DBG("\nOpen port...\n"); + if ((comfd = open(comdev,O_RDWR|O_NOCTTY|O_NONBLOCK)) < 0){ + WARN("Can't use port %s\n",comdev); + ioctl(comfd, TCSANOW, &oldtty); // return TTY to previous state + close(comfd); + signals(0); // quit? + } + DBG(" OK\nGet current settings... "); + if(ioctl(comfd,TCGETA,&oldtty) < 0){ // Get settings + /// "Не могу получить настройки" + WARN(_("Can't get settings")); + signals(0); + } + tty = oldtty; + tty.c_lflag = 0; // ~(ICANON | ECHO | ECHOE | ISIG) + tty.c_oflag = 0; + tty.c_cflag = BAUD_RATE|CS8|CREAD|CLOCAL; // 9.6k, 8N1, RW, ignore line ctrl + tty.c_cc[VMIN] = 0; // non-canonical mode + tty.c_cc[VTIME] = 5; + if(ioctl(comfd,TCSETA,&tty) < 0){ + /// "Не могу установить настройки" + WARN(_("Can't set settings")); + signals(0); + } + DBG(" OK\n"); +} +/** + * Read data from TTY + * @param buff (o) - buffer for data read + * @param length - buffer len + * @return amount of readed bytes + */ +size_t read_tty(uint8_t *buff, size_t length){ + ssize_t L = 0; + fd_set rfds; + struct timeval tv; + int retval; + FD_ZERO(&rfds); + FD_SET(comfd, &rfds); + tv.tv_sec = 0; tv.tv_usec = 50000; // wait for 50ms + retval = select(comfd + 1, &rfds, NULL, NULL, &tv); + if (!retval) return 0; + if(FD_ISSET(comfd, &rfds)){ + if((L = read(comfd, buff, length)) < 1) return 0; + } + return (size_t)L; +} + +int write_tty(uint8_t *buff, size_t length){ + ssize_t L = write(comfd, buff, length); + if((size_t)L != length){ + /// "Ошибка записи!" + WARN("Write error!"); + return 1; + } + return 0; +} + + +/** + * Safely convert data from string to double + * + * @param num (o) - double number read from string + * @param str (i) - input string + * @return 1 if success, 0 if fails + */ +int str2double(double *num, const char *str){ + double res; + char *endptr; + if(!str) return 0; + res = strtod(str, &endptr); + if(endptr == str || *str == '\0' || *endptr != '\0'){ + /// "Неправильный формат числа double!" + WARNX("Wrong double number format!"); + return FALSE; + } + if(num) *num = res; // you may run it like myatod(NULL, str) to test wether str is double number + return TRUE; +} diff --git a/wfs_read/usefull_macros.h b/wfs_read/usefull_macros.h new file mode 100644 index 0000000..5f80b9f --- /dev/null +++ b/wfs_read/usefull_macros.h @@ -0,0 +1,138 @@ +/* + * usefull_macros.h - a set of usefull macros: memory, color etc + * + * Copyright 2013 Edward V. Emelianoff + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ + +#pragma once +#ifndef __USEFULL_MACROS_H__ +#define __USEFULL_MACROS_H__ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#if defined GETTEXT_PACKAGE && defined LOCALEDIR +/* + * GETTEXT + */ +#include +#define _(String) gettext(String) +#define gettext_noop(String) String +#define N_(String) gettext_noop(String) +#else +#define _(String) (String) +#define N_(String) (String) +#endif +#include +#include +#include +#include +#include +#include + + +// unused arguments with -Wall -Werror +#define _U_ __attribute__((__unused__)) + +/* + * Coloured messages output + */ +#define RED "\033[1;31;40m" +#define GREEN "\033[1;32;40m" +#define OLDCOLOR "\033[0;0;0m" + +#ifndef FALSE +#define FALSE (0) +#endif + +#ifndef TRUE +#define TRUE (1) +#endif + +/* + * ERROR/WARNING messages + */ +extern int globErr; +extern void signals(int sig); +#define ERR(...) do{globErr=errno; _WARN(__VA_ARGS__); signals(9);}while(0) +#define ERRX(...) do{globErr=0; _WARN(__VA_ARGS__); signals(9);}while(0) +#define WARN(...) do{globErr=errno; _WARN(__VA_ARGS__);}while(0) +#define WARNX(...) do{globErr=0; _WARN(__VA_ARGS__);}while(0) + +/* + * print function name, debug messages + * debug mode, -DEBUG + */ +#ifdef EBUG + #define FNAME() fprintf(stderr, "\n%s (%s, line %d)\n", __func__, __FILE__, __LINE__) + #define DBG(...) do{fprintf(stderr, "%s (%s, line %d): ", __func__, __FILE__, __LINE__); \ + fprintf(stderr, __VA_ARGS__); \ + fprintf(stderr, "\n");} while(0) +#else + #define FNAME() do{}while(0) + #define DBG(...) do{}while(0) +#endif //EBUG + +/* + * Memory allocation + */ +#define ALLOC(type, var, size) type * var = ((type *)my_alloc(size, sizeof(type))) +#define MALLOC(type, size) ((type *)my_alloc(size, sizeof(type))) +#define FREE(ptr) do{if(ptr){free(ptr); ptr = NULL;}}while(0) + +#ifndef DBL_EPSILON +#define DBL_EPSILON (2.2204460492503131e-16) +#endif + +double dtime(); + +// functions for color output in tty & no-color in pipes +extern int (*red)(const char *fmt, ...); +extern int (*_WARN)(const char *fmt, ...); +extern int (*green)(const char *fmt, ...); +void * my_alloc(size_t N, size_t S); +void initial_setup(); + +// mmap file +typedef struct{ + char *data; + size_t len; +} mmapbuf; +mmapbuf *My_mmap(char *filename); +void My_munmap(mmapbuf *b); + +void restore_console(); +void setup_con(); +int read_console(); +int mygetchar(); + +void restore_tty(); +void tty_init(char *comdev); +size_t read_tty(uint8_t *buff, size_t length); +int write_tty(uint8_t *buff, size_t length); + +int str2double(double *num, const char *str); + +#endif // __USEFULL_MACROS_H__ diff --git a/wfs_read/zernike.c b/wfs_read/zernike.c new file mode 100644 index 0000000..f19f53c --- /dev/null +++ b/wfs_read/zernike.c @@ -0,0 +1,132 @@ +/* + * zernike.c + * + * Copyright 2016 Edward V. Emelianov + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ + +#include +#include "zernike.h" +#include "usefull_macros.h" + +// coordinate step on a grid +static double coord_step = DEFAULT_CRD_STEP; +// default wavelength for wavefront (650nm) in meters +static double wavelength = DEFAULT_WAVELENGTH; +// default coefficient to transform vawefront from wavelengths into user value +static double wf_coeff = 1.; + +/** + * Set default coordinate grid step on an unity circle + * @param step - new step + * @return 0 if all OK, -1 or 1 if `step` bad + */ +int z_set_step(double step){ + if(step < DBL_EPSILON) return -1; + if(step > 1.) return 1; + coord_step = step; + return 0; +} + +double z_get_step(){ + return coord_step; +} + +/** + * Set value of default wavelength + * @param w - new wavelength (from 100nm to 10um) in meters, microns or nanometers + * @return 0 if all OK + */ +int z_set_wavelength(double w){ + if(w > 1e-7 && w < 1e-5) // meters + wavelength = w; + else if(w > 0.1 && w < 10.) // micron + wavelength = w * 1e-6; + else if(w > 100. && w < 10000.) // nanometer + wavelength = w * 1e-9; + else return 1; + return 0; +} + +double z_get_wavelength(){ + return wavelength; +} + +// thanks to http://stackoverflow.com/a/3875555/1965803 +typedef struct{ + double wf_coeff; + const char * const *units; +} wf_units; + +wf_units wfunits[] = { + { 1. , (const char * const []){"meter", "m", NULL}}, + {1e-3 , (const char * const []){"millimeter", "mm", NULL}}, + {1e-6 , (const char * const []){"micrometer", "um", "u", NULL}}, + {1e-9 , (const char * const []){"nanometer", "nm", "n", NULL}}, + {-1. , (const char * const []){"wavelength", "wave", "lambda", "w", "l", NULL}}, + {0. , (const char * const []){NULL}} +}; + +/** + * Set coefficient `wf_coeff` to user defined unit + */ +int z_set_wfunit(char *U){ + wf_units *u = wfunits; + while(u->units[0]){ + const char * const*unit = u->units; + while(*unit){ + if(strcasecmp(*unit, U) == 0){ + wf_coeff = u->wf_coeff; + if(wf_coeff < 0.){ // wavelengths + wf_coeff = 1.; // in wavelengths + }else{ // meters etc + wf_coeff = wavelength / wf_coeff; + } + printf("wf_coeff = %g\n", wf_coeff); + return 0; + } + ++unit; + } + ++u; + } + return 1; +} + +double z_get_wfcoeff(){ + return wf_coeff; +} + +/** + * Print all wf_units available + */ +void z_print_wfunits(){ + wf_units *u = wfunits; + printf(_("Unit (meters)\tAvailable values\n")); + do{ + const char * const*unit = u->units; + double val = u->wf_coeff; + if(val > 0.) + printf("%-8g\t", val); + else + printf("(wavelength)\t"); + do{ + printf("%s ", *unit); + }while(*(++unit)); + printf("\n"); + }while((++u)->units[0]); + printf("\n"); +} diff --git a/wfs_read/zernike.h b/wfs_read/zernike.h new file mode 100644 index 0000000..1e5cc25 --- /dev/null +++ b/wfs_read/zernike.h @@ -0,0 +1,43 @@ +/* + * zernike.h + * + * Copyright 2016 Edward V. Emelianov + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ +#pragma once +#ifndef __ZERNIKE_H__ +#define __ZERNIKE_H__ + +// default step in coordinate grid +#define DEFAULT_CRD_STEP (0.05) +// default wavefront unit: lambda +#define DEFAULT_WF_UNIT "lambda" +// default wavelength +#define DEFAULT_WAVELENGTH (0.65e-6) + +int z_set_step(double step); +double z_get_step(); + +int z_set_wavelength(double w); +double z_get_wavelength(); + +int z_set_wfunit(char *u); +double z_get_wfcoeff(); +void z_print_wfunits(); + + +#endif // __ZERNIKE_H__