Usenet 1994 January

home *** CD-ROM | disk | FTP | other *** search

/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume18 / gl_plot / part06 < prev next >

Wrap

Internet Message Format | 1989-03-23 | 42.1 KB

Subject: v18i064: GL Graphics Library for AT-clone Unix, Part06/07 Newsgroups: comp.sources.unix Sender: sources Approved: rsalz@uunet.UU.NET Submitted-by: umix!m-net!dtlewis!lewis Posting-number: Volume 18, Issue 64 Archive-name: gl_plot/part06 # To recover, type "sh archive" echo restoring config.h sed 's/^X//' > config.h <<XxX--EOF--XxX X/* @(#) config.h 5.1 89/02/20 */ X/* X * Copyright (c) David T. Lewis 1987, 1988 X * All rights reserved. X * X * Permission is granted to use this for any personal noncommercial use. X * You may not distribute source or executable code for profit, nor X * may you distribute it with a commercial product without the written X * consent of the author. Please send modifications to the author for X * inclusion in updates to the program. Thanks. X */ X X/* User modifiable parameters for GL graphics library. */ X/* ===> BEGIN USER MODIFIABLE PARAMETERS <=== */ X X/* Select one of the following to specify your target system (Xenix */ X/* cross compile to MS_DOS should select MS_DOS). */ X X#define SVAT 1 X#define XENIX_286 0 X#define MS_DOS 0 X#define UNIX_386 0 /* (not yet supported) */ X#define XENIX_386 0 /* (not yet supported) */ X X/* If you defined MS_DOS 1, then specify your compiler here. */ X X#if MS_DOS X#define XEN2DOS 1 /* Compile on Xenix 286 for DOS target system */ X#define USOFT 0 /* Microsoft C under DOS */ X#define TCC 0 /* Borland Turbo-C */ X#define MIX_C 0 /* The old CP/M derived MIX-C compiler */ X#endif /* MS_DOS */ X X/* The following should be defined if you do NOT have a numeric */ X/* coprocessor. It will cause some trig functions to be done with */ X/* integer math (see trig.c). */ X X#define NOFLOAT 1 X X/* The following should be defined if you want the gl library to handle */ X/* interrupt signals. This will clear the screen and return to text */ X/* mode when the interrupt key (or ^C, for MS-DOS) is pressed. If you */ X/* need to do your own signal routine (to close files, for example), */ X/* you may prefer not to have this defined. */ X X#define DO_CLEANUP 1 X X/* VIDEO stuff: */ X X/* Define the name of the program or shell script which will be used */ X/* to switch video modes (UNIX only). This will be made from either */ X/* the mode.c program, or the mode.sh shell script, or some equivalent */ X/* program that works with your system and video adapter. */ X X#define MODEPROG "mode" X/* Another possible choice: */ X/* #define MODEPROG "/usr/local/bin/mode" */ X X/* Define the name of the environment variable that you wish to use to */ X/* indicate your default graphics mode. If we call g_init(ENV_MODE), */ X/* then we will use this environment variable to set the graphics mode. */ X X#define GL_ENV_MODE "GLMODE" X X/* If the environment variable is not set, then fall back to */ X/* DEFAULT_MODE as a last resort. Mode 4 is CGA color mode, a safe */ X/* choice for most systems. */ X X#define DEFAULT_MODE 4 X X/* PRINTER stuff: */ X X/* Define name of the environment variable that you wish to set to */ X/* indicate your default print device. */ X X#define GL_PLOT_DEV "PLOTDEV" X X/* For MS-DOS, define your printer device name (and ignore the rest */ X/* of the printer stuff that follows). Note: Microsoft compilers will */ X/* send output to "stdprn" regardless of how you define this; other */ X/* compilers will use the device you define below. See code in */ X/* g_finish.c if you need to change this. */ X X#define DOSPRINTER "PRN:" X X/* Define the standard print spooler program for your system (UNIX). */ X X#define PRINTPROG "/usr/bin/lp" X#define LP_DEV_FLAG "-d" X X/* Define the device to use if GL_PLOT_DEV is not set. */ X/* Note: Use "lp" only if you plan to manually put the printer */ X/* driver in transparency mode (see lpset(1M)). */ X/* On Microport, your printer devices might look something like the */ X/* following, where /dev/lp is the standard printer driver, and */ X/* /dev/lpt is the transparency mode printer driver. See the "Readme" */ X/* file for more information. */ X/* */ X/* \$ ls -li /dev/lp* */ X/* 82 crw-rw-rw- 2 root sys 7, 0 Oct 9 18:03 /dev/lp */ X/* 82 crw-rw-rw- 2 root sys 7, 0 Oct 9 18:03 /dev/lp0 */ X/* 83 crw-rw-rw- 1 root sys 7, 1 Feb 11 1988 /dev/lp1 */ X/* 295 crw-rw-rw- 2 root sys 7,128 Oct 9 18:08 /dev/lpt */ X/* 295 crw-rw-rw- 2 root sys 7,128 Oct 9 18:08 /dev/lpt0 */ X/* 291 crw-rw-rw- 1 root sys 7,129 May 22 18:42 /dev/lpt1 */ X X#define PRINTDEV "lpt" X X/* You may need to tweak the following in order to get round circles. */ X X#define HERC_ASPECT_RATIO 0.7 X#define CGA_ASPECT_RATIO 0.85 X#define EGA_ASPECT_RATIO 0.6 X#define IBM_PR_ASPECT_RATIO 0.7 X#define LJ_PR_ASPECT_RATIO 0.81 X X/* For Xenix System V 286, you must indicate the video adapter you */ X/* are using. Microport users can ignore this (they must, however, */ X/* create a shared memory key with shmcreate(1). MS-DOS users may */ X/* also ignore this. */ X X#define GL_CGA 0 X#define GL_EGA 1 X#define GL_HERC 0 X#define GL_PGA 0 /* (not implemented) */ X#define GL_VGA 0 /* (easy to do, but not implemented) */ X X/* The following definitions specify the shared memory key identifiers */ X/* which are used by Microport System V/AT. You are free to use any */ X/* identifiers you want to map to video memory with shmcreate(1). */ X/* The following are the recommended values. If you use these, the */ X/* key values will be the same as the physical memory addresses. */ X/* Change these definitions only if you are using different shared */ X/* memory keys for your system. Xenix users may ignore this. */ X X#define MCA_KEY 0xB0000L X#define CGA_KEY 0xB8000L X#define HERC_P0KEY 0xB0000L X#define HERC_P1KEY 0xB8000L X#define EGA_KEY 0xA0000L X X/* ===> END USER MODIFIABLE PARAMETERS <=== */ X X/* The following definitions specify the physical memory locations of */ X/* video memory, for use with MS-DOS. */ X X#define DOS_MCA 0xB0000000L X#define DOS_CGA 0xB8000000L X#define DOS_H_P0 0xB0000000L X#define DOS_H_P1 0xB8000000L X#define DOS_EGA 0xA0000000L X X/* Some specific system dependent characteristics. */ X X#if MIX_C X#define HAS_SIG 0 /* System does not have ^C interrupt handling */ X#else X#if USOFT X#define HAS_SIG 0 /* System does not have ^C interrupt handling */ X#else X#if XEN2DOS X#define HAS_SIG 0 /* System does not have ^C interrupt handling */ X#else X#define HAS_SIG 1 /* System has ^C interrupt handling */ X#endif /* XEN2DOS */ X#endif /* USOFT */ X#endif /* MIX_C */ X X#if MIX_C X#define HAS_ENV 0 /* System does not have getenv() call */ X#else X#define HAS_ENV 1 /* System has getenv() call */ X#endif /* MIX_C */ X X#if MS_DOS X#define HAS_PIPES 0 /* System does not have popen() call */ X#else X#define HAS_PIPES 1 /* System has popen() call */ X#endif /* MS_DOS */ X X#if USOFT X#define HAS_SLEEP 0 /* System does not have sleep() call */ X#else X#if XEN2DOS X#define HAS_SLEEP 0 /* System does not have sleep() call */ X#else X#if MIX_C X#define HAS_SLEEP 0 /* System does not have sleep() call */ X#else X#define HAS_SLEEP 1 /* System has sleep() call */ X#endif /* MIX_C */ X#endif /* XEN2DOS */ X#endif /* USOFT */ X X#if MIX_C X#define HAS_FMOD 0 /* System does not have fmod() call */ X#else X#define HAS_FMOD 1 /* System has fmod() call */ X#endif /* MIX_C */ X X#if MIX_C X#define HAS_ATAN2 0 /* System does not have atan2() call */ X#else X#define HAS_ATAN2 1 /* System has atan2() call */ X#endif /* MIX_C */ X X/* Some MS-DOS compilers have "stdprn" predefined for stream output to */ X/* the printer. */ X X#if USOFT X#define HAS_STDPRN 1 X#else X#if XEN2DOS X#define HAS_STDPRN 1 X#else X#if TCC X#define HAS_STDPRN 1 X#else /* "stdprn" is not predefined */ X#define HAS_STDPRN 0 X#endif /* TCC */ X#endif /* XEN2DOS */ X#endif /* USOFT */ X X/* The following should be defined for 286 versions, in which an */ X/* integer is 16 bits. Other machines must do extra work to check */ X/* for out of range on the normalized 2-D screen space (0 through */ X/* 32767). */ X X#if MS_DOS X#else X#if XENIX_286 X#else X#if SVAT X#define INT16 1 X#else /* Not a 16 bit integer machine */ X#define INT16 0 X#endif /* SVAT */ X#endif /* XENIX_286 */ X#endif /* MS_DOS */ X X/* Parameter to signal call is system dependent. Define a macro to */ X/* handle the difference between pointer to void and pointer to int. */ X X#if TCC X#define SIG_TYPE void X#else X#define SIG_TYPE int X#endif /* TCC */ X X/* Some compilers can use a macro for the calculation for transform */ X/* from normalized 2-D to screen coordinates. If yours can't, then */ X/* define N_TO_P_MACRO as 0. */ X/* (All the compilers I've tried are working now with the macro. Leave */ X/* this here just in case...) */ X X#define N_TO_P_MACRO 1 X X/* Compiler specific stuff for MS-DOS. */ X X/* For MS-DOS, use the DO_BIOS macro to point to the library routine */ X/* that invokes a BIOS call. Int is the interrupt number, and reg */ X/* is a pointer to a structure representing machine registers. */ X/* Define REGISTERS as the name of the data structure for machine */ X/* registers (probably declared in <stdlib.h>). */ X/* The remaining macros (AL, AH ...) specify individual registers */ X/* within the REGISTERS data structure, as they would be referenced */ X/* in a REGISTERS structure (e.g. "inreg.AH"). */ X X#if MIX_C X#define DO_BIOS(int,inreg,outreg) bios(int,inreg) X#define REGISTERS REGS X#define AL byte.al X#define AH byte.ah X#define BL byte.bl X#define BH byte.bh X#define CL byte.cl X#define CH byte.ch X#define DL byte.dl X#define DH byte.dh X#endif /* MIX_C */ X X#if USOFT X#define DO_BIOS(int,inreg,outreg) int86(int,inreg,outreg) X#define REGISTERS union REGS X#define AL h.al X#define AH h.ah X#define BL h.bl X#define BH h.bh X#define CL h.cl X#define CH h.ch X#define DL h.dl X#define DH h.dh X#endif /* USOFT */ X X#if XEN2DOS X#define DO_BIOS(int,inreg,outreg) int86(int,inreg,outreg) X#define REGISTERS union REGS X#define AL h.al X#define AH h.ah X#define BL h.bl X#define BH h.bh X#define CL h.cl X#define CH h.ch X#define DL h.dl X#define DH h.dh X#endif /* XEN2DOS */ X X#if TCC X#define DO_BIOS(int,inreg,outreg) int86(int,inreg,outreg) X#define REGISTERS union REGS X#define AL h.al X#define AH h.ah X#define BL h.bl X#define BH h.bh X#define CL h.cl X#define CH h.ch X#define DL h.dl X#define DH h.dh X#endif /* TCC */ X XxX--EOF--XxX echo restoring g_fntctl.c sed 's/^X//' > g_fntctl.c <<XxX--EOF--XxX X#ifndef lint Xstatic char sccsid[] = "@(#) g_fntctl.c 5.1 89/02/20"; X#endif X X/* X * Copyright (c) David T. Lewis 1988 X * All rights reserved. X * X * Permission is granted to use this for any personal noncommercial use. X * You may not distribute source or executable code for profit, nor X * may you distribute it with a commercial product without the written X * consent of the author. Please send modifications to the author for X * inclusion in updates to the program. Thanks. X */ X X/* Control size, aspect ratio, spacing, angle and slant of stroke font. */ X/* Size, aspect ratio and spacing control height, relative width and */ X/* relative spacing of characters, with 1.0 selecting default values. */ X/* Changing size will change the width and spacing appropriately. */ X/* Changing width will change the spacing. */ X/* Angle is the angle of a text string in radians, with positive */ X/* values rotating the text clockwise. Slant is the character slant */ X/* in radians (typically a number on the order of 0.2), with positive */ X/* values slanting the text to the "right," as in italics. */ X X#include "config.h" X#include "bitmaps.h" X#include "graphics.h" X Xextern struct GL_graphics graphics; X Xint g_fontctl(size, aspect_ratio, spacing, angle, slant) Xfloat size, aspect_ratio, spacing, angle, slant; X X{ X graphics.strokefont.xtic X = (int)(size * aspect_ratio * spacing * X (float)graphics.default_strokefont.xtic); X graphics.strokefont.ytic X = (int)(size * (float)graphics.default_strokefont.ytic); X graphics.strokefont.xsize X = (int)(size * aspect_ratio * X (float)graphics.default_strokefont.xsize); X graphics.strokefont.ysize X = (int)(size * (float)graphics.default_strokefont.ysize); X graphics.strokefont.angle = angle; X graphics.strokefont.slant = slant; X X if (angle == 0.0) graphics.strokefont.angle_flag = FALSE; X else graphics.strokefont.angle_flag = TRUE; X X if (slant == 0.0) graphics.strokefont.slant_flag = FALSE; X else graphics.strokefont.slant_flag = TRUE; X X return(0); X} X XxX--EOF--XxX echo restoring gf_types.h sed 's/^X//' > gf_types.h <<XxX--EOF--XxX X/****** Warning! Do not alter this file without updating gl.h! *******/ X X/* @(#) gf_types.h 5.1 89/02/20 */ X/* X * Copyright (c) David T. Lewis 1988 X * All rights reserved. X * X * Permission is granted to use this for any personal noncommercial use. X * You may not distribute source or executable code for profit, nor X * may you distribute it with a commercial product without the written X * consent of the author. Please send modifications to the author for X * inclusion in updates to the program. Thanks. X */ X X/* Definition(s) required for more than one include file. X */ X X/* Define pixel setting modes. */ X X#define CLEAR 0 X#define AND 1 X#define OR 2 X#define XOR 3 X X/* Define colors. */ X X#define BLACK 0 X#define BLUE 1 X#define GREEN 2 X#define CYAN 3 X#define RED 4 X#define MAGENTA 5 X#define BROWN 6 X#define WHITE 7 X#define GREY 8 X#define LT_BLUE 9 X#define LT_GREEN 10 X#define LT_CYAN 11 X#define LT_RED 12 X#define LT_MAGENTA 13 X#define YELLOW 14 X#define LT_WHITE 15 X X/* Define line styles (not yet implemented). */ X X#define SOLID 0xffffffffL /* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */ X#define DOTTED 0x66666666L /* XX..XX..XX..XX..XX..XX..XX..XX.. */ X#define DASHED 0xffe0ffe0L /* XXXXXXXXXXX.....XXXXXXXXXXX..... */ X#define SHORTDASHED 0xf8f8f8f8L /* XXXXX...XXXXX...XXXXX...XXXXX... */ X#define LONGDASHED 0xffffff00L /* XXXXXXXXXXXXXXXXXXXXXXXX........ */ X#define DOTDASHED 0xfc30fc30L /* XXXXXX....XX....XXXXXX....XX.... */ X X/* Define line weights (not yet implemented). */ X X#define LIGHT 1 X#define MEDIUM 2 X#define HEAVY 4 X X XxX--EOF--XxX echo restoring gl.h sed 's/^X//' > gl.h <<XxX--EOF--XxX X/* @(#) gl.h 5.1 89/02/20 */ X/* X * Copyright (c) David T. Lewis 1988 X * All rights reserved. X * X * Permission is granted to use this for any personal noncommercial use. X * You may not distribute source or executable code for profit, nor X * may you distribute it with a commercial product without the written X * consent of the author. Please send modifications to the author for X * inclusion in updates to the program. Thanks. X */ X X/* This file defines the interface to the graphics library, and should X * be included in user programs. X */ X X/* Definition of programming interface to gl library. */ X Xextern int g_clear(); Xextern int g_init(); Xextern int g_finish(); Xextern int g_pix_mode(); Xextern int g_pix_color(); Xextern int g_fontctl(); Xextern long g_style(); Xextern int g_weight(); Xextern int p_wr_pix(); Xextern int c_cellchar(); Xextern int c_cellstr(); Xextern int c_cursor(); Xextern int n_movepen(); Xextern int n_box(); Xextern int n_line(); Xextern int n_draw(); Xextern int n_grafchar(); Xextern int n_grafstr(); Xextern int n_arc(); Xextern int n_ellipse(); Xextern int n_point(); X X/* Everything that follows should be identical to gf_types.h and modes.h. */ X X/* @(#) gf_types.h 1.4 88/12/26 */ X X/* Define pixel setting modes. */ X X#define CLEAR 0 X#define AND 1 X#define OR 2 X#define XOR 3 X X/* Define colors. */ X X#define BLACK 0 X#define BLUE 1 X#define GREEN 2 X#define CYAN 3 X#define RED 4 X#define MAGENTA 5 X#define BROWN 6 X#define WHITE 7 X#define GREY 8 X#define LT_BLUE 9 X#define LT_GREEN 10 X#define LT_CYAN 11 X#define LT_RED 12 X#define LT_MAGENTA 13 X#define YELLOW 14 X#define LT_WHITE 15 X X/* Define line styles. */ X X#define SOLID 0xffffffffL /* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */ X#define DOTTED 0x66666666L /* XX..XX..XX..XX..XX..XX..XX..XX.. */ X#define DASHED 0xffe0ffe0L /* XXXXXXXXXXX.....XXXXXXXXXXX..... */ X#define SHORTDASHED 0xf8f8f8f8L /* XXXXX...XXXXX...XXXXX...XXXXX... */ X#define LONGDASHED 0xffffff00L /* XXXXXXXXXXXXXXXXXXXXXXXX........ */ X#define DOTDASHED 0xfc30fc30L /* XXXXXX....XX....XXXXXX....XX.... */ X X/* Define line weights (not yet implemented). */ X X#define LIGHT 1 X#define MEDIUM 2 X#define HEAVY 4 X X/* @(#) modes.h 1.4 89/01/10 */ X X/* X * Mode definitions. These will be used by init(), and by the mode X * program or shell script. As much as possible, the numeric mode X * values should correspond to those used by the uPort screen driver X * and by DOS. The values given for hercules and for printers are X * arbitrary, but should not conflict with other "standard" assignments. X */ X X/* ENV_MODE means take the mode setting from an environment variable. */ X#define ENV_MODE 0 X X/* CGA text modes */ X#define MONO_TEXT 0x02 X#define COLOR_TEXT 0x03 X X/* CGA modes (for CGA or EGA) */ X#define CGA_COLOR_MODE 0x04 X#define CGA_HI_RES_MODE 0x06 X X/* Monochrome text mode */ X#define MDA_TEXT 0x07 X X/* Hercules mono graphics, page 0 and page 1 */ X/* Note: Modes 8 and 9 were used by the IBM PC Junior. I trust that */ X/* they will not be found on your machine. */ X#define HERC_P0_MODE 0x08 X#define HERC_P1_MODE 0x09 X X/* EGA 640 x 350 color mode */ X#define EGA_COLOR_MODE 0x010 X X/* Anything beyond MAXVIDEO is not a video board. Printers and other */ X/* hardcopy would fall in this category. */ X X#define MAXVIDEO 0x0FF X X/* Non-video modes follow. */ X X#define IBM_PRINTER 0x100 X X XxX--EOF--XxX echo restoring modes.h sed 's/^X//' > modes.h <<XxX--EOF--XxX X/****** Warning! Do not alter this file without updating gl.h! *******/ X X/* @(#) modes.h 5.1 89/02/20 */ X/* X * Copyright (c) David T. Lewis 1987, 1988 X * All rights reserved. X * X * Permission is granted to use this for any personal noncommercial use. X * You may not distribute source or executable code for profit, nor X * may you distribute it with a commercial product without the written X * consent of the author. Please send modifications to the author for X * inclusion in updates to the program. Thanks. X */ X X/* X * Mode definitions. These will be used by init(), and by the mode X * program or shell script. As much as possible, the numeric mode X * values should correspond to those used by the uPort screen driver X * and by DOS. The values given for hercules and for printers are X * arbitrary, but should not conflict with other "standard" assignments. X */ X X/* ENV_MODE means take the mode setting from an environment variable. */ X#define ENV_MODE 0 X X/* CGA text modes */ X#define MONO_TEXT 0x02 X#define COLOR_TEXT 0x03 X X/* CGA modes (for CGA or EGA) */ X#define CGA_COLOR_MODE 0x04 X#define CGA_HI_RES_MODE 0x06 X X/* Monochrome text mode */ X#define MDA_TEXT 0x07 X X/* Hercules mono graphics, page 0 and page 1 */ X/* Note: Modes 8 and 9 were used by the IBM PC Junior. I trust that */ X/* they will not be found on your machine. */ X#define HERC_P0_MODE 0x08 X#define HERC_P1_MODE 0x09 X X/* EGA 640 x 350 color mode */ X#define EGA_COLOR_MODE 0x010 X X/* Anything beyond MAXVIDEO is not a video board. Printers and other */ X/* hardcopy would fall in this category. */ X X#define MAXVIDEO 0x0FF X X/* Non-video modes follow. */ X X#define IBM_PRINTER 0x100 X#define LJ_PRINTER 0x101 X X XxX--EOF--XxX echo restoring n_curves.c sed 's/^X//' > n_curves.c <<XxX--EOF--XxX X#ifndef lint Xstatic char sccsid[] = "@(#) n_curves.c 5.1 89/02/20"; X#endif X X/* X * Copyright (c) David T. Lewis 1988 X * All rights reserved. X * X * Permission is granted to use this for any personal noncommercial use. X * You may not distribute source or executable code for profit, nor X * may you distribute it with a commercial product without the written X * consent of the author. Please send modifications to the author for X * inclusion in updates to the program. Thanks. X */ X X/* Sat Aug 6 20:38:14 EDT 1988 X** X** n_arc(): X** X** Routine to draw an arc as a partial ellipse. This routine uses X** parts of the ellipse() routine to generate the curve. X** The arc is drawn around an ellipse located at (x,y) with axes a and b. X** The arc begins at the angle angle1 and traverses counterclockwise to X** angle2. "Counterclockwise" is in the sense of the normalized coordinate X** system, with an inverted Y axis, so the arcs are actually drawn clockwise X** on the display screen. X** The values of angle1 and angle2 are given in radians, with 0 being to the X** right of the center of the ellipse. X** X** n_ellipse(): X** X** Routine to draw an ellipse in normalized 2-d coordinates. Uses a line X** segment approximation to the ellipse. The trig is done with hard coded X** tables of cos and sin values for speed. The number of vertices on the X** ellipse varies according to the size of the ellipse. The eliminates X** unnecessary calculations of endpoints for small images. X** Another method for ellipe drawing would be to do a modified Bresenham X** type algorithm, but this would be less adaptable for drawing partial arcs. X** X** NOTE: This is an ellipse routine, and not a circle, because the PC display X** adapters do not generally have square pixels. A circle routine should be X** done at a higher level, and should take the screen aspect ration into X** account (see graphics->aspect_ratio in the graphics.h file). X** X** The basic idea is: X** X** Equation of an ellipse: X** X** x^2 / a^2 + y^2 / b^2 = 1 X** X** Therefore the X and Y values are: X** X** X = a * cos(theta) X** Y = b * sin(theta) X** X** For some angle theta. X** X** By stepping through values of theta, we can generate a list of X** line segment endpoints on the ellipse. Then call n_movepen() and X** n_draw() to display the ellipse. X** X** Note: The macros PTS_PER_QUADRANT and TRIG_SCALE are defined X** in graphics.h. X*/ X X#include "config.h" X#if MIX_C X#else X#include <math.h> X#endif /* MIX_C */ X#include "bitmaps.h" X#include "graphics.h" X X#ifndef M_PI X#define M_PI 3.1415926536 X#endif /* M_PI */ X#ifndef M_PI_2 X#define M_PI_2 1.5707963268 X#endif /* M_PI_2 */ X X#define XINDEX 0 /* For specifying array indices. */ X#define YINDEX 1 X X/* The following two arrays are tables of values for cos and sin */ X/* for one quadrant of a circle, divided into PTS_PER_QUADRANT slices. */ X/* They are found in source file trig.c. */ X Xextern long cos_table[PTS_PER_QUADRANT]; Xextern long sin_table[PTS_PER_QUADRANT]; Xextern long longsin(), longcos(); Xextern int n_movepen(), n_draw(); X Xstatic void make_endpoints(x,y,a,b,endpoints,step) Xint x,y,a,b,step; Xint endpoints[4][PTS_PER_QUADRANT][2]; X{ X int idx; /* Loop index. */ X int value; /* Temporary storage of values */ X X /* Set the values for points on the ellipse. While we're */ X /* at it, scale the values back down using TRIG_SCALE, and do */ X /* the x and y translation to the center point of the ellipse. */ X /* Calculations are done with long ints to preserve precision, */ X /* then cast back to short ints in the endpoints array. */ X /* Use the value of step to skip unnecessary points (for small */ X /* ellipes and arcs). */ X X for(idx=step-1; idx<PTS_PER_QUADRANT; idx+= step) { X value = (cos_table[idx] * (long)a) / TRIG_SCALE; X endpoints[0][idx][XINDEX] = value + x; X value = -value; X endpoints[2][idx][XINDEX] = value + x; X value = (sin_table[idx] * (long)a) / TRIG_SCALE; X endpoints[3][idx][XINDEX] = value + x; X value = -value; X endpoints[1][idx][XINDEX] = value + x; X value = (cos_table[idx] * (long)b) / TRIG_SCALE; X endpoints[1][idx][YINDEX] = value + y; X value = -value; X endpoints[3][idx][YINDEX] = value + y; X value = (sin_table[idx] * (long)b) / TRIG_SCALE; X endpoints[0][idx][YINDEX] = value + y; X value = -value; X endpoints[2][idx][YINDEX] = value + y; X } X return; X} X Xstatic int make_step(a,b) Xint a,b; X{ X int size; X size = a + b; /* an indication of the "size" of the ellipse. */ X if (size <= 0) return(1); /* Check for integer overflow. */ X else if (size < 2000) return(16); X else if (size < 8000) return(8); X else if (size < 16000) return(4); X else if (size < 32000) return(2); X else return(1); X} X Xint n_arc(x,y,a,b,angle1,angle2) Xint x,y,a,b; Xfloat angle1,angle2; X{ X int endpoints[4][PTS_PER_QUADRANT][2]; X int x_1,y_1,x_2,y_2; /* The start and end points of the arc. */ X int quadrant; /* Quadrant of first point. */ X int endquadrant; /* Quadrant of second point. */ X int index; /* First index into endpoints array. */ X int endindex; /* Last index into endpoints array. */ X int istat = 0; /* Function call return status. */ X int step; /* Amount by which to step through array. */ X X /* Size of a circle, in radians. */ X float cir_size = M_PI * 2; X X /* Don't feed huge numbers to the trig functions. */ X if (fabs(angle1) > cir_size) X angle1 = fmod((double)angle1,(double)cir_size); X if (fabs(angle2) > cir_size) X angle2 = fmod((double)angle2,(double)cir_size); X X /* Make the angles positive. */ X while (angle1 < 0) angle1 += cir_size; X while (angle2 < 0) angle2 += cir_size; X X /* Calculate a value for step, so we can use fewer endpoints */ X /* for small arcs. */ X step = make_step(a,b); X X#ifdef DEBUG X printf("step is %d\n",step); X#endif /* DEBUG */ X X /* Calculate the end points. */ X X#if NOFLOAT X x_1 = x + (int)((longcos(angle1) * a) / TRIG_SCALE); X y_1 = y + (int)((longsin(angle1) * b) / TRIG_SCALE); X x_2 = x + (int)((longcos(angle2) * a) / TRIG_SCALE); X y_2 = y + (int)((longsin(angle2) * b) / TRIG_SCALE); X#else X x_1 = x + (int)(a * cos((double)angle1)); X y_1 = y + (int)(b * sin((double)angle1)); X x_2 = x + (int)(a * cos((double)angle2)); X y_2 = y + (int)(b * sin((double)angle2)); X#endif /* NOFLOAT */ X X /* Generate the array of arc endpoints. */ X make_endpoints(x,y,a,b,endpoints,step); X X /* Deduce the first and last element of interest in the */ X /* endpoint array. */ X X /* First calculate the initial index value. */ X index = (int)(angle1 / M_PI_2 * (float)PTS_PER_QUADRANT); X /* Now figure the quadrant. */ X quadrant = (index / PTS_PER_QUADRANT) % 4; X /* Wrap around so we point at the array. */ X index = (index % PTS_PER_QUADRANT); X index = index + step - (index % step) - 1; X X#ifdef DEBUG X printf("In n_arc(), index is %d\n",index); X#endif /* DEBUG */ X X /* Calculate the final index value. */ X endindex = (int)(angle2 / M_PI_2 * (float)PTS_PER_QUADRANT); X /* Now figure the quadrant. */ X endquadrant = (endindex / PTS_PER_QUADRANT) % 4; X /* Wrap around so we point at the array. */ X endindex = (endindex % PTS_PER_QUADRANT); X endindex = endindex + step - (endindex % step) - 1; X X#ifdef DEBUG X printf("In n_arc(), endindex is %d\n",endindex); X#endif /* DEBUG */ X X /* Move pen to start point. */ X X#ifdef DEBUG X printf("Move pen to %d %d\n",x_1,y_1); X#endif /* DEBUG */ X X if(n_movepen(x_1,y_1)) istat = 1; X X /* Start drawing, beginning with the first point of interest. */ X /* Wrap around the array if needed. */ X X while ((index != endindex) || (quadrant != endquadrant)) { X X#ifdef DEBUG X printf("Draw to %d %d -- quadrant %d index %d\n", X endpoints[quadrant][index][XINDEX], X endpoints[quadrant][index][YINDEX],quadrant,index); X#endif /* DEBUG */ X X if(n_draw(endpoints[quadrant][index][XINDEX], X endpoints[quadrant][index][YINDEX])) { X istat = 1; X /* This is just for cleaner error recovery: */ X n_movepen(endpoints[quadrant][index][XINDEX], X endpoints[quadrant][index][YINDEX]); X } X /* Increment the indices. */ X if ((index+=step) >= PTS_PER_QUADRANT) { X index = step - 1; X if ((++quadrant) >= 4) { X quadrant = 0; X } X } X }; X X /* Finish at last point of interest. */ X X#ifdef DEBUG X printf("Finish by drawing to %d %d\n",x_2,y_2); X#endif /* DEBUG */ X X if(n_draw(x_2,y_2)) { X istat = 1; X /* This is just for cleaner error recovery: */ X n_movepen(x_2,y_2); X } X return(istat); X} X Xint n_ellipse(x,y,a,b) Xint x,y,a,b; X{ X /* The endpoints array will hold line segment (x,y) end points. */ X /* There are four quadrants, each with PTS_PER_QUADRANT points, */ X /* with two values (X and Y) each. */ X int endpoints[4][PTS_PER_QUADRANT][2]; X int pointindex, quadrant; /* Loop index. */ X int istat = 0; /* Function call return status. */ X int step; /* Amount by which to step through array. */ X X /* Calculate a value for step, so we can use fewer endpoints */ X /* for small ellipses. */ X step = make_step(a,b); X X /* Build the array of endpoints. */ X make_endpoints(x,y,a,b,endpoints,step); X X /* Display the result, drawing all four quadrants. */ X X /* Start the pen at the location of the last endpoint. This */ X /* is the point we want to end up on. */ X if(n_movepen(endpoints[3][PTS_PER_QUADRANT-1][XINDEX], X endpoints[3][PTS_PER_QUADRANT-1][YINDEX])) X istat = 1; X X for (quadrant=0; quadrant<=3; quadrant++) { X X for (pointindex = step -1; pointindex < PTS_PER_QUADRANT; X pointindex += step) { X if(n_draw(endpoints[quadrant][pointindex][XINDEX], X endpoints[quadrant][pointindex][YINDEX])) { X istat = 1; X /* This is just for cleaner error recovery: */ X n_movepen(endpoints[quadrant][pointindex] X [XINDEX], X endpoints[quadrant][pointindex] X [YINDEX]); X } X } X } X return(istat); X} X XxX--EOF--XxX echo restoring plot.c sed 's/^X//' > plot.c <<XxX--EOF--XxX X#ifndef lint Xstatic char sccsid[] = "@(#) plot.c 5.1 89/02/20"; X#endif X X/* X * Copyright (c) David T. Lewis 1988 X * All rights reserved. X * X * Permission is granted to use this for any personal noncommercial use. X * You may not distribute source or executable code for profit, nor X * may you distribute it with a commercial product without the written X * consent of the author. Please send modifications to the author for X * inclusion in updates to the program. Thanks. X */ X X#include "config.h" X#include "gf_types.h" X#include <stdio.h> X#if MIX_C X#else X#include <math.h> X#endif /* MIX_C */ X#include "modes.h" X#include "bitmaps.h" X#include "graphics.h" X X/* The following declarations copied from gl.h. */ Xextern int g_clear(); Xextern int g_init(); Xextern int g_finish(); Xextern long g_style(); Xextern int c_cellstr(); Xextern int n_movepen(); Xextern int n_line(); Xextern int n_draw(); Xextern int n_arc(); Xextern int n_ellipse(); Xextern int n_point(); X Xextern struct GL_graphics graphics; X X/* These routines emulate the BSD plot(3) library. X * X * The arc() routine may vary slightly from the BSD version, X * in that it calculates start and end angles with trig X * functions, rather than with simple integer approximations X * used in the BSD routine. X * X * plot: openpl, erase, label, line, circle, arc, move, cont, X * point, linemod, space, closepl - graphics interface X * X * Coordinate transformations, using X0, X1, Y0, Y1 set in space(): X * X: X * x' = x * (NRM_X_RANGE)/(X1-X0) - (X0*NRM_X_RANGE)/(X1-X0) X * x' = (X0*NRM_X_RANGE + x*NRM_X_RANGE) / (X1-X0) X * X * xconst = X0*NRM_X_RANGE; X * xdiv = X1-X0; X * x' = (xconst+x*NRM_X_RANGE)/xdiv; X * X * Y: X * y' = y * (-NRM_Y_RANGE)/(Y1-Y0) + (Y1*NRM_Y_RANGE)/(Y1-Y0) X * y' = (Y1*NRM_Y_RANGE - y*NRM_Y_RANGE) / (Y1-Y0) X * X * yconst = Y1*NRM_Y_RANGE; X * ydiv = Y1-Y0; X * y' = (yconst-y*NRM_Y_RANGE)/ydiv; X */ X X/* X_TO_NORM(x) and Y_TO_NORM(y) are used to translate from the plot() */ X/* coordinate system, as defined by scale(), to the normalized 2-D */ X/* coordinate system of the screen. */ X X#define X_TO_NORM(x) ((int)((xconst+x*NRM_X_RANGE)/xdiv)) X#define Y_TO_NORM(y) ((int)((yconst-y*NRM_Y_RANGE)/ydiv)) X X/* X_SCALE_NORM() and Y_SCALE_NORM() are used for scaling magnitudes. */ X X#define X_SCALE_NORM(x) (((x)*(NRM_X_RANGE))/(xdiv)) X#define Y_SCALE_NORM(y) (((y)*(NRM_Y_RANGE))/(ydiv)) X Xstatic long xconst,xdiv,yconst,ydiv; /* Used in space() transforms. */ X Xint openpl() X{ X /* Try to get the mode from the environment. */ X /* If no environment variable, use a default. */ X if((g_init(ENV_MODE)) == 0) return(0); X else { X /* Put warning message to standard error, then */ X /* continue. */ X fprintf(stderr,"Use environment variable %s to control mode.\n", X GL_ENV_MODE); X fprintf(stderr,"Continuing with default mode %d\n", X DEFAULT_MODE); X sleep(2); X return(g_init(DEFAULT_MODE)); X } X} X Xint erase() X{ X return(g_clear()); X} X Xint label(s) Xchar s[]; X{ X return(c_cellstr(s)); X} X Xint line(x_1, y_1, x_2, y_2) Xint x_1,y_1,x_2,y_2; X{ X return(n_line( X X_TO_NORM(x_1),Y_TO_NORM(y_1),X_TO_NORM(x_2),Y_TO_NORM(y_2))); X} X Xint circle(x, y, r) X{ X int x_axis=X_SCALE_NORM(r); X int y_axis=Y_SCALE_NORM(r); X return(n_ellipse(X_TO_NORM(x), Y_TO_NORM(y), x_axis, y_axis)); X} X Xint arc(x, y, x_0, y_0, x_1, y_1) X{ X int x_axis, y_axis; /* Major and minor axes. */ X float angle1, angle2; /* Start and end angles. */ X int radius; /* Radius, as calculated from sqrt(x**2+y**2). */ X long dx_0 = x_0 - x; X long dy_0 = y_0 - y; X long dx_1 = x_1 - x; X long dy_1 = y_1 - y; X X /* We will draw a section of elliptical arc with major and */ X /* minor axes such that it appears as a circle on the screen. */ X /* We know the center of the arc (x and y), and the ratio of */ X /* the major and minor axes (b/a equals graphics.aspect_ratio). */ X /* Given the start and end points of the arc, we need to solve */ X /* for the first and second angle, and then for major and minor */ X /* axes. */ X /* These values can be used to call the n_arc() routine. */ X X /* WARNING: The value of angle2 is calculated directly as the */ X /* angle of the vector from (x,y) to (x_1,y_1). The original */ X /* versions of plot(3) from the BSD code apparently use */ X /* a simplistic approximation to this, which may lead to */ X /* different screen displays for arcs drawn with the BSD */ X /* code. The basic idea for the user, however, should be to */ X /* specify x_1 and y_1 such that they fall very close to the */ X /* intended angle. */ X X angle1 = (float)(-atan2((double)dy_0,(double)dx_0)); X angle2 = (float)(-atan2((double)dy_1,(double)dx_1)); X X radius = ((int)(sqrt(fabs((double)(dx_0*dx_0+dy_0*dy_0))))); X x_axis = X_SCALE_NORM(radius); X y_axis = Y_SCALE_NORM(radius); X X return(n_arc(X_TO_NORM(x),Y_TO_NORM(y),x_axis,y_axis,angle2,angle1)); X} X Xint move(x, y) Xint x,y; X{ X return(n_movepen(X_TO_NORM(x),Y_TO_NORM(y))); X} X Xint cont(x, y) Xint x,y; X{ X return(n_draw(X_TO_NORM(x),Y_TO_NORM(y))); X} X Xint point(x, y) Xint x, y; X{ X return(n_point(X_TO_NORM(x),Y_TO_NORM(y))); X} X Xint linemod(s) Xchar s[]; X{ X if (strncmp(s, "dotted", 6) == 0) { X g_style(DOTTED); X } X else if (strncmp(s, "dotdashed", 9) == 0) { X g_style(DOTDASHED); X } X else if (strncmp(s, "longdashed", 10) == 0) { X g_style(LONGDASHED); X } X else if (strncmp(s, "shortdashed", 11) == 0) { X g_style(SHORTDASHED); X } X else if (strncmp(s, "solid", 5) == 0) { X g_style(SOLID); X } X else { X g_style(SOLID); X } X return(0); X} X Xint space(x_0, y_0, x_1, y_1) X{ X /* Set constants for coordinate transformations. */ X /* Adjust x axis for aspect ratio so that output is square. */ X X xconst = (long)(x_0) * NRM_X_RANGE; X xdiv = (long)((float)(x_1-x_0) / graphics.aspect_ratio); X yconst = y_1*NRM_Y_RANGE; X ydiv = y_1-y_0; X} X Xint closepl() X{ X return(g_finish()); X} X XxX--EOF--XxX echo restoring trig.c sed 's/^X//' > trig.c <<XxX--EOF--XxX X#ifndef lint Xstatic char sccsid[] = "@(#) trig.c 5.1 89/02/20"; X#endif X X/* X * Copyright (c) David T. Lewis 1988 X * All rights reserved. X * X * Permission is granted to use this for any personal noncommercial use. X * You may not distribute source or executable code for profit, nor X * may you distribute it with a commercial product without the written X * consent of the author. Please send modifications to the author for X * inclusion in updates to the program. Thanks. X */ X X/* Integer approximations to simple trig functions. Results are scaled */ X/* by a factor of TRIG_SCALE. */ X X/* The macro TRIG_SCALE is defined in graphics.h so that other routines */ X/* can use it. F_TRIG_SCALE is the same value, but in floating point */ X/* format. The defines should look like this: */ X/* */ X/* #define TRIG_SCALE 32768 */ X/* #define F_TRIG_SCALE 32768.0 */ X/* */ X/* The macro PTS_PER_QUADRANT defines the size of the sin_table and */ X/* cos_table arrays. It is defined in graphics.h and should look */ X/* like this: */ X/* */ X/* #define PTS_PER_QUADRANT 64 */ X/* */ X X#include "config.h" X#if MIX_C X#else X#include <math.h> X#endif /* MIX_C */ X#include "bitmaps.h" X#include "graphics.h" X X#define L_PI 102944L /* Value of pi times TRIG_SCALE. */ X#define L_PI_2 51472L /* Value of pi/2 times TRIG_SCALE. */ X#define L_PI_4 25736L /* Value of pi/4 times TRIG_SCALE. */ X X#define CIRCLE_SIZE 205887L /* Value of pi * 2 * TRIG_SCALE. */ X X#define TABLESLICE 804L /* (L_PI_2 / PTS_PER_QUADRANT) */ X X#define XINDEX 0 /* For specifying array indices. */ X#define YINDEX 1 X X/* The following two arrays are tables of values for cos and sin */ X/* for one quadrant of a circle, divided into PTS_PER_QUADRANT slices. */ X Xlong cos_table[PTS_PER_QUADRANT] = { X 32758L, 32729L, 32679L, 32610L, 32522L, 32413L, 32286L, 32138L, X 31972L, 31786L, 31581L, 31357L, 31114L, 30853L, 30572L, 30274L, X 29957L, 29622L, 29269L, 28899L, 28511L, 28106L, 27684L, 27246L, X 26791L, 26320L, 25833L, 25330L, 24812L, 24279L, 23732L, 23170L, X 22595L, 22006L, 21403L, 20788L, 20160L, 19520L, 18868L, 18205L, X 17531L, 16846L, 16151L, 15447L, 14733L, 14010L, 13279L, 12540L, X 11793L, 11039L, 10279L, 9512L, 8740L, 7962L, 7180L, 6393L, X 5602L, 4808L, 4011L, 3212L, 2411L, 1608L, 804L, 0L X}; X Xlong sin_table[PTS_PER_QUADRANT] = { X 804L, 1608L, 2411L, 3212L, 4011L, 4808L, 5602L, 6393L, X 7180L, 7962L, 8740L, 9512L, 10279L, 11039L, 11793L, 12540L, X 13279L, 14010L, 14733L, 15447L, 16151L, 16846L, 17531L, 18205L, X 18868L, 19520L, 20160L, 20788L, 21403L, 22006L, 22595L, 23170L, X 23732L, 24279L, 24812L, 25330L, 25833L, 26320L, 26791L, 27246L, X 27684L, 28106L, 28511L, 28899L, 29269L, 29622L, 29957L, 30274L, X 30572L, 30853L, 31114L, 31357L, 31581L, 31786L, 31972L, 32138L, X 32286L, 32413L, 32522L, 32610L, 32679L, 32729L, 32758L, 32768L X}; X X/* Estimate sin by interpolation. Return long integer value. */ X Xlong longsin(theta) Xfloat theta; X{ X long longtheta; X int quadrant; X long value1, value2; X long value; X long intpart; X long fractionpart; X X /* We have a floating point value for theta. Put theta */ X /* into a long integer for the rest of the processing. */ X /* Keep everything scaled by a factor of TRIG_SCALE. */ X X longtheta = (long)(theta * F_TRIG_SCALE); X X /* Make angle positive. */ X X while (longtheta < 0) longtheta += CIRCLE_SIZE; X X /* Figure quadrant while making it less than PI/2. */ X X quadrant = 1; X X while (longtheta > L_PI_2) { X longtheta -= L_PI_2; X quadrant++; X if (quadrant > 4) quadrant = 1; X } X X /* If Quadrant 2 or 4 we need to use the reverse of the */ X /* interpolation table. */ X X if (quadrant == 2 || quadrant == 4) longtheta = L_PI_2 - longtheta; X X /* Express angle in terms of number of table increments. */ X X intpart = longtheta / TABLESLICE; X X fractionpart = longtheta % TABLESLICE; X X /* This looks like a kludge, but it isn't. When TABLESLICE is */ X /* set to TABLESLICE, we have the smallest error in the result. */ X /* This just rounds back down when we overshoot the table. */ X X if (intpart >= PTS_PER_QUADRANT) { X intpart = PTS_PER_QUADRANT - 1; X fractionpart = TABLESLICE; X } X X /* Interpolate. */ X X if (intpart <= 0) { X value1 = 0; X value2 = sin_table[0]; X } X else { X value2 = sin_table[(int)(intpart--)]; X value1 = sin_table[(int)intpart]; X } X X value = value1 + (fractionpart * (value2 - value1)) / TABLESLICE; X X /* If Quadrant 3 or 4 the result should be negative. */ X X if (quadrant == 3 || quadrant == 4) return(-value); X else return(value); X} X X X/* Estimate cos by interpolation. Return long integer value. */ X Xlong longcos(theta) Xfloat theta; X{ X long longtheta; X int quadrant; X long value1, value2; X long value; X long intpart; X long fractionpart; X X /* We have a floating point value for theta. Put theta */ X /* into a long integer for the rest of the processing. */ X /* Keep everything scaled by a factor of TRIG_SCALE. */ X X longtheta = (long)(theta * F_TRIG_SCALE); X X /* Make angle positive. */ X X while (longtheta < 0) longtheta += CIRCLE_SIZE; X X /* Figure quadrant while making it less than PI/2. */ X X quadrant = 1; X X while (longtheta > L_PI_2) { X longtheta -= L_PI_2; X quadrant++; X if (quadrant > 4) quadrant = 1; X } X X /* If Quadrant 2 or 4 we need to use the reverse of the */ X /* interpolation table. */ X X if (quadrant == 2 || quadrant == 4) longtheta = L_PI_2 - longtheta; X X /* Express angle in terms of number of table increments. */ X X intpart = longtheta / TABLESLICE; X X fractionpart = longtheta % TABLESLICE; X X /* This looks like a kludge, but it isn't. When TABLESLICE is */ X /* set to TABLESLICE, we have the smallest error in the result. */ X /* This just rounds back down when we overshoot the table. */ X X if (intpart >= PTS_PER_QUADRANT) { X intpart = PTS_PER_QUADRANT - 1; X fractionpart = TABLESLICE; X } X X /* Interpolate. */ X X if (intpart <= 0) { X value1 = 32768L; X value2 = cos_table[0]; X } X else { X value2 = cos_table[(int)(intpart--)]; X value1 = cos_table[(int)intpart]; X } X X value = value1 + (fractionpart * (value2 - value1)) / TABLESLICE; X X /* If Quadrant 2 or 3 the result should be negative. */ X X if (quadrant == 2 || quadrant == 3) return(-value); X else return(value); X} X X/* Test program: Xmain() { X float theta; X Xfloat sinval; Xfloat lsinval; Xfloat cosval; Xfloat lcosval; X X for (theta = -8.3; theta < 100.0; theta += 0.1) { X X sinval = sin((double)theta); X lsinval = longsin(theta) / F_TRIG_SCALE; X cosval = cos((double)theta); X lcosval = longcos(theta) / F_TRIG_SCALE; X X printf("SIN: angle %g %lg %g err %g\n",theta,sinval, X lsinval,sinval-lsinval); X printf("COS: angle %g %lg %g err %g\n",theta,cosval, X lcosval,cosval-lcosval); X } X} X*/ X XxX--EOF--XxX