import java.awt.*;
import java.util.*;
import java.lang.*;
import java.text.*;

public class graphUtil{
    private static final double one=1.0e0;
    private static final int Itwo=2;
    private double clipFactor;
    private int Umin, Umax, Vmin, Vmax;
    private int UMIN, UMAX, VMIN, VMAX;
    private double V1[] = new double[20];

    graphUtil(){
        setClipFactor(0.9e0);
    }
    public int[] get2DWindowLimits(){
        int v[] = new int[4];
        v[0] = UMIN; v[1] = UMAX; v[2] = VMIN; v[3] = VMAX;
        return(v);
    }
    public void ViewportWindowBounds(int Mx, int My, double xleft, 
                              double ybottom, double xright, double ytop)
    { 
        int delta, deltaX, deltaY, Side, zero=0, two=2;
    
        delta = Math.abs(Mx - My);
        Side = Math.min(Mx, My);
        if(Mx > My){
	      deltaX = delta / two;
	      deltaY = zero;
        }else if(My > Mx){
	      deltaX = zero;
	      deltaY = delta / two ;
        }else{
	      deltaX = deltaY = zero;
        }
        UMIN = (int)(Side * xleft + deltaX); 
        UMAX = (int)(Mx - deltaX - xright  * Side);
        VMIN = (int)(Side * ytop  + deltaY); 
        VMAX = (int)(My - deltaY - ybottom * Side);
        return;
    }
    public void DrawFrame(Graphics g, boolean BiggerFrame) 
    {

        //Define slightly larger bounds for frame so that lines drawn
        //do not overlap it 
        if(BiggerFrame){
            Umin = UMIN - 2; Umax = UMAX + 2; 
            Vmin = VMIN - 2; Vmax = VMAX + 2;
            g.drawLine(Umin, Vmin, Umin, Vmax);
            g.drawLine(Umin, Vmax, Umax, Vmax);
            g.drawLine(Umax, Vmax, Umax, Vmin);
            g.drawLine(Umax, Vmin, Umin, Vmin);
            return;
        }else{
            g.drawLine(UMIN, VMIN, UMIN, VMAX);
            g.drawLine(UMIN, VMAX, UMAX, VMAX);
            g.drawLine(UMAX, VMAX, UMAX, VMIN);
            g.drawLine(UMAX, VMIN, UMIN, VMIN);
        }
        return;
    }
    //For a window delimited by diagonal corners (UMIN, VMIN)
    //and (UMAX, VMAX), set a clipping rectangle inside these
    //bounds.
    public void setClipRectangle(Graphics g)
    {    
        int deltax = UMAX - UMIN; int deltay = VMAX - VMIN;
        int Wclip = (int)(clipFactor*deltax);
        int Hclip = (int)(clipFactor*deltay);
        int shiftedX = (int)((one - clipFactor)*(double)deltax) / Itwo;
        int shiftedY = (int)((one - clipFactor)*(double)deltay) / Itwo;
        shiftedX += UMIN;
        shiftedY += VMIN;
        g.clipRect(shiftedX, shiftedY, Wclip, Hclip);
    }
    //Set the fraction of the window that will be visible. A factor
    //of 1 implies that everything inside the window will be visible.
    public void setClipFactor(double clipFactor)
    {
        this.clipFactor = clipFactor;
    }
//  Assuming that coordinate vectors "x" are arranged in rows,
//  but T is the transformation matrix for the "x" arranged in
//  columns, compute: X' = X.(T)T to output transformed "x'" in rows.
    public void TransformCoord2D(int n, double X[][], double T[][])
    {
        int i, j, k;
        double zero=0.0e0;

        for(i=0; i<n; i++){
            for(j=0; j<3; j++){
	          for(V1[j]=zero, k=0; k<3; k++){
		        V1[j] += T[j][k] * X[i][k];
	          }
	      }
            for(k=0; k<3; k++)X[i][k] = V1[k];
        }
        return;
    }
//  Compute x' = Tx
    public void TransformCoord2D(double X[], double T[][])
    {
        int i, j, k;
        double zero=0.0e0;

        for(j=0; j<3; j++){
	      for(V1[j]=zero, k=0; k<3; k++){
		    V1[j] += T[j][k] * X[k];
	      }
        }
	  for(k=0; k<3; k++)X[k] = V1[k];
        return;
    }
    public void TransformCoord3D(int n, double X[][], double T[][])
    {
        int i, j, k;
        double zero=0.0e0;

        for(i=0; i<n; i++){
            for(j=0; j<4; j++){
	          for(V1[j]=zero, k=0; k<4; k++){
		        V1[j] += T[j][k] * X[i][k];
	          }
	      }
            for(k=0; k<4; k++)X[i][k] = V1[k];
        }
        return;
    }
//  Compute x' = Tx
    public void TransformCoord3D(double X[], double T[][])
    {
        int i, j, k;
        double zero=0.0e0;

        for(j=0; j<4; j++){
	      for(V1[j]=zero, k=0; k<4; k++){
		    V1[j] += T[j][k] * X[k];
	      }
        }
	  for(k=0; k<4; k++)X[k] = V1[k];
        return;
    }
    public void Translate2D(double T[][], double x[], char c)
    {
        int i; double one=1.0e0;

        zero_mat(T, 3, 3);
        for(i=0; i<3; i++)T[i][i] = one;
        for(i=0; i<2; i++){
	      T[i][2] = x[i];
	      if(c == '-')T[i][2] = -T[i][2];
        }
        return;
    }
    public void Translate3D(double T[][], double x[], char c)
    {
        int i; double one=1.0e0;

        zero_mat(T, 4, 4);
        for(i=0; i<4; i++)T[i][i] = one;
        for(i=0; i<3; i++){
	      T[i][3] = x[i];
	      if(c == '-')T[i][3] = -T[i][3];
        }
        return;
    }
    public void Scale2D(double T[][], double Sx, double Sy)
    {
        int i; double one=1.0e0;

        zero_mat(T, 3, 3);
        T[0][0] = Sx; 
        T[1][1] = Sy;
        T[2][2] = one;
        return;
    }
    public void Scale3D(double T[][], double Sx, double Sy, double Sz)
    {
        int i; double one=1.0e0;

        zero_mat(T, 4, 4);
        T[0][0] = Sx; 
        T[1][1] = Sy;
        T[2][2] = Sz;
        T[3][3] = one;
        return;
    }
    public void ShearXY(double T[][], double Shx, double Shy)
    {
        int i; double one=1.0e0;

        zero_mat(T, 4, 4);
        for(i=0; i<4; i++)T[i][i] = one;
        T[0][2] = Shx;
        T[1][2] = Shy;
        return;
    }
/*
    public void UserVrc(double T[][], double vpn[], double vup[])
    {
        int i;
        double delta=1.0e-06, one=1.0e0, fact, Rx[3], Ry[3], Rz[3];

      //The identity transformation corresponds to: 
      //vpn = (0, 0, 1), vup = (0, 1, 0). On the other hand, 
      //vup = (0, 0, 1), vpn = (0, 1, 0) yields:  T= | -1   0   0 |
	//					 |  0   0   1 |
	//					 |  0   1   0 |  
        fact = norm(vpn);
        for(i=0; i<3; i++)Rz[i] = vpn[i] * fact;
        produit_vectoriel(vup, Rz, Rx);
        if(Math.abs(Rx[0]) < delta && Math.abs(Rx[1]) < delta &&
            Math.abs(Rx[2]) < delta){
            closegraph(); 
	      fprintf(stdout,"VUP and VPN colinear - EXIT -\n");
	      exit(1);
        }
        fact = norm(Rx);
        for(i=0; i<3; i++)Rx[i] *= fact;
        produit_vectoriel(Rz, Rx, Ry);
        zero_mat(T, 4, 4);
        for(i=0; i<3; i++)T[0][i] = Rx[i];
        for(i=0; i<3; i++)T[1][i] = Ry[i];
        for(i=0; i<3; i++)T[2][i] = Rz[i];
        T[3][3] = one;
        return;
    }
    public void Rotate(double T[][], double lon, double lat)
    { 
        int i, j;
        double zero=0.0e0, one=1.0e0, sin_lon, cos_lon, sin_lat, cos_lat;

  //The transformation below implies that unit vector n (of VPN) is equated 
  //to the viewing direction; 
  //    n = Rz = ( cos(lon)cos(lat), sin(lon)cos(lat), sin(lat) );
  //    Unit vector u : Rx = (VUP^Rz)
  //                         --------  with VUP = (0, 0, 1) (or z axis);
  //                         |VUP^Rz| 
  //    Unit vector v : Ry = Rz ^ Rx 
        zero_mat(T, 4, 4);
        sin_lon = sin(degres_radians(lon));
        cos_lon = cos(degres_radians(lon));
        sin_lat = sin(degres_radians(lat));
        cos_lat = cos(degres_radians(lat));
        T[0][0] = -sin_lon;         T[0][1] =  cos_lon;         
        T[0][2] = zero;
        T[1][0] = -cos_lon*sin_lat; T[1][1] = -sin_lon*sin_lat; 
        T[1][2] = cos_lat;
        T[2][0] =  cos_lon*cos_lat; T[2][1] =  sin_lon*cos_lat;
        T[2][2] = sin_lat;
        T[3][3] =  one; 
        return;
    }
*/
    public void transpose(double a[][], int n)
    {
        int i, j; double temp;
    
        for(i=0; i<n; i++){
	      for(j=0; j<=i; j++){
	          temp = a[i][j];
	          a[i][j] = a[j][i];
	          a[j][i] = temp;
	      }
        }
        return;
    }
    public void zero_mat(double A[][], int n, int m)
    {
        int i, j; double zero=0.0e0;

        for(i=0; i<n; i++){
	      for(j=0; j<m; j++){
	          A[i][j] = zero;
	      }
        }
        return;
    }
}