XS-MLVP
/
swig
mirror of https://github.com/swig/swig
5
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Revert rev 11918 "merge revisions 11872:11876 from trunk to gsoc2008-maciekd branch - license changes" 

This reverts commit ec942f04ca8b33520442f079e2ea2d8d3e4be73c.

From: William S Fulton <wsf@fultondesigns.co.uk>

git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/branches/gsoc2008-maciekd@13032 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
William S Fulton 2012-05-06 00:49:56 +00:00
parent d1e871f0d2
commit 34a628c7c7
433 changed files with 12591 additions and 1381 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
ANNOUNCE
View File

@ -1,10 +1,10 @@
*** ANNOUNCE: SWIG 2.0.0 (in progress) ***
*** ANNOUNCE: SWIG 1.3.40 (in progress) ***
http://www.swig.org
We're pleased to announce SWIG-2.0.0, the latest installment in the
SWIG development effort. SWIG-2.0.0 includes a number of bug fixes
We're pleased to announce SWIG-1.3.40, the latest installment in the
SWIG development effort. SWIG-1.3.40 includes a number of bug fixes
and enhancements.
What is SWIG?
@ -24,11 +24,11 @@ Availability:
-------------
The release is available for download on Sourceforge at
http://prdownloads.sourceforge.net/swig/swig-2.0.0.tar.gz
http://prdownloads.sourceforge.net/swig/swig-1.3.40.tar.gz
A Windows version is also available at
http://prdownloads.sourceforge.net/swig/swigwin-2.0.0.zip
http://prdownloads.sourceforge.net/swig/swigwin-1.3.40.zip
Please report problems with this release to the swig-dev mailing list,
details at http://www.swig.org/mail.html.

63
COPYRIGHT
View File

@ -1,63 +0,0 @@
SWIG Copyright and Authors
--------------------------
Copyright (c) 1995-2010 The SWIG Developers
Copyright (c) 2005-2006 Arizona Board of Regents (University of Arizona).
Copyright (c) 1998-2005 University of Chicago.
Copyright (c) 1995-1998 The University of Utah and the Regents of the University of California
Portions also copyrighted by:
Network Applied Communication Laboratory, Inc
Information-technology Promotion Agency, Japan
Active SWIG Developers:
William Fulton (wsf@fultondesigns.co.uk) (SWIG core, Java, C#, Windows, Cygwin)
Olly Betts (olly@survex.com) (PHP)
Joseph Wang (joequant@gmail.com) (R)
Xavier Delacour (xavier.delacour@gmail.com) (Octave)
Past SWIG developers and major contributors include:
Dave Beazley (dave-swig@dabeaz.com) (SWIG core, Python, Tcl, Perl)
Henning Thielemann (swig@henning-thielemann.de) (Modula3)
Matthias Köppe (mkoeppe@mail.math.uni-magdeburg.de) (Guile, MzScheme)
Luigi Ballabio (luigi.ballabio@fastwebnet.it) (STL wrapping)
Mikel Bancroft (mikel@franz.com) (Allegro CL)
Surendra Singhi (efuzzyone@netscape.net) (CLISP, CFFI)
Marcelo Matus (mmatus@acms.arizona.edu) (SWIG core, Python, UTL[python,perl,tcl,ruby])
Art Yerkes (ayerkes@speakeasy.net) (Ocaml)
Lyle Johnson (lyle@users.sourceforge.net) (Ruby)
Charlie Savage (cfis@interserv.com) (Ruby)
Thien-Thi Nguyen (ttn@glug.org) (build/test/misc)
Richard Palmer (richard@magicality.org) (PHP)
Sam Liddicott - Anonova Ltd (saml@liddicott.com) (PHP)
Tim Hockin - Sun Microsystems (thockin@sun.com) (PHP)
Kevin Ruland (PHP)
Shibukawa Yoshiki (Japanese Translation)
Jason Stewart (jason@openinformatics.com) (Perl5)
Loic Dachary (Perl5)
David Fletcher (Perl5)
Gary Holt (Perl5)
Masaki Fukushima (Ruby)
Scott Michel (scottm@cs.ucla.edu) (Java directors)
Tiger Feng (songyanf@cs.uchicago.edu) (SWIG core)
Mark Rose (mrose@stm.lbl.gov) (Directors)
Jonah Beckford (beckford@usermail.com) (CHICKEN)
Ahmon Dancy (dancy@franz.com) (Allegro CL)
Dirk Gerrits (Allegro CL)
Neil Cawse (C#)
Harco de Hilster (Java)
Alexey Dyachenko (dyachenko@fromru.com) (Tcl)
Bob Techentin (Tcl)
Martin Froehlich <MartinFroehlich@ACM.org> (Guile)
Marcio Luis Teixeira <marciot@holly.colostate.edu> (Guile)
Duncan Temple Lang (R)
Miklos Vajna <vmiklos@frugalware.org> (PHP directors)
Mark Gossage (mark@gossage.cjb.net) (Lua)
Gonzalo Garramuno (ggarra@advancedsl.com.ar) (Ruby, Ruby's UTL)
John Lenz (Guile, MzScheme updates, Chicken module, runtime system)
Past contributors include:
James Michael DuPont, Clark McGrew, Dustin Mitchell, Ian Cooke, Catalin Dumitrescu, Baran
Kovuk, Oleg Tolmatcev, Tal Shalif, Lluis Padro, Chris Seatory, Igor Bely, Robin Dunn
(See CHANGES and CHANGES.current for a more complete list).

2
Doc/Manual/Sections.html
View File

@ -6,7 +6,7 @@
<body bgcolor="#ffffff">
<H1><a name="Sections"></a>SWIG-1.3 Development Documentation</H1>
Last update : SWIG-2.0.0 (in progress)
Last update : SWIG-1.3.40 (in progress)
<H2>Sections</H2>

17
Examples/GIFPlot/C/Makefile Normal file
View File

@ -0,0 +1,17 @@
TOP = ../..
SWIG = $(TOP)/../preinst-swig
SWIGOPT = -I../Include
SRCS =
TARGET = gifplot
INTERFACE = gifplot.i
LIBS = -L.. -lgifplot
INCLUDES = -I../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' LIBS='$(LIBS)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' c
clean:
rm -f *.o *.out *.so *.a *.dll *.dylib *.exe *_wrap* *_proxy* *~ runme
check: all

15
Examples/GIFPlot/C/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 "../Include/gifplot.h"
%}
%include gifplot.h

3
Examples/GIFPlot/Chicken/check.list Normal file
View File

@ -0,0 +1,3 @@
# see top-level Makefile.in
full
simple

28
Examples/GIFPlot/Chicken/full/Makefile Normal file
View File

@ -0,0 +1,28 @@
TOP = ../../..
SWIG = $(TOP)/../preinst-swig
INTERFACE = gifplot.i
SRCS =
CXXSRCS =
TARGET = gifplot
INCLUDE = -I. -I../../Include
SWIGOPT = -I../../Include
CFLAGS =
VARIANT =
LIBS = -L../.. -lgifplot -lm
# comment the following two lines to build a dynamic so file
CHICKEN_MAIN = test-gifplot.scm
VARIANT = _static
all:: $(TARGET)
$(TARGET): $(INTERFACE) $(SRCS)
$(MAKE) -f $(TOP)/Makefile \
SRCS='$(SRCS)' CXXSRCS='$(CXXSRCS)' CHICKEN_MAIN='$(CHICKEN_MAIN)' \
INCLUDE='$(INCLUDE)' SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='$(TARGET)' \
SWIG='$(SWIG)' INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT)
clean::
$(MAKE) -f $(TOP)/Makefile chicken_clean
rm -f gifplot.scm image.gif
rm -f $(TARGET)

6
Examples/GIFPlot/Chicken/full/README Normal file
View File

@ -0,0 +1,6 @@
This example runs the entire gifplot.h header file through SWIG without
any changes. The Scheme program 'test-gifplot.scm' does something a
little more interesting. You'll have to go look at the header file to
get a complete listing of the functions.
`make' will build a static binary. Run ./gifplot to test it.

BIN
Examples/GIFPlot/Chicken/full/cmap Normal file
View File

Binary file not shown.

26
Examples/GIFPlot/Chicken/full/gifplot.i Normal file
View File

@ -0,0 +1,26 @@
/* 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"
%}
/* Pixel is typedef'd to unsigned char, and SWIG will translate this
type into Scheme characters. We would like to translate Pixels to
Scheme integers instead, so: */
SIMPLE_TYPEMAP(Pixel, C_unfix, C_fix, C_swig_is_fixnum, (int), 0);
%{
static Pixel int_to_Pixel (int v) { return (Pixel) v; }
%}
extern Pixel int_to_Pixel (int v);
%include gifplot.h

66
Examples/GIFPlot/Chicken/full/test-gifplot.scm Normal file
View File

@ -0,0 +1,66 @@
;;; Plot a 3D function
(declare (uses gifplot))
;; Here is the function to plot
(define (func x y)
(* 5
(cos (* 2 (sqrt (+ (* x x) (* y y)))))
(exp (* -0.3 (sqrt (+ (* x x) (* y y)))))))
;; Here are some plotting parameters
(define xmin -5.0)
(define xmax 5.0)
(define ymin -5.0)
(define ymax 5.0)
(define zmin -5.0)
(define zmax 5.0)
;; Grid resolution
(define nxpoints 60)
(define nypoints 60)
(define cmap (gifplot:new-ColorMap "cmap"))
(define frame (gifplot:new-FrameBuffer 500 500))
(gifplot:FrameBuffer-clear frame (gifplot:BLACK))
(define p3 (gifplot:new-Plot3D frame xmin ymin zmin xmax ymax zmax))
(gifplot:Plot3D-lookat p3 (* 2 (- zmax zmin)))
(gifplot:Plot3D-autoperspective p3 40.0)
(gifplot:Plot3D-rotu p3 60.0)
(gifplot:Plot3D-rotr p3 30.0)
(gifplot:Plot3D-rotd p3 10.0)
(define (drawsolid)
(gifplot:Plot3D-clear p3 (gifplot:BLACK))
(gifplot:Plot3D-start p3)
(let ((dx (/ (- xmax xmin) nxpoints))
(dy (/ (- ymax ymin) nypoints))
(cscale (/ 240 (- zmax zmin))))
(let x-loop ((x xmin) (i 0))
(cond
((< i nxpoints)
(let y-loop ((y ymin) (j 0))
(cond
((< j nypoints)
(let* ((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)))
(cc (/ (+ c1 c2 c3 c4) 4))
(c (inexact->exact (round (max (min cc 239) 0)))))
(gifplot:Plot3D-solidquad p3 x y z1 (+ x dx) y z2 (+ x dx) (+ y dy)
z3 x (+ y dy) z4
(gifplot:int->Pixel (+ c 16))))
(y-loop (+ y dy) (+ j 1)))))
(x-loop (+ x dx) (+ i 1)))))))
(display "Making a nice 3D plot...\n")
(drawsolid)
(gifplot:FrameBuffer-writeGIF frame cmap "image.gif")
(display "Wrote image.gif\n")

28
Examples/GIFPlot/Chicken/simple/Makefile Normal file
View File

@ -0,0 +1,28 @@
TOP = ../../..
SWIG = $(TOP)/../preinst-swig
INTERFACE = simple.i
SRCS =
CXXSRCS =
TARGET = simple
INCLUDE = -I. -I../../Include
SWIGOPT = -I../../Include
CFLAGS =
VARIANT =
LIBS = -L../.. -lgifplot -lm
# comment the following two lines to build a dynamic so file
CHICKEN_MAIN = test-simple.scm
VARIANT = _static
all:: $(TARGET)
$(TARGET): $(INTERFACE) $(SRCS)
$(MAKE) -f $(TOP)/Makefile \
SRCS='$(SRCS)' CXXSRCS='$(CXXSRCS)' CHICKEN_MAIN='$(CHICKEN_MAIN)' \
INCLUDE='$(INCLUDE)' SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='$(TARGET)' \
SWIG='$(SWIG)' INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT)
clean::
$(MAKE) -f $(TOP)/Makefile chicken_clean
rm -f simple.scm image.gif
rm -f $(TARGET)

5
Examples/GIFPlot/Chicken/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.
`make' will build an exe. Run ./simple to test it.

34
Examples/GIFPlot/Chicken/simple/simple.i Normal file
View File

@ -0,0 +1,34 @@
/* This example shows a very simple interface wrapping a few
primitive declarations */
%module simple
%{
#include "gifplot.h"
%}
typedef unsigned int 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, which we redefine (from gifplot.h) so
that SWIG sees them */
#define BLACK 0
#define WHITE 1
#define RED 2
#define GREEN 3
#define BLUE 4
#define YELLOW 5
#define CYAN 6
#define MAGENTA 7

29
Examples/GIFPlot/Chicken/simple/test-simple.scm Normal file
View File

@ -0,0 +1,29 @@
;;; Draw some simple shapes
(declare (uses simple))
(display "Drawing some basic shapes\n")
(define cmap (simple:new-ColorMap #f))
(define 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")
(display "Wrote image.gif\n")
(simple:delete-FrameBuffer f)
(simple:delete-ColorMap cmap)

BIN
Examples/GIFPlot/Common-Lisp/full/cmap Normal file
View File

Binary file not shown.

21
Examples/GIFPlot/Common-Lisp/full/gifplot.i Normal file
View File

@ -0,0 +1,21 @@
/* 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"
%}
/* Pixel is typedef'd to unsigned char, and SWIG will translate this
type into Scheme characters. We would like to translate Pixels to
Scheme integers instead, so: */
SIMPLE_MAP(Pixel, gh_scm2int, gh_int2scm, integer);
%include gifplot.h

59
Examples/GIFPlot/Common-Lisp/full/runme.lisp Normal file
View File

@ -0,0 +1,59 @@
;;; Plot a 3D function
;; Here is the function to plot
(defun func (x y)
(* 5
(cos (* 2 (sqrt (+ (* x x) (* y y)))))
(exp (* -0.3 (sqrt (+ (* x x) (* y y)))))))
;; Here are some plotting parameters
(defvar xmin -5D0)
(defvar xmax 5D0)
(defvar ymin -5D0)
(defvar ymax 5D0)
(defvar zmin -5D0)
(defvar zmax 5D0)
;; Grid resolution
(defvar nxpoints 60)
(defvar nypoints 60)
(defun drawsolid (p3)
(Plot3D-clear p3 0)
(Plot3D-start p3)
(let ((dx (/ (- xmax xmin) nxpoints))
(dy (/ (- ymax ymin) nypoints))
(cscale (/ 240 (- zmax zmin))))
(loop for x from xmin by dx
repeat nxpoints
do (loop for y from ymin by dy
repeat nypoints
do (let* ((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)))
(cc (/ (+ c1 c2 c3 c4) 4))
(c (round (max (min cc 239) 0))))
(Plot3D-solidquad p3 x y z1 (+ x dx) y z2 (+ x dx) (+ y dy)
z3 x (+ y dy) z4 (+ c 16)))))))
(defun action (cmap-filename)
(let ((cmap (new-ColorMap cmap-filename))
(frame (new-FrameBuffer 500 500)))
(format t "Making a nice 3D plot...~%")
(FrameBuffer-clear frame 0)
(let ((p3 (new-Plot3D frame xmin ymin zmin xmax ymax zmax)))
(Plot3D-lookat p3 (* 2 (- zmax zmin)))
(Plot3D-autoperspective p3 40D0)
(Plot3D-rotu p3 60D0)
(Plot3D-rotr p3 30D0)
(Plot3D-rotd p3 10D0)
(drawsolid p3))
(FrameBuffer-writeGIF frame cmap "/tmp/image.gif")
(format t "Wrote image.gif~%")))

3
Examples/GIFPlot/Guile/check.list Normal file
View File

@ -0,0 +1,3 @@
# see top-level Makefile.in
full
simple

28
Examples/GIFPlot/Guile/full/Makefile Normal file
View File

@ -0,0 +1,28 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT = -I../../Include
SRCS =
TARGET = gifplot
INTERFACE = gifplot.i
LIBS = -L../.. -lgifplot -lm
INCLUDES = -I../../Include
all:: static
dynamic::
$(MAKE) -f $(TOP)/Makefile TOP='$(TOP)' \
SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' guile
static::
$(MAKE) -f $(TOP)/Makefile TOP='$(TOP)' \
SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' guile_static
clean::
$(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' guile_clean
rm -f *.gif
check: all

8
Examples/GIFPlot/Guile/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 Scheme program 'runme.scm' 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/Guile/full/cmap Normal file
View File

Binary file not shown.

21
Examples/GIFPlot/Guile/full/gifplot.i Normal file
View File

@ -0,0 +1,21 @@
/* 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"
%}
/* Pixel is typedef'd to unsigned char, and SWIG will translate this
type into Scheme characters. We would like to translate Pixels to
Scheme integers instead, so: */
SIMPLE_MAP(Pixel, gh_scm2int, gh_int2scm, integer);
%include gifplot.h

66
Examples/GIFPlot/Guile/full/runme.scm Normal file
View File

@ -0,0 +1,66 @@
;;; Plot a 3D function
;; Use the wrapped GIFPlot library
(use-modules (gifplot))
;; Here is the function to plot
(define (func x y)
(* 5
(cos (* 2 (sqrt (+ (* x x) (* y y)))))
(exp (* -0.3 (sqrt (+ (* x x) (* y y)))))))
;; Here are some plotting parameters
(define xmin -5.0)
(define xmax 5.0)
(define ymin -5.0)
(define ymax 5.0)
(define zmin -5.0)
(define zmax 5.0)
;; Grid resolution
(define nxpoints 60)
(define nypoints 60)
(define cmap (new-ColorMap "cmap"))
(define frame (new-FrameBuffer 500 500))
(FrameBuffer-clear frame (BLACK))
(define 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)
(define (drawsolid)
(Plot3D-clear p3 (BLACK))
(Plot3D-start p3)
(let ((dx (/ (- xmax xmin) nxpoints))
(dy (/ (- ymax ymin) nypoints))
(cscale (/ 240 (- zmax zmin))))
(let x-loop ((x xmin) (i 0))
(cond
((< i nxpoints)
(let y-loop ((y ymin) (j 0))
(cond
((< j nypoints)
(let* ((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)))
(cc (/ (+ c1 c2 c3 c4) 4))
(c (round (max (min cc 239) 0))))
(Plot3D-solidquad p3 x y z1 (+ x dx) y z2 (+ x dx) (+ y dy)
z3 x (+ y dy) z4 (+ c 16)))
(y-loop (+ y dy) (+ j 1)))))
(x-loop (+ x dx) (+ i 1)))))))
(display "Making a nice 3D plot...\n")
(drawsolid)
(FrameBuffer-writeGIF frame cmap "image.gif")
(display "Wrote image.gif\n")

28
Examples/GIFPlot/Guile/simple/Makefile Normal file
View File

@ -0,0 +1,28 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT =
SRCS =
TARGET = simple
INTERFACE = simple.i
LIBS = -L../.. -lgifplot
INCLUDES = -I../../Include
all:: static
dynamic::
$(MAKE) -f $(TOP)/Makefile TOP='$(TOP)' \
SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' guile
static::
$(MAKE) -f $(TOP)/Makefile TOP='$(TOP)' \
SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' guile_static
clean::
$(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' guile_clean
rm -f *.gif
check: all

11
Examples/GIFPlot/Guile/simple/README Normal file
View File

@ -0,0 +1,11 @@
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.
`make' will build a version of Guile which defines an additional
module (simple). Run `./simple-guile -s runme.scm' to test it.
`make dynamic' will build a dynamically loadable module, which can be
loaded from any Guile interpreter. Run `guile -s runme.scm' to test
it. The `use-modules' call in `runme.scm' dynamically loads the
module.

30
Examples/GIFPlot/Guile/simple/runme.scm Normal file
View File

@ -0,0 +1,30 @@
;;; Draw some simple shapes
;; Use the wrapped GIFPlot library
(use-modules (simple))
(display "Drawing some basic shapes\n")
(define cmap (new-ColorMap))
(define 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")
(display "Wrote image.gif\n")
(delete-FrameBuffer f)
(delete-ColorMap cmap)

34
Examples/GIFPlot/Guile/simple/simple.i Normal file
View File

@ -0,0 +1,34 @@
/* This example shows a very simple interface wrapping a few
primitive declarations */
%module simple
%{
#include "gifplot.h"
%}
typedef unsigned int 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

333
Examples/GIFPlot/Include/gifplot.h Normal file
View File

@ -0,0 +1,333 @@
/* -----------------------------------------------------------------------------
* 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
#ifdef SWIG
%nodefault;
#endif
/* 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 GIFPLOT_TRANSPARENT 0
#define GIFPLOT_FOREGROUND 1
#define GIFPLOT_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

264
Examples/GIFPlot/Interface/gifplot.i Normal file
View File

@ -0,0 +1,264 @@
//
// Graphics module
//
%module gifplot
%{
#include "gifplot.h"
%}
#if defined(SWIGJAVA ) || defined(SWIGPHP)
%rename(make_default) ColorMap::default();
#endif
%rename(__getitem__) ColorMap::getitem(int index);
%rename(__setitem__) ColorMap::setitem(int index, int value);
/* Pixel is 8-bits */
typedef unsigned char Pixel;
typedef float Zvalue;
/* ------------------------------------------------------------------------
ColorMap
Definition and methods for colormaps
------------------------------------------------------------------------ */
typedef struct ColorMap {
char *name;
//
// %extend 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...
%extend {
ColorMap(char *filename);
~ColorMap();
void default();
void assign(int index,int r, int g, int b);
int getitem(int index);
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;
%extend {
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 GIFPLOT_TRANSPARENT 0
#define GIFPLOT_FOREGROUND 1
#define GIFPLOT_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;
%extend {
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;
%extend {
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;
#ifndef SWIGJAVA
/* These directives create constants of a specific type. They
do not correspond to any C variable or declared constant in the
header file */
%constant PixMap * SQUARE = &PixMap_SQUARE;
%constant PixMap * TRIANGLE = &PixMap_TRIANGLE;
%constant PixMap * CROSS = &PixMap_CROSS;
#endif

4
Examples/GIFPlot/Java/check.list Normal file
View File

@ -0,0 +1,4 @@
# see top-level Makefile.in
full
shadow
simple

20
Examples/GIFPlot/Java/full/Makefile Normal file
View File

@ -0,0 +1,20 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT = -I../../Include -noproxy
SRCS =
TARGET = gifplot
INTERFACE = gifplot.i
LIBS = -L../.. -lgifplot
INCLUDES = -I../../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' java
javac *.java
clean::
$(MAKE) -f $(TOP)/Makefile java_clean
rm -f *.gif
check: all

8
Examples/GIFPlot/Java/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 program 'runme.java' does something a little more
interesting. After doing a make, run it using 'java runme'. You'll have to go
look at the header file to get a complete listing of the functions.
Note the differences in the runme.java files between this example and the
'full' example. This example does not use shadow classes.

BIN
Examples/GIFPlot/Java/full/cmap Normal file
View File

Binary file not shown.

15
Examples/GIFPlot/Java/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

75
Examples/GIFPlot/Java/full/runme.java Normal file
View File

@ -0,0 +1,75 @@
// Plot a 3D function
import java.lang.Math;
public class runme {
static {
try {
System.loadLibrary("gifplot");
} catch (UnsatisfiedLinkError e) {
System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
System.exit(1);
}
}
public static void main(String argv[]) {
// Here are some plotting parameters
double xmin = -5.0;
double xmax = 5.0;
double ymin = -5.0;
double ymax = 5.0;
double zmin = -5.0;
double zmax = 5.0;
// Grid resolution
int nxpoints = 60;
int nypoints = 60;
SWIGTYPE_p_ColorMap cmap = gifplot.new_ColorMap("cmap");
SWIGTYPE_p_FrameBuffer frame = gifplot.new_FrameBuffer(500,500);
gifplot.FrameBuffer_clear(frame,(short)gifplot.BLACK);
SWIGTYPE_p_Plot3D p3 = gifplot.new_Plot3D(frame,xmin,ymin,zmin,xmax,ymax,zmax);
gifplot.Plot3D_lookat(p3,2*(zmax-zmin));
gifplot.Plot3D_autoperspective(p3,40);
gifplot.Plot3D_rotu(p3,60);
gifplot.Plot3D_rotr(p3,30);
gifplot.Plot3D_rotd(p3,10);
System.out.println( "Making a nice 3D plot..." );
gifplot.Plot3D_clear(p3,(short)gifplot.BLACK);
gifplot.Plot3D_start(p3);
double dx = 1.0*(xmax-xmin)/nxpoints;
double dy = 1.0*(ymax-ymin)/nypoints;
double cscale = 240.0/(zmax-zmin);
double x = xmin;
for (int i = 0; i < nxpoints; i++) {
double y = ymin;
for (int j = 0; j < nypoints; j++) {
double z1 = func(x,y);
double z2 = func(x+dx,y);
double z3 = func(x+dx,y+dy);
double z4 = func(x,y+dy);
double c1 = cscale*(z1-zmin);
double c2 = cscale*(z2-zmin);
double c3 = cscale*(z3-zmin);
double c4 = cscale*(z4-zmin);
double c = (c1+c2+c3+c4)/4;
if (c < 0) c = 0;
if (c > 239) c = 239;
gifplot.Plot3D_solidquad(p3,x,y,z1,x+dx,y,z2,x+dx,y+dy,z3,x,y+dy,z4,(short)(c+16));
y = y + dy;
}
x = x + dx;
}
gifplot.FrameBuffer_writeGIF(frame,cmap,"image.gif");
System.out.println( "Wrote image.gif" );
}
// Here is the function to plot
public static double func(double x, double y) {
return 5*java.lang.Math.cos(2*java.lang.Math.sqrt(x*x+y*y))*java.lang.Math.exp(-0.3*java.lang.Math.sqrt(x*x+y*y));
}
}

21
Examples/GIFPlot/Java/shadow/Makefile Normal file
View File

@ -0,0 +1,21 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT = -outcurrentdir
SRCS =
TARGET = gifplot
INTERFACEDIR = ../../Interface/
INTERFACE = gifplot.i
LIBS = -L../.. -lgifplot
INCLUDES = -I../../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' INTERFACEDIR='$(INTERFACEDIR)' java
javac *.java
clean::
$(MAKE) -f $(TOP)/Makefile java_clean
rm -f *.gif
check: all

5
Examples/GIFPlot/Java/shadow/README Normal file
View File

@ -0,0 +1,5 @@
This example uses the file in ../../Interface/gifplot.i to build
an interface with shadow classes. After doing a make, run the program runme, ie: 'java runme'.
Note the differences in the runme.java files between this example and the
'full' example. This example uses the shadow classes.

BIN
Examples/GIFPlot/Java/shadow/cmap Normal file
View File

Binary file not shown.

76
Examples/GIFPlot/Java/shadow/runme.java Normal file
View File

@ -0,0 +1,76 @@
// Plot a 3D function
import java.lang.Math;
public class runme {
static {
try {
System.loadLibrary("gifplot");
} catch (UnsatisfiedLinkError e) {
System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
System.exit(1);
}
}
public static void main(String argv[]) {
// Here are some plotting parameters
double xmin = -5.0;
double xmax = 5.0;
double ymin = -5.0;
double ymax = 5.0;
double zmin = -5.0;
double zmax = 5.0;
// Grid resolution
int nxpoints = 60;
int nypoints = 60;
ColorMap cmap = new ColorMap("cmap");
FrameBuffer frame = new FrameBuffer(500,500);
frame.clear((short)gifplot.BLACK);
Plot3D p3 = new Plot3D(frame,xmin,ymin,zmin,xmax,ymax,zmax);
p3.lookat(2*(zmax-zmin));
p3.autoperspective(40);
p3.rotu(60);
p3.rotr(30);
p3.rotd(10);
System.out.println( "Making a nice 3D plot..." );
p3.clear((short)gifplot.BLACK);
p3.start();
double dx = 1.0*(xmax-xmin)/nxpoints;
double dy = 1.0*(ymax-ymin)/nypoints;
double cscale = 240.0/(zmax-zmin);
double x = xmin;
for (int i = 0; i < nxpoints; i++) {
double y = ymin;
for (int j = 0; j < nypoints; j++) {
double z1 = func(x,y);
double z2 = func(x+dx,y);
double z3 = func(x+dx,y+dy);
double z4 = func(x,y+dy);
double c1 = cscale*(z1-zmin);
double c2 = cscale*(z2-zmin);
double c3 = cscale*(z3-zmin);
double c4 = cscale*(z4-zmin);
double c = (c1+c2+c3+c4)/4;
if (c < 0) c = 0;
if (c > 239) c = 239;
p3.solidquad(x,y,z1,x+dx,y,z2,x+dx,y+dy,z3,x,y+dy,z4,(short)(c+16));
y = y + dy;
}
x = x + dx;
}
frame.writeGIF(cmap,"image.gif");
System.out.println( "Wrote image.gif" );
}
// Here is the function to plot
public static double func(double x, double y) {
return 5*java.lang.Math.cos(2*java.lang.Math.sqrt(x*x+y*y))*java.lang.Math.exp(-0.3*java.lang.Math.sqrt(x*x+y*y));
}
}

21
Examples/GIFPlot/Java/simple/Makefile Normal file
View File

@ -0,0 +1,21 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT = -noproxy
SRCS =
TARGET = simple
INTERFACE = simple.i
LIBS = -L../.. -lgifplot
INCLUDES = -I../../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' java
javac *.java
clean::
$(MAKE) -f $(TOP)/Makefile java_clean
rm -f *.gif
check: all

5
Examples/GIFPlot/Java/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. After doing a make, run the java program, ie 'java runme'.

41
Examples/GIFPlot/Java/simple/runme.java Normal file
View File

@ -0,0 +1,41 @@
public class runme {
static {
try {
System.loadLibrary("simple");
} catch (UnsatisfiedLinkError e) {
System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
System.exit(1);
}
}
public static void main(String argv[]) {
// Draw some simple shapes
System.out.println( "Drawing some basic shapes" );
SWIGTYPE_p_ColorMap cmap = simple.new_ColorMap(null);
SWIGTYPE_p_FrameBuffer f = simple.new_FrameBuffer(400,400);
// Clear the picture
simple.FrameBuffer_clear(f,(short)simple.BLACK);
// Make a red box
simple.FrameBuffer_box(f,40,40,200,200,(short)simple.RED);
// Make a blue circle
simple.FrameBuffer_circle(f,200,200,40,(short)simple.BLUE);
// Make green line
simple.FrameBuffer_line(f,10,390,390,200, (short)simple.GREEN);
// Write an image out to disk
simple.FrameBuffer_writeGIF(f,cmap,"image.gif");
System.out.println( "Wrote image.gif" );
simple.delete_FrameBuffer(f);
simple.delete_ColorMap(cmap);
}
}

38
Examples/GIFPlot/Java/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

22
Examples/GIFPlot/Lib/Makefile.in Normal file
View File

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

143
Examples/GIFPlot/Lib/color.c Normal file
View File

@ -0,0 +1,143 @@
/* -----------------------------------------------------------------------------
* 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");
if (fwrite(cm->cmap,768,1,f) != 1) {
fclose(f);
return -1;
}
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--;
}
}
}
}

672
Examples/GIFPlot/Lib/gif.c Normal file
View File

@ -0,0 +1,672 @@
/**********************************************************************
* 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.
*
**************************************************************************/
/*******************************************************************
* Creates a GIF format file.
*
* Dave Beazley (T-11)
* August 11, 1995
*
* Rather than writing directly to files, this module fills out
* output buffer.
*
* Note : To save memory, this routine uses approximately 50K of the
* output buffer as temporary storage (for hash tables and compression codes).
* The remainder of the output buffer is used to store the final image.
* This feature allows GIF images to be created with no additional
* memory overhead.
*
* -- Revision History
* $Log$
* Revision 1.2 2003/09/01 16:23:31 beazley
* Restored the 'mojo'.
*
* Revision 1.2 1996/09/25 22:39:30 dmb
* Fixed prototypes and use of void pointers for compatibility with the Cray T3D
*
* Revision 1.1 1996/09/10 17:44:00 dmb
* Initial revision
*
* Revision 1.2 1995/08/31 14:46:07 beazley
* Minor changes to support comments and a few bug fixes.
*
*
******************************************************************/
/*
* 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 int 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--;
fcode = (long) ( ( (long) c << maxbits) + ent);
i = (((int) c << hshift) ^ ent); /* xor hashing */
if ( HashTabOf (i) == fcode ) {
ent = CodeTabOf (i);
continue;
}
if ( (long)HashTabOf (i) < 0 ) /* empty slot */
goto nomatch;
disp = hsize_reg - i; /* secondary hash (after G. Knott) */
if ( i == 0 )
disp = 1;
probe:
if ( (i -= disp) < 0 )
i += hsize_reg;
if ( HashTabOf (i) == fcode ) {
ent = CodeTabOf (i);
continue;
}
if ( (long)HashTabOf (i) >= 0 )
goto probe;
nomatch:
output_GIF(ent);
out_count++;
ent = c;
if ( free_ent < maxmaxcode ) {
CodeTabOf (i) = free_ent++; /* code -> hashtable */
HashTabOf (i) = fcode;
}
else
cl_block();
}
/* 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;
}
if (fwrite(buffer,nbytes,1,file) != 1) {
free(buffer);
fclose(file);
return -1;
}
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 GIFPLOT_FOREGROUND:
f->pixels[j][i] = fgcolor;
break;
case GIFPLOT_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 *.@OBJEXT@ *~ libgifplot.a *_wrap* *_man*
cd Lib && $(MAKE) clean
rm -f config.log config.status config.cache
check: all

3
Examples/GIFPlot/Ocaml/check.list Normal file
View File

@ -0,0 +1,3 @@
# see top-level Makefile.in
full
simple

33
Examples/GIFPlot/Ocaml/full/Makefile Normal file
View File

@ -0,0 +1,33 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT = -I../../Include
SRCS =
TARGET = gifcaml
INTERFACE = gifplot.i
LIBS = -L../.. -lgifplot -lm
INCLUDES = -I../../Include
MLFILE = gifplot.ml
IOBJS = runme.cmo
PROGFILE = runme.ml
all:: static
static::
$(MAKE) -f $(TOP)/Makefile TOP='$(TOP)' \
IOBJS='$(IOBJS)' PROGFILE='$(PROGFILE)' \
SRCS='$(SRCS)' SWIG='$(SWIG)' MLFILE='$(MLFILE)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ocaml_static
dynamic::
$(MAKE) -f $(TOP)/Makefile TOP='$(TOP)' \
IOBJS='$(IOBJS)' PROGFILE='$(PROGFILE)' \
SRCS='$(SRCS)' SWIG='$(SWIG)' MLFILE='$(MLFILE)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ocaml_dynamic
clean::
$(MAKE) -f $(TOP)/Makefile MLFILE='$(MLFILE)' ocaml_clean
rm -f *.gif
check: all

8
Examples/GIFPlot/Ocaml/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 ocaml program 'runme.ml' 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/Ocaml/full/cmap Normal file
View File

Binary file not shown.

15
Examples/GIFPlot/Ocaml/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"
%}
typedef int Pixel;
%include gifplot.h

87
Examples/GIFPlot/Ocaml/full/runme.ml Normal file
View File

@ -0,0 +1,87 @@
(* Plot a 3D Function *)
(* Use the wrapped GIFPlot library *)
open Swig
open Gifplot
open Int32
(* Here is the function to plot *)
let func x y =
5.0 *.
(cos (2.0 *. (sqrt (x *. x) +. (y *. y)))) *.
(exp (-0.3 *. (sqrt (x *. x) +. (y *. y))))
(* Here are some plotting parameters *)
let xmin = -5.0
let xmax = 5.0
let ymin = -5.0
let ymax = 5.0
let zmin = -5.0
let zmax = 5.0
(* Grid resolution *)
let nxpoints = 60
let nypoints = 60
let cmap = _new_ColorMap (C_string "cmap")
let frame = _new_FrameBuffer (C_list [ C_int 500 ;
C_int 500 ])
let _ = _FrameBuffer_clear (C_list [ frame ; _BLACK C_void ])
let p2 = _new_Plot3D (C_list [ frame ;
C_float xmin ; C_float ymin ; C_float zmin ;
C_float xmax ; C_float ymax ; C_float zmax ])
let _ = _Plot3D_lookat (C_list [ p2 ; C_float (2.0 *. (zmax -. zmin)) ])
let _ = _Plot3D_autoperspective (C_list [ p2 ; C_float 40.0 ])
let _ = _Plot3D_rotu (C_list [ p2 ; C_float 60.0 ])
let _ = _Plot3D_rotr (C_list [ p2 ; C_float 30.0 ])
let _ = _Plot3D_rotd (C_list [ p2 ; C_float 10.0 ])
let drawsolid () =
begin
_Plot3D_clear (C_list [ p2 ; _BLACK C_void ]) ;
_Plot3D_start p2 ;
let dx = ((xmax -. xmin) /. (float_of_int nxpoints))
and dy = ((ymax -. ymin) /. (float_of_int nypoints))
and cscale = (240.0 /. (zmax -. zmin)) in
let rec x_loop x i =
if i < nxpoints then
begin
let rec y_loop y j =
begin
if j < nypoints then
let z1 = func x y
and z2 = func (x +. dx) y
and z3 = func (x +. dx) (y +. dy)
and z4 = func x (y +. dy) in
let c1 = cscale *. (z1 -. zmin)
and c2 = cscale *. (z2 -. zmin)
and c3 = cscale *. (z3 -. zmin)
and c4 = cscale *. (z4 -. zmin) in
let cc = (c1 +. c2 +. c3 +. c4) /. 4.0 in
let c = (max (min (int_of_float cc) 239) 0) in
_Plot3D_solidquad
(C_list (p2 ::
(List.map
(fun x -> C_float x)
[ x ; y ; z1 ;
(x +. dx) ; y ; z2 ;
(x +. dx) ; (y +. dy) ; z3 ;
x ; (y +. dx) ; z4 ;
(float_of_int (c + 16)) ]))) ;
y_loop (y +. dy) (j + 1)
end in
begin
y_loop ymin 0 ;
x_loop (x +. dx) (i + 1)
end
end in
x_loop xmin 0
end
let _ = print_endline "Making a nice 3D plot..."
let _ = drawsolid ()
let _ = _FrameBuffer_writeGIF (C_list [ frame ; cmap ; C_string "image.gif" ])
let _ = print_endline "Write image.gif"

33
Examples/GIFPlot/Ocaml/simple/Makefile Normal file
View File

@ -0,0 +1,33 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT = -I../../Include
SRCS =
TARGET = gifsimple
INTERFACE = simple.i
LIBS = -L../.. -lgifplot -lm
INCLUDES = -I../../Include
MLFILE = simple.ml
IOBJS = simple_wrap.o simple.cmo runme.cmo
PROGFILE = runme.ml
all:: static
static::
$(MAKE) -f $(TOP)/Makefile TOP='$(TOP)' \
IOBJS='$(IOBJS)' PROGFILE='$(PROGFILE)' \
SRCS='$(SRCS)' SWIG='$(SWIG)' MLFILE='$(MLFILE)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ocaml_static
dynamic::
$(MAKE) -f $(TOP)/Makefile TOP='$(TOP)' \
IOBJS='$(IOBJS)' PROGFILE='$(PROGFILE)' \
SRCS='$(SRCS)' SWIG='$(SWIG)' MLFILE='$(MLFILE)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ocaml_static
clean::
$(MAKE) -f $(TOP)/Makefile MLFILE='$(MLFILE)' ocaml_clean
rm -f *.gif
check: all

BIN
Examples/GIFPlot/Ocaml/simple/cmap Normal file
View File

Binary file not shown.

35
Examples/GIFPlot/Ocaml/simple/runme.ml Normal file
View File

@ -0,0 +1,35 @@
(* Draw some simple shapes *)
(* Use the wrapped GIFPlot library *)
open Swig
open Simple
open Int32
let _ = print_endline "Drawing some basic shapes"
let cmap = _new_ColorMap (C_string "cmap")
let f = _new_FrameBuffer (C_list [ C_int 400 ; C_int 400 ])
(* Clear the picture *)
let _ = _FrameBuffer_clear (C_list [ f ; _BLACK C_void ])
(* Make a red box *)
let _ = _FrameBuffer_box
(C_list [ f ; C_int 40 ; C_int 40 ; C_int 200 ; C_int 200 ; _RED C_void ])
(* Make a blue circle *)
let _ = _FrameBuffer_circle
(C_list [ f ; C_int 200 ; C_int 200 ; C_int 40 ; _BLUE C_void ])
(* Make green line *)
let _ = _FrameBuffer_line
(C_list [ f ; C_int 10 ; C_int 390 ; C_int 390 ; C_int 200 ; _GREEN C_void ])
(* Write an image out to disk *)
let _ = _FrameBuffer_writeGIF (C_list [ f ; cmap ; C_string "image.gif" ])
let _ = print_endline "Wrote image.gif"
let _ = _delete_FrameBuffer f
let _ = _delete_ColorMap cmap

33
Examples/GIFPlot/Ocaml/simple/simple.i Normal file
View File

@ -0,0 +1,33 @@
/* This example shows a very simple interface wrapping a few
primitive declarations */
%module simple
%{
#include "gifplot.h"
%}
typedef int 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

4
Examples/GIFPlot/Perl5/check.list Normal file
View File

@ -0,0 +1,4 @@
# see top-level Makefile.in
full
shadow
simple

24
Examples/GIFPlot/Perl5/full/Makefile Normal file
View File

@ -0,0 +1,24 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT = -I../../Include -noproxy
SRCS =
TARGET = gifplot
INTERFACE = gifplot.i
LIBS = -L../.. -lgifplot -lm
INCLUDES = -I../../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' perl5
static::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='myperl' INTERFACE='$(INTERFACE)' perl5_static
clean::
$(MAKE) -f $(TOP)/Makefile perl5_clean
rm -f *.gif
check: all

8
Examples/GIFPlot/Perl5/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/Perl5/full/cmap Normal file
View File

Binary file not shown.

15
Examples/GIFPlot/Perl5/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/Perl5/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";

25
Examples/GIFPlot/Perl5/shadow/Makefile Normal file
View File

@ -0,0 +1,25 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT = -outcurrentdir
SRCS =
TARGET = gifplot
INTERFACEDIR = ../../Interface/
INTERFACE = gifplot.i
LIBS = -L../.. -lgifplot -lm
INCLUDES = -I../../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' INTERFACEDIR='$(INTERFACEDIR)' perl5
static::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='myperl' INTERFACE='$(INTERFACE)' INTERFACEDIR='$(INTERFACEDIR)' perl5_static
clean::
$(MAKE) -f $(TOP)/Makefile perl5_clean
rm -f *.gif
check: all

2
Examples/GIFPlot/Perl5/shadow/README Normal file
View File

@ -0,0 +1,2 @@
This example use the file in ../../Interface/gifplot.i to build
an interface with shadow classes. Run the script 'runme.pl'.

BIN
Examples/GIFPlot/Perl5/shadow/cmap Normal file
View File

Binary file not shown.

68
Examples/GIFPlot/Perl5/shadow/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 gifplot::ColorMap("cmap");
$frame = new gifplot::FrameBuffer(500,500);
$frame->clear($BLACK);
$p3 = new gifplot::Plot3D($frame,$xmin,$ymin,$zmin,$xmax,$ymax,$zmax);
$p3->lookat(2*($zmax-$zmin));
$p3->autoperspective(40);
$p3->rotu(60);
$p3->rotr(30);
$p3->rotd(10);
sub drawsolid {
$p3->clear($BLACK);
$p3->start();
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; }
$p3->solidquad($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();
$frame->writeGIF($cmap,"image.gif");
print "Wrote image.gif\n";

24
Examples/GIFPlot/Perl5/simple/Makefile Normal file
View File

@ -0,0 +1,24 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT =
SRCS =
TARGET = simple
INTERFACE = simple.i
LIBS = -L../.. -lgifplot
INCLUDES = -I../../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' perl5
static::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='myperl' INTERFACE='$(INTERFACE)' perl5_static
clean::
$(MAKE) -f $(TOP)/Makefile perl5_clean
rm -f *.gif
check: all

5
Examples/GIFPlot/Perl5/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/Perl5/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/Perl5/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

3
Examples/GIFPlot/Php/check.list Normal file
View File

@ -0,0 +1,3 @@
# see top-level Makefile.in
full
simple

20
Examples/GIFPlot/Php/full/Makefile Normal file
View File

@ -0,0 +1,20 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT = -I../../Include -noproxy
SRCS =
TARGET = php_gifplot
INTERFACE = gifplot.i
LIBS = -L../.. -lgifplot -lm
INCLUDES = -I../../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' php
clean::
$(MAKE) -f $(TOP)/Makefile php_clean
rm -f *.gif
rm -f php_gifplot.h
check: all

4
Examples/GIFPlot/Php/full/README Normal file
View File

@ -0,0 +1,4 @@
This example runs the entire gifplot.h header file through SWIG without
any changes. The script 'runme.php3' 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/Php/full/cmap Normal file
View File

Binary file not shown.

15
Examples/GIFPlot/Php/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

78
Examples/GIFPlot/Php/full/runme.php Normal file
View File

@ -0,0 +1,78 @@
<?
# Plot a 3D function
require "gifplot.php";
# Here is the function to plot
function 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*($zmax-$zmin));
Plot3D_autoperspective($p3, 40);
Plot3D_rotu($p3, 60);
Plot3D_rotr($p3, 30);
Plot3D_rotd($p3, 10);
function drawsolid() {
global $p3;
global $xmax;
global $xmin;
global $ymax;
global $ymin;
global $zmin;
global $zmax;
global $nxpoints;
global $nypoints;
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 = 0; $i < $nxpoints; $i++) {
$y = $ymin;
for ($j = 0; $j < $nypoints; $j++) {
$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...\n";
drawsolid();
FrameBuffer_writeGIF($frame, $cmap,"image.gif");
print "Wrote image.gif\n";
?>

19
Examples/GIFPlot/Php/shadow/Makefile Normal file
View File

@ -0,0 +1,19 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT = -I../../Interface
SRCS =
TARGET = php_gifplot
INTERFACE = gifplot.i
LIBS = -L../.. -lgifplot -lm
INCLUDES = -I../../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' php
clean::
$(MAKE) -f $(TOP)/Makefile php_clean
rm -f *.gif
check: all

2
Examples/GIFPlot/Php/shadow/README Normal file
View File

@ -0,0 +1,2 @@
This example use the file in ../../Interface/gifplot.i to build
an interface with shadow classes. Run the script 'runme.php3'.

BIN
Examples/GIFPlot/Php/shadow/cmap Normal file
View File

Binary file not shown.

79
Examples/GIFPlot/Php/shadow/runme.php Normal file
View File

@ -0,0 +1,79 @@
<?
# Plot a 3D function
include("gifplot.php");
# Here is the function to plot
function 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);
$frame->clear(BLACK);
$p3 = new Plot3D($frame,$xmin,$ymin,$zmin,$xmax,$ymax,$zmax);
$p3->lookat(2*($zmax-$zmin));
$p3->autoperspective(40);
$p3->rotu(60);
$p3->rotr(30);
$p3->rotd(10);
function drawsolid() {
global $xmax;
global $xmin;
global $ymax;
global $ymin;
global $zmin;
global $zmax;
global $nxpoints;
global $nypoints;
global $p3;
$p3->clear(BLACK);
$p3->start();
$dx = 1.0*($xmax-$xmin)/$nxpoints;
$dy = 1.0*($ymax-$ymin)/$nypoints;
$cscale = 240.0/($zmax-$zmin);
$x = $xmin;
for ($i = 0; $i < $nxpoints; $i++) {
$y = $ymin;
for ($j = 0; $j < $nypoints; $j++) {
$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; }
$p3->solidquad($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();
$frame->writeGIF($cmap,"image.gif");
print "Wrote image.gif\n";
?>

20
Examples/GIFPlot/Php/simple/Makefile Normal file
View File

@ -0,0 +1,20 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT = -noproxy
SRCS =
TARGET = php_simple
INTERFACE = simple.i
LIBS = -L../.. -lgifplot
INCLUDES = -I../../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' php
clean::
$(MAKE) -f $(TOP)/Makefile php_clean
rm -f *.gif
rm -f php_simple.h
check: all

5
Examples/GIFPlot/Php/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.

32
Examples/GIFPlot/Php/simple/runme.php Normal file
View File

@ -0,0 +1,32 @@
<?
# Draw some simple shapes
print "Drawing some basic shapes\n";
require "simple.php";
$cmap = new_ColorMap();
$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");
print "Wrote image.gif\n";
delete_FrameBuffer($f);
delete_ColorMap($cmap);
?>

38
Examples/GIFPlot/Php/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

2
Examples/GIFPlot/Pike/check.list Normal file
View File

@ -0,0 +1,2 @@
# see top-level Makefile.in
simple

24
Examples/GIFPlot/Pike/simple/Makefile Normal file
View File

@ -0,0 +1,24 @@
TOP = ../../..
SWIG = $(TOP)/../swig
SWIGOPT =
SRCS =
TARGET = simple
INTERFACE = simple.i
LIBS = -L../.. -lgifplot
INCLUDES = -I../../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' pike
static::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='mypike' INTERFACE='$(INTERFACE)' pike_static
clean::
$(MAKE) -f $(TOP)/Makefile pike_clean
rm -f *.gif
check: all

5
Examples/GIFPlot/Pike/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.pike' runs the example.

30
Examples/GIFPlot/Pike/simple/runme.pike Normal file
View File

@ -0,0 +1,30 @@
int main()
{
// Draw some simple shapes
write("Drawing some basic shapes\n");
.simple.ColorMap cmap = .simple.new_ColorMap();
.simple.FrameBuffer 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");
write("Wrote image.gif\n");
.simple.delete_FrameBuffer(f);
.simple.delete_ColorMap(cmap);
return 0;
}

38
Examples/GIFPlot/Pike/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

4
Examples/GIFPlot/Python/check.list Normal file
View File

@ -0,0 +1,4 @@
# see top-level Makefile.in
full
shadow
simple

26
Examples/GIFPlot/Python/full/Makefile Normal file
View File

@ -0,0 +1,26 @@
TOP = ../../..
SWIG = $(TOP)/../preinst-swig
SWIGOPT = -I../../Include
SRCS =
TARGET = gifplot
INTERFACE = gifplot.i
LIBS = -L../.. -lgifplot
INCLUDES = -I../../Include
all::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python
static::
$(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
INCLUDES='$(INCLUDES)' LIBS='$(LIBS)' SWIGOPT='$(SWIGOPT)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_static
clean::
$(MAKE) -f $(TOP)/Makefile python_clean
rm -f $(TARGET).py
rm -f *.gif
check: all
$(MAKE) -f $(TOP)/Makefile python_run

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.

Some files were not shown because too many files have changed in this diff Show More