comparison src/samer/tools/Plotter.java @ 0:bf79fb79ee13

Initial Mercurial check in.

+/*
+ *	Copyright (c) 2000, Samer Abdallah, King's College London.
+ *	All rights reserved.
+ *
+ *	This software is provided AS iS and WITHOUT ANY WARRANTY; 
+ *	without even the implied warranty of MERCHANTABILITY or 
+ *	FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+package samer.tools;
+import  samer.core.*;
+import  samer.core.util.*;
+import  java.awt.*;
+
+/**
+	<p>
+	A Plotter object is a Canvas with its own Graphics
+	(ie a GCanvas) which has two LinearMaps
+	to map a portion of 2d space to the window.
+	It can optionally draw the X and Y axes.
+
+	<p>
+	The inner class Pen provides access to drawing
+	functions in the real-valued coordinate space.
+ */
+
+public class Plotter extends samer.core.util.heavy.VCanvas
+{
+	/** for passing to setAxes(int) */
+	public static final int NEITHER = 0;
+	public static final int YAXIS = 2;
+	public static final int XAXIS = 1;
+	public static final int BOTH = 3;
+	public IMap	xmap, ymap;
+	
+	int			axesFlags=BOTH;
+	Color		axesColor;
+
+	/** 
+		Default constructor makes Plotter with both axes
+		drawn, in grey. LinearMaps take their default 
+		setup.
+		
+		@see samer.core.util.LinearMap
+	 */
+
+	public Plotter()
+	{
+		xmap = new LinearMap();
+		ymap = new LinearMap();
+
+		axesColor=Shell.getColor("axesColor",Color.gray);
+	}
+
+	public void exposeMaps() {
+		exposeCommands(new VMap(xmap));
+		exposeCommands(new VMap(ymap));
+	}
+
+	protected void sized() {
+		// make sure maps map to whole window
+		xmap.setIntRange(width);
+		ymap.setIntRange(height);
+	}
+
+	public Dimension getPreferredSize() { return new Dimension(256,256); }
+
+	/** use one of NONE, XAXIS, YAXIS or BOTH */
+	public void setAxes(int f) { axesFlags=f; }
+	public void setAxesColor(Color c) { axesColor=c; }
+
+	/** not really for public use */
+	public void drawAxes(Graphics g)
+	{ 
+		if (axesFlags!=0) {
+			g.setColor(axesColor);
+			
+			if ((axesFlags&XAXIS)!=0) {
+				int oy = height-ymap.toInt(0.0);
+				if (!ymap.wasClipped()) g.drawLine(0,oy,width-1,oy);
+			}
+
+			if ((axesFlags&YAXIS)!=0) {
+				int ox = xmap.toInt(0.0);
+				if (!xmap.wasClipped()) g.drawLine(ox,0,ox,height-1);
+			}
+
+			g.setColor(getForeground());
+		}
+	}
+
+	public void clear(Graphics g) { super.clear(g); drawAxes(g); }
+	public void paint(Graphics g) { Tools.initGraphics(g); drawAxes(g); }
+
+	/** return a new Pen for this Plotter */
+	public Pen	getPen() { return new Pen(graphics); }
+	public Pen	getPen(Graphics g) { return new Pen(g); }
+
+	// ----- drawing tools -------
+
+	/**
+		<p>
+		This class provides a state based plotting
+		environment (slightly inspired by Postscripts
+		crazy reverse polish). There is are <i>two</i>
+		current points: one for general use and another
+		which serves as the other point for lines,
+		rectangles and ellipses.
+
+		<p>
+		The primary current point can be set in absolute
+		coordinates using <code>abs(x,y)</code> or 
+		moved relatively using <code>rel(dx,dy)</code>.
+		The folling functions use <i>only</i> the primary 
+		current point:
+		<ul>
+			<li> <code>marker()</code>;
+			<li> <code>pixel()</code>;
+			<li> <code>blob()</code>.
+		</ul>
+		Calling <code>move()</code> copies the the location
+		of the primary current point to the secondary 
+		current point. The following functions use both
+		the current points:
+		<ul>
+			<li> <code>line()</code>: line between both points;
+			<li> <code>rect()</code>: empty rectangle bounding both points 
+			<li> <code>fillRect()</code>;
+			<li> <code>fill3DRect(boolean inOrOut)</code>;
+			<li> <code>ellipse()</code>;
+			<li> <code>fillEllipse()</code>.
+		</ul>
+		<p>
+		Some of the rectangle drawing commands
+		only work if the primary current point is below
+		and to the right (on the screen, that is) of the
+		secondary. The <code>rectify</code> function
+		swaps coordinates between the two points to make
+		it so. It will screw up any line drawing though.
+
+ */
+		
+	public class Pen
+	{
+		Graphics			graphics;
+		public Point		p0=new Point(); // secondary
+		public Point		p1=new Point(); // primary
+		vec2				r=new vec2(0,0);
+		int					moff=3, msz=moff*2;	// marker size
+		int					ix, iy;							// blob image hotspot
+		Color				col=getForeground();		// current colour
+		Image			blobImg;						// drawn by blob()
+
+		/**
+			<p>
+			A program can have several Pens, each with different
+			colours, but the underlying Graphics has a
+			single current Color. So, if you have multiple Pens,
+			each pen must <code>activate()</code> its colour
+			before drawing anything.
+		 */
+
+		public Pen(Graphics g) { graphics=g; }
+		final public Pen  activate() { graphics.setColor(col); return this; }
+		final public Pen  setColor(Color c) { col=c; graphics.setColor(c); return this; }
+		final public void setMarkerSize(int r) { moff=r; msz=2*r; }
+
+		/** returns true if the last primary current point was clipped */
+		public final boolean clipped() { return xmap.wasClipped() | ymap.wasClipped(); }
+		public final Pen abs( double x, double y) { r.x=x; r.y=y; map(); return this; }
+		public final Pen rel( double x, double y) { r.x+=x; r.y+=y; map(); return this; }
+
+		/** copies position of given pen to primary current point */
+		public final Pen set( Pen p) { r.x=p.r.x; r.y=p.r.y; p1.x=p.p1.x; p1.y=p.p1.y; return this; }
+		public final Pen move() { p0.x=p1.x; p0.y=p1.y; return this; }
+		public final Pen line() {
+			graphics.drawLine(p0.x,p0.y,p1.x,p1.y);
+			return this;
+		}
+
+		public Pen rect() { 
+			graphics.drawRect(p0.x,p0.y,p1.x-p0.x,p1.y-p0.y);
+			return this;
+		}
+
+		public Pen fillRect() { 
+			graphics.fillRect(p0.x,p0.y,p1.x-p0.x,p1.y-p0.y);
+			return this;
+		}
+
+		/** this swaps xs and ys to make sure rectangles work */
+		public Pen rectify() {
+			if (p1.y<p0.y)	{ int tmp=p0.y; p0.y=p1.y; p1.y=tmp; }
+			if (p1.x<p0.x)	{ int tmp=p0.x; p0.x=p1.x; p1.x=tmp;	}
+			return this;
+		}
+
+		public Pen fill3DRect(boolean outin) {
+			if (p1.y!=p0.y) { // goes wrong otherwise
+				graphics.fill3DRect(p0.x,p0.y,p1.x-p0.x,p1.y-p0.y,outin);
+			}
+			return this;
+		}
+
+		public Pen ellipse() { 
+			graphics.drawOval(p0.x,p0.y,p1.x-p0.x,p1.y-p0.y);
+			return this;
+		}
+
+		public Pen fillEllipse() {
+			graphics.fillOval(p0.x,p0.y,p1.x-p0.x,p1.y-p0.y);
+			return this;
+		}
+
+		public Pen marker() {
+			// graphics.drawOval(p1.x-moff,p1.y-moff,msz,msz);
+			graphics.fillRect(p1.x-moff,p1.y-moff,msz+1,msz+1);
+			// graphics.drawRect(p1.x-moff,p1.y-moff,msz,msz);
+			return this;
+		}
+
+		/** pixel drawn as 1x1 filled rectangle */
+		public Pen pixel() {
+			graphics.fillRect(p1.x,p1.y,1,1);
+			return this;
+		}
+
+		private Pen map() {
+			p1.x=xmap.toInt(r.x);
+			p1.y=ymap.toInt(r.y);
+//			if (xmap.wasClipped()) {
+//				if (p1.x<-16000) p1.x=-16000; else p1.x=16000;
+//			}
+			if (ymap.wasClipped()) {
+				if (p1.y<-32000) p1.y=32000;
+				else if (p1.y>32000) p1.y=-32000;
+				else p1.y=height-p1.y;
+			} else p1.y=height-p1.y;
+			return this;
+		}
+
+		/* These last three functions are here to speed up 
+		   two common operations: 
+
+				moveto(x,y) is exactly equivalent to abs(x,y).map().move();
+				lineto(x,y) is exactly equivalent to abs(x,y).map().line().move();
+				lineto(x,y) is exactly equivalent to line().move() ;
+		 */
+
+		public final Pen lineto() 
+		{ 
+			graphics.drawLine(p0.x,p0.y,p1.x,p1.y);
+			p0.x=p1.x; p0.y=p1.y; 
+			return this;
+		}
+
+		public final Pen lineto(double x, double y) 
+		{ 
+			r.x=x; r.y=y; map();
+			graphics.drawLine(p0.x,p0.y,p1.x,p1.y);
+			p0.x=p1.x; p0.y=p1.y; 
+			return this;
+		}
+
+		// this is exactly equivalent to abs(x,y).map().move();
+		public final Pen moveto(double x, double y) 
+		{ 
+			r.x=x; r.y=y; map();
+			p0.x=p1.x; p0.y=p1.y; 
+			return this;
+		}
+
+		/** draws the current blob image at the current point */
+		public Pen blob() { 
+			graphics.drawImage(blobImg,ix+p1.x,iy+p1.y,null); 
+			return this; 
+		}
+		
+		/** sets the blob image to be pixel of a given colour */	
+		public void setBlobColor(Color col) {
+			blobImg=createPixel(col); 
+		}
+
+		/** sets blob image to given image */
+		public void setBlobImage(Image i) { blobImg=i; ix=0; iy=0; }
+
+		/** sets blob image with given hotspot */
+		public void setBlobImage(Image i, int xhot, int yhot) { blobImg=i; ix=-xhot; iy=-yhot; }
+	}
+}
+