jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Added GIFPlot example

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@219 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Dave Beazley 2000-02-11 05:37:31 +00:00
commit a6743ff85a
49 changed files with 8487 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

329
Examples/GIFPlot/Include/gifplot.h Normal file
View file

@ -0,0 +1,329 @@
/* -----------------------------------------------------------------------------
* gifplot.h
*
* Main header file for the GIFPlot library.
*
* Author(s) : David Beazley (beazley@cs.uchicago.edu)
* Copyright (C) 1995-1996
*
* See the file LICENSE for information on usage and redistribution.
* ----------------------------------------------------------------------------- */
#include <stdio.h>
#include <fcntl.h>
#include <float.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#ifndef GIFPLOT_H
/* Pixel is 8-bits */
typedef unsigned char Pixel;
typedef float Zvalue;
/* ------------------------------------------------------------------------
ColorMap
Definition and methods for colormaps
------------------------------------------------------------------------ */
typedef struct ColorMap {
unsigned char *cmap;
char *name;
} ColorMap;
extern ColorMap *new_ColorMap(char *filename);
extern void delete_ColorMap(ColorMap *c);
extern void ColorMap_default(ColorMap *c);
extern void ColorMap_assign(ColorMap *c, int index, int r, int g, int b);
extern int ColorMap_getitem(ColorMap *c, int index);
extern void ColorMap_setitem(ColorMap *c, int index, int value);
extern int ColorMap_write(ColorMap *c, char *filename);
/* Some default colors */
#define BLACK 0
#define WHITE 1
#define RED 2
#define GREEN 3
#define BLUE 4
#define YELLOW 5
#define CYAN 6
#define MAGENTA 7
/*-------------------------------------------------------------------------
FrameBuffer
This structure defines a simple 8 bit framebuffer.
------------------------------------------------------------------------- */
typedef struct FrameBuffer {
Pixel **pixels;
Zvalue **zbuffer;
unsigned int height;
unsigned int width;
int xmin; /* These are used for clipping */
int ymin;
int xmax;
int ymax;
} FrameBuffer;
#define ZMIN 1e+36
/* FrameBuffer Methods */
extern FrameBuffer *new_FrameBuffer(unsigned int width, unsigned int height);
extern void delete_FrameBuffer(FrameBuffer *frame);
extern int FrameBuffer_resize(FrameBuffer *frame, int width, int height);
extern void FrameBuffer_clear(FrameBuffer *frame, Pixel color);
extern void FrameBuffer_plot(FrameBuffer *frame, int x, int y, Pixel color);
extern void FrameBuffer_horizontal(FrameBuffer *frame, int xmin, int xmax, int y, Pixel color);
extern void FrameBuffer_horizontalinterp(FrameBuffer *f, int xmin, int xmax, int y, Pixel c1, Pixel c2);
extern void FrameBuffer_vertical(FrameBuffer *frame, int ymin, int ymax, int x, Pixel color);
extern void FrameBuffer_box(FrameBuffer *frame, int x1, int y1, int x2, int y2, Pixel color);
extern void FrameBuffer_solidbox(FrameBuffer *frame, int x1, int y1, int x2, int y2, Pixel color);
extern void FrameBuffer_interpbox(FrameBuffer *f, int x1, int y1, int x2, int y2, Pixel c1, Pixel c2, Pixel c3, Pixel c4);
extern void FrameBuffer_circle(FrameBuffer *frame, int x1, int y1, int radius, Pixel color);
extern void FrameBuffer_solidcircle(FrameBuffer *frame, int x1, int y1, int radius, Pixel color);
extern void FrameBuffer_line(FrameBuffer *frame, int x1, int y1, int x2, int y2, Pixel color);
extern void FrameBuffer_setclip(FrameBuffer *frame, int xmin, int ymin, int xmax, int ymax);
extern void FrameBuffer_noclip(FrameBuffer *frame);
extern int FrameBuffer_makeGIF(FrameBuffer *frame, ColorMap *cmap, void *buffer, unsigned int maxsize);
extern int FrameBuffer_writeGIF(FrameBuffer *f, ColorMap *c, char *filename);
extern void FrameBuffer_zresize(FrameBuffer *f, int width, int height);
extern void FrameBuffer_zclear(FrameBuffer *f);
extern void FrameBuffer_solidtriangle(FrameBuffer *f, int x1, int y1, int x2, int y2, int x3, int y3, Pixel c);
extern void FrameBuffer_interptriangle(FrameBuffer *f, int tx1, int ty1, Pixel c1,
int tx2, int ty2, Pixel c2, int tx3, int ty3, Pixel c3);
#define HORIZONTAL 1
#define VERTICAL 2
extern void FrameBuffer_drawchar(FrameBuffer *frame, int x, int y, int fgcolor, int bgcolor, char chr, int orientation);
extern void FrameBuffer_drawstring(FrameBuffer *f, int x, int y, int fgcolor, int bgcolor, char *text, int orientation);
/* ------------------------------------------------------------------------
PixMap
The equivalent of "bit-maps".
------------------------------------------------------------------------ */
typedef struct PixMap {
int width;
int height;
int centerx;
int centery;
int *map;
} PixMap;
/* PIXMAP methods */
extern PixMap *new_PixMap(int width, int height, int centerx, int centery);
extern void delete_PixMap(PixMap *pm);
extern void PixMap_set(PixMap *pm, int x, int y, int pix);
extern void FrameBuffer_drawpixmap(FrameBuffer *f, PixMap *pm, int x, int y, int fgcolor, int bgcolor);
#define TRANSPARENT 0
#define FOREGROUND 1
#define BACKGROUND 2
/* ------------------------------------------------------------------------
Plot2D
Definition and methods for 2D plots.
------------------------------------------------------------------------ */
typedef struct Plot2D {
FrameBuffer *frame; /* what frame buffer are we using */
int view_xmin; /* Minimum coordinates of view region */
int view_ymin;
int view_xmax; /* Maximum coordinates of view region */
int view_ymax;
double xmin; /* Minimum coordinates of plot region */
double ymin;
double xmax; /* Maximum coordinates of plot region */
double ymax;
int xscale; /* Type of scaling (LINEAR, LOG, etc..) */
int yscale;
double dx; /* Private scaling parameters */
double dy;
} Plot2D;
/* 2D Plot methods */
extern Plot2D *new_Plot2D(FrameBuffer *frame,double xmin,double ymin, double xmax, double ymax);
extern void delete_Plot2D(Plot2D *p2);
extern Plot2D *Plot2D_copy(Plot2D *p2);
extern void Plot2D_clear(Plot2D *p2, Pixel c);
extern void Plot2D_setview(Plot2D *p2, int vxmin, int vymin, int vxmax, int vymax);
extern void Plot2D_setrange(Plot2D *p2, double xmin, double ymin, double xmax, double ymax);
extern void Plot2D_setscale(Plot2D *p2, int xscale, int yscale);
extern void Plot2D_plot(Plot2D *p2, double x, double y, Pixel color);
extern void Plot2D_box(Plot2D *p2, double x1, double y1, double x2, double y2, Pixel color);
extern void Plot2D_solidbox(Plot2D *p2, double x1, double y1,double x2, double y2, Pixel color);
extern void Plot2D_interpbox(Plot2D *p2, double x1, double y1, double x2, double y2, Pixel c1, Pixel c2, Pixel c3, Pixel c4);
extern void Plot2D_circle(Plot2D *p2, double x, double y, double radius, Pixel color);
extern void Plot2D_solidcircle(Plot2D *p2, double x, double y, double radius, Pixel color);
extern void Plot2D_line(Plot2D *p2, double x1, double y1, double x2, double y2, Pixel color);
extern void Plot2D_start(Plot2D *p2);
extern void Plot2D_drawpixmap(Plot2D *p2, PixMap *pm, double x, double y, Pixel color, Pixel bgcolor);
extern void Plot2D_xaxis(Plot2D *p2, double x, double y, double xtick, int ticklength, Pixel c);
extern void Plot2D_yaxis(Plot2D *p2, double x, double y, double ytick, int ticklength, Pixel c);
extern void Plot2D_triangle(Plot2D *p2, double x1, double y1, double x2, double y2, double x3, double y3, Pixel c);
extern void Plot2D_solidtriangle(Plot2D *p2, double x1, double y1, double x2, double y2, double x3, double y3, Pixel c);
extern void Plot2D_interptriangle(Plot2D *p2, double x1, double y1, Pixel c1,
double x2, double y2, Pixel c2,
double x3, double y3, Pixel c3);
#define LINEAR 10
#define LOG 11
/* -----------------------------------------------------------------------
Matrix
Operations on 4x4 transformation matrices and vectors.
Matrices are represented as a double array of 16 elements
----------------------------------------------------------------------- */
typedef double *Matrix;
typedef struct GL_Vector {
double x;
double y;
double z;
double w;
} GL_Vector;
extern Matrix new_Matrix();
extern void delete_Matrix(Matrix a);
extern Matrix Matrix_copy(Matrix a);
extern void Matrix_multiply(Matrix a, Matrix b, Matrix c);
extern void Matrix_identity(Matrix a);
extern void Matrix_zero(Matrix a);
extern void Matrix_transpose(Matrix a, Matrix result);
extern void Matrix_invert(Matrix a, Matrix inva);
extern void Matrix_transform(Matrix a, GL_Vector *r, GL_Vector *t);
extern void Matrix_transform4(Matrix a, double rx, double ry, double rz,
double rw, GL_Vector *t);
extern void Matrix_print(Matrix a);
extern void Matrix_translate(Matrix a, double tx, double ty, double tz);
extern void Matrix_rotatex(Matrix a, double deg);
extern void Matrix_rotatey(Matrix a, double deg);
extern void Matrix_rotatez(Matrix a, double deg);
/* -----------------------------------------------------------------------
Plot3D
Data Structure for 3-D plots
------------------------------------------------------------------------ */
typedef struct Plot3D {
FrameBuffer *frame; /* Frame buffer being used */
int view_xmin; /* Viewing region */
int view_ymin;
int view_xmax;
int view_ymax;
double xmin; /* Bounding box */
double ymin;
double zmin;
double xmax;
double ymax;
double zmax;
double xcenter; /* Center point */
double ycenter;
double zcenter;
double fovy; /* Field of view */
double aspect; /* Aspect ratio */
double znear; /* near "clipping" plane */
double zfar; /* far "clipping" plane */
Matrix center_mat; /* Matrix used for centering the model */
Matrix model_mat; /* Model rotation matrix */
Matrix view_mat; /* Viewing matrix */
Matrix fullmodel_mat; /* Full model matrix. Used by sphere plot */
Matrix trans_mat; /* Total transformation matrix */
double lookatz; /* Where is the z-lookat point */
double xshift; /* Used for translation and stuff */
double yshift;
double zoom;
int width;
int height;
int pers_mode; /* Perspective mode (private) */
double ortho_left,ortho_right,ortho_bottom,ortho_top;
} Plot3D;
extern Plot3D *new_Plot3D(FrameBuffer *frame, double xmin, double ymin, double zmin,
double xmax, double ymax, double zmax);
extern void delete_Plot3D(Plot3D *p3);
extern Plot3D *Plot3D_copy(Plot3D *p3);
extern void Plot3D_clear(Plot3D *p3, Pixel Color);
extern void Plot3D_perspective(Plot3D *p3, double fovy, double znear, double zfar);
extern void Plot3D_ortho(Plot3D *p3, double left, double right, double top, double bottom);
extern void Plot3D_lookat(Plot3D *p3, double z);
extern void Plot3D_autoperspective(Plot3D *p3, double fovy);
extern void Plot3D_autoortho(Plot3D *p3);
extern void Plot3D_rotx(Plot3D *p3, double deg);
extern void Plot3D_roty(Plot3D *p3, double deg);
extern void Plot3D_rotz(Plot3D *p3, double deg);
extern void Plot3D_rotl(Plot3D *p3, double deg);
extern void Plot3D_rotr(Plot3D *p3, double deg);
extern void Plot3D_rotd(Plot3D *p3, double deg);
extern void Plot3D_rotu(Plot3D *p3, double deg);
extern void Plot3D_rotc(Plot3D *p3, double deg);
extern void Plot3D_zoom(Plot3D *p3, double percent);
extern void Plot3D_left(Plot3D *p3, double percent);
extern void Plot3D_right(Plot3D *p3, double percent);
extern void Plot3D_down(Plot3D *p3, double percent);
extern void Plot3D_up(Plot3D *p3, double percent);
extern void Plot3D_center(Plot3D *p3, double cx, double cy);
extern void Plot3D_plot(Plot3D *p3, double x, double y, double z, Pixel Color);
extern void Plot3D_setview(Plot3D *p3, int vxmin, int vymin, int vxmax, int vymax);
extern void Plot3D_start(Plot3D *p3);
extern void Plot3D_line(Plot3D *p3, double x1, double y1, double z1,
double x2, double y2, double z2, Pixel color);
extern void Plot3D_triangle(Plot3D *p3, double x1, double y1, double z1,
double x2, double y2, double z2,
double x3, double y3, double z3, Pixel color);
extern void Plot3D_solidtriangle(Plot3D *p3, double x1, double y1, double z1,
double x2, double y2, double z2,
double x3, double y3, double z3, Pixel color);
extern void Plot3D_interptriangle(Plot3D *p3,
double x1, double y1, double z1, Pixel c1,
double x2, double y2, double z2, Pixel c2,
double x3, double y3, double z3, Pixel c3);
extern void Plot3D_quad(Plot3D *p3, double x1, double y1, double z1,
double x2, double y2, double z2,
double x3, double y3, double z3,
double x4, double y4, double z4,
Pixel color);
extern void Plot3D_solidquad(Plot3D *p3, double x1, double y1, double z1,
double x2, double y2, double z2,
double x3, double y3, double z3,
double x4, double y4, double z4,
Pixel color);
extern void Plot3D_interpquad(Plot3D *p3, double x1, double y1, double z1, Pixel c1,
double x2, double y2, double z2, Pixel c2,
double x3, double y3, double z3, Pixel c3,
double x4, double y4, double z4, Pixel c4);
extern void Plot3D_solidsphere(Plot3D *p3, double x, double y, double z, double radius,Pixel c);
extern void Plot3D_outlinesphere(Plot3D *p3, double x, double y, double z, double radius,Pixel c, Pixel bc);
extern PixMap PixMap_SQUARE;
extern PixMap PixMap_TRIANGLE;
extern PixMap PixMap_CROSS;
#endif
#define GIFPLOT_H

256
Examples/GIFPlot/Interface/gifplot.i Normal file
View file

@ -0,0 +1,256 @@
//
// Graphics module
//
%module gifplot
%{
#include "gifplot.h"
%}
/* Pixel is 8-bits */
typedef unsigned char Pixel;
typedef float Zvalue;
%disabledoc
/* ------------------------------------------------------------------------
ColorMap
Definition and methods for colormaps
------------------------------------------------------------------------ */
typedef struct ColorMap {
char *name;
//
// %addmethods adds some C methods to this structure to make it
// look like a C++ class in Python.
// These are really named things like ColorMap_default, ColorMap_assign, etc...
%addmethods {
ColorMap(char *filename);
~ColorMap();
void default();
void assign(int index,int r, int g, int b);
%name(__getitem__) int getitem(int index);
%name(__setitem__) void setitem(int index, int value);
int write(char *filename);
}
} ColorMap;
/* Some default colors */
#define BLACK 0
#define WHITE 1
#define RED 2
#define GREEN 3
#define BLUE 4
#define YELLOW 5
#define CYAN 6
#define MAGENTA 7
/*-------------------------------------------------------------------------
FrameBuffer
This structure defines a simple 8 bit framebuffer.
------------------------------------------------------------------------- */
typedef struct FrameBuffer {
unsigned int height;
unsigned int width;
int xmin; /* These are used for clipping */
int ymin;
int xmax;
int ymax;
%addmethods {
FrameBuffer(unsigned int width, unsigned int height);
~FrameBuffer();
void resize(int width, int height);
void clear(Pixel color);
void plot(int x, int y, Pixel color);
void horizontal(int xmin, int xmax, int y, Pixel color);
void horizontalinterp(int xmin, int xmax, int y, Pixel c1, Pixel c2);
void vertical(int ymin, int ymax, int x, Pixel color);
void box(int x1, int y1, int x2, int y2, Pixel color);
void solidbox(int x1, int y1, int x2, int y2, Pixel color);
void interpbox(int x1, int y1, int x2, int y2, Pixel c1, Pixel c2, Pixel c3, Pixel c4);
void circle(int x1, int y1, int radius, Pixel color);
void solidcircle(int x1, int y1, int radius, Pixel color);
void line(int x1, int y1, int x2, int y2, Pixel color);
void setclip(int xmin, int ymin, int xmax, int ymax);
void noclip();
int makeGIF(ColorMap *cmap, void *buffer, unsigned int maxsize);
void zresize(int width, int height);
void zclear();
void drawchar(int x, int y, int fgcolor, int bgcolor, char chr, int orientation);
void drawstring(int x, int y, int fgcolor, int bgcolor, char *text, int orientation);
void drawpixmap(PixMap *pm, int x, int y, int fgcolor, int bgcolor);
int writeGIF(ColorMap *cmap, char *filename);
}
} FrameBuffer;
#define HORIZONTAL 1
#define VERTICAL 2
/* --------------------------------------------------------------------------
PixMap
The equivalent of "bit-maps".
-------------------------------------------------------------------------- */
/* PIXMAP methods */
extern PixMap *new_PixMap(int width, int height, int centerx, int centery);
extern void delete_PixMap(PixMap *pm);
extern void PixMap_set(PixMap *pm, int x, int y, int pix);
#define TRANSPARENT 0
#define FOREGROUND 1
#define BACKGROUND 2
/* --------------------------------------------------------------------------
Plot2D
Definition and methods for 2D plots.
--------------------------------------------------------------------------- */
typedef struct Plot2D {
FrameBuffer *frame;
int view_xmin; /* Minimum coordinates of view region */
int view_ymin;
int view_xmax; /* Maximum coordinates of view region */
int view_ymax;
double xmin; /* Minimum coordinates of plot region */
double ymin;
double xmax; /* Maximum coordinates of plot region */
double ymax;
int xscale; /* Type of scaling (LINEAR, LOG, etc..) */
int yscale;
%addmethods {
Plot2D(FrameBuffer *frame,double xmin,double ymin, double xmax, double ymax);
~Plot2D();
Plot2D *copy();
void clear(Pixel c);
void setview(int vxmin, int vymin, int vxmax, int vymax);
void setrange(double xmin, double ymin, double xmax, double ymax);
void setscale(int xscale, int yscale);
void plot(double x, double y, Pixel color);
void box(double x1, double y1, double x2, double y2, Pixel color);
void solidbox(double x1, double y1, double x2, double y2, Pixel color);
void interpbox(double x1, double y1, double x2, double y2, Pixel c1, Pixel c2, Pixel c3, Pixel c4);
void circle(double x, double y, double radius, Pixel color);
void solidcircle(double x, double y, double radius, Pixel color);
void line(double x1, double y1, double x2, double y2, Pixel color);
void start();
void drawpixmap(PixMap *pm, double x, double y, Pixel color, Pixel bgcolor);
void xaxis(double x, double y, double xtick, int ticklength, Pixel color);
void yaxis(double x, double y, double ytick, int ticklength, Pixel color);
void triangle(double x1, double y1, double x2, double y2, double x3, double y3, Pixel c);
void solidtriangle(double x1, double y1, double x2, double y2, double x3, double y3, Pixel c);
void interptriangle(double x1, double y1, Pixel c1,
double x2, double y2, Pixel c2,
double x3, double y3, Pixel c3);
}
} Plot2D;
#define LINEAR 10
#define LOG 11
/* ------------------------------------------------------------------------------
Plot3D
Data Structure for 3-D plots
------------------------------------------------------------------------------ */
typedef struct Plot3D {
FrameBuffer *frame;
int view_xmin; /* Viewing region */
int view_ymin;
int view_xmax;
int view_ymax;
double xmin; /* Bounding box */
double ymin;
double zmin;
double xmax;
double ymax;
double zmax;
double xcenter; /* Center point */
double ycenter;
double zcenter;
double fovy; /* Field of view */
double aspect; /* Aspect ratio */
double znear; /* near "clipping" plane */
double zfar; /* far "clipping" plane */
double lookatz; /* Where is the z-lookat point */
double xshift; /* Used for translation and stuff */
double yshift;
%addmethods {
Plot3D(FrameBuffer *frame, double xmin, double ymin, double zmin, double xmax, double ymax, double zmax);
~Plot3D();
Plot3D *copy();
void clear(Pixel bgcolor);
void perspective( double fovy, double znear, double zfar);
void lookat( double z);
void autoperspective( double fovy);
void ortho(double left, double right, double bottom, double top);
void autoortho();
void rotx( double deg);
void roty( double deg);
void rotz( double deg);
void rotl( double deg);
void rotr( double deg);
void rotd( double deg);
void rotu( double deg);
void rotc( double deg);
void zoom( double percent);
void left( double percent);
void right( double percent);
void down( double percent);
void up( double percent);
void center( double cx, double cy);
void plot( double x, double y, double z, Pixel Color);
void setview( int vxmin, int vymin, int vxmax, int vymax);
void start();
void line( double x1, double y1, double z1,
double x2, double y2, double z2, Pixel color);
void triangle( double x1, double y1, double z1,
double x2, double y2, double z2,
double x3, double y3, double z3, Pixel color);
void solidtriangle( double x1, double y1, double z1,
double x2, double y2, double z2,
double x3, double y3, double z3, Pixel color);
void interptriangle(double x1, double y1, double z1, Pixel c1,
double x2, double y2, double z2, Pixel c2,
double x3, double y3, double z3, Pixel c3);
void quad( double x1, double y1, double z1,
double x2, double y2, double z2,
double x3, double y3, double z3,
double x4, double y4, double z4,
Pixel color);
void solidquad( double x1, double y1, double z1,
double x2, double y2, double z2,
double x3, double y3, double z3,
double x4, double y4, double z4,
Pixel color);
void interpquad( double x1, double y1, double z1, Pixel c1,
double x2, double y2, double z2, Pixel c2,
double x3, double y3, double z3, Pixel c3,
double x4, double y4, double z4, Pixel c4);
void solidsphere( double x, double y, double z, double radius,Pixel c);
void outlinesphere( double x, double y, double z, double radius,Pixel c, Pixel bc);
}
} Plot3D;
const PixMap *SQUARE = &PixMap_SQUARE;
const PixMap *TRIANGLE = &PixMap_TRIANGLE;
const PixMap *CROSS = &PixMap_CROSS;
%enabledoc

41
Examples/GIFPlot/LICENSE Normal file
View file

@ -0,0 +1,41 @@
/**********************************************************************
* GIFPlot 0.0
*
* Dave Beazley
*
* Department of Computer Science Theoretical Division (T-11)
* University of Utah Los Alamos National Laboratory
* Salt Lake City, Utah 84112 Los Alamos, New Mexico 87545
* beazley@cs.utah.edu beazley@lanl.gov
*
* Copyright (c) 1996
* The Regents of the University of California and the University of Utah
* All Rights Reserved
*
* Permission is hereby granted, without written agreement and without
* license or royalty fees, to use, copy, modify, and distribute this
* software and its documentation for any purpose, provided that
* (1) The above copyright notice and the following two paragraphs
* appear in all copies of the source code and (2) redistributions
* including binaries reproduces these notices in the supporting
* documentation. Substantial modifications to this software may be
* copyrighted by their authors and need not follow the licensing terms
* described here, provided that the new terms are clearly indicated in
* all files where they apply.
*
* IN NO EVENT SHALL THE AUTHOR, THE UNIVERSITY OF CALIFORNIA, THE
* UNIVERSITY OF UTAH OR DISTRIBUTORS OF THIS SOFTWARE BE LIABLE TO ANY
* PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
* DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION,
* EVEN IF THE AUTHORS OR ANY OF THE ABOVE PARTIES HAVE BEEN ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*
* THE AUTHOR, THE UNIVERSITY OF CALIFORNIA, AND THE UNIVERSITY OF UTAH
* SPECIFICALLY DISCLAIM ANY WARRANTIES,INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND
* THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE MAINTENANCE,
* SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*
**************************************************************************/

21
Examples/GIFPlot/Lib/Makefile.in Normal file
View file

@ -0,0 +1,21 @@
CC = @CC@
INCLUDE = -I../Include
CFLAGS = -O
SRCS = frame.c color.c plot2d.c plot3d.c font.c pixmap.c matrix.c gif.c
OBJS = $(SRCS:.c=.o)
AR = @AR@
RANLIB = @RANLIB@
TARGET = ../libgifplot.a
.c.o:
$(CC) $(INCLUDE) $(CFLAGS) -c -o $*.o $<
all: $(OBJS)
@rm -f ../libgifplot.a
$(AR) cr $(TARGET) $(OBJS)
$(RANLIB) $(TARGET)
clean:
rm -f *.o *~ $(TARGET)

140
Examples/GIFPlot/Lib/color.c Normal file
View file

@ -0,0 +1,140 @@
/* -----------------------------------------------------------------------------
* color.c
*
* Colormaps
*
* Author(s) : David Beazley (beazley@cs.uchicago.edu)
* Copyright (C) 1995-1996
*
* See the file LICENSE for information on usage and redistribution.
* ----------------------------------------------------------------------------- */
#define COLORMAP
#include "gifplot.h"
#include <string.h>
/* ------------------------------------------------------------------------
ColorMap *new_ColorMap(char *filename)
Read a colormap from a file.
------------------------------------------------------------------------ */
ColorMap *new_ColorMap(char *filename) {
ColorMap *c;
FILE *cm;
void ColorMap_default(ColorMap *);
if (!filename) {
c = (ColorMap *) malloc(sizeof(ColorMap));
c->cmap = (unsigned char *) malloc(768*sizeof(char));
c->name = 0;
ColorMap_default(c);
return c;
}
if (strlen(filename) == 0) {
c = (ColorMap *) malloc(sizeof(ColorMap));
c->cmap = (unsigned char *) malloc(768*sizeof(char));
ColorMap_default(c);
return c;
}
if ((cm = fopen(filename,"rb")) == NULL) {
return (ColorMap *) 0;
}
c = (ColorMap *) malloc(sizeof(ColorMap));
c->cmap = (unsigned char *) malloc(768*sizeof(char));
if (fread(c->cmap, 768, 1, cm) != 1) {
free((char *)c->cmap);
free((char *)c);
fclose(cm);
return (ColorMap *) 0;
}
fclose(cm);
c->name = (char *) malloc(strlen(filename)+1);
strcpy(c->name, filename);
ColorMap_default(c);
return c;
}
/* --------------------------------------------------------------------------
delete_ColorMap(ColorMap *cm)
Destroy a ColorMap
-------------------------------------------------------------------------- */
void delete_ColorMap(ColorMap *cm) {
if (cm) {
free((char *)cm->cmap);
if (cm->name)
free((char *)cm->name);
free((char *)cm);
}
}
/* --------------------------------------------------------------------------
ColorMap_default(ColorMap *cm)
This function fills in default values for the first 8 entries of the
colormap. These are *fixed* values---used internally.
-------------------------------------------------------------------------- */
void ColorMap_default(ColorMap *cm) {
unsigned char *r,*g,*b;
if (cm) {
r = cm->cmap;
g = cm->cmap+256;
b = cm->cmap+512;
r[0] = 0; g[0] = 0; b[0] = 0; /* BLACK */
r[1] = 255; g[1] = 255; b[1] = 255; /* WHITE */
r[2] = 255; g[2] = 0; b[2] = 0; /* RED */
r[3] = 0; g[3] = 255; b[3] = 0; /* GREEN */
r[4] = 0; g[4] = 0; b[4] = 255; /* BLUE */
r[5] = 255; g[5] = 255; b[5] = 0; /* YELLOW */
r[6] = 0; g[6] = 255; b[6] = 255; /* CYAN */
r[7] = 255; g[7] = 0; b[7] = 255; /* MAGENTA */
}
}
void ColorMap_assign(ColorMap *cm, int index, int r, int g, int b) {
unsigned char *rb,*gb,*bb;
rb = cm->cmap;
gb = cm->cmap+256;
bb = cm->cmap+512;
rb[index] = r;
gb[index] = g;
bb[index] = b;
}
int ColorMap_getitem(ColorMap *cm, int index) {
if ((index < 0) && (index >= 768)) return -1;
return cm->cmap[index];
}
void ColorMap_setitem(ColorMap *cm, int index, int value) {
if ((index < 0) && (index >= 768)) return;
cm->cmap[index]=value;
}
/* --------------------------------------------------------------------
ColorMap_write(ColorMap *cm, char *filename)
Write out a colormap to disk.
-------------------------------------------------------------------- */
int ColorMap_write(ColorMap *cm, char *filename) {
FILE *f;
if (!cm) return -1;
if (!filename) return -1;
if (strlen(filename) == 0) return -1;
f = fopen(filename,"w");
fwrite(cm->cmap,768,1,f);
fclose(f);
return 0;
}
#undef COLORMAP

705
Examples/GIFPlot/Lib/font.c Normal file
View file

@ -0,0 +1,705 @@
/* -----------------------------------------------------------------------------
* font.c
*
* Some basic fonts.
*
* Author(s) : David Beazley (beazley@cs.uchicago.edu)
* Copyright (C) 1995-1996
*
* See the file LICENSE for information on usage and redistribution.
* ----------------------------------------------------------------------------- */
#define FONT
#include "gifplot.h"
static char Char_A[80] = "\
...x....\
...x....\
..x.x...\
..x.x...\
.x...x..\
.xxxxx..\
x.....x.\
x.....x.\
x.....x.\
........";
static char Char_B[80] = "\
xxxxxx..\
x.....x.\
x.....x.\
x.....x.\
xxxxxx..\
x.....x.\
x.....x.\
x.....x.\
xxxxxx..\
........";
static char Char_C[80] = "\
..xxxx..\
.x....x.\
x.......\
x.......\
x.......\
x.......\
x.......\
.x....x.\
..xxxx..\
........";
static char Char_D[80] = "\
xxxxx...\
x....x..\
x.....x.\
x.....x.\
x.....x.\
x.....x.\
x.....x.\
x....x..\
xxxxx...\
........";
static char Char_E[80] = "\
xxxxxxx.\
x.......\
x.......\
x.......\
xxxxx...\
x.......\
x.......\
x.......\
xxxxxxx.\
........";
static char Char_F[80] = "\
xxxxxxx.\
x.......\
x.......\
x.......\
xxxxx...\
x.......\
x.......\
x.......\
x.......\
........";
static char Char_G[80] = "\
.xxxxx..\
x.....x.\
x.......\
x.......\
x...xxx.\
x.....x.\
x.....x.\
x.....x.\
.xxxxx..\
........";
static char Char_H[80] = "\
x.....x.\
x.....x.\
x.....x.\
x.....x.\
xxxxxxx.\
x.....x.\
x.....x.\
x.....x.\
x.....x.\
........";
static char Char_I[80] = "\
xxxxxxx.\
...x....\
...x....\
...x....\
...x....\
...x....\
...x....\
...x....\
xxxxxxx.\
........";
static char Char_J[80] = "\
......x.\
......x.\
......x.\
......x.\
......x.\
......x.\
x.....x.\
.x...x..\
..xxx...\
........";
static char Char_K[80] = "\
x.....x.\
x....x..\
x...x...\
x..x....\
xxx.....\
x..x....\
x...x...\
x....x..\
x.....x.\
........";
static char Char_L[80] = "\
x.......\
x.......\
x.......\
x.......\
x.......\
x.......\
x.......\
x.......\
xxxxxxx.\
........";
static char Char_M[80] = "\
x.....x.\
xx...xx.\
xx...xx.\
x.x.x.x.\
x.x.x.x.\
x..x..x.\
x..x..x.\
x.....x.\
x.....x.\
........";
static char Char_N[80] = "\
x.....x.\
xx....x.\
x.x...x.\
x.x...x.\
x..x..x.\
x...x.x.\
x...x.x.\
x....xx.\
x.....x.\
........";
static char Char_O[80] = "\
.xxxxx..\
x.....x.\
x.....x.\
x.....x.\
x.....x.\
x.....x.\
x.....x.\
x.....x.\
.xxxxx..\
........";
static char Char_P[80] = "\
xxxxxx..\
x.....x.\
x.....x.\
x.....x.\
xxxxxx..\
x.......\
x.......\
x.......\
x.......\
........";
static char Char_Q[80] = "\
.xxxxx..\
x.....x.\
x.....x.\
x.....x.\
x.....x.\
x.....x.\
x...x.x.\
x....x..\
.xxxx.x.\
........";
static char Char_R[80] = "\
xxxxxx..\
x.....x.\
x.....x.\
x.....x.\
xxxxxx..\
x..x....\
x...x...\
x....x..\
x.....x.\
........";
static char Char_S[80] = "\
.xxxxx..\
x.....x.\
x.......\
x.......\
.xxxxx..\
......x.\
......x.\
x.....x.\
.xxxxx..\
........";
static char Char_T[80] = "\
xxxxxxx.\
...x....\
...x....\
...x....\
...x....\
...x....\
...x....\
...x....\
...x....\
........";
static char Char_U[80] = "\
x.....x.\
x.....x.\
x.....x.\
x.....x.\
x.....x.\
x.....x.\
x.....x.\
x.....x.\
.xxxxx..\
........";
static char Char_V[80] = "\
x.....x.\
x.....x.\
.x...x..\
.x...x..\
..x.x...\
..x.x...\
...x....\
...x....\
...x....\
........";
static char Char_W[80] = "\
x.....x.\
x.....x.\
x.....x.\
x.....x.\
x.....x.\
x..x..x.\
x..x..x.\
x.x.x.x.\
.x...x..\
........";
static char Char_X[80] = "\
x.....x.\
x.....x.\
.x...x..\
..x.x...\
...x....\
..x.x...\
.x...x..\
x.....x.\
x.....x.\
........";
static char Char_Y[80] = "\
x.....x.\
x.....x.\
.x...x..\
..x.x...\
...x....\
...x....\
...x....\
...x....\
...x....\
........";
static char Char_Z[80] = "\
xxxxxxx.\
......x.\
.....x..\
....x...\
...x....\
..x.....\
.x......\
x.......\
xxxxxxx.\
........";
static char Char_0[80] = "\
.xxxxx..\
x....xx.\
x...x.x.\
x..x..x.\
x..x..x.\
x.x...x.\
x.x...x.\
xx....x.\
.xxxxx..\
........";
static char Char_1[80] = "\
...x....\
..xx....\
...x....\
...x....\
...x....\
...x....\
...x....\
...x....\
..xxx...\
........";
static char Char_2[80] = "\
..xxxx..\
.x....x.\
x.....x.\
.....x..\
....x...\
...x....\
..x.....\
.x......\
xxxxxxx.\
........";
static char Char_3[80] = "\
.xxxxx..\
x.....x.\
......x.\
......x.\
...xxx..\
......x.\
......x.\
x.....x.\
.xxxxx..\
........";
static char Char_4[80] = "\
....xx..\
...x.x..\
..x..x..\
.x...x..\
xxxxxxx.\
.....x..\
.....x..\
.....x..\
.....x..\
........";
static char Char_5[80] = "\
xxxxxxx.\
x.......\
x.......\
x.......\
xxxxxx..\
......x.\
......x.\
x.....x.\
.xxxxx..\
........";
static char Char_6[80] = "\
....xxx.\
..xx....\
.x......\
x.......\
x.xxx...\
xx...x..\
x.....x.\
.x...x..\
..xxx...\
........";
static char Char_7[80] = "\
xxxxxxx.\
x.....x.\
.....x..\
....x...\
...x....\
..x.....\
.x......\
x.......\
x.......\
........";
static char Char_8[80] = "\
.xxxxx..\
x.....x.\
x.....x.\
x.....x.\
.xxxxx..\
x.....x.\
x.....x.\
x.....x.\
.xxxxx..\
........";
static char Char_9[80] = "\
..xxxx..\
.x....x.\
x.....x.\
x....xx.\
.xxxx.x.\
......x.\
......x.\
....xx..\
.xxx....\
........";
static char Char_MINUS[80] = "\
........\
........\
........\
........\
.xxxxxx.\
........\
........\
........\
........\
........";
static char Char_PLUS[80] = "\
........\
........\
...x....\
...x....\
.xxxxx..\
...x....\
...x....\
........\
........\
........";
static char Char_EQUAL[80] = "\
........\
........\
........\
.xxxxx..\
........\
.xxxxx..\
........\
........\
........\
........";
static char Char_LPAREN[80] = "\
....x...\
...x....\
..x.....\
.x......\
.x......\
.x......\
..x.....\
...x....\
....x...\
........";
static char Char_RPAREN[80] = "\
...x....\
....x...\
.....x..\
......x.\
......x.\
......x.\
.....x..\
....x...\
...x....\
........";
static char Char_QUOTE[80] = "\
..x.x...\
..x.x...\
........\
........\
........\
........\
........\
........\
........\
........";
static char Char_COLON[80] = "\
........\
........\
...xx...\
...xx...\
........\
...xx...\
...xx...\
........\
........\
........";
static char Char_PERIOD[80] = "\
........\
........\
........\
........\
........\
........\
........\
...xx...\
...xx...\
........";
static char Char_COMMA[80] = "\
........\
........\
........\
........\
........\
........\
...xx...\
...xx...\
....x...\
...x....";
static char Char_SLASH[80] = "\
........\
......x.\
.....x..\
....x...\
...x....\
..x.....\
.x......\
x.......\
........\
........";
static char Char_SPACE[80] = "\
........\
........\
........\
........\
........\
........\
........\
........\
........\
........";
static char *GP_Font[128];
static int InitGP_Font = 0;
static void initGP_Fonts(void) {
int i;
for (i = 0; i < 128; i++)
GP_Font[i] = (char *) 0;
GP_Font['A'] = GP_Font['a'] = Char_A;
GP_Font['B'] = GP_Font['b'] = Char_B;
GP_Font['C'] = GP_Font['c'] = Char_C;
GP_Font['D'] = GP_Font['d'] = Char_D;
GP_Font['E'] = GP_Font['e'] = Char_E;
GP_Font['F'] = GP_Font['f'] = Char_F;
GP_Font['G'] = GP_Font['g'] = Char_G;
GP_Font['H'] = GP_Font['h'] = Char_H;
GP_Font['I'] = GP_Font['i'] = Char_I;
GP_Font['J'] = GP_Font['j'] = Char_J;
GP_Font['K'] = GP_Font['k'] = Char_K;
GP_Font['L'] = GP_Font['l'] = Char_L;
GP_Font['M'] = GP_Font['m'] = Char_M;
GP_Font['N'] = GP_Font['n'] = Char_N;
GP_Font['O'] = GP_Font['o'] = Char_O;
GP_Font['P'] = GP_Font['p'] = Char_P;
GP_Font['Q'] = GP_Font['q'] = Char_Q;
GP_Font['R'] = GP_Font['r'] = Char_R;
GP_Font['S'] = GP_Font['s'] = Char_S;
GP_Font['T'] = GP_Font['t'] = Char_T;
GP_Font['U'] = GP_Font['u'] = Char_U;
GP_Font['V'] = GP_Font['v'] = Char_V;
GP_Font['W'] = GP_Font['w'] = Char_W;
GP_Font['X'] = GP_Font['x'] = Char_X;
GP_Font['Y'] = GP_Font['y'] = Char_Y;
GP_Font['Z'] = GP_Font['z'] = Char_Z;
GP_Font['0'] = Char_0;
GP_Font['1'] = Char_1;
GP_Font['2'] = Char_2;
GP_Font['3'] = Char_3;
GP_Font['4'] = Char_4;
GP_Font['5'] = Char_5;
GP_Font['6'] = Char_6;
GP_Font['7'] = Char_7;
GP_Font['8'] = Char_8;
GP_Font['9'] = Char_9;
GP_Font['.'] = Char_PERIOD;
GP_Font[','] = Char_COMMA;
GP_Font['='] = Char_EQUAL;
GP_Font['-'] = Char_MINUS;
GP_Font['+'] = Char_PLUS;
GP_Font['\"'] = Char_QUOTE;
GP_Font['('] = Char_LPAREN;
GP_Font[')'] = Char_RPAREN;
GP_Font[':'] = Char_COLON;
GP_Font['/'] = Char_SLASH;
GP_Font[' '] = Char_SPACE;
InitGP_Font = 1;
}
/* -----------------------------------------------------------------------
void FrameBuffer_drawchar(FrameBuffer *f, int x, int y, Pixel fgcolor, Pixel bgcolor, char chr, int orientation)
Draws a character at location x, y with given color and orientation parameters.
Orientation can either be HORIZONTAL or VERTICAL
----------------------------------------------------------------------- */
void FrameBuffer_drawchar(FrameBuffer *f, int x, int y, int fgcolor,
int bgcolor, char chr, int orientation) {
Pixel c, bc,*p,*p1;
char *ch;
int i,j;
int xpixels,ypixels;
if (!InitGP_Font) initGP_Fonts();
c = (Pixel) fgcolor;
bc = (Pixel) bgcolor;
xpixels = f->width;
ypixels = f->height;
if (orientation == HORIZONTAL) {
if ((x < f->xmin) || (x > f->xmax-8) ||
(y < f->ymin) || (y > f->ymax-10)) return;
ch = GP_Font[(int) chr];
if (!ch) return;
p = &f->pixels[y+9][x];
for (i = 0; i < 10; i++) {
p1 = p;
for (j = 0; j< 8; j++) {
if (*(ch++) == 'x') *p= c;
else if (bgcolor >= 0)
*p = bc;
p++;
}
p = (p1 - xpixels);
}
} else {
if ((x < f->xmin+10) || (x >= f->xmax) ||
(y < f->ymin) || (y > f->ymax-8)) return;
ch = GP_Font[(int) chr];
if (!ch) return;
p = &f->pixels[y][x-9];
for (i = 0; i < 10; i++) {
p1 = p;
for (j = 0; j< 8; j++) {
if (*(ch++) == 'x') *p= c;
else if (bgcolor >= 0)
*p = bc;
p+=xpixels;
}
p = p1 + 1;
}
}
}
/* ----------------------------------------------------------------------
void FrameBuffer_drawstring(FrameBuffer *f, int x, int y, int fgcolor,
int bgcolor, char *text, int orientation)
Draws an ASCII string on the framebuffer. Can be oriented either horizontally
or vertically.
---------------------------------------------------------------------- */
void FrameBuffer_drawstring(FrameBuffer *f, int x, int y, int fgcolor, int bgcolor, char *text, int orientation) {
char *c;
int x1, y1;
int xpixels, ypixels;
x1 = x;
y1 = y;
xpixels = f->width;
ypixels = f->height;
c = text;
while (*c) {
if (*c == '\n') {
if (orientation == HORIZONTAL) {
x1 = x; y1= y1- 10*xpixels;
} else {
y1 = y; x1= x1 + 10*ypixels;
}
} else {
FrameBuffer_drawchar(f, x1,y1,fgcolor, bgcolor,*c, orientation);
if (orientation == HORIZONTAL) {
x1+=8;
if (x1 >= (xpixels-8)) {
x1 = x; y1= y1- 10;}
if (y1 < 0) return;
} else {
y1 += 8;
if (y1 >= (ypixels-8)) {
y1 = y; x1 = x1 + 10;}
if (x1 > (xpixels-10)) return;
}
}
c++;
}
}

924
Examples/GIFPlot/Lib/frame.c Normal file
View file

@ -0,0 +1,924 @@
/* -----------------------------------------------------------------------------
* frame.c
*
* Frame buffer management
*
* Author(s) : David Beazley (beazley@cs.uchicago.edu)
* Copyright (C) 1995-1996
*
* See the file LICENSE for information on usage and redistribution.
* ----------------------------------------------------------------------------- */
#define FRAME
#include "gifplot.h"
#include <float.h>
/* ------------------------------------------------------------------------
FrameBuffer *new_FrameBuffer(int width, int height)
Creates a new framebuffer for storing data.
------------------------------------------------------------------------ */
FrameBuffer *new_FrameBuffer(unsigned int width, unsigned int height) {
FrameBuffer *f;
int FrameBuffer_resize(FrameBuffer *f, int width, int height);
/* Create a new frame buffer */
f = (FrameBuffer *) malloc(sizeof(FrameBuffer));
f->pixels = (Pixel **) 0;
f->zbuffer = (Zvalue **) 0;
/* Set its size */
if (FrameBuffer_resize(f, width, height) == -1) {
free((char *) f);
return (FrameBuffer *) 0;
}
f->xmin = 0;
f->ymin = 0;
f->xmax = width;
f->ymax = height;
return f;
}
/* ------------------------------------------------------------------------
void delete_FrameBuffer(FrameBuffer *f)
Destroys the given framebuffer
------------------------------------------------------------------------ */
void delete_FrameBuffer(FrameBuffer *f) {
if (f) {
if (f->pixels) {
free((char *) f->pixels[0]);
free((char *) f->pixels);
}
if (f->zbuffer) {
free((char *) f->zbuffer[0]);
free((char *) f->zbuffer);
}
free((char *)f);
}
}
/* ------------------------------------------------------------------------
int *FrameBuffer_resize(FrameBuffer *f, int width, int height)
Resize the given framebuffer. Returns 0 on success, -1 on failure.
------------------------------------------------------------------------ */
int FrameBuffer_resize(FrameBuffer *f, int width, int height) {
int i;
if ((f) && (width > 0) && (height > 0)) {
if (f->pixels) {
free((char *)f->pixels[0]);
free((char *)f->pixels);
}
f->pixels = (Pixel **) malloc (height*sizeof(Pixel *));
if (!f->pixels) return -1;
f->pixels[0] = (Pixel *) malloc(height*width*sizeof(Pixel));
if (!f->pixels[0]) {
free((char *)f->pixels);
return -1;
}
for (i = 0; i < height; i++)
f->pixels[i] = f->pixels[0] + i*width;
f->width = width;
f->height = height;
if (f->zbuffer) {
FrameBuffer_zresize(f,width,height);
}
return 0;
} else {
return -1;
}
}
/* ------------------------------------------------------------------------
void FrameBuffer_clear(FrameBuffer *f, Pixel color)
Clears the current FrameBuffer
------------------------------------------------------------------------ */
void FrameBuffer_clear(FrameBuffer *f, Pixel color) {
Pixel *p;
unsigned int i;
p = &f->pixels[0][0];
for (i = 0; i < f->width*f->height; i++, p++)
*p = color;
}
/* ------------------------------------------------------------------------
void FrameBuffer_plot(FrameBuffer *f, int x1, int y1, Pixel color)
Plots a point and does a bounds check.
------------------------------------------------------------------------ */
void FrameBuffer_plot(FrameBuffer *f, int x1, int y1, Pixel color) {
if ((x1 < f->xmin) || (x1 >= f->xmax) || (y1 < f->ymin) || (y1 >= f->ymax))
return;
f->pixels[y1][x1] = color;
}
/* ------------------------------------------------------------------------
FrameBuffer_horizontal(Framebuffer *f, int xmin, int xmax, int y, Pixel color)
Draw a horizontal line (clipped)
------------------------------------------------------------------------ */
void FrameBuffer_horizontal(FrameBuffer *f, int xmin, int xmax, int y, Pixel color) {
Pixel *p;
int i;
if ((y < f->ymin) || (y >= f->ymax)) return;
if (xmin < f->xmin) xmin = f->xmin;
if (xmax >= f->xmax) xmax = f->xmax - 1;
p = &f->pixels[y][xmin];
for (i = xmin; i <= xmax; i++, p++)
*p = color;
}
/* ------------------------------------------------------------------------
FrameBuffer_horizontalinterp(Framebuffer *f, int xmin, int xmax, int y,
Pixel c1, Pixel c2)
Draw a horizontal line (clipped) with color interpolation.
------------------------------------------------------------------------ */
void FrameBuffer_horizontalinterp(FrameBuffer *f, int xmin, int xmax, int y,
Pixel c1, Pixel c2) {
Pixel *p;
int i;
double mc;
int x1;
if ((y < f->ymin) || (y >= f->ymax)) return;
x1 = xmin;
if (xmin < f->xmin) xmin = f->xmin;
if (xmax >= f->xmax) xmax = f->xmax - 1;
if (xmax < f->xmin) return;
if (xmin >= f->xmax) return;
if (xmin != xmax)
mc = (double)(c2 - c1)/(double) (xmax - xmin);
else
mc = 0.0;
p = &f->pixels[y][xmin];
for (i = xmin; i <= xmax; i++, p++)
*p = (Pixel) (mc*(i-x1) + c1);
}
/* ------------------------------------------------------------------------
FrameBuffer_vertical(Framebuffer *f, int xmin, int xmax, int y, Pixel color)
Draw a Vertical line (clipped)
------------------------------------------------------------------------ */
void FrameBuffer_vertical(FrameBuffer *f, int ymin, int ymax, int x, Pixel color) {
Pixel *p;
int i;
if ((x < f->xmin) || (x >= f->xmax)) return;
if (ymax < f->ymin) return;
if (ymin > f->ymax) return;
if (ymin < f->ymin) ymin = f->ymin;
if (ymax >= f->ymax) ymax = f->ymax - 1;
p = &f->pixels[ymin][x];
for (i = 0; i <= (ymax - ymin); i++, p+=f->width)
*p = color;
}
/* ------------------------------------------------------------------------
void FrameBuffer_box(FrameBuffer *f, int x1, int y1, int x2, int y2, Pixel color)
Makes an outline box.
------------------------------------------------------------------------ */
void FrameBuffer_box(FrameBuffer *f, int x1, int y1, int x2, int y2, Pixel color) {
int xt, yt;
/* Make sure points are in correct order */
if (x2 < x1) {
xt = x2;
x2 = x1;
x1 = xt;
}
if (y2 < y1) {
yt = y2;
y2 = y1;
y1 = yt;
}
/* Draw lower edge */
FrameBuffer_horizontal(f,x1,x2,y1,color);
/* Draw upper edge */
FrameBuffer_horizontal(f,x1,x2,y2,color);
/* Draw left side */
FrameBuffer_vertical(f,y1,y2,x1,color);
/* Draw right side */
FrameBuffer_vertical(f,y1,y2,x2,color);
}
/* ------------------------------------------------------------------------
void FrameBuffer_solidbox(FrameBuffer *f, int x1, int y1, int x2, int y2, Pixel color)
Makes an solid box.
------------------------------------------------------------------------ */
void FrameBuffer_solidbox(FrameBuffer *f, int x1, int y1, int x2, int y2, Pixel color) {
int xt, yt;
/* Make sure points are in correct order */
if (x2 < x1) {
xt = x2;
x2 = x1;
x1 = xt;
}
if (y2 < y1) {
yt = y2;
y2 = y1;
y1 = yt;
}
/* Now perform some clipping */
if (y1 < f->ymin) y1 = f->ymin;
if (y2 >= f->ymax) y2 = f->ymax - 1;
/* Fill it in using horizontal lines */
for (yt = y1; yt <= y2; yt++)
FrameBuffer_horizontal(f,x1,x2,yt,color);
}
/* ------------------------------------------------------------------------
void FrameBuffer_interpbox(FrameBuffer *f, int x1, int y1, int x2, int y2
Pixel c1, Pixel c2, Pixel c3, Pixel c4)
Makes a box with interpolated color. Colors are assigned as follows :
(x1,y1) = c1
(x1,y2) = c2
(x2,y1) = c3
(x2,y2) = c4
------------------------------------------------------------------------ */
void FrameBuffer_interpbox(FrameBuffer *f, int x1, int y1, int x2, int y2,
Pixel c1, Pixel c2, Pixel c3, Pixel c4) {
int xt, yt;
Pixel ct;
double mc1,mc2;
int ystart;
/* Make sure points are in correct order */
if (x2 < x1) {
xt = x2;
x2 = x1;
x1 = xt;
ct = c1;
c1 = c3;
c3 = ct;
ct = c2;
c2 = c4;
c4 = ct;
}
if (y2 < y1) {
yt = y2;
y2 = y1;
y1 = yt;
ct = c1;
c1 = c2;
c2 = ct;
ct = c3;
c3 = c4;
c4 = ct;
}
/* Now perform some clipping */
ystart = y1;
mc1 = (double) (c2 - c1)/(double) (y2 - y1);
mc2 = (double) (c4 - c3)/(double) (y2 - y1);
if (y1 < f->ymin) y1 = f->ymin;
if (y2 >= f->ymax) y2 = f->ymax - 1;
/* Fill it in using horizontal lines */
for (yt = y1; yt <= y2; yt++)
FrameBuffer_horizontalinterp(f,x1,x2,yt,(Pixel) ((mc1*(yt - ystart)) + c1),
(Pixel) ((mc2*(yt-ystart))+c3));
}
/* ---------------------------------------------------------------------------
FrameBuffer_line(FrameBuffer *f, int x1, int y1, int x2, int y2, color)
Draws a line on the framebuffer using the Bresenham line algorithm. The
line is clipped to fit within the current view window.
---------------------------------------------------------------------------- */
void FrameBuffer_line(FrameBuffer *f, int x1, int y1, int x2, int y2, Pixel c) {
int dx,dy,dxneg,dyneg, inc1,inc2,di;
int x, y, xpixels, ypixels, xt, yt;
Pixel *p;
double m;
int end1 = 0, end2 = 0;
/* Need to figure out where in the heck this line is */
dx = x2 - x1;
dy = y2 - y1;
if (dx == 0) {
/* Draw a Vertical Line */
if (y1 < y2)
FrameBuffer_vertical(f,y1,y2,x1,c);
else
FrameBuffer_vertical(f,y2,y1,x1,c);
return;
}
if (dy == 0) {
/* Draw a Horizontal Line */
if (x1 < x2)
FrameBuffer_horizontal(f,x1,x2,y1,c);
else
FrameBuffer_horizontal(f,x2,x1,y1,c);
return;
}
/* Figure out where in the heck these lines are using the
Cohen-Sutherland Line Clipping Scheme. */
end1 = ((x1 - f->xmin) < 0) |
(((f->xmax- 1 - x1) < 0) << 1) |
(((y1 - f->ymin) < 0) << 2) |
(((f->ymax-1 - y1) < 0) << 3);
end2 = ((x2 - f->xmin) < 0) |
(((f->xmax-1 - x2) < 0) << 1) |
(((y2 - f->ymin) < 0) << 2) |
(((f->ymax-1 - y2) < 0) << 3);
if (end1 & end2) return; /* Nope : Not visible */
/* Make sure points have a favorable orientation */
if (x1 > x2) {
xt = x1;
x1 = x2;
x2 = xt;
yt = y1;
y1 = y2;
y2 = yt;
}
/* Clip against the boundaries */
m = (y2 - y1)/(double) (x2-x1);
if (x1 < f->xmin) {
y1 = (int) ((f->xmin - x1)*m + y1);
x1 = (int) f->xmin;
}
if (x2 >= f->xmax) {
y2 = (int) ((f->xmax -1 -x1)*m + y1);
x2 = (int) (f->xmax - 1);
}
if (y1 > y2) {
xt = x1;
x1 = x2;
x2 = xt;
yt = y1;
y1 = y2;
y2 = yt;
}
m = 1/m;
if (y1 < f->ymin) {
x1 = (int) ((f->ymin - y1)*m + x1);
y1 = (int) f->ymin;
}
if (y2 >= f->ymax) {
x2 = (int) ((f->ymax-1-y1)*m + x1);
y2 = (int) (f->ymax-1);
}
if ((x1 < f->xmin) || (x1 >= f->xmax) || (y1 < f->ymin) || (y1 >= f->ymax) ||
(x2 < f->xmin) || (x2 >= f->xmax) || (y2 < f->ymin) || (y2 >= f->ymax)) return;
dx = x2 - x1;
dy = y2 - y1;
xpixels = f->width;
ypixels = f->height;
dxneg = (dx < 0) ? 1 : 0;
dyneg = (dy < 0) ? 1 : 0;
dx = abs(dx);
dy = abs(dy);
if (dx >= dy) {
/* Slope between -1 and 1. */
if (dxneg) {
x = x1;
y = y1;
x1 = x2;
y1 = y2;
x2 = x;
y2 = y;
dyneg = !dyneg;
}
inc1 = 2*dy;
inc2 = 2*(dy-dx);
di = 2*dy-dx;
/* Draw a line using x as independent variable */
p = &f->pixels[y1][x1];
x = x1;
while (x <= x2) {
*(p++) = c;
if (di < 0) {
di = di + inc1;
} else {
if (dyneg) {
p = p - xpixels;
di = di + inc2;
} else {
p = p + xpixels;
di = di + inc2;
}
}
x++;
}
} else {
/* Slope < -1 or > 1 */
if (dyneg) {
x = x1;
y = y1;
x1 = x2;
y1 = y2;
x2 = x;
y2 = y;
dxneg = !dxneg;
}
inc1 = 2*dx;
inc2 = 2*(dx-dy);
di = 2*dx-dy;
/* Draw a line using y as independent variable */
p = &f->pixels[y1][x1];
y = y1;
while (y <= y2) {
*p = c;
p = p + xpixels;
if (di < 0) {
di = di + inc1;
} else {
if (dxneg) {
p = p - 1;
di = di + inc2;
} else {
p = p + 1;
di = di + inc2;
}
}
y++;
}
}
}
/* -------------------------------------------------------------------------
FrameBuffer_circle(FrameBuffer f, int xc, int yc, int radius, Pixel c)
Create an outline circle
------------------------------------------------------------------------- */
#define plot_circle(x,y,c) \
if ((x >= xmin) && (x < xmax) && \
(y >= ymin) && (y < ymax)) \
pixels[y][x] = c;
void FrameBuffer_circle(FrameBuffer *f, int xc, int yc, int radius, Pixel c) {
int xpixels, ypixels, x, y, p;
int xmin, ymin, xmax, ymax;
Pixel **pixels;
if (radius <= 0) return;
xpixels = f->width;
ypixels = f->height;
pixels = f->pixels;
xmin = f->xmin;
ymin = f->ymin;
xmax = f->xmax;
ymax = f->ymax;
x = 0;
y = radius;
p = 3-2*radius;
while (x <= y) {
plot_circle(xc+x,yc+y,c);
plot_circle(xc-x,yc+y,c);
plot_circle(xc+x,yc-y,c);
plot_circle(xc-x,yc-y,c);
plot_circle(xc+y,yc+x,c);
plot_circle(xc-y,yc+x,c);
plot_circle(xc+y,yc-x,c);
plot_circle(xc-y,yc-x,c);
if (p < 0) p = p + 4*x + 6;
else {
p = p + 4*(x-y) + 10;
y = y -1;
}
x++;
}
}
/* -------------------------------------------------------------------------
FrameBuffer_solidcircle(FrameBuffer f, int xc, int yc, int radius, Pixel c)
Create an filled circle
------------------------------------------------------------------------- */
#define fill_circle(x,y,c) \
x1 = xc - x; \
x2 = xc + x; \
FrameBuffer_horizontal(f,x1,x2,y,c);
void FrameBuffer_solidcircle(FrameBuffer *f, int xc, int yc, int radius, Pixel c) {
int xpixels, ypixels, x, y, p;
int x1,x2;
int xmin, ymin, xmax, ymax;
Pixel **pixels;
if (radius <= 0) return;
xpixels = f->width;
ypixels = f->height;
pixels = f->pixels;
xmin = f->xmin;
ymin = f->ymin;
xmax = f->xmax;
ymax = f->ymax;
x = 0;
y = radius;
p = 3-2*radius;
while (x <= y) {
fill_circle(x,yc+y,c);
fill_circle(x,yc-y,c);
fill_circle(y,yc+x,c);
fill_circle(y,yc-x,c);
if (p < 0) p = p + 4*x + 6;
else {
p = p + 4*(x-y) + 10;
y = y -1;
}
x++;
}
}
/* ------------------------------------------------------------------------
void FrameBuffer_setclip(f,xmin,ymin,xmax,ymax)
Set clipping region for plotting
------------------------------------------------------------------------ */
void FrameBuffer_setclip(FrameBuffer *f, int xmin, int ymin, int xmax, int ymax) {
if (xmin >= xmax) return;
if (ymin >= ymax) return;
if (xmin < 0) xmin = 0;
if (ymin < 0) ymin = 0;
if (xmax > (int) f->width) xmax = f->width;
if (ymax > (int) f->height) ymax = f->height;
f->xmin = xmin;
f->ymin = ymin;
f->xmax = xmax;
f->ymax = ymax;
}
/* ------------------------------------------------------------------------
void FrameBuffer_noclip(f)
Disable clipping region
------------------------------------------------------------------------ */
void FrameBuffer_noclip(FrameBuffer *f) {
f->xmin = 0;
f->ymin = 0;
f->xmax = f->width;
f->ymax = f->height;
}
/* ------------------------------------------------------------------------
FrameBuffer_zresize(FrameBuffer *f, int width, int height)
This function resizes the framebuffer's zbuffer. If none exist, it
creates a new one.
------------------------------------------------------------------------ */
void FrameBuffer_zresize(FrameBuffer *f, int width, int height) {
int i;
if (f->zbuffer) {
free((char *)f->zbuffer[0]);
free((char *)f->zbuffer);
}
f->zbuffer = (Zvalue **) malloc(height*sizeof(Zvalue *));
f->zbuffer[0] = (Zvalue *) malloc(height*width*sizeof(Zvalue));
for (i = 0; i < height; i++)
f->zbuffer[i] = f->zbuffer[0]+i*width;
}
/* ------------------------------------------------------------------------
FrameBuffer_zclear(FrameBuffer *f)
Clears the z-buffer for a particular frame. Sets all of the z-values to
ZMIN.
------------------------------------------------------------------------- */
void FrameBuffer_zclear(FrameBuffer *f) {
unsigned int i,j;
if (f) {
if (f->zbuffer) {
for (i = 0; i < f->width; i++)
for (j = 0; j < f->height; j++)
f->zbuffer[j][i] = ZMIN;
}
}
}
/* -------------------------------------------------------------------------
FrameBuffer_solidtriangle(FrameBuffer *f, int tx1, int ty2,
int tx2, int ty2,
int tx3, int ty3, Pixel color)
This function draws a 2D filled triangle.
General idea :
1. Transform the three points into screen coordinates
2. Order three points vertically on screen.
3. Check for degenerate cases (where 3 points are colinear).
4. Fill in the resulting triangle using horizontal lines.
-------------------------------------------------------------------------- */
void FrameBuffer_solidtriangle(FrameBuffer *f, int tx1, int ty1,
int tx2, int ty2,
int tx3, int ty3, Pixel color) {
int tempx, tempy;
double m1,m2,m3;
int y;
int ix1, ix2;
/* Figure out which point has the greatest "y" value */
if (ty2 > ty1) { /* Swap points 1 and 2 if 2 is higher */
tempx = tx1;
tempy = ty1;
tx1 = tx2;
ty1 = ty2;
tx2 = tempx;
ty2 = tempy;
}
if (ty3 > ty1) { /* Swap points 1 and 3 if 3 is higher */
tempx = tx1;
tempy = ty1;
tx1 = tx3;
ty1 = ty3;
tx3 = tempx;
ty3 = tempy;
}
if (ty3 > ty2) { /* Swap points 2 and 3 if 3 is higher */
tempx = tx2;
tempy = ty2;
tx2 = tx3;
ty2 = ty3;
tx3 = tempx;
ty3 = tempy;
}
/* Points are now order so that t_1 is the highest point, t_2 is the
middle point, and t_3 is the lowest point */
/* Check for degenerate cases here */
if ((ty1 == ty2) && (ty2 == ty3)) {
/* Points are aligned horizontally. Handle as a special case */
/* Just draw three lines using the outline color */
FrameBuffer_line(f,tx1,ty1,tx2,ty2,color);
FrameBuffer_line(f,tx1,ty1,tx3,ty3,color);
FrameBuffer_line(f,tx2,ty2,tx3,ty3,color);
} else {
if (ty2 < ty1) {
/* First process line segments between (x1,y1)-(x2,y2)
And between (x1,y1),(x3,y3) */
m1 = (double) (tx2 - tx1)/(double) (ty2 - ty1);
m2 = (double) (tx3 - tx1)/(double) (ty3 - ty1);
y = ty1;
while (y >= ty2) {
/* Calculate x values from slope */
ix1 = (int) (m1*(y-ty1)+0.5) + tx1;
ix2 = (int) (m2*(y-ty1)+0.5) + tx1;
if (ix1 > ix2)
FrameBuffer_horizontal(f,ix2,ix1,y,color);
else
FrameBuffer_horizontal(f,ix1,ix2,y,color);
y--;
}
}
if (ty3 < ty2) {
/* Draw lower half of the triangle */
m2 = (double) (tx3 - tx1)/(double) (ty3 - ty1);
m3 = (double) (tx3 - tx2)/(double)(ty3 - ty2);
y = ty2;
while (y >= ty3) {
ix1 = (int) (m3*(y-ty2)+0.5)+tx2;
ix2 = (int) (m2*(y-ty1)+0.5)+tx1;
if (ix1 > ix2)
FrameBuffer_horizontal(f,ix2,ix1,y,color);
else
FrameBuffer_horizontal(f,ix1,ix2,y,color);
y--;
}
}
}
}
/* -------------------------------------------------------------------------
FrameBuffer_interptriangle(FrameBuffer *f,
int tx1, int ty2, Pixel c1,
int tx2, int ty2, Pixel c2,
int tx3, int ty3, Pixel c3)
This function draws a filled triangle with color
interpolation.
General idea :
1. Transform the three points into screen coordinates
2. Order three points vertically on screen.
3. Check for degenerate cases (where 3 points are colinear).
4. Fill in the resulting triangle using horizontal lines.
5. Colors are interpolated between end points
-------------------------------------------------------------------------- */
void FrameBuffer_interptriangle(FrameBuffer *f,
int tx1, int ty1, Pixel c1,
int tx2, int ty2, Pixel c2,
int tx3, int ty3, Pixel c3) {
int tempx, tempy;
double m1,m2,m3;
double mc1,mc2,mc3;
Pixel ic1,ic2,tempc;
int y;
int ix1, ix2;
/* Figure out which point has the greatest "y" value */
if (ty2 > ty1) { /* Swap points 1 and 2 if 2 is higher */
tempx = tx1;
tempy = ty1;
tempc = c1;
tx1 = tx2;
ty1 = ty2;
c1 = c2;
tx2 = tempx;
ty2 = tempy;
c2 = tempc;
}
if (ty3 > ty1) { /* Swap points 1 and 3 if 3 is higher */
tempx = tx1;
tempy = ty1;
tempc = c1;
tx1 = tx3;
ty1 = ty3;
c1 = c3;
tx3 = tempx;
ty3 = tempy;
c3 = tempc;
}
if (ty3 > ty2) { /* Swap points 2 and 3 if 3 is higher */
tempx = tx2;
tempy = ty2;
tempc = c2;
tx2 = tx3;
ty2 = ty3;
c2 = c3;
tx3 = tempx;
ty3 = tempy;
c3 = tempc;
}
/* Points are now order so that t_1 is the highest point, t_2 is the
middle point, and t_3 is the lowest point */
/* Check for degenerate cases here */
if ((ty1 == ty2) && (ty2 == ty3)) {
/* Points are aligned horizontally. Handle as a special case */
/* Just draw three lines using the outline color */
if (tx2 > tx1)
FrameBuffer_horizontalinterp(f,tx1,tx2,ty1,c1,c2);
else
FrameBuffer_horizontalinterp(f,tx2,tx1,ty1,c2,c1);
if (tx3 > tx1)
FrameBuffer_horizontalinterp(f,tx1,tx3,ty1,c1,c3);
else
FrameBuffer_horizontalinterp(f,tx3,tx1,ty1,c3,c1);
if (tx3 > tx2)
FrameBuffer_horizontalinterp(f,tx2,tx3,ty2,c2,c3);
else
FrameBuffer_horizontalinterp(f,tx3,tx2,ty2,c3,c2);
} else {
/* First process line segments between (x1,y1)-(x2,y2)
And between (x1,y1),(x3,y3) */
if (ty2 < ty1) {
m1 = (double) (tx2 - tx1)/(double) (ty2 - ty1);
m2 = (double) (tx3 - tx1)/(double) (ty3 - ty1);
mc1 = (c2 - c1)/(double) (ty2 - ty1);
mc2 = (c3 - c1)/(double) (ty3 - ty1);
y = ty1;
while (y >= ty2) {
/* Calculate x values from slope */
ix1 = (int) (m1*(y-ty1)+0.5) + tx1;
ix2 = (int) (m2*(y-ty1)+0.5) + tx1;
ic1 = (int) (mc1*(y-ty1) + c1);
ic2 = (int) (mc2*(y-ty1) + c1);
if (ix1 > ix2)
FrameBuffer_horizontalinterp(f,ix2,ix1,y,ic2,ic1);
else
FrameBuffer_horizontalinterp(f,ix1,ix2,y,ic1,ic2);
y--;
}
}
if (ty3 < ty2) {
/* Draw lower half of the triangle */
m2 = (double) (tx3 - tx1)/(double) (ty3 - ty1);
mc2 = (c3 - c1)/(double) (ty3 - ty1);
m3 = (double) (tx3 - tx2)/(double)(ty3 - ty2);
mc3 = (c3 - c2)/(double) (ty3 - ty2);
y = ty2;
while (y >= ty3) {
ix1 = (int) (m3*(y-ty2)+0.5)+tx2;
ix2 = (int) (m2*(y-ty1)+0.5)+tx1;
ic1 = (int) (mc3*(y-ty2)+c2);
ic2 = (int) (mc2*(y-ty1)+c1);
if (ix1 > ix2)
FrameBuffer_horizontalinterp(f,ix2,ix1,y,ic2,ic1);
else
FrameBuffer_horizontalinterp(f,ix1,ix2,y,ic1,ic2);
y--;
}
}
}
}

572
Examples/GIFPlot/Lib/gif.c Normal file
View file

@ -0,0 +1,572 @@
/* -----------------------------------------------------------------------------
* gif.c
*
* GIF encoding with broken compression algorithm to avoid LZW.
*
* Author(s) : David Beazley (beazley@cs.uchicago.edu)
* Copyright (C) 1995-1996
*
* See the file LICENSE for information on usage and redistribution.
* ----------------------------------------------------------------------------- */
/*
* xvgifwr.c - handles writing of GIF files. based on flgife.c and
* flgifc.c from the FBM Library, by Michael Maudlin
*
* Contains:
* WriteGIF(fp, pic, ptype, w, h, rmap, gmap, bmap, numcols, colorstyle,
* comment)
*
* Note: slightly brain-damaged, in that it'll only write non-interlaced
* GIF files (in the interests of speed, or something)
*
*/
/*****************************************************************
* Portions of this code Copyright (C) 1989 by Michael Mauldin.
* Permission is granted to use this file in whole or in
* part for any purpose, educational, recreational or commercial,
* provided that this copyright notice is retained unchanged.
* This software is available to all free of charge by anonymous
* FTP and in the UUNET archives.
*
*
* Authors: Michael Mauldin (mlm@cs.cmu.edu)
* David Rowley (mgardi@watdcsu.waterloo.edu)
*
* Based on: compress.c - File compression ala IEEE Computer, June 1984.
*
* Spencer W. Thomas (decvax!harpo!utah-cs!utah-gr!thomas)
* Jim McKie (decvax!mcvax!jim)
* Steve Davies (decvax!vax135!petsd!peora!srd)
* Ken Turkowski (decvax!decwrl!turtlevax!ken)
* James A. Woods (decvax!ihnp4!ames!jaw)
* Joe Orost (decvax!vax135!petsd!joe)
*****************************************************************/
#include "gifplot.h"
#include <string.h>
typedef long int count_int;
typedef unsigned char byte;
static int gif_error;
static unsigned char *op;
static int Width, Height;
static int curx, cury;
static int Interlace;
static void putgifword(int);
static void compress(int, byte **, int);
static void output_GIF(int);
static void cl_block(void);
static void cl_hash(count_int);
static void char_init(void);
static void char_out(int);
static void flush_char(void);
static void *OutBuffer;
static int OutBufSize;
static FrameBuffer *GIF_frame;
static unsigned char pc2nc[256],r1[256],g1[256],b1[256];
/*************************************************************/
int FrameBuffer_makeGIF(FrameBuffer *f, ColorMap *c, void *outbuffer, unsigned int outbufsize)
{
int RWidth, RHeight;
int LeftOfs, TopOfs;
int ColorMapSize, InitCodeSize, Background, BitsPerPixel;
int i,j,nc;
char *rmap, *gmap, *bmap;
char *cmap;
int count;
Interlace = 0;
Background = 0;
OutBuffer = outbuffer;
OutBufSize = outbufsize;
GIF_frame = f;
cmap = (char *) c->cmap;
op = (unsigned char *) outbuffer;
gif_error = 0;
for (i=0; i<256; i++) { pc2nc[i] = r1[i] = g1[i] = b1[i] = 0; }
/* compute number of unique colors */
nc = 0;
rmap = &cmap[0];
gmap = &cmap[256];
bmap = &cmap[512];
for (i=0; i<256; i++) {
/* see if color #i is already used */
for (j=0; j<i; j++) {
if (rmap[i] == rmap[j] && gmap[i] == gmap[j] &&
bmap[i] == bmap[j]) break;
}
if (j==i) { /* wasn't found */
pc2nc[i] = nc;
r1[nc] = rmap[i];
g1[nc] = gmap[i];
b1[nc] = bmap[i];
nc++;
}
else pc2nc[i] = pc2nc[j];
}
/* figure out 'BitsPerPixel' */
for (i=1; i<8; i++)
if ( (1<<i) >= nc) break;
BitsPerPixel = i;
ColorMapSize = 1 << BitsPerPixel;
RWidth = Width = f->width;
RHeight = Height = f->height;
LeftOfs = TopOfs = 0;
if (BitsPerPixel <= 1) InitCodeSize = 2;
else InitCodeSize = BitsPerPixel;
curx = 0;
cury = f->height - 1;
strcpy((char *) op,"GIF89a"); /* Put in GIF magic number */
op+=6;
putgifword(RWidth); /* screen descriptor */
putgifword(RHeight);
i = 0x80; /* Yes, there is a color map */
i |= (8-1)<<4; /* OR in the color resolution (hardwired 8) */
i |= (BitsPerPixel - 1); /* OR in the # of bits per pixel */
*(op++) = i;
*(op++) = Background; /* background color */
*(op++) = 0;
for (i=0; i<ColorMapSize; i++) { /* write out Global colormap */
*(op++) = r1[i];
*(op++) = g1[i];
*(op++) = b1[i];
}
*(op++) = ','; /* image separator */
/* Write the Image header */
putgifword(LeftOfs);
putgifword(TopOfs);
putgifword(Width);
putgifword(Height);
*(op++) = 0;
*(op++) = InitCodeSize;
compress(InitCodeSize+1, f->pixels, f->width*f->height);
*(op++) = 0;
*(op++) = ';';
count = (op - (unsigned char *) OutBuffer);
if (gif_error) return -1;
else return count;
}
/******************************/
static void putgifword(w)
int w;
{
/* writes a 16-bit integer in GIF order (LSB first) */
*(op++) = w & 0xff;
*(op++) = (w>>8)&0xff;
}
/***********************************************************************/
static unsigned long cur_accum = 0;
static int cur_bits = 0;
#define GP_BITS 12 /* BITS was already defined on some systems */
#define HSIZE 5003 /* 80% occupancy */
typedef unsigned char char_type;
static int n_bits; /* number of bits/code */
static int maxbits = GP_BITS; /* user settable max # bits/code */
static int maxcode; /* maximum code, given n_bits */
static int maxmaxcode = 1 << GP_BITS; /* NEVER generate this */
#define MAXCODE(n_bits) ( (1 << (n_bits)) - 1)
static count_int *htab;
static unsigned short *codetab;
static GIFOutBufSize;
/* static count_int htab [HSIZE];
static unsigned short codetab [HSIZE]; */
#define HashTabOf(i) htab[i]
#define CodeTabOf(i) codetab[i]
static int hsize = HSIZE; /* for dynamic table sizing */
/*
* To save much memory, we overlay the table used by compress() with those
* used by decompress(). The tab_prefix table is the same size and type
* as the codetab. The tab_suffix table needs 2**BITS characters. We
* get this from the beginning of htab. The output stack uses the rest
* of htab, and contains characters. There is plenty of room for any
* possible stack (stack used to be 8000 characters).
*/
#define tab_prefixof(i) CodeTabOf(i)
#define tab_suffixof(i) ((char_type *)(htab))[i]
#define de_stack ((char_type *)&tab_suffixof(1<<GP_BITS))
static int free_ent = 0; /* first unused entry */
/*
* block compression parameters -- after all codes are used up,
* and compression rate changes, start over.
*/
static int clear_flg = 0;
static long int out_count = 0; /* # of codes output (for debugging) */
/*
* compress stdin to stdout
*
* Algorithm: use open addressing double hashing (no chaining) on the
* prefix code / next character combination. We do a variant of Knuth's
* algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
* secondary probe. Here, the modular division first probe is gives way
* to a faster exclusive-or manipulation. Also do block compression with
* an adaptive reset, whereby the code table is cleared when the compression
* ratio decreases, but after the table fills. The variable-length output
* codes are re-sized at this point, and a special CLEAR code is generated
* for the decompressor. Late addition: construct the table according to
* file size for noticeable speed improvement on small files. Please direct
* questions about this implementation to ames!jaw.
*/
static int g_init_bits;
static int ClearCode;
static int EOFCode;
/********************************************************/
static void compress(init_bits, data, len)
int init_bits;
unsigned char **data;
int len;
{
register long fcode;
register int i = 0;
register int c;
register int ent;
register int disp;
register int hsize_reg;
register int hshift;
int code_count = 0;
/* Use the output buffer as temporary storage for GIF data */
if (OutBufSize < HSIZE*(sizeof(count_int) + sizeof(unsigned short))) {
gif_error =1;
return;
}
/* Put htab and codetab arrays into the output buffer */
GIFOutBufSize = OutBufSize - HSIZE*(sizeof(count_int) + sizeof(unsigned short)) - 16;
GIFOutBufSize = GIFOutBufSize & (~0x3); /* Make sure it's double word alligned */
htab = (count_int *) ((char *) OutBuffer + GIFOutBufSize);
codetab = (unsigned short *) ((char *) OutBuffer + GIFOutBufSize + HSIZE*sizeof(count_int));
/*
* Set up the globals: g_init_bits - initial number of bits
* g_outfile - pointer to output file
*/
g_init_bits = init_bits;
/* initialize 'compress' globals */
maxbits = GP_BITS;
maxmaxcode = 1<<GP_BITS;
memset(htab,0,sizeof(htab));
memset(codetab,0,sizeof(codetab));
hsize = HSIZE;
free_ent = 0;
clear_flg = 0;
out_count = 0;
cur_accum = 0;
cur_bits = 0;
/*
* Set up the necessary values
*/
out_count = 0;
clear_flg = 0;
maxcode = MAXCODE(n_bits = g_init_bits);
ClearCode = (1 << (init_bits - 1));
EOFCode = ClearCode + 1;
free_ent = ClearCode + 2;
char_init();
ent = pc2nc[data[cury][curx]];
curx++;
if (curx >= GIF_frame->width) {
curx = 0;
cury--;
}
len--;
hshift = 0;
for ( fcode = (long) hsize; fcode < 65536L; fcode *= 2L )
hshift++;
hshift = 8 - hshift; /* set hash code range bound */
hsize_reg = hsize;
cl_hash( (count_int) hsize_reg); /* clear hash table */
output_GIF(ClearCode);
while (len) {
c = pc2nc[data[cury][curx]];
curx++;
if (curx >= GIF_frame->width) {
curx = 0;
cury--;
}
len--;
/* Uncompressed GIF */
output_GIF(ent);
code_count++;
if (code_count >= ClearCode-2) {
output_GIF(ClearCode);
code_count = 0;
}
ent = c;
}
/* Put out the final code */
output_GIF(ent);
output_GIF(EOFCode);
}
/*****************************************************************
* TAG( output_GIF )
*
* Output the given code.
* Inputs:
* code: A n_bits-bit integer. If == -1, then EOF. This assumes
* that n_bits =< (long)wordsize - 1.
* Outputs:
* Outputs code to the file.
* Assumptions:
* Chars are 8 bits long.
* Algorithm:
* Maintain a BITS character long buffer (so that 8 codes will
* fit in it exactly). Use the VAX insv instruction to insert each
* code in turn. When the buffer fills up empty it and start over.
*/
static
unsigned long masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
0x001F, 0x003F, 0x007F, 0x00FF,
0x01FF, 0x03FF, 0x07FF, 0x0FFF,
0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
static void output_GIF(code)
int code;
{
cur_accum &= masks[cur_bits];
if (cur_bits > 0)
cur_accum |= ((long)code << cur_bits);
else
cur_accum = code;
cur_bits += n_bits;
while( cur_bits >= 8 ) {
char_out( (int) (cur_accum & 0xff) );
cur_accum >>= 8;
cur_bits -= 8;
}
/*
* If the next entry is going to be too big for the code size,
* then increase it, if possible.
*/
if (free_ent > maxcode || clear_flg) {
if( clear_flg ) {
maxcode = MAXCODE (n_bits = g_init_bits);
clear_flg = 0;
}
else {
n_bits++;
if ( n_bits == maxbits )
maxcode = maxmaxcode;
else
maxcode = MAXCODE(n_bits);
}
}
if( code == EOFCode ) {
/* At EOF, write the rest of the buffer */
while( cur_bits > 0 ) {
char_out( (int)(cur_accum & 0xff) );
cur_accum >>= 8;
cur_bits -= 8;
}
flush_char();
}
}
/********************************/
static void cl_block () /* table clear for block compress */
{
/* Clear out the hash table */
cl_hash ( (count_int) hsize );
free_ent = ClearCode + 2;
clear_flg = 1;
output_GIF(ClearCode);
}
/********************************/
static void cl_hash(hsize) /* reset code table */
register count_int hsize;
{
register count_int *htab_p = htab+hsize;
register long i;
register long m1 = -1;
i = hsize - 16;
do { /* might use Sys V memset(3) here */
*(htab_p-16) = m1;
*(htab_p-15) = m1;
*(htab_p-14) = m1;
*(htab_p-13) = m1;
*(htab_p-12) = m1;
*(htab_p-11) = m1;
*(htab_p-10) = m1;
*(htab_p-9) = m1;
*(htab_p-8) = m1;
*(htab_p-7) = m1;
*(htab_p-6) = m1;
*(htab_p-5) = m1;
*(htab_p-4) = m1;
*(htab_p-3) = m1;
*(htab_p-2) = m1;
*(htab_p-1) = m1;
htab_p -= 16;
} while ((i -= 16) >= 0);
for ( i += 16; i > 0; i-- )
*--htab_p = m1;
}
/******************************************************************************
*
* GIF Specific routines
*
******************************************************************************/
/*
* Number of characters so far in this 'packet'
*/
static int a_count;
/*
* Set up the 'byte output' routine
*/
static void char_init()
{
a_count = 0;
}
/*
* Define the storage for the packet accumulator
*/
static char accum[ 256 ];
/*
* Add a character to the end of the current packet, and if it is 254
* characters, flush the packet to disk.
*/
static void char_out(c)
int c;
{
accum[ a_count++ ] = c;
if( a_count >= 254 )
flush_char();
}
/*
* Flush the packet to disk, and reset the accumulator
*/
static void flush_char()
{
if (gif_error) return;
if( a_count > 0 ) {
*(op++) = a_count;
memcpy(op,accum,a_count);
op+=a_count;
a_count = 0;
if (op > (unsigned char *) ((char *) OutBuffer + (GIFOutBufSize - 2048))) {
gif_error = 1;
}
}
}
/* ----------------------------------------------------------------------
int FrameBuffer_writeGIF(char *filename)
Write a GIF file to filename
----------------------------------------------------------------------- */
int FrameBuffer_writeGIF(FrameBuffer *f, ColorMap *c, char *filename) {
FILE *file;
void *buffer;
int nbytes;
int bufsize;
file = fopen(filename,"wb");
if (file == NULL) return -1;
bufsize = (f->width*f->height*3)/2;
buffer = (void *) malloc(bufsize);
nbytes = FrameBuffer_makeGIF(f,c,buffer,bufsize);
if (nbytes == -1) {
free(buffer);
fclose(file);
return -1;
}
fwrite(buffer,nbytes,1,file);
fclose(file);
free(buffer);
return 0;
}

343
Examples/GIFPlot/Lib/matrix.c Normal file
View file

@ -0,0 +1,343 @@
/* -----------------------------------------------------------------------------
* matrix.c
*
* Some 4x4 matrix operations
*
* Author(s) : David Beazley (beazley@cs.uchicago.edu)
* Copyright (C) 1995-1996
*
* See the file LICENSE for information on usage and redistribution.
* ----------------------------------------------------------------------------- */
#define MATRIX
#include "gifplot.h"
#include <math.h>
/* ------------------------------------------------------------------------
Matrix new_Matrix()
Create a new 4x4 matrix.
------------------------------------------------------------------------ */
Matrix
new_Matrix() {
Matrix m;
m = (Matrix) malloc(16*sizeof(double));
return m;
}
/* ------------------------------------------------------------------------
delete_Matrix(Matrix *m);
Destroy a matrix
------------------------------------------------------------------------ */
void
delete_Matrix(Matrix m) {
if (m)
free((char *) m);
}
/* ------------------------------------------------------------------------
Matrix Matrix_copy(Matrix a)
Makes a copy of matrix a and returns it.
------------------------------------------------------------------------ */
Matrix Matrix_copy(Matrix a) {
int i;
Matrix r = 0;
if (a) {
r = new_Matrix();
if (r) {
for (i = 0; i < 16; i++)
r[i] = a[i];
}
}
return r;
}
/* ------------------------------------------------------------------------
Matrix_multiply(Matrix a, Matrix b, Matrix c)
Multiplies a*b = c
c may be one of the source matrices
------------------------------------------------------------------------ */
void
Matrix_multiply(Matrix a, Matrix b, Matrix c) {
double temp[16];
int i,j,k;
for (i =0; i < 4; i++)
for (j = 0; j < 4; j++) {
temp[i*4+j] = 0.0;
for (k = 0; k < 4; k++)
temp[i*4+j] += a[i*4+k]*b[k*4+j];
}
for (i = 0; i < 16; i++)
c[i] = temp[i];
}
/* ------------------------------------------------------------------------
Matrix_identity(Matrix a)
Puts an identity matrix in matrix a
------------------------------------------------------------------------ */
void
Matrix_identity(Matrix a) {
int i;
for (i = 0; i < 16; i++) a[i] = 0;
a[0] = 1;
a[5] = 1;
a[10] = 1;
a[15] = 1;
}
/* ------------------------------------------------------------------------
Matrix_zero(Matrix a)
Puts a zero matrix in matrix a
------------------------------------------------------------------------ */
void
Matrix_zero(Matrix a) {
int i;
for (i = 0; i < 16; i++) a[i] = 0;
}
/* ------------------------------------------------------------------------
Matrix_transpose(Matrix a, Matrix result)
Transposes matrix a and puts it in result.
------------------------------------------------------------------------ */
void
Matrix_transpose(Matrix a, Matrix result) {
double temp[16];
int i,j;
for (i = 0; i < 4; i++)
for (j = 0; j < 4; j++)
temp[4*i+j] = a[4*j+i];
for (i = 0; i < 16; i++)
result[i] = temp[i];
}
/* ------------------------------------------------------------------------
Matrix_gauss(Matrix a, Matrix b)
Solves ax=b for x, using Gaussian elimination. Destroys a.
Really only used for calculating inverses of 4x4 transformation
matrices.
------------------------------------------------------------------------ */
void Matrix_gauss(Matrix a, Matrix b) {
int ipiv[4], indxr[4], indxc[4];
int i,j,k,l,ll;
int irow=0, icol=0;
double big, pivinv;
double dum;
for (j = 0; j < 4; j++)
ipiv[j] = 0;
for (i = 0; i < 4; i++) {
big = 0;
for (j = 0; j < 4; j++) {
if (ipiv[j] != 1) {
for (k = 0; k < 4; k++) {
if (ipiv[k] == 0) {
if (fabs(a[4*j+k]) >= big) {
big = fabs(a[4*j+k]);
irow = j;
icol = k;
}
} else if (ipiv[k] > 1)
return; /* Singular matrix */
}
}
}
ipiv[icol] = ipiv[icol]+1;
if (irow != icol) {
for (l = 0; l < 4; l++) {
dum = a[4*irow+l];
a[4*irow+l] = a[4*icol+l];
a[4*icol+l] = dum;
}
for (l = 0; l < 4; l++) {
dum = b[4*irow+l];
b[4*irow+l] = b[4*icol+l];
b[4*icol+l] = dum;
}
}
indxr[i] = irow;
indxc[i] = icol;
if (a[4*icol+icol] == 0) return;
pivinv = 1.0/a[4*icol+icol];
a[4*icol+icol] = 1.0;
for (l = 0; l < 4; l++)
a[4*icol+l] = a[4*icol+l]*pivinv;
for (l = 0; l < 4; l++)
b[4*icol+l] = b[4*icol+l]*pivinv;
for (ll = 0; ll < 4; ll++) {
if (ll != icol) {
dum = a[4*ll+icol];
a[4*ll+icol] = 0;
for (l = 0; l < 4; l++)
a[4*ll+l] = a[4*ll+l] - a[4*icol+l]*dum;
for (l = 0; l < 4; l++)
b[4*ll+l] = b[4*ll+l] - b[4*icol+l]*dum;
}
}
}
for (l = 3; l >= 0; l--) {
if (indxr[l] != indxc[l]) {
for (k = 0; k < 4; k++) {
dum = a[4*k+indxr[l]];
a[4*k+indxr[l]] = a[4*k+indxc[l]];
a[4*k+indxc[l]] = dum;
}
}
}
}
/* ------------------------------------------------------------------------
Matrix_invert(Matrix a, Matrix inva)
Inverts Matrix a and places the result in inva.
Relies on the Gaussian Elimination code above. (See Numerical recipes).
------------------------------------------------------------------------ */
void
Matrix_invert(Matrix a, Matrix inva) {
double temp[16];
int i;
for (i = 0; i < 16; i++)
temp[i] = a[i];
Matrix_identity(inva);
Matrix_gauss(temp,inva);
}
/* ------------------------------------------------------------------------
Matrix_transform(Matrix a, GL_Vector *r, GL_Vector *t)
Transform a vector. a*r ----> t
------------------------------------------------------------------------ */
void Matrix_transform(Matrix a, GL_Vector *r, GL_Vector *t) {
double rx, ry, rz, rw;
rx = r->x;
ry = r->y;
rz = r->z;
rw = r->w;
t->x = a[0]*rx + a[1]*ry + a[2]*rz + a[3]*rw;
t->y = a[4]*rx + a[5]*ry + a[6]*rz + a[7]*rw;
t->z = a[8]*rx + a[9]*ry + a[10]*rz + a[11]*rw;
t->w = a[12]*rx + a[13]*ry + a[14]*rz + a[15]*rw;
}
/* ------------------------------------------------------------------------
Matrix_transform4(Matrix a, double x, double y, double z, double w, GL_Vector *t)
Transform a vector from a point specified as 4 doubles
------------------------------------------------------------------------ */
void Matrix_transform4(Matrix a, double rx, double ry, double rz, double rw,
GL_Vector *t) {
t->x = a[0]*rx + a[1]*ry + a[2]*rz + a[3]*rw;
t->y = a[4]*rx + a[5]*ry + a[6]*rz + a[7]*rw;
t->z = a[8]*rx + a[9]*ry + a[10]*rz + a[11]*rw;
t->w = a[12]*rx + a[13]*ry + a[14]*rz + a[15]*rw;
}
/* ---------------------------------------------------------------------
Matrix_translate(Matrix a, double tx, double ty, double tz)
Put a translation matrix in Matrix a
---------------------------------------------------------------------- */
void Matrix_translate(Matrix a, double tx, double ty, double tz) {
Matrix_identity(a);
a[3] = tx;
a[7] = ty;
a[11] = tz;
a[15] = 1;
}
/* -----------------------------------------------------------------------
Matrix_rotatex(Matrix a, double deg)
Produce an x-rotation matrix for given angle in degrees.
----------------------------------------------------------------------- */
void
Matrix_rotatex(Matrix a, double deg) {
double r;
r = 3.1415926*deg/180.0;
Matrix_zero(a);
a[0] = 1.0;
a[5] = cos(r);
a[6] = -sin(r);
a[9] = sin(r);
a[10] = cos(r);
a[15] = 1.0;
}
/* -----------------------------------------------------------------------
Matrix_rotatey(Matrix a, double deg)
Produce an y-rotation matrix for given angle in degrees.
----------------------------------------------------------------------- */
void
Matrix_rotatey(Matrix a, double deg) {
double r;
r = 3.1415926*deg/180.0;
Matrix_zero(a);
a[0] = cos(r);
a[2] = sin(r);
a[5] = 1.0;
a[8] = -sin(r);
a[10] = cos(r);
a[15] = 1;
}
/* -----------------------------------------------------------------------
Matrix_RotateZ(Matrix a, double deg)
Produce an z-rotation matrix for given angle in degrees.
----------------------------------------------------------------------- */
void
Matrix_rotatez(Matrix a, double deg) {
double r;
r = 3.1415926*deg/180.0;
Matrix_zero(a);
a[0] = cos(r);
a[1] = -sin(r);
a[4] = sin(r);
a[5] = cos(r);
a[10] = 1.0;
a[15] = 1.0;
}
/* A debugging routine */
void Matrix_set(Matrix a, int i, int j, double val) {
a[4*j+i] = val;
}
void Matrix_print(Matrix a) {
int i,j;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
fprintf(stdout,"%10f ",a[4*i+j]);
}
fprintf(stdout,"\n");
}
fprintf(stdout,"\n");
}

159
Examples/GIFPlot/Lib/pixmap.c Normal file
View file

@ -0,0 +1,159 @@
/* -----------------------------------------------------------------------------
* pixmap.c
*
* Pixel maps (i.e., bitmaps)
*
* Author(s) : David Beazley (beazley@cs.uchicago.edu)
* Copyright (C) 1995-1996
*
* See the file LICENSE for information on usage and redistribution.
* ----------------------------------------------------------------------------- */
#define PIXMAP
#include "gifplot.h"
/* -----------------------------------------------------------------------
PixMap *new_PixMap(int width, int height, int centerx, int centery)
Create a new pixmap of given size
----------------------------------------------------------------------- */
PixMap *new_PixMap(int width, int height, int centerx, int centery) {
PixMap *pm;
if ((width > 0) && (height > 0)) {
pm = (PixMap *) malloc(sizeof(PixMap));
pm->width = width;
pm->height = height;
pm->centerx = centerx;
pm->centery = centery;
pm->map = (int *) malloc(height*width*sizeof(int));
return pm;
}
return (PixMap *) 0;
}
/* --------------------------------------------------------------------------
void delete_PixMap(PixMap *pm)
Destroy a pixmap
-------------------------------------------------------------------------- */
void delete_PixMap(PixMap *pm) {
if (pm) {
free((char *) pm->map);
free((char *) pm);
}
}
/* ---------------------------------------------------------------------------
void PixMap_set(PixMap *pm, int x, int y, int pix)
Set a pixel in the bitmap
--------------------------------------------------------------------------- */
void
PixMap_set(PixMap *pm, int x, int y, int pix) {
if ((x < 0) || (x>=pm->width)) return;
if ((y < 0) || (y>=pm->height)) return;
pm->map[pm->width*y + x] = pix;
}
/* -----------------------------------------------------------------------------
void FrameBuffer_drawpixmap(FrameBuffer *f, PixMap *pm, int x, int y, int fgcolor, int bgcolor)
Draw a pixmap onto the framebuffer. This is somewhat optimized for speed.
------------------------------------------------------------------------------ */
void
FrameBuffer_drawpixmap(FrameBuffer *f, PixMap *pm, int x, int y, int fgcolor, int bgcolor) {
int startx, starty; /* Starting location on framebuffer */
int startpixx = 0, startpixy = 0; /* Starting location in pixmap */
int endx, endy; /* Ending location on framebuffer */
int i,j, px, py;
int c;
startx = x - pm->centerx;
starty = y + pm->centery;
endx = startx + pm->width;
endy = starty - pm->height;
/* Figure out if we need to clip */
if (startx < f->xmin) {
startpixx = f->xmin - startx;
startx = f->xmin;
}
if (starty >= f->ymax) {
startpixy = starty - f->ymax;
starty = f->ymax-1;
}
if (endx >= f->xmax) {
endx = f->xmax-1;
}
if (endy < f->ymin) {
endy = f->ymin;
}
py = startpixy;
for (j = starty; j >= endy; j--) {
px = startpixx;
for (i = startx; i < endx; i++) {
c = pm->map[py*pm->width + px];
switch (c) {
case FOREGROUND:
f->pixels[j][i] = fgcolor;
break;
case BACKGROUND:
f->pixels[j][i] = bgcolor;
break;
default:
break;
}
px++;
}
py++;
}
}
/**************************************************************************
* Some common PixMaps (for plotting)
*
**************************************************************************/
int _SQUARE_MAP[] = {
0,1,1,1,1,1,1,1,
0,1,1,1,1,1,1,1,
0,1,1,1,1,1,1,1,
0,1,1,1,1,1,1,1,
0,1,1,1,1,1,1,1,
0,1,1,1,1,1,1,1,
0,1,1,1,1,1,1,1,
0,0,0,0,0,0,0,0 };
PixMap PixMap_SQUARE = { 8,8,4,4, _SQUARE_MAP};
int _TRIANGLE_MAP[] = {
0,0,0,1,0,0,0,0,
0,0,0,1,0,0,0,0,
0,0,1,1,1,0,0,0,
0,0,1,1,1,0,0,0,
0,1,1,1,1,1,0,0,
0,1,1,1,1,1,0,0,
1,1,1,1,1,1,1,0,
0,0,0,0,0,0,0,0 };
PixMap PixMap_TRIANGLE = { 8,8,4,4,_TRIANGLE_MAP};
int _CROSS_MAP[] = {
0,0,0,1,0,0,0,0,
0,0,0,1,0,0,0,0,
0,0,0,1,0,0,0,0,
1,1,1,1,1,1,1,0,
0,0,0,1,0,0,0,0,
0,0,0,1,0,0,0,0,
0,0,0,1,0,0,0,0,
0,0,0,0,0,0,0,0 };
PixMap PixMap_CROSS = { 8,8,4,4,_CROSS_MAP};

445
Examples/GIFPlot/Lib/plot2d.c Normal file
View file

@ -0,0 +1,445 @@
/* -----------------------------------------------------------------------------
* plot2d.c
*
* 2-Dimensional plotting
*
* Author(s) : David Beazley (beazley@cs.uchicago.edu)
* Copyright (C) 1995-1996
*
* See the file LICENSE for information on usage and redistribution.
* ----------------------------------------------------------------------------- */
#define PLOT2D
#include "gifplot.h"
/* ------------------------------------------------------------------------
Plot2D *new_Plot2D(FrameBuffer *frame, xmin, ymin, xmax, ymax)
Create a new 2D plot with given minimum and maximum coordinates.
------------------------------------------------------------------------ */
Plot2D *new_Plot2D(FrameBuffer *frame,double xmin,double ymin,double xmax,double ymax) {
Plot2D *p2;
if (frame) {
if (xmax <= xmin) return (Plot2D *) 0;
if (ymax <= ymin) return (Plot2D *) 0;
p2 = (Plot2D *) malloc(sizeof(Plot2D));
p2->frame = frame;
p2->xmin = xmin;
p2->ymin = ymin;
p2->xmax = xmax;
p2->ymax = ymax;
p2->view_xmin = 0;
p2->view_xmax = frame->width;
p2->view_ymin = 0;
p2->view_ymax = frame->height;
p2->xscale = LINEAR;
p2->yscale = LINEAR;
p2->dx = (p2->view_xmax - p2->view_xmin)/(p2->xmax - p2->xmin);
p2->dy = (p2->view_ymax - p2->view_ymin)/(p2->ymax - p2->ymin);
return p2;
}
return (Plot2D *) 0;
}
/* ----------------------------------------------------------------------------
delete_Plot2D(Plot2D *p2)
Delete a 2D plot
---------------------------------------------------------------------------- */
void
delete_Plot2D(Plot2D *p2) {
if (p2)
free((char *) p2);
}
/* -----------------------------------------------------------------------------
Plot2D *Plot2D_copy(Plot2D *p2)
Makes a copy of the Plot2D data structure.
----------------------------------------------------------------------------- */
Plot2D *Plot2D_copy(Plot2D *p2) {
Plot2D *c2;
if (p2) {
c2 = (Plot2D *) malloc(sizeof(Plot2D));
if (c2) {
c2->frame = p2->frame;
c2->view_xmin = p2->view_xmin;
c2->view_ymin = p2->view_ymin;
c2->view_xmax = p2->view_xmax;
c2->view_ymax = p2->view_ymax;
c2->xmin = p2->xmin;
c2->ymin = p2->ymin;
c2->xmax = p2->xmax;
c2->ymax = p2->ymax;
c2->xscale = p2->xscale;
c2->yscale = p2->yscale;
c2->dx = p2->dx;
c2->dy = p2->dy;
}
return c2;
} else {
return (Plot2D *) 0;
}
}
/* -----------------------------------------------------------------------------
Plot2D_clear(Plot2D *p2, Pixel c)
Clear the region assigned to this plot to the given color.
-------------------------------------------------------------------------- */
void Plot2D_clear(Plot2D *p2, Pixel c) {
int i,j;
for (i = p2->view_xmin; i < p2->view_xmax; i++)
for (j = p2->view_ymin; j < p2->view_ymax; j++) {
p2->frame->pixels[j][i] = c;
}
}
/* ------------------------------------------------------------------------------
Plot2D_setview
Sets the plot region on the framebuffer
------------------------------------------------------------------------------ */
void
Plot2D_setview(Plot2D *p2, int vxmin, int vymin, int vxmax, int vymax) {
if (p2) {
p2->view_xmin = vxmin;
p2->view_ymin = vymin;
p2->view_xmax = vxmax;
p2->view_ymax = vymax;
p2->dx = (p2->view_xmax - p2->view_xmin)/(p2->xmax - p2->xmin);
p2->dy = (p2->view_ymax - p2->view_ymin)/(p2->ymax - p2->ymin);
FrameBuffer_setclip(p2->frame,vxmin,vymin,vxmax,vymax);
}
}
/* -------------------------------------------------------------------------------
Plot2D_setrange(Plot2D *p2, double xmin, double ymin, double xmax, double ymax)
Sets the plotting range.
------------------------------------------------------------------------------- */
void
Plot2D_setrange(Plot2D *p2, double xmin, double ymin, double xmax, double ymax) {
if (p2) {
p2->xmin = xmin;
p2->ymin = ymin;
p2->xmax = xmax;
p2->ymax = ymax;
p2->dx = (p2->view_xmax - p2->view_xmin)/(p2->xmax - p2->xmin);
p2->dy = (p2->view_ymax - p2->view_ymin)/(p2->ymax - p2->ymin);
}
}
/* -------------------------------------------------------------------------------
Plot2D_setscale(Plot2D *p2, int xscale, int yscale)
Sets the plotting scaling method
------------------------------------------------------------------------------- */
void
Plot2D_setscale(Plot2D *p2, int xscale, int yscale) {
if (p2) {
p2->xscale = xscale;
p2->yscale = yscale;
}
}
/* ----------------------------------------------------------------------------
Plot2D_transform(Plot2D *p2, double x, double y, int *px, int *py)
Transforms x,y into screen coordinates px and py. Result is returned
in px and py. Rounds to the nearest pixel instead of truncating.
----------------------------------------------------------------------------- */
void
Plot2D_transform(Plot2D *p2, double x, double y, int *px, int *py) {
if (p2) {
*px = p2->view_xmin + (int) (p2->dx*(x-p2->xmin) + 0.5);
*py = p2->view_ymin + (int) (p2->dy*(y-p2->ymin) + 0.5);
}
}
/* -------------------------------------------------------------------------------
Plot2D_plot(Plot2D *p2, double x, double y, Pixel color)
Plot a 2D Point of a given color
------------------------------------------------------------------------------- */
void
Plot2D_plot(Plot2D *p2, double x, double y, Pixel color) {
int px, py;
Plot2D_transform(p2,x,y,&px,&py);
FrameBuffer_plot(p2->frame, px, py, color);
}
/* -------------------------------------------------------------------------------
Plot2D_box(Plot2D *p2, double x1, double y1, double x2, double y2, Pixel Color)
Plot an outline box on the 2D plot
------------------------------------------------------------------------------- */
void
Plot2D_box(Plot2D *p2, double x1, double y1,double x2, double y2, Pixel color) {
int ix1, ix2,iy1, iy2;
Plot2D_transform(p2,x1,y1,&ix1,&iy1);
Plot2D_transform(p2,x2,y2,&ix2,&iy2);
FrameBuffer_box(p2->frame,ix1,iy1,ix2,iy2,color);
}
/* -------------------------------------------------------------------------------
Plot2D_solidbox(Plot2D *p2, double x1, double y1, double x2, double y2, Pixel Color)
Plot a solid box box on the 2D plot
------------------------------------------------------------------------------- */
void
Plot2D_solidbox(Plot2D *p2, double x1, double y1,double x2, double y2, Pixel color) {
int ix1, ix2,iy1, iy2;
Plot2D_transform(p2,x1,y1,&ix1,&iy1);
Plot2D_transform(p2,x2,y2,&ix2,&iy2);
FrameBuffer_solidbox(p2->frame,ix1,iy1,ix2,iy2,color);
}
/* -------------------------------------------------------------------------------
Plot2D_interpbox(Plot2D *p2, double x1, double y1, double x2, double y2,
Pixel c1, Pixel c2, Pixel c3, Pixel c4)
Plot a color-interpolated box on the 2D plot
------------------------------------------------------------------------------- */
void
Plot2D_interpbox(Plot2D *p2, double x1, double y1,double x2, double y2,
Pixel c1, Pixel c2, Pixel c3, Pixel c4) {
int ix1, ix2,iy1, iy2;
Plot2D_transform(p2,x1,y1,&ix1,&iy1);
Plot2D_transform(p2,x2,y2,&ix2,&iy2);
FrameBuffer_interpbox(p2->frame,ix1,iy1,ix2,iy2,c1,c2,c3,c4);
}
/* -------------------------------------------------------------------------------
Plot2D_circle(Plot2D *p2, double x, double y, double radius, Pixel color)
Make an outline circle on the 2D plot.
------------------------------------------------------------------------------- */
void
Plot2D_circle(Plot2D *p2, double x, double y, double radius, Pixel color) {
int ix, iy, ir;
Plot2D_transform(p2,x,y,&ix,&iy);
ir = p2->dx * radius; /* This is really incorrect. Will need ellipse */
if (ir > 1)
FrameBuffer_circle(p2->frame,ix,iy,ir,color);
else
FrameBuffer_plot(p2->frame,ix,iy,color);
}
/* -------------------------------------------------------------------------------
Plot2D_solidcircle(Plot2D *p2, double x, double y, double radius, Pixel color)
Make an solid circle on the 2D plot.
------------------------------------------------------------------------------- */
void
Plot2D_solidcircle(Plot2D *p2, double x, double y, double radius, Pixel color) {
int ix, iy, ir;
Plot2D_transform(p2,x,y,&ix,&iy);
ir = p2->dx * radius; /* This is really incorrect. Will need ellipse */
if (ir > 1)
FrameBuffer_solidcircle(p2->frame,ix,iy,ir,color);
else
FrameBuffer_plot(p2->frame,ix,iy,color);
}
/* -------------------------------------------------------------------------------
Plot2D_line(Plot2D *p2, double x1, double y1, double x2, double y2, Pixel color)
Draw a line
------------------------------------------------------------------------------- */
void
Plot2D_line(Plot2D *p2, double x1, double y1, double x2, double y2, Pixel color) {
int ix1, ix2, iy1, iy2;
Plot2D_transform(p2,x1,y1,&ix1,&iy1);
Plot2D_transform(p2,x2,y2,&ix2,&iy2);
FrameBuffer_line(p2->frame,ix1,iy1,ix2,iy2,color);
}
/* -------------------------------------------------------------------------------
Plot2D_start(Plot2D *p2)
This should be called before starting to make a 2D plot. It will change
the viewport coordinates for the framebuffer and do other stuff.
------------------------------------------------------------------------------- */
void Plot2D_start(Plot2D *p2) {
if (p2) {
FrameBuffer_setclip(p2->frame, p2->view_xmin,p2->view_ymin,p2->view_xmax, p2->view_ymax);
p2->dx = (p2->view_xmax - p2->view_xmin)/(p2->xmax - p2->xmin);
p2->dy = (p2->view_ymax - p2->view_ymin)/(p2->ymax - p2->ymin);
}
}
/* --------------------------------------------------------------------------
void Plot2D_drawpixmap(Plot2D *p2, PixMap *pm, double x, double y, Pixel color, Pixel bgcolor)
Draw a pixel map at the given coordinates. (Used for putting symbols on 2D
plots).
-------------------------------------------------------------------------- */
void
Plot2D_drawpixmap(Plot2D *p2, PixMap *pm, double x, double y, Pixel color, Pixel bgcolor) {
int ix, iy;
Plot2D_transform(p2,x,y,&ix,&iy);
FrameBuffer_drawpixmap(p2->frame,pm,ix,iy,color,bgcolor);
}
/* ----------------------------------------------------------------------------
void Plot2D_xaxis(Plot2D *p2, double x, double y, double xtick, int ticklength, Pixel color)
Draw an X axis bar at location x,y with ticks spaced every xtick units.
Ticks are spaced starting at "x"
----------------------------------------------------------------------------- */
void Plot2D_xaxis(Plot2D *p2, double x, double y, double xtick, int ticklength, Pixel color) {
int ix, iy,iy2;
double xt;
/* Draw a line fox the axis */
Plot2D_line(p2,p2->xmin,y,p2->xmax,y,color);
xt = x;
while (xt >= p2->xmin) {
Plot2D_transform(p2,xt,y,&ix,&iy);
iy2 = iy+ticklength;
iy = iy-ticklength;
FrameBuffer_line(p2->frame,ix,iy,ix,iy2,color);
xt = xt - xtick;
}
xt = x + xtick;
while (xt < p2->xmax) {
Plot2D_transform(p2,xt,y,&ix,&iy);
iy2 = iy+ticklength;
iy = iy-ticklength;
FrameBuffer_line(p2->frame,ix,iy,ix,iy2,color);
xt = xt + xtick;
}
}
/* ----------------------------------------------------------------------------
void Plot2D_yaxis(Plot2D *p2, double x, double y, double ytick, int ticklength, Pixel c)
Draw an Y axis bar at location x,y with ticks spaced every xtick units.
Ticks are spaced starting at "y"
----------------------------------------------------------------------------- */
void Plot2D_yaxis(Plot2D *p2, double x, double y, double ytick, int ticklength, Pixel color) {
int ix, iy, ix2;
double yt;
/* Draw a line fox the axis */
Plot2D_line(p2,x,p2->ymin,x,p2->ymax,color);
yt = y;
while (yt >= p2->ymin) {
Plot2D_transform(p2,x,yt,&ix,&iy);
ix2 = ix+ticklength;
ix = ix-ticklength;
FrameBuffer_line(p2->frame,ix,iy,ix2,iy,color);
yt = yt - ytick;
}
yt = y + ytick;
while (yt < p2->ymax) {
Plot2D_transform(p2,x,yt,&ix,&iy);
ix2 = ix+ticklength;
ix = ix-ticklength;
FrameBuffer_line(p2->frame,ix,iy,ix2,iy,color);
yt = yt + ytick;
}
}
/* -------------------------------------------------------------------------
Plot2D_triangle(Plot2D *p2, double x1, double y1,
double x2, double y2,
double x3, double y3,
Pixel fillcolor)
This function draws a 2D outline triangle.
-------------------------------------------------------------------------- */
void Plot2D_triangle(Plot2D *p2, double x1, double y1,
double x2, double y2,
double x3, double y3, Pixel color) {
Plot2D_line(p2,x1,y1,x2,y2,color);
Plot2D_line(p2,x2,y2,x3,y3,color);
Plot2D_line(p2,x3,y3,x1,y1,color);
}
/* -------------------------------------------------------------------------
Plot2D_solidtriangle(Plot2D *p2, double x1, double y1,
double x2, double y2,
double x3, double y3,
Pixel color)
This function draws a 2D filled triangle. Can be used to
draw other primitives such as quadralaterals, etc...
-------------------------------------------------------------------------- */
void Plot2D_solidtriangle(Plot2D *p2, double x1, double y1,
double x2, double y2,
double x3, double y3, Pixel color) {
int tx1, tx2, tx3, ty1, ty2, ty3;
/* Transform the three points into screen coordinates */
Plot2D_transform(p2,x1,y1,&tx1,&ty1);
Plot2D_transform(p2,x2,y2,&tx2,&ty2);
Plot2D_transform(p2,x3,y3,&tx3,&ty3);
FrameBuffer_solidtriangle(p2->frame,tx1,ty1,tx2,ty2,tx3,ty3,color);
}
/* -------------------------------------------------------------------------
Plot2D_interptriangle(Plot2D *p2, double x1, double y1, Pixel c1,
double x2, double y2, Pixel c2,
double x3, double y3, Pixel c3);
This function draws a 2D filled triangle with color interpolation.
Can be used to draw other primitives such as quadralaterals, etc...
-------------------------------------------------------------------------- */
void Plot2D_interptriangle(Plot2D *p2, double x1, double y1, Pixel c1,
double x2, double y2, Pixel c2,
double x3, double y3, Pixel c3) {
int tx1, tx2, tx3, ty1, ty2, ty3;
/* Transform the three points into screen coordinates */
Plot2D_transform(p2,x1,y1,&tx1,&ty1);
Plot2D_transform(p2,x2,y2,&tx2,&ty2);
Plot2D_transform(p2,x3,y3,&tx3,&ty3);
FrameBuffer_interptriangle(p2->frame,tx1,ty1,c1,tx2,ty2,c2,tx3,ty3,c3);
}

2181
Examples/GIFPlot/Lib/plot3d.c Normal file
View file

File diff suppressed because it is too large Load diff

23
Examples/GIFPlot/Makefile.in Normal file
View file

@ -0,0 +1,23 @@
prefix = @prefix@
exec_prefix = @exec_prefix@
RANLIB = @RANLIB@
OPT =
INSTALL = ../install-sh -c
INSTALL_DATA = ${INSTALL} -m 644
SHELL = /bin/sh
all:
cd Lib; $(MAKE) OPT="$(OPT)"
install:
$(INSTALL_DATA) Include/gifplot.h $(prefix)/include/gifplot.h
$(INSTALL_DATA) libgifplot.a $(exec_prefix)/lib/libgifplot.a
$(RANLIB) $(exec_prefix)/lib/libgifplot.a
clean::
rm -f *.o *~ libgifplot.a *_wrap* *_man*
cd Lib; $(MAKE) clean
rm -f config.log config.status config.cache

23
Examples/GIFPlot/Perl/full/Makefile Normal file
View file

@ -0,0 +1,23 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT = -I../../Include
SRCS =
TARGET = gifplot
INTERFACE = gifplot.i
LIBS = -L../.. -lgifplot
INCLUDE = -I../../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDE='$(INCLUDE)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' perl5
static::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDE='$(INCLUDE)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='myperl' INTERFACE='$(INTERFACE)' perl5_static
clean::
rm -f *_wrap* *.o *~ *.so myperl *.pm .~* core *.gif

8
Examples/GIFPlot/Perl/full/README Normal file
View file

@ -0,0 +1,8 @@
This example runs the entire gifplot.h header file through SWIG without
any changes. The script 'runme.pl' does something a little more
interesting. You'll have to go look at the header file to get a complete
listing of the functions.

BIN
Examples/GIFPlot/Perl/full/cmap Normal file
View file

Binary file not shown.

15
Examples/GIFPlot/Perl/full/gifplot.i Normal file
View file

@ -0,0 +1,15 @@
/* Oh what the heck, let's just grab the whole darn header file
and see what happens. */
%module gifplot
%{
/* Note: You still need this part because the %include directive
merely causes SWIG to interpret the contents of a file. It doesn't
include the right include headers for the resulting C code */
#include "gifplot.h"
%}
%include gifplot.h

68
Examples/GIFPlot/Perl/full/runme.pl Normal file
View file

@ -0,0 +1,68 @@
# Plot a 3D function
use gifplot;
package gifplot;
# Here is the function to plot
sub func {
my $x = shift;
my $y = shift;
return 5*cos(2*sqrt($x*$x+$y*$y))*exp(-0.3*sqrt($x*$x+$y*$y));
}
# Here are some plotting parameters
$xmin = -5.0;
$xmax = 5.0;
$ymin = -5.0;
$ymax = 5.0;
$zmin = -5.0;
$zmax = 5.0;
# Grid resolution
$nxpoints = 60;
$nypoints = 60;
$cmap = new_ColorMap("cmap");
$frame = new_FrameBuffer(500,500);
FrameBuffer_clear($frame,$BLACK);
$p3 = new_Plot3D($frame,$xmin,$ymin,$zmin,$xmax,$ymax,$zmax);
Plot3D_lookat($p3,2*($zmax-$zmin));
Plot3D_autoperspective($p3,40);
Plot3D_rotu($p3,60);
Plot3D_rotr($p3,30);
Plot3D_rotd($p3,10);
sub drawsolid {
Plot3D_clear($p3,$BLACK);
Plot3D_start($p3);
my $dx = 1.0*($xmax-$xmin)/$nxpoints;
my $dy = 1.0*($ymax-$ymin)/$nypoints;
my $cscale = 240.0/($zmax-$zmin);
my $x = $xmin;
for ($i = 0; $i < $nxpoints; $i++) {
my $y = $ymin;
for ($j = 0; $j < $nypoints; $j++) {
my $z1 = func($x,$y);
my $z2 = func($x+$dx,$y);
my $z3 = func($x+$dx,$y+$dy);
my $z4 = func($x,$y+$dy);
my $c1 = $cscale*($z1-$zmin);
my $c2 = $cscale*($z2-$zmin);
my $c3 = $cscale*($z3-$zmin);
my $c4 = $cscale*($z4-$zmin);
my $c = ($c1+$c2+$c3+$c4)/4;
if ($c < 0) { $c = 0; }
if ($c > 239) { $c = 239; }
Plot3D_solidquad($p3,$x,$y,$z1,$x+$dx,$y,$z2,$x+$dx,$y+$dy,$z3,$x,$y+$dy,$z4,$c+16);
$y = $y + $dy;
}
$x = $x + $dx;
}
}
print "Making a nice 3D plot...\n";
drawsolid();
FrameBuffer_writeGIF($frame,$cmap,"image.gif");
print "Wrote image.gif\n";

23
Examples/GIFPlot/Perl/simple/Makefile Normal file
View file

@ -0,0 +1,23 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT =
SRCS =
TARGET = simple
INTERFACE = simple.i
LIBS = -L../.. -lgifplot
INCLUDE = -I../../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDE='$(INCLUDE)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' perl5
static::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDE='$(INCLUDE)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='myperl' INTERFACE='$(INTERFACE)' perl5_static
clean::
rm -f *_wrap* *.o *~ *.so myperl *.pm .~* core *.gif

5
Examples/GIFPlot/Perl/simple/README Normal file
View file

@ -0,0 +1,5 @@
This is a very minimalistic example in which just a few functions
and constants from library are wrapped and used to draw some simple
shapes. The script 'runme.pl' runs the example.

28
Examples/GIFPlot/Perl/simple/runme.pl Normal file
View file

@ -0,0 +1,28 @@
# Draw some simple shapes
print "Drawing some basic shapes\n";
use simple;
$cmap = simple::new_ColorMap();
$f = simple::new_FrameBuffer(400,400);
# Clear the picture
simple::FrameBuffer_clear($f,$simple::BLACK);
# Make a red box
simple::FrameBuffer_box($f,40,40,200,200,$simple::RED);
# Make a blue circle
simple::FrameBuffer_circle($f,200,200,40,$simple::BLUE);
# Make green line
simple::FrameBuffer_line($f,10,390,390,200, $simple::GREEN);
# Write an image out to disk
simple::FrameBuffer_writeGIF($f,$cmap,"image.gif");
print "Wrote image.gif\n";
simple::delete_FrameBuffer($f);
simple::delete_ColorMap($cmap);

38
Examples/GIFPlot/Perl/simple/simple.i Normal file
View file

@ -0,0 +1,38 @@
/* This example shows a very simple interface wrapping a few
primitive declarations */
%module simple
%{
#include "gifplot.h"
%}
typedef unsigned char Pixel;
/* Here are a few useful functions */
ColorMap *new_ColorMap(char *filename = 0);
void delete_ColorMap(ColorMap *cmap);
FrameBuffer *new_FrameBuffer(unsigned int width, unsigned int height);
void delete_FrameBuffer(FrameBuffer *frame);
void FrameBuffer_clear(FrameBuffer *frame, Pixel color);
void FrameBuffer_line(FrameBuffer *frame, int x1, int y1, int x2, int y2, Pixel color);
void FrameBuffer_box(FrameBuffer *frame, int x1, int y1, int x2, int y2, Pixel color);
void FrameBuffer_circle(FrameBuffer *frame, int x1, int y1, int radius, Pixel color);
int FrameBuffer_writeGIF(FrameBuffer *f, ColorMap *c, char *filename);
/* And some useful constants */
#define BLACK 0
#define WHITE 1
#define RED 2
#define GREEN 3
#define BLUE 4
#define YELLOW 5
#define CYAN 6
#define MAGENTA 7

23
Examples/GIFPlot/Python/full/Makefile Normal file
View file

@ -0,0 +1,23 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT = -I../../Include
SRCS =
TARGET = gifplot
INTERFACE = gifplot.i
LIBS = -L../.. -lgifplot
INCLUDE = -I../../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDE='$(INCLUDE)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python
static::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDE='$(INCLUDE)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_static
clean::
rm -f *_wrap* *.o *~ *.so mypython *.pyc .~* core *.gif

8
Examples/GIFPlot/Python/full/README Normal file
View file

@ -0,0 +1,8 @@
This example runs the entire gifplot.h header file through SWIG without
any changes. The script 'runme.py' does something a little more
interesting. You'll have to go look at the header file to get a complete
listing of the functions.

BIN
Examples/GIFPlot/Python/full/cmap Normal file
View file

Binary file not shown.

15
Examples/GIFPlot/Python/full/gifplot.i Normal file
View file

@ -0,0 +1,15 @@
/* Oh what the heck, let's just grab the whole darn header file
and see what happens. */
%module gifplot
%{
/* Note: You still need this part because the %include directive
merely causes SWIG to interpret the contents of a file. It doesn't
include the right include headers for the resulting C code */
#include "gifplot.h"
%}
%include gifplot.h

62
Examples/GIFPlot/Python/full/runme.py Normal file
View file

@ -0,0 +1,62 @@
# Plot a 3D function
from gifplot import *
from math import *
# Here is the function to plot
def func(x,y):
return 5*cos(2*sqrt(x*x+y*y))*exp(-0.3*sqrt(x*x+y*y))
# Here are some plotting parameters
xmin = -5.0
xmax = 5.0
ymin = -5.0
ymax = 5.0
zmin = -5.0
zmax = 5.0
# Grid resolution
nxpoints = 60
nypoints = 60
cmap = new_ColorMap("cmap")
frame = new_FrameBuffer(500,500)
FrameBuffer_clear(frame,BLACK)
p3 = new_Plot3D(frame,xmin,ymin,zmin,xmax,ymax,zmax)
Plot3D_lookat(p3,2*max([xmax-xmin,ymax-ymin,zmax-zmin]))
Plot3D_autoperspective(p3,40)
Plot3D_rotu(p3,60)
Plot3D_rotr(p3,30)
Plot3D_rotd(p3,10)
def drawsolid():
Plot3D_clear(p3,BLACK)
Plot3D_start(p3)
dx = 1.0*(xmax-xmin)/nxpoints
dy = 1.0*(ymax-ymin)/nypoints
cscale = 240.0/(zmax-zmin)
x = xmin
for i in xrange(0,nxpoints):
y = ymin
for j in xrange(0,nypoints):
z1 = func(x,y)
z2 = func(x+dx,y)
z3 = func(x+dx,y+dy)
z4 = func(x,y+dy)
c1 = cscale*(z1-zmin)
c2 = cscale*(z2-zmin)
c3 = cscale*(z3-zmin)
c4 = cscale*(z4-zmin)
c = (c1+c2+c3+c4)/4
if (c < 0) : c = 0
if c > 239 : c = 239
Plot3D_solidquad(p3,x,y,z1,x+dx,y,z2,x+dx,y+dy,z3,x,y+dy,z4,c+16)
y = y + dy
x = x + dx
print "Making a nice 3D plot..."
drawsolid()
FrameBuffer_writeGIF(frame,cmap,"image.gif")
print "Wrote image.gif"

23
Examples/GIFPlot/Python/simple/Makefile Normal file
View file

@ -0,0 +1,23 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT =
SRCS =
TARGET = simple
INTERFACE = simple.i
LIBS = -L../.. -lgifplot
INCLUDE = -I../../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDE='$(INCLUDE)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python
static::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDE='$(INCLUDE)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_static
clean::
rm -f *_wrap* *.o *~ *.so mypython *.pyc .~* core *.gif

5
Examples/GIFPlot/Python/simple/README Normal file
View file

@ -0,0 +1,5 @@
This is a very minimalistic example in which just a few functions
and constants from library are wrapped and used to draw some simple
shapes. The script 'runme.py' runs the example.

27
Examples/GIFPlot/Python/simple/runme.py Normal file
View file

@ -0,0 +1,27 @@
# Draw some simple shapes
print "Drawing some basic shapes"
import simple
cmap = simple.new_ColorMap()
f = simple.new_FrameBuffer(400,400)
# Clear the picture
simple.FrameBuffer_clear(f,simple.BLACK)
# Make a red box
simple.FrameBuffer_box(f,40,40,200,200,simple.RED)
# Make a blue circle
simple.FrameBuffer_circle(f,200,200,40,simple.BLUE)
# Make green line
simple.FrameBuffer_line(f,10,390,390,200, simple.GREEN)
# Write an image out to disk
simple.FrameBuffer_writeGIF(f,cmap,"image.gif")
print "Wrote image.gif"
simple.delete_FrameBuffer(f)
simple.delete_ColorMap(cmap)

38
Examples/GIFPlot/Python/simple/simple.i Normal file
View file

@ -0,0 +1,38 @@
/* This example shows a very simple interface wrapping a few
primitive declarations */
%module simple
%{
#include "gifplot.h"
%}
typedef unsigned char Pixel;
/* Here are a few useful functions */
ColorMap *new_ColorMap(char *filename = 0);
void delete_ColorMap(ColorMap *cmap);
FrameBuffer *new_FrameBuffer(unsigned int width, unsigned int height);
void delete_FrameBuffer(FrameBuffer *frame);
void FrameBuffer_clear(FrameBuffer *frame, Pixel color);
void FrameBuffer_line(FrameBuffer *frame, int x1, int y1, int x2, int y2, Pixel color);
void FrameBuffer_box(FrameBuffer *frame, int x1, int y1, int x2, int y2, Pixel color);
void FrameBuffer_circle(FrameBuffer *frame, int x1, int y1, int radius, Pixel color);
int FrameBuffer_writeGIF(FrameBuffer *f, ColorMap *c, char *filename);
/* And some useful constants */
#define BLACK 0
#define WHITE 1
#define RED 2
#define GREEN 3
#define BLUE 4
#define YELLOW 5
#define CYAN 6
#define MAGENTA 7

65
Examples/GIFPlot/README Normal file
View file

@ -0,0 +1,65 @@
GIFPlot
=======
To illustrate various SWIG features, the following examples involve
building an interface to a small, but somewhat useful graphics library
for creating 2D and 3D images in the form of GIF files. The Perl,
Python, and Tcl directories contain various examples specific to those
languages.
This library was originally developed as part of the SPaSM molecular
dynamics project at Los Alamos National Laboratory. However, due to
patent enforcement issues related to LZW encoding and a general lack
of time on the part of the author, the library was never officially
released. On the plus side, a number of people have found it to be a
useful easter egg within the SWIG distribution :-).
<LEGAL>
DUE TO PATENT RESTRICTIONS ON THE LZW COMPRESSION ALGORITHM, THIS
LIBRARY ONLY PRODUCES UNCOMPRESSED GIF FILES. SO THERE.
</LEGAL>
Building the Library
====================
In order to run the examples, it is first necessary to build the GIFPlot
C library. To do this, simply follow these instructions:
./configure
make
On Windows, you can probably just do this:
cd Lib
nmake /f Makefile.msc
Running the Examples
====================
Once the library has been built, go the Perl, Python, or Tcl directory to see
various SWIG examples. Each example should have a README file with a
description.
The examples are compiled using the makefile located in the top level "Examples"
directory of the distribution. If they don't compile, you will need to
adjust the settings in this file.
Documentation
=============
Read the source Luke. The examples should be pretty much self-explanatory.
The header file Include/gifplot.h contains the full API.
The original documentation for the library can be found online at:
http://islab.cs.uchicago.edu/gifplot
Let me know what you think!
===========================
If you found this example to be useful, confusing, or otherwise, I would like to know
about it. Suggestions for improvement are welcome.
-- Dave (beazley@cs.uchicago.edu)

23
Examples/GIFPlot/Tcl/full/Makefile Normal file
View file

@ -0,0 +1,23 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT = -I../../Include
SRCS =
TARGET = gifplot
INTERFACE = gifplot.i
LIBS = -L../.. -lgifplot
INCLUDE = -I../../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDE='$(INCLUDE)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' tcl
static::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDE='$(INCLUDE)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='mytclsh' INTERFACE='$(INTERFACE)' tclsh
clean::
rm -f *_wrap* *.o *~ *.so mytclsh .~* core *.gif

8
Examples/GIFPlot/Tcl/full/README Normal file
View file

@ -0,0 +1,8 @@
This example runs the entire gifplot.h header file through SWIG without
any changes. The script 'runme.tcl' does something a little more
interesting. You'll have to go look at the header file to get a complete
listing of the functions.

BIN
Examples/GIFPlot/Tcl/full/cmap Normal file
View file

Binary file not shown.

15
Examples/GIFPlot/Tcl/full/gifplot.i Normal file
View file

@ -0,0 +1,15 @@
/* Oh what the heck, let's just grab the whole darn header file
and see what happens. */
%module gifplot
%{
/* Note: You still need this part because the %include directive
merely causes SWIG to interpret the contents of a file. It doesn't
include the right include headers for the resulting C code */
#include "gifplot.h"
%}
%include gifplot.h

68
Examples/GIFPlot/Tcl/full/runme.tcl Normal file
View file

@ -0,0 +1,68 @@
# Plot a 3D function
catch { load ./gifplot.so gifplot}
catch { load ./gifplot.dll gifplot} ;# Windows
# Here is the function to plot
proc func { x y } {
return [expr { 5*cos(2*sqrt($x*$x+$y*$y))*exp(-0.3*sqrt($x*$x+$y*$y)) }]
}
# Here are some plotting parameters
set xmin -5.0
set xmax 5.0
set ymin -5.0
set ymax 5.0
set zmin -5.0
set zmax 5.0
# Grid resolution
set nxpoints 60
set nypoints 60
set cmap [new_ColorMap cmap]
set frame [new_FrameBuffer 500 500]
FrameBuffer_clear $frame $BLACK
set p3 [new_Plot3D $frame $xmin $ymin $zmin $xmax $ymax $zmax ]
Plot3D_lookat $p3 [expr {2*($zmax-$zmin)}]
Plot3D_autoperspective $p3 40
Plot3D_rotu $p3 60
Plot3D_rotr $p3 30
Plot3D_rotd $p3 10
proc drawsolid { } {
global xmin ymin zmin xmax ymax zmax nxpoints nypoints p3 BLACK
Plot3D_clear $p3 $BLACK
Plot3D_start $p3
set dx [expr {1.0*($xmax-$xmin)/$nxpoints}]
set dy [expr {1.0*($ymax-$ymin)/$nypoints}]
set cscale [expr {240.0/($zmax-$zmin)}]
set x $xmin
for {set i 0} {$i < $nxpoints} {incr i 1} {
set y $ymin
for {set j 0} {$j < $nypoints} {incr j 1} {
set z1 [func $x $y]
set z2 [func [expr {$x+$dx}] $y]
set z3 [func [expr {$x+$dx}] [expr {$y+$dy}]]
set z4 [func $x [expr {$y+$dy}]]
set c1 [expr {$cscale*($z1-$zmin)}]
set c2 [expr {$cscale*($z2-$zmin)}]
set c3 [expr {$cscale*($z3-$zmin)}]
set c4 [expr {$cscale*($z4-$zmin)}]
set c [expr {int(($c1+$c2+$c3+$c4)/4)}]
if {$c < 0} { set c 0 }
if {$c > 239} { set c 239 }
Plot3D_solidquad $p3 $x $y $z1 [expr {$x+$dx}] $y $z2 [expr {$x+$dx}] [expr {$y+$dy}] $z3 $x [expr {$y+$dy}] $z4 [expr {$c+16}]
set y [expr {$y + $dy}]
}
set x [expr {$x + $dx}]
}
}
puts "Making a nice 3D plot..."
drawsolid
FrameBuffer_writeGIF $frame $cmap "image.gif"
puts "Wrote image.gif"

23
Examples/GIFPlot/Tcl/mandel/Makefile Normal file
View file

@ -0,0 +1,23 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT = -I../../Interface
SRCS =
TARGET = gifplot
INTERFACE = mandel.i
LIBS = -L../.. -lgifplot
INCLUDE = -I../../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDE='$(INCLUDE)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' tcl
static::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDE='$(INCLUDE)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='mywish' INTERFACE='$(INTERFACE)' wish
clean::
rm -f *_wrap* *.o *~ *.so mywish .~* core *.gif

6
Examples/GIFPlot/Tcl/mandel/README Normal file
View file

@ -0,0 +1,6 @@
Kill lots of time exploring the Mandelbrot set. This example uses
the full SWIG interface file located in ../../Interface. To run
the program, type 'wish mandel.tcl'.

BIN
Examples/GIFPlot/Tcl/mandel/cmap Normal file
View file

Binary file not shown.

68
Examples/GIFPlot/Tcl/mandel/display.tcl Normal file
View file

@ -0,0 +1,68 @@
# Tcl code to display a image in a widget
set __imageno 0
proc dismiss {t i} {
destroy $t
image delete $i
}
proc BoxInit { c p2 mxmin mymin mxmax mymax func } {
bind $c <Button-1> {BoxBegin %W %x %y}
bind $c <B1-Motion> {BoxDrag %W %x %y}
bind $c <ButtonRelease-1> "BoxFinish %W %x %y $p2 $mxmin $mymin $mxmax $mymax $func"
}
proc BoxBegin {w x y} {
global box
set box(anchor) [list $x $y]
catch {unset box(last)}
}
proc BoxDrag { w x y} {
global box
catch {$w delete $box(last)}
set box(last) [eval {$w create rect} $box(anchor) {$x $y -tag box -outline white}]
}
proc BoxFinish {w x y p2 mxmin mymin mxmax mymax func } {
global box
set start $box(anchor)
set x1 [lrange $start 0 0]
set y1 [lrange $start 1 1]
catch {$w delete $box(last)}
# Call the handler function
$func $p2 $mxmin $mymin $mxmax $mymax $x1 $y1 $x $y
}
proc display_image {filename p2 handler} {
global __imageno __images
set i [image create photo -file $filename]
set tl .image$__imageno
toplevel $tl
frame $tl.img
frame $tl.button
set width [image width $i]
set height [image height $i]
canvas $tl.img.c -width [expr {$width+0}] -height [expr {$height+0}]
pack $tl.img.c
$tl.img.c create image 0 0 -image $i -anchor nw
label $tl.button.label -text $filename
pack $tl.button.label -side left
button $tl.button.dismiss -text "Dismiss" -command "dismiss $tl $i" -width 10
pack $tl.button.dismiss -side right
pack $tl.img $tl.button -side top -fill x
BoxInit $tl.img.c $p2 [$p2 cget -xmin] [$p2 cget -ymin] [$p2 cget -xmax] [$p2 cget -ymax] $handler
bind $tl <Key-q> "dismiss $tl $i"
bind $tl <Key-Escape> "dismiss $tl $i"
# Bind some actions to the canvas
incr __imageno 1
}
proc test {} {
puts "hello"
}

47
Examples/GIFPlot/Tcl/mandel/mandel.i Normal file
View file

@ -0,0 +1,47 @@
// Special module to run the mandlebrot set
%module gifplot
%include gifplot.i
%inline %{
void mandel(Plot2D *p2, int tol) {
double scalingx;
double scalingy;
double zr,zi,ztr,zti,cr,ci;
double cscale;
int i,j,n;
FrameBuffer *f;
f = p2->frame;
scalingx = (p2->xmax-p2->xmin)/f->width;
scalingy = (p2->ymax-p2->ymin)/f->height;
cscale = 239.0/tol;
printf("working...\n");
for (i = 0; i < f->width; i++) {
for (j = 0; j < f->height; j++) {
zr = scalingx*i + p2->xmin;
zi = scalingy*j + p2->ymin;
cr = zr;
ci = zi;
n = 0;
while (n < tol) {
ztr = zr*zr-zi*zi + cr;
zti = 2*zr*zi + ci;
zr = ztr;
zi = zti;
if (ztr*ztr + zti*zti > 20) break;
n = n + 1;
}
if (n >= tol) FrameBuffer_plot(f,i,j,BLACK);
else FrameBuffer_plot(f,i,j,16+(int) (n*cscale));
}
if ((i % 10) == 0) printf("%d\n",i);
}
}
%}

171
Examples/GIFPlot/Tcl/mandel/mandel.tcl Normal file
View file

@ -0,0 +1,171 @@
catch { load ./gifplot.so }
catch { load ./gifplot.dll } ; # Windows
source display.tcl
set tcl_precision 17
set f [FrameBuffer -args 400 400]
set cmap [ColorMap -args cmap]
set p2 [Plot2D -args $f -3 -2 1 2]
set xmin -3
set xmax 1
set ymin -2.0
set ymax 2.0
set tolerance 240
set filename mandel.gif
# Make a plot from the above parms
proc make_plot {} {
global p2 cmap tolerance
global xmin ymin xmax ymax filename
$p2 setrange $xmin $ymin $xmax $ymax
$p2 start
. config -cursor watch
update
mandel $p2 $tolerance
. config -cursor arrow
[$p2 cget -frame] writeGIF $cmap $filename
display_image $filename $p2 set_zoom
}
# Take some screen coordinates and set global min and max values
proc set_zoom {p2 mxmin mymin mxmax mymax x1 y1 x2 y2} {
global xmin ymin xmax ymax
set frame [$p2 cget -frame]
set width [$frame cget -width]
set height [$frame cget -height]
if {$x1 < 0} {set x1 0}
if {$x1 > ($width)} {set x1 $width}
if {$x2 < 0} {set x2 0}
if {$x2 > ($width)} {set x2 $width}
if {$x1 < $x2} {set ixmin $x1; set ixmax $x2} {set ixmin $x2; set ixmax $x1}
if {$y1 < 0} {set y1 0}
if {$y1 > ($height)} {set y1 $height}
if {$y2 < 0} {set y2 0}
if {$y2 > ($height)} {set y2 $height}
if {$y1 < $y2} {set iymin $y1; set iymax $y2} {set iymin $y2; set iymax $y1}
# Now determine new min and max values based on screen location
set xmin [expr {$mxmin + ($mxmax-$mxmin)*($ixmin)/($width)}]
set xmax [expr {$mxmin + ($mxmax-$mxmin)*($ixmax)/($width)}]
set ymin [expr {$mymin + ($mymax-$mymin)*(($height)-($iymax))/($height)}]
set ymax [expr {$mymin + ($mymax-$mymin)*(($height)-($iymin))/($height)}]
catch {make_plot}
}
# Box drag constrained to a square
proc BoxDrag { w x y} {
global box
catch {$w delete $box(last)}
set x1 [lrange $box(anchor) 0 0]
set y1 [lrange $box(anchor) 1 1]
set dx [expr {$x - $x1}]
set dy [expr {$y - $y1}]
if {abs($dy) > abs($dx)} {set dx $dy}
set newx [expr {$x1 + $dx}]
set newy [expr {$y1 + $dx}]
set box(last) [eval {$w create rect} $box(anchor) {$newx $newy -tag box -outline white}]
}
proc BoxFinish {w x y p2 mxmin mymin mxmax mymax func } {
global box
set start $box(anchor)
set x1 [lrange $box(anchor) 0 0]
set y1 [lrange $box(anchor) 1 1]
set dx [expr {$x - $x1}]
set dy [expr {$y - $y1}]
if {($dx == 0) || ($dy == 0)} {
catch {$w delete $box(last)}
return
}
if {abs($dy) > abs($dx)} {set dx $dy}
set newx [expr {$x1 + $dx}]
set newy [expr {$y1 + $dx}]
$w config -cursor watch
update
# Call the handler function
$func $p2 $mxmin $mymin $mxmax $mymax $x1 $y1 $newx $newy
catch {$w delete $box(last)}
$w config -cursor arrow
}
# Create a few frames
wm title . Mandelbrot
frame .title -relief groove -borderwidth 1
label .title.name -text "Mandelbrot Set"
button .title.quit -text "Quit" -command "exit"
button .title.about -text "About" -command "about"
pack .title.name -side left
pack .title.quit .title.about -side right
frame .func -relief groove -borderwidth 1
frame .func.xrange
label .func.xrange.xrlabel -text "X range" -width 12
entry .func.xrange.xmin -textvar xmin -width 8
label .func.xrange.xtolabel -text "to"
entry .func.xrange.xmax -textvar xmax -width 8
pack .func.xrange.xrlabel .func.xrange.xmin .func.xrange.xtolabel .func.xrange.xmax -side left
frame .func.yrange
label .func.yrange.yrlabel -text "Y range" -width 12
entry .func.yrange.ymin -textvar ymin -width 8
label .func.yrange.ytolabel -text "to"
entry .func.yrange.ymax -textvar ymax -width 8
pack .func.yrange.yrlabel .func.yrange.ymin .func.yrange.ytolabel .func.yrange.ymax -side left
frame .func.npoints
label .func.npoints.label -text "Tolerance " -width 12
entry .func.npoints.npoints -textvar tolerance -width 8
scale .func.npoints.scale -from 0 -to 2500 -variable tolerance -orient horizontal -showvalue false \
-sliderlength 13 -bigincrement 10 -resolution 10
pack .func.npoints.label .func.npoints.npoints .func.npoints.scale -side left
pack .func.xrange .func.yrange .func.npoints -side top -fill x
# Filename dialog
frame .save -relief groove -borderwidth 1
frame .save.file
label .save.file.label -text "Save as" -width 12
entry .save.file.filename -textvar filename -width 20
pack .save.file.label .save.file.filename -side left
pack .save.file -side left -fill x
button .save.go -text "Plot" -command "make_plot"
pack .save.go -side right
bind .save.file.filename <Return> {make_plot}
pack .title .func .save -side top -fill both
proc about { } {
toplevel .about -width 350
message .about.m -text "\
Mandelbrot Set\n\n\
Copyright (c) 1997\n\
Dave Beazley\n\
University of Utah\n\n\
Creates a plot of the Mandelbrot set. Any displayed image can be zoomed by clicking and \
dragging. Although the main calculation is written in C, it may take awhile for each \
image to be calculated (be patient). Image quality can be improved at the expense of speed \
by increasing the tolerance value.\n"
button .about.okay -text "Ok" -command {destroy .about}
pack .about.m .about.okay -side top
focus .about.okay
}
make_plot

23
Examples/GIFPlot/Tcl/simple/Makefile Normal file
View file

@ -0,0 +1,23 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT =
SRCS =
TARGET = simple
INTERFACE = simple.i
LIBS = -L../.. -lgifplot
INCLUDE = -I../../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDE='$(INCLUDE)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' tcl
static::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDE='$(INCLUDE)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='mytclsh' INTERFACE='$(INTERFACE)' tclsh
clean::
rm -f *_wrap* *.o *~ *.so mytclsh .~* core *.gif

5
Examples/GIFPlot/Tcl/simple/README Normal file
View file

@ -0,0 +1,5 @@
This is a very minimalistic example in which just a few functions
and constants from library are wrapped and used to draw some simple
shapes. The script 'runme.tcl' runs the example.

28
Examples/GIFPlot/Tcl/simple/runme.tcl Normal file
View file

@ -0,0 +1,28 @@
# Draw some simple shapes
puts "Drawing some basic shapes"
catch { load ./simple.so simple}
catch { load ./simple.dll simple} ;# Windows
set cmap [new_ColorMap]
set f [new_FrameBuffer 400 400]
# Clear the picture
FrameBuffer_clear $f $BLACK
# Make a red box
FrameBuffer_box $f 40 40 200 200 $RED
# Make a blue circle
FrameBuffer_circle $f 200 200 40 $BLUE
# Make green line
FrameBuffer_line $f 10 390 390 200 $GREEN
# Write an image out to disk
FrameBuffer_writeGIF $f $cmap image.gif
puts "Wrote image.gif"
delete_FrameBuffer $f
delete_ColorMap $cmap

38
Examples/GIFPlot/Tcl/simple/simple.i Normal file
View file

@ -0,0 +1,38 @@
/* This example shows a very simple interface wrapping a few
primitive declarations */
%module simple
%{
#include "gifplot.h"
%}
typedef unsigned char Pixel;
/* Here are a few useful functions */
ColorMap *new_ColorMap(char *filename = 0);
void delete_ColorMap(ColorMap *cmap);
FrameBuffer *new_FrameBuffer(unsigned int width, unsigned int height);
void delete_FrameBuffer(FrameBuffer *frame);
void FrameBuffer_clear(FrameBuffer *frame, Pixel color);
void FrameBuffer_line(FrameBuffer *frame, int x1, int y1, int x2, int y2, Pixel color);
void FrameBuffer_box(FrameBuffer *frame, int x1, int y1, int x2, int y2, Pixel color);
void FrameBuffer_circle(FrameBuffer *frame, int x1, int y1, int radius, Pixel color);
int FrameBuffer_writeGIF(FrameBuffer *f, ColorMap *c, char *filename);
/* And some useful constants */
#define BLACK 0
#define WHITE 1
#define RED 2
#define GREEN 3
#define BLUE 4
#define YELLOW 5
#define CYAN 6
#define MAGENTA 7

1299
Examples/GIFPlot/configure vendored Executable file
View file

File diff suppressed because it is too large Load diff

52
Examples/GIFPlot/configure.in Normal file
View file

@ -0,0 +1,52 @@
dnl Process this file with autoconf to produce a configure script.
AC_INIT(Include/gifplot.h)
AC_PREREQ(2.0)
# Set name for machine-dependent library files
AC_SUBST(MACHDEP)
AC_MSG_CHECKING(MACHDEP)
if test -z "$MACHDEP"
then
if test -f /usr/lib/NextStep/software_version; then
set X `hostinfo | grep 'NeXT Mach.*:' | \
sed -e 's/://' -e 's/\./_/'` && \
ac_sys_system=next && ac_sys_release=$4
MACHDEP="$ac_sys_system$ac_sys_release$ac_sys_cpu"
else
ac_sys_system=`uname -s`
if test "$ac_sys_system" = "AIX" ; then
ac_sys_release=`uname -v`
else
ac_sys_release=`uname -r`
fi
ac_md_system=`echo $ac_sys_system |
tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
ac_md_release=`echo $ac_sys_release |
tr -d '[/ ]' | sed 's/\..*//'`
MACHDEP="$ac_md_system$ac_md_release"
fi
case MACHDEP in
'') MACHDEP=unknown;;
esac
fi
AC_MSG_RESULT($MACHDEP)
AC_LANG_C
dnl Checks for programs.
AC_PROG_CC
AC_PROG_RANLIB
AC_SUBST(AR)
AC_CHECK_PROGS(AR, ar aal, ar)
dnl Checks for header files.
AC_HEADER_STDC
dnl Checks for library functions.
AC_OUTPUT(Makefile Lib/Makefile)