Index: /trunk/Ohana/src/libkapa/.cvsignore =================================================================== --- /trunk/Ohana/src/libkapa/.cvsignore (revision 5848) +++ /trunk/Ohana/src/libkapa/.cvsignore (revision 5848) @@ -0,0 +1,1 @@ +lib Index: /trunk/Ohana/src/libkapa/Makefile =================================================================== --- /trunk/Ohana/src/libkapa/Makefile (revision 5848) +++ /trunk/Ohana/src/libkapa/Makefile (revision 5848) @@ -0,0 +1,62 @@ +include ../../Configure + +HOME = $(ROOT)/src/libkapa +LIB = $(HOME)/lib +SRC = $(HOME)/src +MAN = $(HOME)/doc +INC = $(HOME)/include +DESTBIN = $(LBIN) +DESTLIB = $(LLIB) +DESTINC = $(LINC) +DESTMAN = $(LMAN) + +CFLAGS = -I$(LINC) -I$(INC) -D$(ARCH) + +default: install + +install: $(DESTLIB)/libkapa.a + +libkapa: $(LIB)/libkapa.$(ARCH).a + +INCS = $(DESTINC)/kapa.h + +OBJS = \ +$(SRC)/IOfuncs.$(ARCH).o \ +$(SRC)/KiiPicture.$(ARCH).o \ +$(SRC)/KiiOpen.$(ARCH).o \ +$(SRC)/KiiOverlay.$(ARCH).o \ +$(SRC)/KiiCursor.$(ARCH).o \ +$(SRC)/KiiConvert.$(ARCH).o + +# $(SRC)/KiiTickmarks.$(ARCH).o + +$(OBJS): $(INCS) + +$(DESTLIB)/libkapa.a: $(LIB)/libkapa.$(ARCH).a + @if [ ! -d $(DESTLIB) ]; then mkdir -p $(DESTLIB); fi + rm -f $(DESTLIB)/libkapa.a + cp $(LIB)/libkapa.$(ARCH).a $(DESTLIB)/libkapa.a + +$(LIB)/libkapa.$(ARCH).a: $(OBJS) + @if [ ! -d $(LIB) ]; then mkdir -p $(LIB); fi + rm -f $(LIB)/libkapa.$(ARCH).a + ar rcv $(LIB)/libkapa.$(ARCH).a $(OBJS) + $(RANLIB) $(LIB)/libkapa.$(ARCH).a + +$(DESTINC)/%: $(INC)/% + @if [ ! -d $(DESTINC) ]; then mkdir -p $(DESTINC); fi + rm -f $(DESTINC)/$* + cp $(INC)/$* $(DESTINC)/ + +clean: + rm -f */*~ + rm -f */#* + rm -f */*.o + rm -f */*.a + +dist: clean + +.SUFFIXES: .$(ARCH).o + +.c.$(ARCH).o: + $(CC) $(CFLAGS) -c $*.c -o $@ Index: /trunk/Ohana/src/libkapa/doc/notes.txt =================================================================== --- /trunk/Ohana/src/libkapa/doc/notes.txt (revision 5848) +++ /trunk/Ohana/src/libkapa/doc/notes.txt (revision 5848) @@ -0,0 +1,31 @@ + +KII library functions: + +KiiOpen () +KiiClose () +KiiNewPicture () +KiiLoadOverlay () +KiiLoadTickmarks () +KiiEraseOverlay () +KiiSaveOverlay () +KiiPS +KiiJPEG +KiiResize + + +----------------------- + +KapaOpen () +KapaClose +KapaPS +KapaPNG +KapaPPM +KapaResize +KapaLoadObject +KapaSetLimits +KapaLoadLabels +KapaSetSection +KapaLoadText +KapaSetFont +KapaErase +KapaLoadBox Index: /trunk/Ohana/src/libkapa/include/kapa.h =================================================================== --- /trunk/Ohana/src/libkapa/include/kapa.h (revision 5848) +++ /trunk/Ohana/src/libkapa/include/kapa.h (revision 5848) @@ -0,0 +1,68 @@ +# ifndef KAPA_H +# define KAPA_H + +typedef struct { + float *data1d; + float **data2d; + int Nx; + int Ny; + char *file; + char *name; +} KiiImage; + +typedef struct { + double zero; + double range; + int logflux; +} KiiDisplayMode; + +typedef struct { + float x; + float y; + float dx; + float dy; + int type; + char *text; +} KiiOverlay; + +typedef enum { + KII_OVERLAY_NONE, + KII_OVERLAY_TEXT, + KII_OVERLAY_BOX, + KII_OVERLAY_LINE, + KII_OVERLAY_CIRCLE +} KiiOverlayType; + +/* IOfuncs.c */ +int KiiSendMessage (int device, char *format, ...); +int KiiSendCommand (int device, int length, char *format, ...); +int KiiSendCommandV (int device, int length, char *format, va_list argp); + +/* KiiOpen.c */ +int KiiOpen (char *kii_exec, char *name); +int KiiClose (int socket); + +/* KiiPicture.c */ +int KiiNewPicture1D (int fd, KiiImage *image, KiiDisplayMode *mode, Coords *coords); +int KiiNewPicture2D (int fd, KiiImage *image, KiiDisplayMode *mode, Coords *coords); +int KiiResize (int fd, int Nx, int Ny); +int KiiCenter (int fd, double x, double y, int zoom); + +/* KiiOverlay.c */ +int KiiSelectOverlay (char *name, int *number); +int KiiLoadOverlay (int fd, KiiOverlay *overlay, int Noverlay, char *name); +int KiiEraseOverlay (int fd, char *name); +int KiiSaveOverlay (int fd, int celestial, char *name, char *file); +int KiiOverlayTypeByName (char *name); +char *KiiOverlayTypeByNumber (int n); + +/* KiiConvert.c */ +int KiiJpeg (int fd, char *filename); +int KiiPS (int fd, int scale, int raw, char *filename); + +/* KiiCursor.c */ +int KiiCursorOn (int fd); +int KiiCursorOff (int fd); +int KiiCursorRead (int fd, double *x, double *y, char *key); + +# endif Index: /trunk/Ohana/src/libkapa/include/kapa_internal.h =================================================================== --- /trunk/Ohana/src/libkapa/include/kapa_internal.h (revision 5848) +++ /trunk/Ohana/src/libkapa/include/kapa_internal.h (revision 5848) @@ -0,0 +1,17 @@ +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include + +/* do we need to move the Coords structure outside + of libautocode? */ Index: /trunk/Ohana/src/libkapa/src/IOfuncs.c =================================================================== --- /trunk/Ohana/src/libkapa/src/IOfuncs.c (revision 5848) +++ /trunk/Ohana/src/libkapa/src/IOfuncs.c (revision 5848) @@ -0,0 +1,47 @@ +# include + +/* send a message of arbitrary size, sending the size first */ +int KiiSendMessage (int device, char *format, ...) { + + int Nbyte, status; + char tmp; + va_list argp; + + va_start (argp, format); + Nbyte = vsnprintf (&tmp, 0, format, argp); + va_end (argp); + + if (!Nbyte) return (FALSE); + + va_start (argp, format); + KiiSendCommand (device, 16, "NBYTES: %6d", Nbyte); + status = KiiSendCommandV (device, Nbyte, format, argp); + va_end (argp); + return (status); +} + +int KiiSendCommand (int device, int length, char *format, ...) { + + int status; + va_list argp; + + va_start (argp, format); + status = KiiSendCommandV (device, length, format, argp); + va_end (argp); + return (status); +} + +int KiiSendCommandV (int device, int length, char *format, va_list argp) { + + char *string; + + /* I allocated and zero 1 extra byte */ + ALLOCATE (string, char, length + 1); + memset (string, 0, length + 1); + vsnprintf (string, length + 1, format, argp); + + /* fprintf (stderr, "msg: %s\n", string); */ + write (device, string, length); + free (string); + return (TRUE); +} Index: /trunk/Ohana/src/libkapa/src/KiiConvert.c =================================================================== --- /trunk/Ohana/src/libkapa/src/KiiConvert.c (revision 5848) +++ /trunk/Ohana/src/libkapa/src/KiiConvert.c (revision 5848) @@ -0,0 +1,40 @@ +# include + +int KiiJpeg (int fd, char *filename) { + + char buffer[20]; + + KiiSendCommand (fd, 4, "JPEG"); + KiiSendCommand (fd, 16, "LEN: %11d", strlen(filename)); + write (fd, filename, strlen(filename)); + + /* block for the response, which says the operation completed */ + read (fd, buffer, 4); + return (TRUE); +} + +int KiiPS (int fd, int scale, int raw, char *filename) { + + char buffer[20]; + + if (raw) { + KiiSendCommand (fd, 4, "PSRW"); + goto name; + } + if (scale) { + KiiSendCommand (fd, 4, "PSNS"); + goto name; + } + if (!raw && !scale) { + KiiSendCommand (fd, 4, "PSIT"); + goto name; + } + +name: + KiiSendCommand (fd, 16, "LEN: %11d", strlen(filename)); + write (fd, filename, strlen(filename)); + + /* block for the response, which says the operation completed */ + read (fd, buffer, 4); + return (TRUE); +} Index: /trunk/Ohana/src/libkapa/src/KiiCursor.c =================================================================== --- /trunk/Ohana/src/libkapa/src/KiiCursor.c (revision 5848) +++ /trunk/Ohana/src/libkapa/src/KiiCursor.c (revision 5848) @@ -0,0 +1,25 @@ +# include + +int KiiCursorOn (int fd) { + write (fd, "CURS", 4); /* ask Source to look for the keystrokes */ + return (TRUE); +} + +int KiiCursorOff (int fd) { + write (fd, "NCUR", 4); /* ask Source to look for the keystrokes */ + return (TRUE); +} + +int KiiCursorRead (int fd, double *x, double *y, char *key) { + + char buffer[40]; + + bzero (buffer, 40); + read (fd, buffer, 40); + buffer[39] = 0; + + sscanf (buffer, "%s %lf %lf", key, x, y); + if (ispunct(key[0])) strcpy (key, "_"); + + return (TRUE); +} Index: /trunk/Ohana/src/libkapa/src/KiiOpen.c =================================================================== --- /trunk/Ohana/src/libkapa/src/KiiOpen.c (revision 5848) +++ /trunk/Ohana/src/libkapa/src/KiiOpen.c (revision 5848) @@ -0,0 +1,57 @@ +# include + +/** start socketed connection */ +int KiiOpen (char *kii_exec, char *name) { + + int InitSocket, status, addreslen; + struct sockaddr_un Address; + char temp[128], socket_name[64]; + int Ntry, fd; + + sprintf (socket_name, "/tmp/Kii.XXXXXX"); + if ((fd = mkstemp (socket_name)) == -1) { + fprintf (stderr, "error starting kii\n"); + return (-1); + } + close (fd); + unlink (socket_name); + + strcpy (Address.sun_path, socket_name); + Address.sun_family = AF_UNIX; + InitSocket = socket (AF_UNIX, SOCK_STREAM, 0); + status = bind (InitSocket, (struct sockaddr *) &Address, sizeof (Address)); + status = listen (InitSocket, 1); + + if (name == NULL) { + sprintf (temp, "%s %s &", kii_exec, socket_name); + } else { + sprintf (temp, "%s %s -name %s &", kii_exec, socket_name, name); + } + system (temp); + + addreslen = sizeof (Address); + fcntl (InitSocket, F_SETFL, O_NONBLOCK); + +# define NTRY 500 + Ntry = 0; + while (Ntry < NTRY) { + fd = accept (InitSocket, (struct sockaddr *)&Address, &addreslen); + if (fd != -1) break; + if (errno != EAGAIN) break; + usleep (10000); + Ntry ++; + } + + if (fd < 0) return (-1); + + fcntl (fd, F_SETFL, !O_NONBLOCK); + return (fd); +} + +int KiiClose (int fd) { + + if (fd < 1) return (FALSE); + KiiSendCommand (fd, 4, "QUIT"); + close (fd); + return (TRUE); +} Index: /trunk/Ohana/src/libkapa/src/KiiOverlay.c =================================================================== --- /trunk/Ohana/src/libkapa/src/KiiOverlay.c (revision 5848) +++ /trunk/Ohana/src/libkapa/src/KiiOverlay.c (revision 5848) @@ -0,0 +1,119 @@ +# include + +# define NOVERLAY_TYPE 5 +static char KiiOverlayTypeName[NOVERLAY_TYPE][16] = { + "NONE", + "TEXT", + "BOX", + "LINE", + "CIRCLE", +}; + +int KiiOverlayTypeByName (char *overname) { + + int i; + + for (i = 1; i < NOVERLAY_TYPE; i++) { + if (!strcasecmp (overname, KiiOverlayTypeName[i])) return (i); + } + return (0); +} + +char *KiiOverlayTypeByNumber (int n) { + + if ((n < 0) || (n >= NOVERLAY_TYPE)) return NULL; + return (KiiOverlayTypeName[n]); +} + +int KiiSelectOverlay (char *overname, int *number) { + + *number = -1; + if (!strcmp (overname, "red") || !strcmp (overname, "0")) { + *number = 0; + return (TRUE); + } + if (!strcmp (overname, "green") || !strcmp (overname, "1")) { + *number = 1; + return (TRUE); + } + if (!strcmp (overname, "blue") || !strcmp (overname, "2")) { + *number = 2; + return (TRUE); + } + if (!strcmp (overname, "yellow") || !strcmp (overname, "3")) { + *number = 3; + return (TRUE); + } + + fprintf (stderr, "valid overlays may be: red (0), green (1), blue (2), yellow (3)\n"); + return (FALSE); +} + +int KiiLoadOverlay (int fd, KiiOverlay *overlay, int Noverlay, char *overname) { + + int i, n, Nline; + char *buffer, *type; + + KiiSelectOverlay (overname, &n); + + KiiSendCommand (fd, 4, "LOAD"); + KiiSendCommand (fd, 16, "OVER %9d ", n); + + Nline = 0; + ALLOCATE (buffer, char, 65536); /* space for 512 lines of 128 bytes */ + bzero (buffer, 65536); + + for (i = 0; i < Noverlay; i++) { + type = KiiOverlayTypeByNumber(overlay[i].type); + if (overlay[i].type == KII_OVERLAY_TEXT) { + snprintf (&buffer[Nline*128], 128, "%15s %20.10f %20.10f %s ", type, overlay[i].x, overlay[i].y, overlay[i].text); + } else { + snprintf (&buffer[Nline*128], 128, "%15s %20.10f %20.10f %20.10f %20.10f ", type, overlay[i].x, overlay[i].y, overlay[i].dx, overlay[i].dy); + } + Nline ++; + if (Nline == 512) { + KiiSendCommand (fd, 16, "NLINES %7d ", Nline); + write (fd, buffer, Nline*128); + bzero (buffer, 65536); + Nline = 0; + } + } + KiiSendCommand (fd, 16, "NLINES %7d ", Nline); + write (fd, buffer, Nline*128); + KiiSendCommand (fd, 16, "DONE"); + + free (buffer); + + /* this is very inefficient: 128 bytes per object vs 17 as binary, plus the + conversions back and forth + */ + return (TRUE); +} + +int KiiEraseOverlay (int fd, char *overname) { + + int n; + + KiiSelectOverlay (overname, &n); + + KiiSendCommand (fd, 4, "ERAS"); + KiiSendCommand (fd, 16, "OVERLAY %7d ", n); + + return (TRUE); +} + +int KiiSaveOverlay (int fd, int celestial, char *overname, char *file) { + + int n; + + KiiSelectOverlay (overname, &n); + + if (celestial) { + KiiSendCommand (fd, 4, "CSVE"); + } else { + KiiSendCommand (fd, 4, "SAVE"); + } + + KiiSendMessage (fd, "FILE: %d %s", n, file); + return (TRUE); +} Index: /trunk/Ohana/src/libkapa/src/KiiPicture.c =================================================================== --- /trunk/Ohana/src/libkapa/src/KiiPicture.c (revision 5848) +++ /trunk/Ohana/src/libkapa/src/KiiPicture.c (revision 5848) @@ -0,0 +1,150 @@ +# include + +int KiiNewPicture1D (int fd, KiiImage *image, KiiDisplayMode *mode, Coords *coords) { + + int i; + int Npix, Ncolors, NNcolors, size; + float *in, min, max; + char *out, *outbuffer, *root; + char buffer[1024]; + double a1, a2; + + Npix = image[0].Nx*image[0].Ny; + + KiiSendCommand (fd, 4, "READ"); /* tell Ximage to look for the incoming image */ + + /* convert from (float *) to 1 byte chars -- depends on how many colors Kii owns */ + /* use this response as a handshake test */ + read (fd, buffer, 16); + sscanf (buffer, "%*s %d", &Ncolors); + + ALLOCATE (outbuffer, char, Npix); + out = outbuffer; + in = image[0].data1d; + + /* need to invert the logic if range < 0 */ + + /* define color table, */ + NNcolors = Ncolors - 1; + if (mode[0].logflux) { + mode[0].range = MAX (2, mode[0].range); + a1 = Ncolors / log10 (mode[0].range); + a2 = mode[0].zero; + for (i = 0; i < Npix; i++, in++, out++) { + *out = (char) MIN (a1 * log10 (MAX (*in - a2, 1.0)), NNcolors); + } + } else { + a1 = Ncolors / mode[0].range; + a2 = Ncolors * mode[0].zero / mode[0].range; + for (i = 0; i < Npix; i++, in++, out++) { + *out = (char) MIN (MAX (a1 * *in - a2, 0), NNcolors); + } + } + + /* these are for a future upgrade */ + min = max = 0.0; + size = Npix*sizeof(char); + + /* done with the conversion, now send Ximage the converted picture */ + KiiSendMessage (fd, "%8d %8d 8 1 %f %f", image[0].Nx, image[0].Ny, 0.0, 1.0); + KiiSendMessage (fd, "%f %f %f %f %d ", mode[0].zero, mode[0].range, min, max, size); + KiiSendMessage (fd, "%f %f %g %g %g ", coords[0].crval1, coords[0].crpix1, coords[0].cdelt1, coords[0].pc1_1, coords[0].pc1_2); + KiiSendMessage (fd, "%f %f %g %g %g ", coords[0].crval2, coords[0].crpix2, coords[0].cdelt2, coords[0].pc2_1, coords[0].pc2_2); + + /* send the filename */ + root = filerootname (image[0].file); + KiiSendMessage (fd, "%s %s %s ", coords[0].ctype, root, image[0].name); + + /* send the image data */ + write (fd, outbuffer, size); + free (outbuffer); + + return (TRUE); +} + +int KiiNewPicture2D (int fd, KiiImage *image, KiiDisplayMode *mode, Coords *coords) { + + int i, j; + int Npix, Ncolors, NNcolors, size; + float *in, min, max; + char *out, *outbuffer, *root; + char buffer[1024]; + double a1, a2; + + Npix = image[0].Nx*image[0].Ny; + + KiiSendCommand (fd, 4, "READ"); /* tell Ximage to look for the incoming image */ + + /* convert from (float *) to 1 byte chars -- depends on how many colors Kii owns */ + /* use this response as a handshake test */ + read (fd, buffer, 16); + sscanf (buffer, "%*s %d", &Ncolors); + + ALLOCATE (outbuffer, char, Npix); + out = outbuffer; + + /* need to invert the logic if range < 0 */ + + /* define color table, */ + NNcolors = Ncolors - 1; + if (mode[0].logflux) { + mode[0].range = MAX (2, mode[0].range); + a1 = Ncolors / log10 (mode[0].range); + a2 = mode[0].zero; + for (j = 0; j < image[0].Ny; j++) { + in = image[0].data2d[j]; + for (i = 0; i < image[0].Nx; i++, in++, out++) { + *out = (char) MIN (a1 * log10 (MAX (*in - a2, 1.0)), NNcolors); + } + } + } else { + a1 = Ncolors / mode[0].range; + a2 = Ncolors * mode[0].zero / mode[0].range; + for (j = 0; j < image[0].Ny; j++) { + in = image[0].data2d[j]; + for (i = 0; i < image[0].Nx; i++, in++, out++) { + *out = (char) MIN (MAX (a1 * *in - a2, 0), NNcolors); + } + } + } + + /* these are for a future upgrade */ + min = max = 0.0; + size = Npix*sizeof(char); + + /* done with the conversion, now send Ximage the converted picture */ + KiiSendMessage (fd, "%8d %8d 8 1 %f %f", image[0].Nx, image[0].Ny, 0.0, 1.0); + KiiSendMessage (fd, "%f %f %f %f %d ", mode[0].zero, mode[0].range, min, max, size); + KiiSendMessage (fd, "%f %f %g %g %g ", coords[0].crval1, coords[0].crpix1, coords[0].cdelt1, coords[0].pc1_1, coords[0].pc1_2); + KiiSendMessage (fd, "%f %f %g %g %g ", coords[0].crval2, coords[0].crpix2, coords[0].cdelt2, coords[0].pc2_1, coords[0].pc2_2); + + /* send the filename */ + root = filerootname (image[0].file); + KiiSendMessage (fd, "%s %s %s ", coords[0].ctype, root, image[0].name); + + /* send the image data */ + write (fd, outbuffer, size); + free (outbuffer); + + return (TRUE); +} + +/* this function should be broken into pieces: + KiiSendImage + KiiSendCoords (default to 0 otherwise) + KiiSendFilename +*/ + +int KiiResize (int fd, int Nx, int Ny) { + + KiiSendCommand (fd, 4, "RSIZ"); + KiiSendMessage (fd, "%d %d", Nx, Ny); + return (TRUE); +} + +int KiiCenter (int fd, double x, double y, int zoom) { + + KiiSendCommand (fd, 4, "CENT"); + KiiSendMessage (fd, "%8.3f %8.3f %8d ", x, y, zoom); + return (TRUE); +} Index: /trunk/Ohana/src/libkapa/src/KiiTickmarks.c =================================================================== --- /trunk/Ohana/src/libkapa/src/KiiTickmarks.c (revision 5848) +++ /trunk/Ohana/src/libkapa/src/KiiTickmarks.c (revision 5848) @@ -0,0 +1,5 @@ +# include "kapa_internals.h" + +int KiiTickmarks () { + +}