//
//  gc.java --- java version of gc
//  gc: a simple graph plotting tool
//
//  author: keiji imoto
//          department of information physiology
//          national insttitute for physiological sciences 
//          okazaki 444-8787, japan  
//
//  compile: javac gc.java
//  usage:
//        java gc            ::file chooser will show up      
//        java gc filename   ::if x-axis is linear, gc detects the number 
//                             of traces. 
//        java gc filename number_of_traces
//  
//  remarks:
//        java programs use BIG_ENDIAN, while the byte order used by 
//        C and C++ are OS-dependent (LITTLE_ENDIAN on Windows, Intel
//        Mac-OS). Endian is checked with the following statement.
//        System.out.println(java.nio.ByteOrder.nativeOrder().toString());
//
//        only binary file 
//
//  initially created on 2003/11/14
//  modified on 20-feb-2009: clean up
//              15-Dec-2010: A bug in endian conversion was corrected. 
//
//  to do:
//        1. multi-color traces
//        2. infput for text data file


import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.nio.*;

//------------------------------------------------------------------
//------------------------------------------------------------------
//------------------------------------------------------------------

class graphPanel extends javax.swing.JPanel
    implements MouseListener,MouseMotionListener  {
        
        int oldx, oldy, oldx1, oldy1,px1, py1;
        int ticLength;
        double ticUnit;
        double XScaleFactor,YScaleFactor;
        double cXOffset, cYOffset;
        
        int IMin, IMax;
        double XMin, XMax, YMin, YMax;
        double rXMin,rYMin,rXMax,rYMax;
        
        boolean lineDraw;
        boolean firstDraw;
        boolean debugFlag;
        
        private Point pressedPoint;  
        boolean rightButtonClicked;
        boolean leftButtonClicked;
        
        int nt;
        int npts;
        double[] X;
        double[][] Y;
        String xLabel;
        String yLabel;
        
        int traceColor;
        
        Color [] colors;
        
        public graphPanel() {
            super();
            nt = 0;
            npts = 0;
            xLabel = "";
            yLabel = "";
            pressedPoint = new Point(0,0);
            addMouseListener(this);
            addMouseMotionListener(this);
            lineDraw = false;
            firstDraw = true;
            debugFlag = false;
            rightButtonClicked = false;
            leftButtonClicked = false;
            traceColor = 1;
            
            colors = new Color[9];
            colors[0] = new Color(0.86F, 0.08F, 0.24F);  // red
            colors[1] = new Color(0.13F, 0.54F, 0.13F);  // green
            colors[2] = new Color(0.28F, 0.51F, 0.71F);  // blue;
            colors[3] = new Color(0.95F, 0.27F, 0.0F);   // orange
            colors[4] = new Color(0.0F, 0.0F, 0.50F);    // dark blue
            colors[5] = new Color(1.0F, 0.84F, 0.0F);    // yellow
            colors[6] = new Color(0.58F, 0.0F, 0.83F);   // purple
            colors[7] = new Color(0.41F,0.41F,0.41F);    // gray       
            colors[8] = new Color(0.0F,0.0F,0.0F);       // black
            
/*            
            color.red=0.58; color.green=0.0; color.blue=0.83; // purple
            break;
        case 7:
            color.red=0.41; color.green=0.41; color.blue=0.41; //gray
            break;
        default:
            color.red=0.0; color.green=0.0; color.blue=0.0;    //black
            ;
        }    
        */
        //                    jjcolors.add("aaa");
        }
        
        void findMinMax(){
            if(nt==0)return;        
            XMin=XMax=X[0];
            for(int i=0;i<npts;i++){
                double tx=X[i];
                if(tx>XMax){
                    XMax=tx;
                }else if(tx<XMin){
                    XMin = tx;
                }
            }
            
            YMin = Y[0][0];
            YMax = YMin;
            for(int i=0;i<nt;i++){
                for(int j=0;j<npts;j++){
                    double ty = Y[i][j];
                    if(ty>YMax){
                        YMax = ty;
                    }else if(ty<YMin){
                        YMin = ty;
                    }
                }
            }
        }
        
        void makeWave(){
            X = new double[npts];
            Y = new double[nt][];
            for(int i=0;i<nt;i++){
                Y[i] = new double[npts];
            }
        }
        
        
        
        //------------------------------------------------------------------
        //  Scaling utilities
        //
        
        int getXScaled( double x ) {
            return  (int)(0.5 + cXOffset + XScaleFactor*(x-rXMin)) ;
        }
        
        int getYScaled( double y ) {
            return  (int)(0.5 + cYOffset - (YScaleFactor*(y-rYMin))) ;
        }
        
        int getYScaledInRange( double y ) {
            if(y<rYMin){
                y = rYMin;
            }else if(y>rYMax){
                y = rYMax;
            }
            return  (int)(0.5 + cYOffset - (YScaleFactor*(y-rYMin))) ;
        }
        
        double getXScaleBack( int ix ) {
            return  rXMin + (ix-cXOffset)/XScaleFactor;
        }
        
        double getYScaleBack(int iy ) {
            return  rYMin + (cYOffset -iy)/YScaleFactor;
        }
        
        // tic utilities
        
        double getAutoRange(double ZMin,double ZMax) {
            int nTic = 3;            
            double ZDelta = ZMax-ZMin;
            if(ZDelta<0)ZDelta = -ZDelta;
            double ZTic = (int)(Math.log(ZDelta)/Math.log(10.0));
            ZTic = Math.pow(10.0, ZTic);
            while(true){
                if ( (ZDelta/ZTic) >= nTic)break;            
                ZTic = 0.5 *  ZTic;
                if((ZDelta/ZTic)>= nTic)break;
                ZTic = 0.4 *  ZTic;
                if((ZDelta/ZTic)>=nTic)break;
                ZTic = 0.5 *  ZTic;
                if((ZDelta/ZTic)>=nTic)break;
            }
            return ZTic;
        }
        
        // =====================================================================
        //         PAINT
        // =====================================================================
        
        protected void paintComponent(Graphics comp) {
            int i, n, cX, cY, cx1, cy1 ;
            double aX,aY;
            String s;
            
            Graphics2D g2 = (Graphics2D)comp;
            Color fg3D = new java.awt.Color(255, 255, 204);
            Dimension d = getSize();
            
            if(lineDraw){
                g2.setXORMode(new Color(64,64,64));
                if(firstDraw==false){
                    g2.drawRect(Math.min(oldx,oldx1),Math.min(oldy,oldy1), 
                                Math.abs(oldx1-oldx), Math.abs(oldy1-oldy));
                }
                g2.drawRect(Math.min(oldx,px1),Math.min( oldy, py1), 
                            Math.abs(px1-oldx), Math.abs(py1-oldy));
                oldx1 = px1;
                oldy1 = py1;
                lineDraw = false;
                firstDraw = false;
                return;
            }
            
            g2.setPaint(Color.white);//fg3D);
            g2.fillRect(0, 0, d.width - 1, d.height - 1);
            g2.setFont(new Font("Arial", Font.ITALIC|Font.BOLD, 12));
            FontMetrics fm = g2.getFontMetrics();
            g2.setColor(Color.GRAY);
            
            if(nt == 0){
                g2.drawString("x="+pressedPoint.x+", y="+pressedPoint.y,20,20);
                return;
            }
            
            
            //            facCmToPixels =toolkit.getScreenResolution()/2.54; //   
            double facCmToPixels = 72;
            cXOffset = 0.1*d.width;
            cYOffset = 0.9*d.height; 
            
            XScaleFactor = 0.85*d.width/(rXMax-rXMin);
            YScaleFactor = 0.8*d.height/(rYMax-rYMin);
            ticLength = (int)(0.15 * facCmToPixels);
            
            aX = getXScaleBack( pressedPoint.x );
            aY = getYScaleBack( pressedPoint.y );
            g2.drawString("x=" + (float)aX + ", y=" + (float)aY, 20, 20);
            
            // X-Axis
            g2.drawLine((int)cXOffset,(int)cYOffset,getXScaled(XMax),(int)cYOffset);
            
            ticUnit = getAutoRange(rXMin, rXMax);
            n = (int)(-Math.log(ticUnit)/Math.log(10.0))+1;
            if( n < 0 ) n = 0;
            i= (int)(rXMin/ticUnit);
            if( i * ticUnit < rXMin ) i++;
            while(true){
                aX = i * ticUnit;
                if(aX > rXMax ) break;
                s = Double.toString(aX);
                cX = getXScaled(aX);
                cx1 = fm.stringWidth(s);
                cy1 = fm.getHeight();
                g2.drawString(s,cX-cx1/2,(int)(cYOffset+cy1+ticLength));
                g2.drawLine(cX, (int)cYOffset, cX, (int)(cYOffset + ticLength));
                i++;
            }
            /*
             s = pGraph->xLabel;
             cs= pDC->GetOutputTextExtent(s);
             cX = cXScale( 0.5*(rXMin+pGraph->XMax));
             pDC->TextOut((int)(cX-(cs.cx/2)),cYOffset+ (int)(CmToPixels*1.0) , s);
             */
            
            // Y-Axis
            g2.drawLine((int)cXOffset,(int)cYOffset,(int)cXOffset,getYScaled(rYMax));
            ticUnit = getAutoRange(rYMin,rYMax);
            n = (int)(Math.log(ticUnit)/Math.log(10.0))+1;
            if ( n< 0 ) n= 0;
            
            i= (int)(rYMin / ticUnit);
            if(i*ticUnit < rYMin)i++;
            while(true){
                aY =  i*ticUnit;
                if(aY > rYMax)break;
                s = Double.toString(aY);
                cY = getYScaled(aY);
                cx1 = fm.stringWidth(s);
                cy1 = fm.getHeight();
                g2.drawString(s,(int)(cXOffset-cx1-2*ticLength),cY+cy1/4);
                g2.drawLine((int)(cXOffset-ticLength),cY,(int)cXOffset,cY);
                i++;
            }
            
            n = IMin;
            for(int j=0;j<nt;j++){
                int x0,x1,y0,y1;
                double yy;
                java.awt.geom.GeneralPath polyline = new java.awt.geom.GeneralPath();
                x0 = getXScaled(X[n]);
                y0 = getYScaledInRange(Y[j][n]);
                polyline.moveTo(x0,y0);                
                for(i=n+1 ; i<IMax;i++){
                    x1 = getXScaled(X[i]);
                    y1 = getYScaledInRange(Y[j][i]);


                    if((x1!=x0) || (y1!=y0)){
                        polyline.lineTo(x1,y1);
                        x0=x1;
                        y0=y1;
                    }
                }
                
                if(traceColor==0){
                    g2.setColor(colors[j % 9]);
                }else{
                    if(traceColor==1){
                        g2.setColor(colors[0]);
                    }else if(traceColor==2){
                        g2.setColor(colors[1]);
                    }else{
                        g2.setColor(colors[8]);
                    }
                }
                g2.draw(polyline);
            }
        }
        
        // =====================================================================
        //         MENU
        // =====================================================================
        
        public void openFile(String[] args)
        {
            java.io.File dataFile;
            java.io.RandomAccessFile fp;
            
            nt = 0;
            
            if((args==null) || (args.length==0)){
                javax.swing.JFileChooser chooser = new javax.swing.JFileChooser();
                if(chooser.showOpenDialog(this) != javax.swing.JFileChooser.APPROVE_OPTION)return;
                dataFile = chooser.getSelectedFile();
            }else{
                dataFile = new java.io.File(args[0]);
                if(args.length==2){
                    System.out.println("args[0] = " + args[0]);                    
                    System.out.println("args[1] = " + args[1]);
                    nt = java.lang.Integer.parseInt(args[1]);
                }
            }            
            
            int datasize = (int)(dataFile.length()/8);
            if(datasize==0)return;
            
            try{
                fp= new java.io.RandomAccessFile(dataFile,"r");
            }catch (java.io.IOException e) {
                System.out.println("? File open error ?");
                System.out.println(e);
                return;
            }
            
            //-----------------------                
            if(nt==0){  // guess the number of traces
                int na;
                double a0,d0,d1;
                boolean Success = false;	
                for(na=2 ; na < datasize/4 ; na++){
                    if(datasize % na ==0){
                        try{
                            fp.seek(0);
                            a0 = convertEndian(fp.readDouble());

                            fp.seek(na*8);
                            d0 = convertEndian(fp.readDouble());
                            d0 = d0 - a0;
                            
                            if(d0!=0){
                                int i=2;
                                while(true){
                                    fp.seek(i*na*8);
                                    d1 = convertEndian(fp.readDouble());
                                    d1 = (d1-a0)/(double)i;
                                    if(java.lang.Math.abs((d1-d0)/d0)>1e-3 )break;
                                    i++;
                                    if((i*na>=datasize) || (i>30)){
                                        Success = true;
                                        break;
                                    }
                                } // endo of while-loop
                            }
                        }catch (java.io.IOException e) {
                            System.out.println("? File read error ?");
                            System.out.println(e);
                            return;
                        }
                    }
                    if(Success)break; 
                }  // end of for-loop
                nt = na-1;
            }            
            //-----------------------            
            npts = (int)(datasize/(nt+1));
            makeWave();
            System.out.println("npts = " + npts);
            
            try{
                fp.seek(0);
                for(int i = 0; i<npts; i++){
                    X[i]  = convertEndian(fp.readDouble());
                    for(int j=0;j<nt;j++){
                        Y[j][i] = convertEndian(fp.readDouble());
                    }
                }
                fp.close();
            }catch (java.io.IOException e) {
                System.out.println("? I/O READ error ?");
                System.out.println(e);
                return;
            }
            findMinMax();
            drawAll();
        }
        
        public void  drawFake(){
            nt = 1;
            npts = 512;
            makeWave();
            double r = 5.0*Math.random();
            for(int i=0 ; i<npts; i++){
                X[i]  =  i;
                Y[0][i]  = 20.0 + 50.0 * Math.sin(r+0.05 * i);
            }            
            findMinMax();
            drawAll();
        }
        
        public void drawAll(){
            if(nt>0){
                IMin = 0;
                IMax = npts-1;
                rXMin = XMin;
                rXMax = XMax;
                rYMin = YMin;
                rYMax = YMax;
                repaint();
            }
        }
        
        public void setColor(int c){
            traceColor = c;
            repaint();
        }
        
        // =====================================================================
        //           Mouse 
        // =====================================================================
        
        public void mouseMoved(MouseEvent e) {
            pressedPoint = e.getPoint();
            repaint();
        }    
        
        public void mouseClicked(MouseEvent e) { 
        }
        public void mouseDragged(MouseEvent e) {
            px1 = e.getX();
            py1 = e.getY();
            lineDraw = true;        
            repaint();
        }
        public void mouseEntered(MouseEvent e) {  }
        public void mouseExited(MouseEvent e) {  }
        public void mousePressed(MouseEvent e) {
            px1 = oldx1 = oldx = e.getX();
            py1 = oldy1 = oldy = e.getY();
            if(javax.swing.SwingUtilities.isRightMouseButton(e)){
                rightButtonClicked = true;
                leftButtonClicked = false;
            } else if(javax.swing.SwingUtilities.isLeftMouseButton(e)){
                rightButtonClicked = false;
                leftButtonClicked = true;
            }
        }
        public void mouseReleased(MouseEvent e) {        
            
            if(leftButtonClicked){
                
                boolean inRange=false;
                int iXlow,iXup;
                double x0=getXScaleBack(Math.min(oldx,oldx1));
                double x1=getXScaleBack(Math.max(oldx,oldx1));
                
                iXup = IMin;
                iXlow = IMax;
                for(int i=IMin;i<IMax;i++){
                    if((X[i]>=x0)&&(X[i]<=x1)){
                        if(inRange){
                            if(i<iXlow){
                                iXlow = i;
                            }else if (i>iXup){
                                iXup=i;
                            }
                        }else{
                            iXlow = iXup = i;
                            inRange = true;
                        }
                    }
                }
                if(inRange){
                    IMin = iXlow;
                    IMax = iXup;
                    if(IMin==IMax){
                        IMin = (IMin>0) ? IMin-1:0;
                        IMax = (IMax<npts-1) ? IMax+1:npts-1;
                    }
                }
                
                
                rXMin = X[IMin];
                rXMax = X[IMax];
                if(rXMin > rXMax){
                    rXMin = X[IMax];
                    rXMax = X[IMin];
                }
                
                /*            xpStart = (int)( (getXScaleBack(Math.min(oldx,oldx1))-xOrigin)/xDelta);
                 if(xpStart<0) xpStart=0;
                 if(xpStart>npts) xpStart = npts -1;
                 
                 displayPoints = (int)( (getXScaleBack(Math.max(oldx,oldx1))-xOrigin)/xDelta);
                 if(displayPoints <=0 ) displayPoints = 1;	
                 if(displayPoints > npts ) displayPoints = npts;	
                 
                 displayPoints = displayPoints - xpStart + 1;
                 */
                //                System.out.println("rXMin = "+rXMin+", rXMax = "+rXMax);
                firstDraw = true;
                repaint();
                
            }
            if(rightButtonClicked){
                double y0=getYScaleBack(Math.max(oldy,oldy1));
                double y1=getYScaleBack(Math.min(oldy,oldy1));
                
                if(y0==y1){
                    return;
                }else if (y0<y1){
                    rYMin = y0;
                    rYMax = y1;
                }else{
                    rYMin = y1;
                    rYMax = y0;
                }
                firstDraw = true;
                repaint();
            }
            leftButtonClicked=false;
            rightButtonClicked=false;
        }
        // =====================================================================
        //                           Utilities 
        // =====================================================================
        
        
        static double convertEndian(double value)
        {
            ByteBuffer bb = ByteBuffer.allocate(8);
            bb.order(ByteOrder.LITTLE_ENDIAN);
            bb.putDouble(0, value);
            bb.order(ByteOrder.BIG_ENDIAN);
            return bb.getDouble(0);
        }
    }   // end of "class GraphPanel"




//******************************************************************
//******************************************************************
//                     M A I N    F R A M E
//******************************************************************
//******************************************************************

class GFrame extends javax.swing.JFrame {
    
    static graphPanel gPanel;
    JMenuBar jMenuBar1;
    JMenu fileMenu;
    JMenuItem openMenuItem;
    JMenuItem exitMenuItem;
    JMenu graphMenu;
    JMenuItem drawMenuItem;
    JMenuItem drawAllMenuItem;
    JMenu colorMenu;
    JMenuItem colorRedMenuItem;
    JMenuItem colorGreenMenuItem;
    JMenuItem colorBlackMenuItem;
    JMenuItem colorMultiMenuItem;
    
    public GFrame(String[] args) {
        jMenuBar1 = new JMenuBar();
        fileMenu = new JMenu("File");
        openMenuItem = new JMenuItem("Open");
        exitMenuItem = new JMenuItem("Exit");
        graphMenu = new JMenu("Graph");
        drawMenuItem = new JMenuItem("Draw Fake");
        drawAllMenuItem = new JMenuItem("Draw All");
        
        colorMenu = new JMenu("Color");
        colorRedMenuItem = new JMenuItem("Red");
        colorGreenMenuItem = new JMenuItem("Green");
        colorBlackMenuItem = new JMenuItem("Black");
        colorMultiMenuItem = new JMenuItem("Multi");

        
        fileMenu.add(openMenuItem);
        fileMenu.add(exitMenuItem);
        jMenuBar1.add(fileMenu);
        graphMenu.add(drawMenuItem);
        graphMenu.add(drawAllMenuItem);
        jMenuBar1.add(graphMenu);
        colorMenu.add(colorRedMenuItem);
        colorMenu.add(colorGreenMenuItem);
        colorMenu.add(colorBlackMenuItem);
        colorMenu.add(colorMultiMenuItem);
        jMenuBar1.add(colorMenu);
        
        
        
        openMenuItem.addActionListener(new ActionListener() {
                                       public void actionPerformed(ActionEvent e1) {gPanel.openFile(null);}});
        exitMenuItem.addActionListener(new ActionListener() {
                                       public void actionPerformed(ActionEvent e1) {System.exit(0);}});
        drawMenuItem.addActionListener(new ActionListener() {
                                       public void actionPerformed(ActionEvent e1) {gPanel.drawFake();}});
        drawAllMenuItem.addActionListener(new ActionListener() {
                                       public void actionPerformed(ActionEvent e1) {gPanel.drawAll();}});

        
        colorRedMenuItem.addActionListener(new ActionListener() {
                                          public void actionPerformed(ActionEvent e1) {gPanel.setColor(1);}});
        colorGreenMenuItem.addActionListener(new ActionListener() {
                                           public void actionPerformed(ActionEvent e1) {gPanel.setColor(2);}});
        colorBlackMenuItem.addActionListener(new ActionListener() {
                                           public void actionPerformed(ActionEvent e1) {gPanel.setColor(3);}});
        colorMultiMenuItem.addActionListener(new ActionListener() {
                                           public void actionPerformed(ActionEvent e1) {gPanel.setColor(0);}});

        
        setJMenuBar(jMenuBar1);
        
        gPanel = new graphPanel();
        gPanel.setBackground(new java.awt.Color(255, 255, 204));
        gPanel.setPreferredSize(new java.awt.Dimension(400, 300));
        getContentPane().add(gPanel, java.awt.BorderLayout.CENTER);
        pack();
        gPanel.openFile(args);
    }
    
    public void exitForm(java.awt.event.WindowEvent evt) {
        System.exit(0);
    }
    
}

public class gc {
    public static void main(String[] args) {
        GFrame gf = new GFrame(args);
        gf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        gf.setLocationRelativeTo(null);
        gf.setVisible(true);
    }
}