//  ArrayPlot.java    
//
//  Shows how to organize separate classes for computing and plottng.
//  Uses a static array to compute and pass an array to a PlotPanel.
//  Demonstrates use of shallow array copy (actually a pointer) to an array.
//
//  Classes in this file:
//      ArrayPlot  -- the public entry point
//      PlotFrame  -- the JFrame container; must be instantiated
//      DoMath     -- the static math library, never instantiated
//      PlotPanel  -- the JPanel doing plots; must be instantiated
//      U          -- a static library of utilities, never instantiated.
//
//  M.Lampton UCB SSL 2015
//


import java.awt.*;
import java.awt.geom.*;
import javax.swing.*;
import java.lang.Math;
import java.io.*;
import java.util.*; 
import java.text.DecimalFormat;


/**
  *  This is the entrypoint of the program.
  *  It does nothing except create a JFrame.
  *  The JFrame does all the work.
  */
public class ArrayPlot
{
    public static void main(String[] args) throws IOException
    {
       PlotFrame frame = new PlotFrame(); 
       frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
       frame.setVisible(true);
    }
}



/**
  *  This class is the foundation of the program.
  *  It creates and holds all static data structures,
  *  and drives their loading and viewing.
  *  It does no actual work itself, but it must set
  *  and maintain the static (permanent) data structures. 
  */
class PlotFrame extends JFrame
{
    static int NPTS = 1000; 
    static double a[] = new double[NPTS];
    static double b[] = new double[NPTS]; 
    
    public PlotFrame()  // the constructor
    {
        setTitle("ArrayPlot"); 
        setSize(900, 600); 
        System.out.println("calling DoMath.fillArrays()"); 
        DoMath.fillArrays(NPTS, a, b); 
        System.out.println("now instantiating PlotPanel"); 
        PlotPanel panel = new PlotPanel(NPTS, a, b);   // triggers its constructor
        Container contentPane = getContentPane(); 
        contentPane.add(panel);     // makes it visible; OS calls repaint().
    }
}



/**
  *  This class does all the math work, filling the given arrays.
  *  Never instantiated; static method is like a math library.
  *  Has no visible appearance on screen. 
  *  Might be slow, but is called only once, at startup.
  */
class DoMath
{
    static void fillArrays(int npts, double a[], double b[])
    {
        for (int i=0; i<npts; i++)
        {
            a[i] = 0.8*Math.sin(0.01*i); 
            b[i] = 0.8*Math.cos(0.01*i); 
        }
    }
}



/**
  *  This class is the visible display panel.
  *  Dynamic: must be instantiated to have an actual JPanel object.
  *  No math work here: must be quick for repainting speed. 
  *  Its constructor does all initial setup work.
  *  Its method paintComponent() is called by OS when the panel must repaint. 
  */
class PlotPanel extends JPanel
{ 
    int npts;           // local dynamic stash
    double a[];         // shallow copy; no additional memory
    double b[];         // shallow copy; no additional memory
    
    public PlotPanel(int gnpts, double ga[], double gb[])  // constructor stashes pointers
    {
        npts = gnpts;   // stash a local copy
        a = ga;         // stash the pointer
        b = gb;         // stash the pointer
        xLeft = 0;      // set display span
        xRight = npts;  // set display span
    }

    // display conversions: integer pixels to/from user units

    static int    iLeft=100,  iRight=800,  jBot=500, jTop=100; 
    static double xLeft=0.,    xRight=1.,  yBot=-1.0, yTop=+1.0; 

    static double getx(int i) 
      {return xLeft + (xRight-xLeft)*(i-iLeft)/(iRight-iLeft);}

    static double gety(int j) 
      {return yBot + (yTop-yBot)*(j-jBot)/(jTop-jBot);}

    static int geti(double x) 
      {return (int) Math.round((iLeft + (iRight-iLeft)*(x-xLeft)/(xRight-xLeft)));}

    static int getj(double y) 
      {return (int) Math.round((jBot + (jTop-jBot)*(y-yBot)/(yTop-yBot)));}

    static int getSWP(Graphics2D g2, String s)  // get string width pixels
    {
        FontMetrics fm = g2.getFontMetrics(); 
        Rectangle2D.Float r2f = (Rectangle2D.Float) fm.getStringBounds(s, g2); 
        return (int) Math.round(r2f.width); 
    }
    
    
    public void paintComponent(Graphics g)  // plot routine called by OS
    {
        double TOL       = 1E-8;
        int    BIGTICK   = 8;
        int    LILTICK   = 5; 
        int    fontsize  = 14; 

        Graphics2D g2 = (Graphics2D) g; 
        g2.setPaint(Color.WHITE); 
        g2.fillRect(0, 0, getWidth(), getHeight()); 
        g2.setFont(new Font("Dialog", Font.PLAIN, fontsize));
        g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
                            RenderingHints.VALUE_TEXT_ANTIALIAS_GASP);
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, 
                            RenderingHints.VALUE_ANTIALIAS_ON);
        g2.setPaint(Color.BLACK);
        g2.setStroke(new BasicStroke(1.0f));    

        //-----draw the plotbox in pixel units----
        g2.drawLine(iLeft, jTop, iRight, jTop);
        g2.drawLine(iRight, jTop, iRight, jBot);
        g2.drawLine(iRight, jBot, iLeft, jBot);
        g2.drawLine(iLeft, jBot, iLeft, jTop);

        for (double y=yBot; y<yTop+TOL; y+=0.2)     // vert axis linear ticks
        {
            int j = getj(y); 
            g2.drawLine(iLeft, getj(y), iLeft+LILTICK, getj(y)); 
            g2.drawLine(iRight, getj(y), iRight-LILTICK, getj(y)); 
            String label = U.fwd(y,6,1).trim(); 
            g2.drawString(label, iLeft-2-getSWP(g2,label), j+fontsize/3); 
        }

        for (int index=0; index<=npts; index+=100)   // horiz axis linear ticks
        {
            int i = geti(index); 
            g2.drawLine(i, jBot, i, jBot-LILTICK); 
            g2.drawLine(i, jTop, i, jTop+LILTICK); 
            String label = U.fwi(index,6).trim(); 
            g2.drawString(label, i-getSWP(g2,label)/2, jBot+fontsize); 
        }
        String title = "array index"; 
        g2.drawString(title, (iLeft+iRight-getSWP(g2,title))/2, jBot+2*fontsize);
        
        //-----plot the array "a"----
        g2.setPaint(Color.BLUE);
        g2.setStroke(new BasicStroke(1.5f));    
        for(int index=1; index<npts; index++)
          g2.drawLine(geti(index), getj(a[index]), geti(index-1), getj(a[index-1]));  

        //-----plot the array "b"----
        g2.setPaint(Color.RED);
        g2.setStroke(new BasicStroke(0.6f));    
        for(int index=1; index<npts; index++)
          g2.drawLine(geti(index), getj(b[index]), geti(index-1), getj(b[index-1]));  
    }
}




/**
  *  a few math and string utilities
  */  
class U
{
    static String fwi(int n, int w)
    // converts an int to a string with given width.
    {
        String s = Integer.toString(n); 
        while (s.length() < w)
           s = " " + s; 
        return s;
    }

    static String fwd(double x, int w, int d)
    // converts a double to a string with given width and decimals.
    {
        java.text.DecimalFormat df = new DecimalFormat();
        df.setMaximumFractionDigits(d); 
        df.setMinimumFractionDigits(d);
        df.setGroupingUsed(false);   
        String s = df.format(x); 
        while (s.length() < w)
          s = " " + s;  
        if (s.length() > w)
        {
            s = "";
            for (int i=0; i<w; i++)
              s = s + "-";
        }  
        return s; 
    }

    static String fwe(double x)
    // converts a double into an e-notation string
    {
        java.text.NumberFormat ef = new DecimalFormat("0.0000E00"); 
        return ef.format(x); 
    }

    static double log10(double arg)
    {
        if (arg>0.0)
          return Math.log(arg)/Math.log(10.0);
        return -999.9;
    }

    static double dex(double arg)
    {
        if ((arg>-300.0) && (arg<300.0))
          return Math.pow(10.0, arg);
        return -999.9;
    }
}