Index: /tags/mana-1-3/Ohana/src/opihi/mana/Makefile =================================================================== --- /tags/mana-1-3/Ohana/src/opihi/mana/Makefile (revision 5936) +++ /tags/mana-1-3/Ohana/src/opihi/mana/Makefile (revision 5936) @@ -0,0 +1,56 @@ +include ../../../Configure + +HOME = $(ROOT)/src/opihi +BIN = $(HOME)/bin +LIB = $(HOME)/lib +INC = $(HOME)/include +SDIR = $(HOME)/mana +# +DESTBIN = $(LBIN) +DESTLIB = $(LLIB) +DESTINC = $(LINC) +DESTMAN = $(LMAN) +DESTHLP = $(LHLP)/mana +# +INCS = -I$(INC) -I$(LINC) -I$(XINC) +LFLAGS = -L$(LLIB) -L$(LIB) +LIBS1 = -lsocket -lnsl -lreadline -ltermcap -ldvo -lkapa -lFITS -lohana -lX11 -lm +LIBS2 = -lbasiccmd -ldatacmd -lastrocmd -lshell -ldata +LIBS = $(LIBS2) $(LIBS1) +CFLAGS = $(INCS) -DHELPDIR_DEFAULT=$(DESTHLP) +CCFLAGS = $(LIBS) + +# mana user commands and support functions ######################## + +manafuncs = \ +$(SDIR)/init.$(ARCH).o \ +$(SDIR)/mana.$(ARCH).o \ +$(SDIR)/findrowpeaks.$(ARCH).o + +manacmds = \ +$(SDIR)/rawstars.$(ARCH).o \ +$(SDIR)/fitcontour.$(ARCH).o \ +$(SDIR)/starcontour.$(ARCH).o \ +$(SDIR)/version.$(ARCH).o \ +$(SDIR)/findpeaks.$(ARCH).o + +mana = $(manacmds) $(manafuncs) + +libs = \ +$(DESTLIB)/libshell.a \ +$(DESTLIB)/libdata.a \ +$(DESTLIB)/libbasiccmd.a \ +$(DESTLIB)/libastrocmd.a \ +$(DESTLIB)/libdatacmd.a + +mana: $(BIN)/mana.$(ARCH) + +$(BIN)/mana.$(ARCH) : $(mana) $(libs) + +install: $(DESTBIN)/mana help + +help: cmd.basic.help cmd.data.help cmd.astro.help mana.help + +.PHONY: mana + +include ../Makefile.Common Index: /tags/mana-1-3/Ohana/src/opihi/mana/adc.c =================================================================== --- /tags/mana-1-3/Ohana/src/opihi/mana/adc.c (revision 5936) +++ /tags/mana-1-3/Ohana/src/opihi/mana/adc.c (revision 5936) @@ -0,0 +1,117 @@ +# include "dimm.h" + +# define DIGITAL_OUT 0x40 +# define ANALOG_IN_INIT 0x00 +# define ANALOG_IN_HIGH 0xa1 +# define ANALOG_IN_LOW 0x91 + +static char SerialConnected = FALSE; +static unsigned char DigitalOutState = 0x00; +static struct timeval reftime; +static char reftimeset = FALSE; + +# define DTIME(A,B) ((A.tv_sec - B.tv_sec) + 1e-6*(A.tv_usec - B.tv_usec)) + +int adc (int argc, char **argv) { + + struct timeval now; + int i, N, mode, hi, lo, value; + unsigned char setbit, output[5], *input; + double dtime; + + if (N = get_argument (argc, argv, "-reset")) { + remove_argument (N, &argc, argv); + gettimeofday (&reftime, (struct timeval *) NULL); + reftimeset = TRUE; + return (TRUE); + } + + if (argc != 4) { + fprintf (stderr, "USAGE: adc ai N (variable)\n"); + fprintf (stderr, "USAGE: adc di N (variable)\n"); + fprintf (stderr, "USAGE: adc do N mode\n"); + return (FALSE); + } + + if (!SerialConnected) { + if (!SerialInit ('b')) { + fprintf (stderr, "error opening serial line\n"); + return (FALSE); + } + SerialConnected = TRUE; + } + + if (!reftimeset) { + gettimeofday (&reftime, (struct timeval *) NULL); + reftimeset = TRUE; + } + + gettimeofday (&now, (struct timeval *) NULL); + dtime = DTIME (now, reftime); + set_variable ("TIME", dtime); + + /* set the digital outputs */ + if (!strcmp (argv[1], "do")) { + N = atof (argv[2]); + if ((N < 1) || (N > 6)) { + fprintf (stderr, "digital output is between 1 and 6\n"); + return (FALSE); + } + if (!strcasecmp (argv[3], "on")) { + mode = TRUE; + } else { + mode = FALSE; + } + setbit = (0x01 << N-1); + if (mode) { + DigitalOutState |= setbit; + } else { + DigitalOutState &= ~setbit; + } + output[0] = (DIGITAL_OUT | DigitalOutState); + output[1] = 0; + SerialCommand (output, &input, 50); + fprintf (stderr, "%x (%x, %x) -> %x (%d, %d)\n", + output[0], setbit, DigitalOutState, input[0], + strlen(input), strlen(output)); + free (input); + return (TRUE); + } + /* read the analog inputs */ + if (!strcmp (argv[1], "ai")) { + N = atof (argv[2]); + if ((N < 2) || (N > 16)) { + fprintf (stderr, "analog input is between 2 and 16\n"); + fprintf (stderr, " (problem with 1 for the moment...)\n"); + return (FALSE); + } + /* init A/D converter */ + output[0] = (ANALOG_IN_INIT | (N-1)); + output[1] = 0; + SerialCommand (output, &input, 50); + free (input); + + usleep (10000); + /* get high byte */ + output[0] = ANALOG_IN_HIGH; + output[1] = 0; + do { + SerialCommand (output, &input, 50); + hi = input[0]; + free (input); + } while (hi & 0x80); + + output[0] = ANALOG_IN_LOW; + output[1] = 0; + SerialCommand (output, &input, 50); + /* fprintf (stderr, "%x -> %x\n", output[0], input[0]); */ + lo = input[0]; + free (input); + value = ((hi & 0x0f) << 8) | lo; + if (hi & 0x10) { value = -value; } + set_variable (argv[3], 0.0001*value); + return (TRUE); + } + + +} Index: /tags/mana-1-3/Ohana/src/opihi/mana/demux.c =================================================================== --- /tags/mana-1-3/Ohana/src/opihi/mana/demux.c (revision 5936) +++ /tags/mana-1-3/Ohana/src/opihi/mana/demux.c (revision 5936) @@ -0,0 +1,72 @@ +# include "dimm.h" + +int demux (int argc, char **argv) { + + int i, j, k, N; + float *out, *in, *inptr, **outptr; + int nx, ny, Nx, Ny, NX, NY, Nmux, Nbuf; + + if (argc != 4) { + fprintf (stderr, "USAGE: demux nx ny\n"); + return (FALSE); + } + + if (!SelectBuffer (&Nbuf, argv[1], OLDBUFFER)) return (FALSE); + + nx = atof (argv[2]); + ny = atof (argv[3]); + Nmux = nx*ny; + + Nx = buffers[Nbuf].matrix.Naxis[0]; + Ny = buffers[Nbuf].matrix.Naxis[1]; + + NX = Nx / nx; + NY = Ny / ny; + + inptr = in = (float *) buffers[Nbuf].matrix.buffer; /* don't lose reference */ + + ALLOCATE (out, float, Nx*Ny); + ALLOCATE (outptr, float *, Nmux); + + for (N = i = 0; i < nx; i++) { + for (j = 0; j < ny; j++, N++) { + outptr[N] = &out[i*NX + j*NX*NY*nx]; + } + } + + for (N = j = 0; j < NY; j++) { + for (i = 0; i < NX; i++) { + for (k = 0; k < Nmux; k++) { + *outptr[k] = *inptr; + outptr[k] ++; + inptr ++; + } + } + for (k = 0; k < Nmux; k++) outptr[k] += NX; + } + + /* + for (X = Y = x = y = i = 0; i < NX*NY; i++) { + out[X + Y*NX + x*NX*(Y+1) + y*NX*NY*nx] = *in; + X++; + if (X == NX) { + X = 0; + Y++; + } + if (Y == NY) { + Y = 0; + x++; + } + if (x == nx) { + x = 0; + y++; + } + } + */ + + free (in); + buffers[Nbuf].matrix.buffer = (char *) out; + + return (TRUE); +} + Index: /tags/mana-1-3/Ohana/src/opihi/mana/findpeaks.c =================================================================== --- /tags/mana-1-3/Ohana/src/opihi/mana/findpeaks.c (revision 5936) +++ /tags/mana-1-3/Ohana/src/opihi/mana/findpeaks.c (revision 5936) @@ -0,0 +1,106 @@ +# include "mana.h" + +int findpeaks (int argc, char **argv) { + + int i, j, n, N, Nx, Ny; + int xo, yo; + int Npeak, NPEAK, Npeaks; + float *v; + int *peaks, *keep, *xp, *yp, *zp; + float threshold, vt, vo; + Vector *vecx, *vecy, *vecz; + Buffer *buf; + + if (argc < 3) goto usage; + + if ((buf = SelectBuffer (argv[1], OLDBUFFER, TRUE)) == NULL) return (FALSE); + threshold = atof (argv[2]); + + if ((vecx = SelectVector ("xp", ANYVECTOR, TRUE)) == NULL) return (FALSE); + if ((vecy = SelectVector ("yp", ANYVECTOR, TRUE)) == NULL) return (FALSE); + if ((vecz = SelectVector ("zp", ANYVECTOR, TRUE)) == NULL) return (FALSE); + + Nx = buf[0].matrix.Naxis[0]; + Ny = buf[0].matrix.Naxis[1]; + + Npeak = 0; + NPEAK = Nx; + ALLOCATE (xp, int, NPEAK); + ALLOCATE (yp, int, NPEAK); + ALLOCATE (zp, int, NPEAK); + + /* find peaks for each row */ + v = (float *) buf[0].matrix.buffer; + for (j = 0; j < Ny; j++) { + peaks = findrowpeaks (&v[j*Nx], Nx, threshold, &Npeaks); + + if (Npeak + Npeaks >= NPEAK) { + NPEAK = Npeak + Npeaks + Nx; + REALLOCATE (xp, int, NPEAK); + REALLOCATE (yp, int, NPEAK); + REALLOCATE (zp, int, NPEAK); + } + for (i = 0; i < Npeaks; i++) { + xp[Npeak + i] = peaks[i]; + yp[Npeak + i] = j; + zp[Npeak + i] = v[peaks[i] + j*Nx]; + } + Npeak += Npeaks; + free (peaks); + } + + /* identify non-local peaks */ + ALLOCATE (keep, int, MAX (Npeak, 1)); + v = (float *) buf[0].matrix.buffer; + for (n = 0; n < Npeak; n++) { + xo = xp[n]; + yo = yp[n]; + vo = v[xo + yo*Nx]; + keep[n] = TRUE; + for (i = xo - 1; i <= xo + 1; i++) { + if (i < 0) continue; + if (i >= Nx) continue; + for (j = yo - 1; j <= yo + 1; j++) { + if ((i == xo) && (j == yo)) continue; + if (j < 0) continue; + if (j >= Ny) continue; + vt = v[i + j*Nx]; + if (vt > vo) { + keep[n] = FALSE; + goto next_peak; + } + } + } + next_peak: + continue; + } + + REALLOCATE (vecx[0].elements, float, MAX (Npeak, 1)); + REALLOCATE (vecy[0].elements, float, MAX (Npeak, 1)); + REALLOCATE (vecz[0].elements, float, MAX (Npeak, 1)); + /* eliminate non-local peaks */ + for (N = n = 0; n < Npeak; n++) { + if (!keep[n]) continue; + vecx[0].elements[N] = xp[n]; + vecy[0].elements[N] = yp[n]; + vecz[0].elements[N] = zp[n]; + N ++; + } + free (xp); + free (yp); + free (zp); + free (keep); + + REALLOCATE (vecx[0].elements, float, MAX (N, 1)); + REALLOCATE (vecy[0].elements, float, MAX (N, 1)); + REALLOCATE (vecz[0].elements, float, MAX (N, 1)); + vecx[0].Nelements = vecy[0].Nelements = vecz[0].Nelements = N; + + return (TRUE); + + usage: + fprintf (stderr, "findpeaks (buffer) (threshold)\n"); + return (FALSE); +} + + Index: /tags/mana-1-3/Ohana/src/opihi/mana/findrowpeaks.c =================================================================== --- /tags/mana-1-3/Ohana/src/opihi/mana/findrowpeaks.c (revision 5936) +++ /tags/mana-1-3/Ohana/src/opihi/mana/findrowpeaks.c (revision 5936) @@ -0,0 +1,45 @@ +# include "mana.h" + +int *findrowpeaks (float *row, int Nrow, float threshold, int *npeaks) { + + int i; + int Npeaks, NPEAKS; + int *peaks; + + Npeaks = 0; + NPEAKS = 100; + ALLOCATE (peaks, int, NPEAKS); + + if (Nrow < 3) { + *npeaks = Npeaks; + return (peaks); + } + + /* special case for first pixel in row */ + if ((row[0] > row[1]) && (row[0] > threshold)) { + peaks[Npeaks] = 0; + Npeaks ++; + } + + for (i = 1; i < Nrow - 1; i++) { + if (row[i] < threshold) continue; + if (row[i] < row[i-1]) continue; + if (row[i] <= row[i+1]) continue; + + peaks[Npeaks] = i; + Npeaks ++; + if (Npeaks >= NPEAKS) { + NPEAKS += 100; + REALLOCATE (peaks, int, NPEAKS); + } + } + + /* special case for last pixel in row */ + if ((row[Nrow-1] >= row[Nrow-2]) && (row[Nrow-1] > threshold)) { + peaks[Npeaks] = Nrow-1; + Npeaks ++; + } + + *npeaks = Npeaks; + return (peaks); +} Index: /tags/mana-1-3/Ohana/src/opihi/mana/fitcontour.c =================================================================== --- /tags/mana-1-3/Ohana/src/opihi/mana/fitcontour.c (revision 5936) +++ /tags/mana-1-3/Ohana/src/opihi/mana/fitcontour.c (revision 5936) @@ -0,0 +1,139 @@ +# include "mana.h" +# define NTERM 3 + +int fitcontour (int argc, char **argv) { + + int i; + double **C, **B; + float cs1, sn1, cs, sn, x, y, r, xo, yo; + float dR, Rmin, Rmaj, Theta, Rx, Ry, Rxy, R1, R2, R3; + Vector *vecx, *vecy; + + /* USAGE fitcontour x y Xo Yo */ + if (argc < 5) goto usage; + + if ((vecx = SelectVector (argv[1], ANYVECTOR, TRUE)) == NULL) return (FALSE); + if ((vecy = SelectVector (argv[2], ANYVECTOR, TRUE)) == NULL) return (FALSE); + xo = atof (argv[3]); + yo = atof (argv[4]); + + ALLOCATE (B, double *, NTERM); + ALLOCATE (C, double *, NTERM); + for (i = 0; i < NTERM; i++) { + ALLOCATE (C[i], double, NTERM); + bzero (C[i], NTERM*sizeof(double)); + ALLOCATE (B[i], double, 1); + bzero (B[i], sizeof(double)); + } + + /* we are fitting r = ro + rs*sin(2theta) + rc*cos(2theta) */ + /* sin(2t) = 2cos(t)sin(t) + cos(2t) = cos^2(t) - sin^2(t) + */ + for (i = 0; i < vecx[0].Nelements; i++) { + x = vecx[0].elements[i] - xo; + y = vecy[0].elements[i] - yo; + r = hypot (x, y); + + /* calculate sin(2t), cos(2t) using 1/2 angle tri relationship above */ + sn1 = y / r; + cs1 = x / r; + sn = 2*sn1*cs1; + cs = cs1*cs1 - sn1*sn1; + + C[0][0] += 1.0; + C[1][0] += sn; + C[1][1] += SQ(sn); + C[2][0] += cs; + C[2][1] += cs*sn; + C[2][2] += SQ(cs); + + B[0][0] += r; + B[1][0] += r*sn; + B[2][0] += r*cs; + } + C[0][1] = C[1][0]; + C[0][2] = C[2][0]; + C[1][2] = C[2][1]; + + gaussj (C, NTERM, B, 1); + + /** this is somewhat weak: if the object is too elongated, Rmin can be < 0 **/ + dR = hypot (B[1][0], B[2][0]); + Rmaj = B[0][0] + dR; + Rmin = B[0][0] - dR; + Theta = DEG_RAD*atan2 (B[1][0], B[2][0]) / 2; + + sn = B[1][0] / dR; + cs = B[2][0] / dR; + + R1 = SQ(Rmaj) + SQ(Rmin); + R2 = SQ(Rmaj) - SQ(Rmin); + R3 = Rmaj*Rmin; + + Rx = R3 / sqrt (R1 - R2*cs); + Ry = R3 / sqrt (R1 + R2*cs); + Rxy = -sn*R2 / SQ(R3); + + set_variable ("Rx", Rx); + set_variable ("Ry", Ry); + set_variable ("Rxy", Rxy); + + set_variable ("Rmin", Rmin); + set_variable ("Rmaj", Rmaj); + set_variable ("Theta", Theta); + + for (i = 0; i < NTERM; i++) { + free (B[i]); + free (C[i]); + } + free (B); + free (C); + + return (TRUE); + + usage: + fprintf (stderr, "fitcontour x y (xo) (yo)\n"); + return (FALSE); +} + + +/* this routine fits a single sine and cosine to the value of dr as a function of the angle around the central + * point, theta. this is NOT an exact fit, an is increasingly in error for more eccentric ellipses. however, + * it does a reasonable job of approximating the value of the major and minor axes, and it gets the angle of + * orientation right at well. We then assume the values of major and minor axis and angle are correct to get + * the parameters for the elliptical gaussian fit: + + z = (x^2) / (2 Rx^2) + (y^2) / (2 Ry^2) + Rxy x y + + the functions above give the correct relationship between these: + + R1 = SQ(Rmaj) + SQ(Rmin); + R2 = SQ(Rmaj) - SQ(Rmin); + R3 = Rmaj*Rmin; + + Rx = R3 / sqrt (R1 - R2*cs); + Ry = R3 / sqrt (R1 + R2*cs); + Rxy = -sn*R2 / SQ(R3); + + to derive these relationships, write the equation for an ellipse with major axis in the x-dir and minor in + the y-dir: + + z = (x^2) / (2 Rmaj^2) + (y^2) / (2 Rmin^2) + + apply the rotation matrix: + + (x)' = (cos, -sin)(x,y) + (y)' = (sin, +cos)(x,y) (modulo the sign on the sine) + + then group the x^2 terms, the y^2 terms, and the xy terms to find the three coeffs. + + NOTE: I spent a while having trouble deriving this from the polar form of an ellipse: + + x = Rmaj*cos(theta) + y = Rmin*sin(theta) + + it turns out that 'theta' above is NOT the angle (0,1)-(0,0)-(x,y). rather, it should be viewed as a + paraterization of the ellipse. + +*/ Index: /tags/mana-1-3/Ohana/src/opihi/mana/focus.c =================================================================== --- /tags/mana-1-3/Ohana/src/opihi/mana/focus.c (revision 5936) +++ /tags/mana-1-3/Ohana/src/opihi/mana/focus.c (revision 5936) @@ -0,0 +1,68 @@ +# include "dimm.h" + +int focus (int argc, char **argv) { + + if (argc < 2) goto usage; + + if (!strcasecmp (argv[1], "init")) { + if (argc != 3) { + fprintf (stderr, "USAGE: focus init (port)\n"); + return (FALSE); + } + if (!SerialInit (argv[2])) return (FALSE); + fprintf (stderr, "focus on port %s\n", argv[2]); + return (TRUE); + } + + if (!strcasecmp (argv[1], "pos")) { + + int status, servo, angle; + char *answer = (char *) NULL; + char line[64]; + + if (argc != 4) { + fprintf (stderr, "USAGE: focus pos Nservo (angle)\n"); + return (FALSE); + } + + servo = atoi (argv[2]); + angle = atoi (argv[3]); + + sprintf (line, "%c%c%c\n", 0xff, servo, angle); + status = SerialCommand (line, &answer, 10); + fprintf (stderr, "status: %d\n", status); + if (answer != (char *) NULL) { + fprintf (stderr, "answer: ..%s..\n", answer); + } + return (TRUE); + } + + if (!strcasecmp (argv[1], "raw")) { + + int status, value; + char *answer = (char *) NULL; + char line[64]; + + if (argc != 3) { + fprintf (stderr, "USAGE: focus raw value\n"); + return (FALSE); + } + + value = atoi (argv[2]); + + sprintf (line, "%c", value); + status = SerialCommand (line, &answer, 10); + fprintf (stderr, "status: %d\n", status); + if (answer != (char *) NULL) { + fprintf (stderr, "answer: ..%s..\n", answer); + } + return (TRUE); + } + + usage: + fprintf (stderr, "focus init port\n"); + fprintf (stderr, "focus pos (string)\n"); + fprintf (stderr, "focus raw (value)\n"); + return (FALSE); +} + Index: /tags/mana-1-3/Ohana/src/opihi/mana/init.c =================================================================== --- /tags/mana-1-3/Ohana/src/opihi/mana/init.c (revision 5936) +++ /tags/mana-1-3/Ohana/src/opihi/mana/init.c (revision 5936) @@ -0,0 +1,25 @@ +# include "opihi.h" + +int findpeaks PROTO((int, char **)); +int fitcontour PROTO((int, char **)); +int starcontour PROTO((int, char **)); +int rawstars PROTO((int, char **)); +int version PROTO((int, char **)); + +static Command cmds[] = { + {"findpeaks", findpeaks, "find image peaks"}, + {"fitcontour", fitcontour, "fit ellipse contour"}, + {"starcontour", starcontour, "object contour"}, + {"rawstars", rawstars, "find raw star stats"}, + {"version", version, "show version information"}, +}; + +void InitMana () { + + int i; + + for (i = 0; i < sizeof (cmds) / sizeof (Command); i++) { + AddCommand (&cmds[i]); + } + +} Index: /tags/mana-1-3/Ohana/src/opihi/mana/mana.c =================================================================== --- /tags/mana-1-3/Ohana/src/opihi/mana/mana.c (revision 5936) +++ /tags/mana-1-3/Ohana/src/opihi/mana/mana.c (revision 5936) @@ -0,0 +1,45 @@ +# include "mana.h" + +# define opihi_name "MANA" +# define opihi_prompt "mana: " +# define opihi_description "an image manipulation tool\n" +# define opihi_history ".mana" +# define opihi_rcfile ".manarc" + +/* program-dependent initialization */ +void program_init (int *argc, char **argv) { + + auto_break = TRUE; + + /* load the commands used by this implementation */ + InitBasic (); + InitData (); + InitAstro (); + InitMana (); + + rl_readline_name = opihi_name; + rl_attempted_completion_function = command_completer; + + set_str_variable ("HISTORY", opihi_history); + set_str_variable ("PROMPT", opihi_prompt); + set_str_variable ("RCFILE", opihi_rcfile); + +# ifdef HELPDIR_DEFAULT + set_str_variable ("HELPDIR", MACRO_NAME(HELPDIR_DEFAULT)); +# endif + + return; +} + +/* standard welcome message */ +void welcome () { + fprintf (stderr, "\n"); + fprintf (stderr, "Welcome to %s - %s\n\n", opihi_name, opihi_description); +} + +/* add program-dependent exit functions here */ +void cleanup () { + QuitImage (); + QuitGraph (); + return; +} Index: /tags/mana-1-3/Ohana/src/opihi/mana/opihi.c =================================================================== --- /tags/mana-1-3/Ohana/src/opihi/mana/opihi.c (revision 5936) +++ /tags/mana-1-3/Ohana/src/opihi/mana/opihi.c (revision 5936) @@ -0,0 +1,74 @@ +# include "opihi.h" + +# define opihi_name "Opihi" +# define opihi_prompt "opihi: " +# define opihi_description "Opihi - test shell\n" +# define opihi_history ".opihi" +# define opihi_rcfile ".opihirc" + +void InitBasic (); + +void welcome () { + fprintf (stderr, "\n"); + fprintf (stderr, "Welcome to %s - %s\n\n", opihi_name, opihi_description); +} + +/* program-dependent initialization */ +void initialize (int argc, char **argv) { + + FILE *f; + + auto_break = TRUE; + + Nlists = 0; + ALLOCATE (lists, List, 1); + + /* init functions required by libraries */ + /* -libopihi */ + InitCommands (); + InitMacros (); + InitBuffers (); + InitVectors (); + InitVariables (); + + /* -libdisplay + InitGraph (); + InitImage (); */ + + /* load the commands used by this implementation */ + InitBasic (); + InitOutfile (); + + rl_readline_name = opihi_name; + rl_attempted_completion_function = command_completer; + + set_str_variable ("HISTORY", opihi_history); + set_str_variable ("PROMPT", opihi_prompt); + set_str_variable ("RCFILE", opihi_rcfile); + + /* here we open the history file for append. it this fails, we + won't be able to write to it, warn the user. otherwise, this + creates the file readline will write to, if it did not exist */ + + /* check history file */ + /* rewrite with fstat or stat */ + f = fopen (opihi_history, "a"); + if (f == NULL) /* no current history file here */ + fprintf (stderr, "can't save history.\n"); + else + fclose (f); + + stifle_history (200); + read_history (opihi_history); + + signal (SIGINT, SIG_IGN); + return; +} + +/* add program-dependent exit functions here */ +void cleanup () { + /* -libdisplay + QuitImage (); + QuitGraph (); */ + return; +} Index: /tags/mana-1-3/Ohana/src/opihi/mana/rawstars.c =================================================================== --- /tags/mana-1-3/Ohana/src/opihi/mana/rawstars.c (revision 5936) +++ /tags/mana-1-3/Ohana/src/opihi/mana/rawstars.c (revision 5936) @@ -0,0 +1,95 @@ +# include "mana.h" + +int rawstars (int argc, char **argv) { + + int i, x, y, N, Nx, Ny, Np; + float *v; + double Raper, Rinner, Router; + Vector *xp, *yp; + Vector *xc, *yc, *sx, *sy, *sxy, *zs, *zc, *sk; + Buffer *buff; + + Raper = 5; + if ((N = get_argument (argc, argv, "-Raper"))) { + remove_argument (N, &argc, argv); + Raper = atof (argv[N]); + remove_argument (N, &argc, argv); + } + Rinner = 10; + if ((N = get_argument (argc, argv, "-Rinner"))) { + remove_argument (N, &argc, argv); + Rinner = atof (argv[N]); + remove_argument (N, &argc, argv); + } + Router = 15; + if ((N = get_argument (argc, argv, "-Router"))) { + remove_argument (N, &argc, argv); + Router = atof (argv[N]); + remove_argument (N, &argc, argv); + } + + if (argc < 4) goto usage; + + if ((buff = SelectBuffer (argv[1], OLDBUFFER, TRUE)) == NULL) return (FALSE); + if ((xp = SelectVector (argv[2], OLDVECTOR, TRUE)) == NULL) return (FALSE); + if ((yp = SelectVector (argv[3], OLDVECTOR, TRUE)) == NULL) return (FALSE); + if (xp[0].Nelements != yp[0].Nelements) { + fprintf (stderr, "vectors are not the same length\n"); + return (FALSE); + } + + set_rough_radii (Raper, Rinner, Router); + + /* output vectors */ + if ((xc = SelectVector ("xc", ANYVECTOR, TRUE)) == NULL) return (FALSE); + if ((yc = SelectVector ("yc", ANYVECTOR, TRUE)) == NULL) return (FALSE); + if ((zc = SelectVector ("zc", ANYVECTOR, TRUE)) == NULL) return (FALSE); + if ((zs = SelectVector ("zs", ANYVECTOR, TRUE)) == NULL) return (FALSE); + if ((sk = SelectVector ("sk", ANYVECTOR, TRUE)) == NULL) return (FALSE); + if ((sx = SelectVector ("sx", ANYVECTOR, TRUE)) == NULL) return (FALSE); + if ((sy = SelectVector ("sy", ANYVECTOR, TRUE)) == NULL) return (FALSE); + if ((sxy = SelectVector ("sxy", ANYVECTOR, TRUE)) == NULL) return (FALSE); + + Nx = buff[0].matrix.Naxis[0]; + Ny = buff[0].matrix.Naxis[1]; + Np = xp[0].Nelements; + + REALLOCATE (xc[0].elements, float, Np); + REALLOCATE (yc[0].elements, float, Np); + REALLOCATE (sx[0].elements, float, Np); + REALLOCATE (sy[0].elements, float, Np); + REALLOCATE (sxy[0].elements, float, Np); + REALLOCATE (zs[0].elements, float, Np); + REALLOCATE (zc[0].elements, float, Np); + REALLOCATE (sk[0].elements, float, Np); + xc[0].Nelements = yc[0].Nelements = sx[0].Nelements = Np; + sy[0].Nelements = zs[0].Nelements = zc[0].Nelements = Np; + sxy[0].Nelements = sk[0].Nelements = Np; + + v = (float *) buff[0].matrix.buffer; + for (i = 0; i < Np; i++) { + x = xp[0].elements[i]; + y = yp[0].elements[i]; + if (x < 0) continue; + if (x >= Nx) continue; + if (y < 0) continue; + if (y >= Ny) continue; + + get_rough_star (v, Nx, Ny, x, y, + &xc[0].elements[i], + &yc[0].elements[i], + &sx[0].elements[i], + &sy[0].elements[i], + &sxy[0].elements[i], + &zs[0].elements[i], + &zc[0].elements[i], + &sk[0].elements[i]); + } + + return (TRUE); + + usage: + fprintf (stderr, "rawstars (buffer) (xp) (yp)\n"); + return (FALSE); +} + Index: /tags/mana-1-3/Ohana/src/opihi/mana/simsignal.c =================================================================== --- /tags/mana-1-3/Ohana/src/opihi/mana/simsignal.c (revision 5936) +++ /tags/mana-1-3/Ohana/src/opihi/mana/simsignal.c (revision 5936) @@ -0,0 +1,50 @@ +# include "dimm.h" + +int simsignal (int argc, char **argv) { + + int Nvect, Nbin, Nbit, i, ivalue, jvalue, Nshift, mask, scale; + float *buf; + double cvalue, dvalue, sigma, SN, period; + double rnd_gauss (); + + if (argc != 5) { + fprintf (stderr, "USAGE: simsignal (vector) Nbin Nbits period\n"); + return (FALSE); + } + + if (!SelectVector (&Nvect, argv[1], ANYVECTOR)) return (FALSE); + Nbin = atof (argv[2]); + Nbit = atof (argv[3]); + /* SN = atof (argv[4]); */ + period = atof (argv[4]); + + vectors[Nvect].Nelements = Nbin; + REALLOCATE (vectors[Nvect].elements, float, vectors[Nvect].Nelements); + + scale = (0x1 << Nbit) - 1; + + buf = vectors[Nvect].elements; + for (i = 0; i < Nbin; i++, buf++) { + ivalue = scale * 0.5 * (sin (i*2*M_PI/period) + 1) + 0.5; + /* + dvalue = rnd_gauss (cvalue, sigma); + cvalue = (dvalue + range) / (2.0*range); + dvalue = MAX (0, MIN (0.99999, cvalue)); + ivalue = scale * dvalue; + *buf = (2.0 * range * ((double) ivalue + 0.5)) / scale - range; + */ + *buf = ivalue; + } + + return (TRUE); +} + +/* + +8 bit = 2^8 + + gauss_init (2*scale); + sigma = 2.0 / SN; + range = 1 + 5*sigma; + +*/ Index: /tags/mana-1-3/Ohana/src/opihi/mana/starcontour.c =================================================================== --- /tags/mana-1-3/Ohana/src/opihi/mana/starcontour.c (revision 5936) +++ /tags/mana-1-3/Ohana/src/opihi/mana/starcontour.c (revision 5936) @@ -0,0 +1,130 @@ +# include "mana.h" + +int starcontour (int argc, char **argv) { + + int x, y, xs, xp, yp; + int Nx, Ny, N, Npts, min, max; + float *v; + float zt, zo, xmin, xmax; + Vector *vecx, *vecy; + Buffer *buf; + + if (argc < 5) goto usage; + + if ((buf = SelectBuffer (argv[1], OLDBUFFER, TRUE)) == NULL) return (FALSE); + xp = atof (argv[2]); + yp = atof (argv[3]); + zo = atof (argv[4]); + + if ((vecx = SelectVector ("xo", ANYVECTOR, TRUE)) == NULL) return (FALSE); + if ((vecy = SelectVector ("yo", ANYVECTOR, TRUE)) == NULL) return (FALSE); + + N = 0; + Npts = 100; + REALLOCATE (vecx[0].elements, float, MAX (Npts, 1)); + REALLOCATE (vecy[0].elements, float, MAX (Npts, 1)); + + Nx = buf[0].matrix.Naxis[0]; + Ny = buf[0].matrix.Naxis[1]; + v = (float *)buf[0].matrix.buffer; + + /* find transition below (limit range?) */ + xmin = xmax = 0; + xs = xp; + for (y = yp; (y >= 0) && (v[xs + y*Nx] > zo); y--) { + /* find transition below (limit range?) */ + min = max = FALSE; + for (x = xs; (x >= 0) && !min; x--) { + min = FALSE; + zt = v[x + y*Nx]; + if (zt < zo) { + min = TRUE; + xmin = x + (zo - zt)/(v[x + 1 + y*Nx] - zt); + vecx[0].elements[N] = xmin; + vecy[0].elements[N] = y; + N ++; + if (N >= Npts) { + Npts += 100; + REALLOCATE (vecx[0].elements, float, MAX (Npts, 1)); + REALLOCATE (vecy[0].elements, float, MAX (Npts, 1)); + } + } + /* ignore edge cases? */ + } + /* find transition above (limit range?) */ + for (x = xs; (x < Nx) && !max; x++) { + max = FALSE; + zt = v[x + y*Nx]; + if (zt < zo) { + max = TRUE; + xmax = x - (zo - zt)/(v[x - 1 + y*Nx] - zt); + vecx[0].elements[N] = xmax; + vecy[0].elements[N] = y; + N ++; + if (N >= Npts) { + Npts += 100; + REALLOCATE (vecx[0].elements, float, MAX (Npts, 1)); + REALLOCATE (vecy[0].elements, float, MAX (Npts, 1)); + } + } + /* ignore edge cases? */ + } + if (min && max) { + xs = 0.5*(xmin + xmax); + } + } + + /* find transition above (limit range?) */ + xs = xp; + for (y = yp; (y < Ny) && (v[xs + y*Nx] > zo); y++) { + /* find transition below (limit range?) */ + min = max = FALSE; + for (x = xs; (x >= 0) && !min; x--) { + min = FALSE; + zt = v[x + y*Nx]; + if (zt < zo) { + min = TRUE; + xmin = x + (zo - zt)/(v[x + 1 + y*Nx] - zt); + vecx[0].elements[N] = xmin; + vecy[0].elements[N] = y; + N ++; + if (N >= Npts) { + Npts += 100; + REALLOCATE (vecx[0].elements, float, MAX (Npts, 1)); + REALLOCATE (vecy[0].elements, float, MAX (Npts, 1)); + } + } + /* ignore edge cases? */ + } + /* find transition above (limit range?) */ + for (x = xs; (x < Nx) && !max; x++) { + max = FALSE; + zt = v[x + y*Nx]; + if (zt < zo) { + max = TRUE; + xmax = x - (zo - zt)/(v[x - 1 + y*Nx] - zt); + vecx[0].elements[N] = xmax; + vecy[0].elements[N] = y; + N ++; + if (N >= Npts) { + Npts += 100; + REALLOCATE (vecx[0].elements, float, MAX (Npts, 1)); + REALLOCATE (vecy[0].elements, float, MAX (Npts, 1)); + } + } + /* ignore edge cases? */ + } + if (min && max) { + xs = 0.5*(xmin + xmax); + } + } + vecx[0].Nelements = N; + vecy[0].Nelements = N; + + return (TRUE); + + usage: + fprintf (stderr, "starcontour (buffer) (xpeak) (ypeak) (level)\n"); + return (FALSE); +} + Index: /tags/mana-1-3/Ohana/src/opihi/mana/tests.c =================================================================== --- /tags/mana-1-3/Ohana/src/opihi/mana/tests.c (revision 5936) +++ /tags/mana-1-3/Ohana/src/opihi/mana/tests.c (revision 5936) @@ -0,0 +1,108 @@ +# include "opihi.h" + +run_tests () { + + /* test1 (); + test1b (); + test2 (); + test3 (); */ + test4 (); + test5 (); +} + +test1 () { + + int i, size; + char *test, *line; + + fprintf (stderr, "starting test 1... "); + ALLOCATE (test, char, 256); + sprintf (test, "100"); + for (i = 0; i < 1000000; i++) { + line = dvomath (1, &test, &size, 0); + if (line != NULL) free (line); + } + fprintf (stderr, "done with test 1\n"); + sleep (1); +} + +test1b () { + + int i, size; + char *test, *line; + + fprintf (stderr, "starting test 1b... "); + ALLOCATE (test, char, 256); + sprintf (test, "dsin(45)"); + for (i = 0; i < 1000000; i++) { + line = dvomath (1, &test, &size, 0); + if (line != NULL) free (line); + } + fprintf (stderr, "done with test 1b\n"); + sleep (1); +} + +test2 () { + + int i, size; + char *test, *line; + + fprintf (stderr, "starting test 2... "); + ALLOCATE (test, char, 256); + sprintf (test, "5 * 100"); + for (i = 0; i < 1000000; i++) { + line = dvomath (1, &test, &size, 0); + if (line != NULL) free (line); + } + fprintf (stderr, "done with test 2\n"); + sleep (1); +} + +test3 () { + + int i, size; + char *test, *line; + + fprintf (stderr, "starting test 3... "); + ALLOCATE (test, char, 256); + sprintf (test, "5 * dsin(45)"); + for (i = 0; i < 1000000; i++) { + line = dvomath (1, &test, &size, 0); + if (line != NULL) free (line); + } + fprintf (stderr, "done with test 3\n"); + sleep (1); +} + +test4 () { + + int i; + char *test, *line; + + fprintf (stderr, "starting test 4... "); + for (i = 0; i < 1000000; i++) { + ALLOCATE (test, char, 256); + sprintf (test, "$N = 100"); + line = parse (test); + if (line != NULL) free (line); + } + fprintf (stderr, "done with test 4\n"); + sleep (1); +} + +test5 () { + + int i; + char *test, *line; + + fprintf (stderr, "starting test 5... "); + for (i = 0; i < 1000000; i++) { + ALLOCATE (test, char, 256); + sprintf (test, "echo {100 * 800}"); + line = parse (test); + if (line != NULL) free (line); + } + fprintf (stderr, "done with test 5\n"); + sleep (1); +} + Index: /tags/mana-1-3/Ohana/src/opihi/mana/version.c =================================================================== --- /tags/mana-1-3/Ohana/src/opihi/mana/version.c (revision 5936) +++ /tags/mana-1-3/Ohana/src/opihi/mana/version.c (revision 5936) @@ -0,0 +1,14 @@ +# include "mana.h" +static char *name = "$Name: not supported by cvs2svn $"; + +int version (int argc, char **argv) { + + fprintf (stderr, "%s\n", name); + + fprintf (stderr, "%s\n", opihi_version()); + fprintf (stderr, "%s\n", ohana_version()); + fprintf (stderr, "%s\n", fits_version()); + + fprintf (stderr, "compiled on %s %s\n", __DATE__, __TIME__); + return (TRUE); +}