/*
*   Class   Plot
*
*   Superclass for the plotting subclasses:
*       PlotGraph and PlotPoleZero
*
*   WRITTEN BY: Dr Michael Thomas Flanagan
*
*   DATE:	 February 2002
*   REVISED: 20 July 2005, 7 July 2008, 27 July 2008, 11 August 2008, 5 February 2011, 21 February 2011
*
*   Copyright (c) 2002 - 2008
*
*   DOCUMENTATION
*   http://www.ee.ucl.ac.uk/~mflanaga/java/PlotGraph.html
*   http://www.ee.ucl.ac.uk/~mflanaga/java/
*
*   PERMISSION TO COPY:
*   Permission to use, copy and modify this software and its documentation for
*   NON-COMMERCIAL purposes is granted, without fee, provided that an acknowledgement
*   to the author, Michael Thomas Flanagan at www.ee.ucl.ac.uk/~mflanaga, appears in all copies.
*
*   Dr Michael Thomas Flanagan makes no representations about the suitability
*   or fitness of the software for any or for a particular purpose.
*   Michael Thomas Flanagan shall not be liable for any damages suffered
*   as a result of using, modifying or distributing this software or its derivatives.
*
***************************************************************************************/


package flanagan.plot;

import java.awt.*;
import java.io.Serializable;

import flanagan.math.Fmath;
import flanagan.math.ArrayMaths;
import flanagan.interpolation.CubicSpline;

public class Plot extends Canvas implements Serializable{

        protected static final long serialVersionUID = 1L;  // serial version unique identifier

    	protected double[][] data = null;               // data to be plotted
                                        	            // data[i][] i = 0, 2, 4 . . .  x values
                                        	            // data[i][] i = 1, 3, 5 . . .  y values for x[i-1][]
    	protected double[][] copy = null;               // copy of original data to be plotted
    	protected int nCurves = 0;                      // number of curves
    	protected int[] nPoints = null;                 // number of points points on curve each curve
    	protected int nmPoints = 0;                     // number of points points on curve with most points
    	protected int niPoints = 200;                   // number of cubic spline interpolation points
    	protected int[] pointOpt = null;                // point plotting option for each curve
                                        	            // pointOpt = 0: no points plotted
                                        	            // pointOpt = i where i = 1,2,3,4,5,6,7,8: points plotted
                                            	        // default options
                                            		        // curve 1 - open circles
                                            		        // curve 2 - open squares
                                            		        // curve 3 - open diamonds
                                            		        // curve 4 - filled circles
                                            		        // curve 5 - filled squares
                                            		        // curve 6 - filled diamonds
                                            		        // curve 7 - x crosses
                                            		        // curve 8 - + crosses
                                            		        // further curves - above sequence repeated
    	protected int[] pointSize = null;               // point size in pixels for each curve
    	protected int npTypes = 8;                      // number of point types
    	protected boolean[] errorBar = null;            // true - error bar plotted, flase no error bar plotted - default = false
    	protected double[][] errors = null;             // error bar values - should be an estimate of the sd of the variable
    	protected double[][] errorsCopy = null;         // copy of error bar values
    	protected int[] lineOpt = null;                 // line drawing option for each curve
                                            	            // lineOpt = 0: no line plotted
                                            	            // lineOpt = 1: cubic spline interpolation line plotted as a continuous line
                                            	            // lineOpt = 2: cubic spline interpolation line plotted as a dashed line
                                            	            // lineOpt = 3: line plotted by joining points
                                            	            // lineOpt = 4: dashed line plotted by joining points
                                            	            // default - lineOpt = 1
    	protected int[] dashLength = null;              // dash length in lineOpt = 2
    	protected boolean[] minMaxOpt = null;           // true - curve included in maximum and minimum axes value calculation
    	protected boolean[] trimOpt = null;             // true - curve trimmed to fit axes rectangle

    	protected int fontSize = 14;                    // text font size
    	protected int xLen = 625;                       // length of the x axis in pixels
   	    protected int yLen = 375;                       // length of the y axis in pixels
    	protected int xBot = 100;                       // x coordinate of the bottom of the x axis in pixels
    	protected int xTop = xBot+xLen;                 // x coordinate of the top of the x axis in pixels
    	protected int yTop = 110;                       // y coordinate of the top of the y axis in pixels
    	protected int yBot = yTop+yLen;                 // y coordinate of the bottom of the y axis in pixels

    	protected double xLow = 0;                      // scaled lower limit data value of the x axis
    	protected double xHigh = 0;                     // scaled upper limit data value of the x axis
    	protected double yLow = 0;                      // scaled lower limit data value of the y axis
    	protected double yHigh = 0;                     // scaled upper limit data value of the y axis
    	protected int xFac = 0;                         // decadic exponent of x axis scaling factor
    	protected int yFac = 0;                         // decadic exponent of y axis scaling factor
    	protected int xTicks = 0;                       // number of x axis ticks
    	protected int yTicks = 0;                       // number of y axis ticks

    	protected double xMin = 0.0D;                   // minimum x data value
    	protected double xMax = 0.0D;                   // maximum x data value
    	protected double yMin = 0.0D;                   // minimum y data value
    	protected double yMax = 0.0D;                   // maximum y data value

    	protected double xOffset = 0.0D;                // xaxis data value offset
   	    protected double yOffset = 0.0D;                // y axis data value offset
    	protected boolean noXoffset = false;            // no x axis offset allowed if true
   	    protected boolean noYoffset = false;            // no y axis offset allowed if true
    	protected double xLowFac = 0.75D;               // x axis data setting low factor
    	protected double yLowFac = 0.75D;               // y axis data setting low factor

    	protected String graphTitle  = "  ";            // graph title
    	protected String graphTitle2 = "  ";            // graph title (secondline)
    	protected String xAxisLegend = "  ";            // x axis legend title
    	protected String xAxisUnits  = "  ";            // x axis unit name, e.g.  V, ohm
    	protected String yAxisLegend = "  ";            // y axis legend title
    	protected String yAxisUnits  = "  ";            // x axis unit name

    	protected boolean xZero = false;                // if true - a (x=0) zero line is required
    	protected boolean yZero = false;                // if true - a (y=0) zero line required
    	protected boolean noXunits = true;              // if true - no x axis units
    	protected boolean noYunits = true;              // if true - no y axis units

    	protected double[] xAxisNo = new double[50];    // x axis legend numbers as double
    	protected double[] yAxisNo = new double[50];    // y axis legend numbers as double
    	protected String[] xAxisChar = new String[50];  // x axis legend numbers as char
    	protected String[] yAxisChar = new String[50];  // y axis legend numbers as char
    	protected int[] axisTicks = new int[50];        // no of ticks for scaled lengths

    	protected static double dataFill = Double.NaN;  // value used to initialise data array by Plot.data()


        // Constructor
    	//One 2-dimensional data arrays
    	public Plot(double[][] data){
        	this.initialise(data);
   	    }

   	    // Constructor
    	//Two 1-dimensional data arrays
    	public Plot(double[] xdata, double[] ydata){
    	    int xl = xdata.length;
    	    int yl = ydata.length;
    	    if(xl!=yl)throw new IllegalArgumentException("x-data length is not equal to the y-data length");
    	    double[][] data = new double[2][xl];
    	    for(int i=0; inmPoints)nmPoints=ll;
        	}

        	// Initialize class 2D arrays
        	this.data = new double[2*nCurves][nmPoints];
        	this.copy = new double[2*nCurves][nmPoints];
        	this.errors = new double[nCurves][nmPoints];
        	this.errorsCopy = new double[nCurves][nmPoints];


            // Calculate curve lengths
            // and check all individual curves have an equal number of  abscissae and ordinates
        	int k = 0, l1 = 0, l2 = 0;
        	boolean testlen=true;
        	for(int i=0; inpTypes)kk = 1;
        	}
    	}

        // sort x elements into ascending order with matching switches of y elements
        // using selection sort method
        public static double[][] doubleSelectionSort(double[][] aa){
            int index = 0;
            int lastIndex = -1;
            int n = aa[0].length;
            double holdx = 0.0D;
            double holdy = 0.0D;
            double[][] bb = new double[2][n];
            for(int i=0; i4)throw new IllegalArgumentException("lineOpt must be 0, 1, 2, 3 or 4");
        	this.lineOpt=lineOpt;

        	// check if data supports cubic spline interpolation if lineOpt = 1 or 2
        	for(int i=0; idata[2*i][j-1])rev++;
            		    }
            		    if(rev==nPoints[i]){
            		        lineOpt[i]=-lineOpt[i];
            		    }
            		    else{
            		        // check if y all in descending order
        	                rev = 1;
        	                for(int j=1; j3)throw new IllegalArgumentException("lineOpt must be 0, 1, 2 or 3");
        	for(int i=0; i8)throw new IllegalArgumentException("pointOpt must be 0, 1, 2, 3, 4, 5, 6, 7, or 8");
        	this.pointOpt=pointOpt;
    	}

    	// Overwrite point plotting option with a single option for all curves
    	public void setPoint(int spointOpt){
        	if(spointOpt<0 || spointOpt>8)throw new IllegalArgumentException("pointOpt must be 0, 1, 2, 3, 4, 5, 6, 7, or 8");
        	for(int i=0; i=0.0 && mmax>0.0){
            		big=mmax;
            		test=true;
        	}
        	else{
            		if(mmin<0.0 && mmax<=0.0){
                		big=-mmin;
                		test=true;
            		}
            		else{
                		if(mmax>0.0 && mmin<0.0){
                    			big=Math.max(mmax, -mmin);
                    			test=true;
                		}
            		}
        	}

        	if(test){
            		if(big>100.0){
                		while(big>1.0){
                    			big/=10.0;
                    			fac--;
                		}
            		}
            		if(big<=0.01){
                		while(big<=0.10){
                    			big*=10.0;
                    			fac++;
                		}
            		}
        	}
        	return fac;
    	}

    	// Set low value on axis
    	public static void limits(double low, double high, double lowfac, double[]limits){

            double facl = 1.0D;
            double fach = 1.0D;
            if(Math.abs(low)<1.0D)facl=10.0D;
            if(Math.abs(low)<0.1D)facl=100.0D;
            if(Math.abs(high)<1.0D)fach=10.0D;
            if(Math.abs(high)<0.1D)fach=100.0D;

        	double ld=Math.floor(10.0*low*facl)/facl;
        	double hd=Math.ceil(10.0*high*fach)/fach;

        	if(ld>=0.0D && hd>0.0D){
            		if(ld1)offset = Math.floor(low*Math.pow(10, -ed))*Math.pow(10,ed);
            		}
            		else{
                		eh=(int)Math.floor(Fmath.log10(Math.abs(low)));
                		if(eh-ed>1)offset = Math.floor(high*Math.pow(10, -ed))*Math.pow(10,ed);
            		}
        	}
        	return offset;
    	}


    	// Calculate scaling and offset values for both axes
    	public void axesScaleOffset(){

        	double[] limit = new double[2];

        	// tranfer data from copy to enable redrawing
        	int k=0;
        	for(int i=0; i0)xZero=true;
        	// y axis
        	limits(this.yMin, this.yMax, this.yLowFac, limit);
        	this.yLow  = limit[0];
        	this.yHigh = limit[1];
        	if(yLow<0 && yHigh>0)yZero=true;

        	// Calculate tick parameters
        	// x axis
        	this.xTicks = ticks(this.xLow, this.xHigh, this.xAxisNo, this.xAxisChar);
        	this.xHigh = this.xAxisNo[this.xTicks-1];
        	if(this.xLow!=this.xAxisNo[0]){
        	    if(this.xOffset!=0.0D){
        	        this.xOffset = this.xOffset - this.xLow + this.xAxisNo[0];
        	    }
        	    this.xLow = this.xAxisNo[0];
        	}
        	// y axis
        	this.yTicks = ticks(this.yLow, this.yHigh, this.yAxisNo, this.yAxisChar);
        	this.yHigh = this.yAxisNo[this.yTicks-1];
        	if(this.yLow!=this.yAxisNo[0]){
        	    if(this.yOffset!=0.0D){
        	        this.yOffset = this.yOffset - this.yLow + this.yAxisNo[0];
        	    }
        	    this.yLow = this.yAxisNo[0];
        	}

    	}

    	// Calculate axis ticks and tick values
    	public static int ticks(double low, double high, double[] tickval, String[] tickchar){

        	// Find range
            int[] trunc = {1, 1, 1, 2, 3};
            double[] scfac1 = {1.0, 10.0, 1.0, 0.1, 0.01};
            double[] scfac2 = {1.0, 1.0, 0.1, 0.01, 0.001};

            double rmax = Math.abs(high);
            double temp = Math.abs(low);
            if(temp>rmax)rmax = temp;
            int range = 0;
            if(rmax<=100.0D){
                range = 1;
            }
            if(rmax<=10.0D){
                range = 2;
            }
            if(rmax<=1.0D){
                range = 3;
            }
            if(rmax<=0.1D){
                range = 4;
            }
            if(rmax>100.0D || rmax<0.01)range = 0;

        	// Calculate number of ticks
        	double inc = 0.0D;
        	double bot = 0.0D;
        	double top = 0.0D;
        	int sgn = 0;
        	int dirn = 0;
        	if(high>0.0D && low>=0.0D){
        	    inc = Math.ceil((high-low)/scfac1[range])*scfac2[range];
        	    dirn = 1;
        	    bot = low;
        	    top = high;
        	    sgn = 1;
        	}
        	else{
        	    if(high<=0 && low<0.0D){
        	        inc = Math.ceil((high-low)/scfac1[range])*scfac2[range];
        	        dirn = -1;
        	        bot = high;
        	        top = low;
        	        sgn = -1;
        	    }
        	    else{
        	        double up = Math.abs(Math.ceil(high));
        	        double down = Math.abs(Math.floor(low));
        	        int np = 0;
        	        if(up>=down){
        	            dirn = 2;
        	            np = (int)Math.rint(10.0*up/(up+down));
        	            inc = Math.ceil((high*10/np)/scfac1[range])*scfac2[range];
                        bot = 0.0D;
        	            top = high;
        	            sgn = 1;
        	        }
        	        else{
        	            dirn = -2;
        	            np = (int)Math.rint(10.0D*down/(up+down));
        	            inc = Math.ceil((Math.abs(low*10/np))/scfac1[range])*scfac2[range];
        	            bot = 0.0D;
        	            top = low;
        	            sgn = -1;
        	        }
        	    }
        	}

            int nticks = 1;
            double sum = bot;
            boolean test = true;
            while(test){
                sum = sum + sgn*inc;
                nticks++;
                if(Math.abs(sum)>=Math.abs(top))test=false;
            }

        	// Calculate tick values
        	int npExtra = 0;
        	double[] ttickval = null;;
        	switch(dirn){
        	    case 1:     ttickval = new double[nticks];
        	                tickval[0]=Fmath.truncate(low, trunc[range]);
        	                for(int i=1; i=nticks)testZero = false;
                }
            }

            // set String form of tick values
        	for(int i=0; inCurves)throw new IllegalArgumentException("At least one curve must be included in the maximum/minimum calculation");
            		}
        	}

        	int k=0;
        	double yMint=0.0D, yMaxt=0.0D;
        	for(int i=0; ithis.data[k][j])this.xMin=this.data[k][j];
                    			if(this.xMaxyMint)this.yMin=yMint;
                    			yMaxt=this.data[k+1][j];
                   		        if(errorBar[i])yMaxt=errors[i][j];
                    			if(this.yMax=0){
                		for(int i=0; ixTop)btest2=false;
	            	if(xnewpointxTop)btest2=false;
            		if(yoldpoint>yBot)btest2=false;
	            	if(yoldpointyBot)btest2=false;
            		if(ynewpointyCharLenMax)yCharLenMax=yAxisChar[ii].length();
        	int shift = (yCharLenMax-3)*5;
        	double ytep=(double)(-yTop+yBot)/((double)(this.yTicks-1));
        	for(int ii=0; iidashLength[i]){
                                				dsum=0;
                                				if(dcheck){
                                    					dcheck=false;
                                				}
								                else{
                                    					dcheck=true;
                                				}
                            				}
                        			}
                        			if(dcheck)g.drawLine(xoldpoint,yoldpoint,xnewpoint,ynewpoint);
                    			}
                    			xoldpoint=xnewpoint;
                    			yoldpoint=ynewpoint;
                		}
            		}

            		if(lineOpt[i]==-1 || lineOpt[i]==-2){
                		CubicSpline cs = new CubicSpline(this.nPoints[i]);
                		for(int ii=0; iidashLength[i]){
                                				dsum=0;
                                				if(dcheck){
                                    					dcheck=false;
                                				}
								else{
                                    					dcheck=true;
                                				}
                            				}
                        			}
                        			if(dcheck)g.drawLine(xoldpoint,yoldpoint,xnewpoint,ynewpoint);
                    			}
                    			xoldpoint=xnewpoint;
                    			yoldpoint=ynewpoint;
                		}
            		}

	            	if(lineOpt[i]==3){
                		// Join points option
                		dsum=0;
                		dcheck=true;
                		xoldpoint=xBot+(int)((((this.data[kk][0])-xLow)/xdenom)*xLen);
                		yoldpoint=yBot-(int)((((this.data[kk+1][0])-yLow)/ydenom)*yLen);
                		for(int ii=1; iidashLength[i]){
                                    dsum=0;
                                    if(dcheck){
                                        dcheck=false;
                                    }
								    else{
                                        dcheck=true;
                                    }
                                }
                    			xnewpoint=xBot+(int)((((this.data[kk][ii])-xLow)/xdenom)*xLen);
                    			ynewpoint=yBot-(int)((((this.data[kk+1][ii])-yLow)/ydenom)*yLen);
                    			btest2=printCheck(trimOpt[i], xoldpoint, xnewpoint, yoldpoint, ynewpoint);
                    			if(dcheck)g.drawLine(xoldpoint,yoldpoint,xnewpoint,ynewpoint);
                    			xoldpoint=xnewpoint;
                    			yoldpoint=ynewpoint;
                		}
            		}


            		// Plot points
            		if(pointOpt[i]>0){
                		for(int ii=0; ii 

Ads help maintain this website.