import java.applet.*;
import java.awt.*;
import java.io.*;
import java.net.URL;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.Hashtable;

public class ZbufSurf extends Applet{
	Dimension appsize;
	Panel p1 = new Panel();
	Panel p2 = new Panel();
	Panel p3 = new Panel();
	Panel p4 = new Panel();
	String datafile;
	TextField t1, t2, t3, t4;
	Label l1, l2, l3, l4, l5,l6;
	Button b1, b2, b3;
	Choice c = new Choice();
	ZbufCanvas zCanvas;
	BezierApplet3 Bezier;
	double scale = 30;
	CheckboxGroup chkgrp;
	int bezdat;
	int jnum;

	public void init() {
		setBackground(Color.black);
		setForeground(Color.red);
		setLayout(new BorderLayout(0,0));
		appsize = size();
		
		//p1に項目の追加
		p1.setBackground(new Color(40,40,125));
		p1.setForeground(Color.white);		//jie.color
		p1.add(l3 = new Label("R:"));
		p1.add(t3 = new TextField("500",3));
		p1.add(l1 = new Label("Theta:"));
		p1.add(t1 = new TextField("20",3));
		p1.add(l2 = new Label("Phi:"));
		p1.add(t2 = new TextField("30",3));
		
		//cに項目の追加
		c.addItem("Squear");
		c.addItem("BezCurve");
		c.addItem("Monitor");
		c.addItem("3D_N");
		c.addItem("Bezball");
		c.addItem("Bezball2");
		c.addItem("Teapot");
		c.addItem("Edit");

        //p2に項目の追加
		p2.setBackground(new Color(40,40,120));
		p2.setForeground(Color.red);
		p2.add(l4 = new Label("Data:"));
		p2.add(c);
		p2.add(b2 = new Button("Read"));
		p2.add(b1 = new Button("ReDraw"));
		p2.add(b3 = new Button("Bezi"));

        //c2に項目の追加
		chkgrp = new CheckboxGroup();
		Checkbox chk1 = new Checkbox("Shading",chkgrp,true);
		Checkbox chk2 = new Checkbox("Drawing",chkgrp,false);
		
		//p3に項目の追加
		p3.setBackground(new Color(50,30,120)); //nis12
		p3.setForeground(Color.white);//jie.color
		p3.add(l6 = new Label("Mode:"));
		p3.add(chk1);
		p3.add(chk2);
		p3.add(l5 = new Label("Scale:"));
		t4 = new TextField("30", 2 );
		p3.add(t4);
		
		//p4に項目の追加
		p4.setLayout(new BorderLayout());
		p4.resize(300,100);
		p4.add("North",p2);
		p4.add("South",p3);
		
		Dimension s = new Dimension(300, 210); //nis
		zCanvas = new ZbufCanvas();
		Bezier = new BezierApplet3();//jie
		zCanvas.setSize(s);
		zCanvas.setViewpoint(500,20,30); //nis
		zCanvas.setLightSource(30,60);
		Image buff=createImage(s.width, s.height);
		Graphics g1 = buff.getGraphics();
		zCanvas.setImageBuffer(buff, g1);

        add("North", p1);
		add("Center",zCanvas);
		add("South", p4);
		resize(appsize);
		datafile = "rei61.pol";
		datafile = "Ncharc.pol";
		double ltheta = 30; double lphi = 60;
        scale =30;
		String str;
		if (( str = getParameter("scene")) != null) {
            datafile  = getParameter(str); 
			datafile  =  str;
			System.out.println("DataFile:"+datafile);
		}
		if ((str = getParameter("ltheta"))!= null) {
            ltheta = Double.valueOf(str).doubleValue();
		} 
		if ((str = getParameter("lphi")) != null) {
            lphi = Double.valueOf(str).doubleValue();
		} 
		if ((str = getParameter("Bez")) != null) {
            bezdat = (int)Double.valueOf(str).doubleValue();
		} 
        zCanvas.setLightSource(ltheta,lphi);
        t4.setText(""+scale);
		if(bezdat==0)  polygon_read();
		else Bez_read(bezdat);
	}
	
	public void paint(Graphics g) {
	}

     /**
     * 選択されたデータを読む
     */
     public boolean action(Event evt, Object obj) {
		 if (evt.target == b1) { //redraw
			 double theta = Integer.parseInt(t1.getText());
			 double phi = Integer.parseInt(t2.getText());
			 double R = Integer.parseInt(t3.getText());
			 double scaleTMP = Integer.parseInt(t4.getText());
			 if((int)scale != (int)scaleTMP) {
				 scale = scaleTMP;
				 if(bezdat==0)  polygon_read();
				 else Bez_read(bezdat);
			 }
			 zCanvas.setViewpoint(R,theta,phi);
			 zCanvas.repaint();
			 return true;
		 } else if(evt.target instanceof Checkbox) {
			 Checkbox chk = (Checkbox)(evt.target);
			 if(chk.getLabel().equals("Shading")) {
				 zCanvas.setShadeMode();
				 zCanvas.repaint();
			 } else if(chk.getLabel().equals("Drawing")) {
				 zCanvas.setLineMode();
				 zCanvas.repaint();
			 }
		 } else if (evt.target == b2) {
			 bezdat=0;
			 switch(c.getSelectedIndex()) {
			 case 0 :
				 datafile = "Ncharc.pol";
				 scale = 30;
				 t4.setText(""+scale);
				 break;
			 case 1 :
				 datafile = "curve.dat";
				 t4.setText(""+scale);
				 scale = 20;
				 bezdat =9;
				 break;
			 case 2 :
				 datafile = "Ncharc3.pol";
				 scale = 15;
				 t4.setText(""+scale);
				 break;
			 case 3 :
				 datafile = "Ncharctrue.pol";
				 scale = 30;
				 t4.setText(""+scale);
				 break;
			 case 4 :
				 datafile = "kyuu.dat";
				 scale = 70;
				 t4.setText(""+scale);
				 bezdat =6;
				 break;
			 case 5 :
				 datafile = "kyuu2.dat";
				 scale = 60;
				 t4.setText(""+scale);
				 bezdat =6;
				 break;
			 case 6 :
				 datafile = "tpot1.dat";
				 scale = 25;
				 t4.setText(""+scale);
				 bezdat =5;
				 break;
			 case 7:
				 Bezier.BezierApplet4();
				 break;
			 }
			 
			 if(bezdat==0)  polygon_read();
			 else Bez_read(bezdat);
			 zCanvas.repaint();
			 return true;
		 }else if (evt.target == b3) {
			 bez_read2();
			 zCanvas.repaint();
			 return true;
		 }
		 else return super.action(evt, obj);
		 return false;
	 }
	 
	 public void bez_read2(){         //jie
		 int i, j, k;
		 double x,y,z;
		 int ndiv=4;
		 int nsurf=Bezier.bcum*4;//1;
		 int nface=0;
		 int surf_deg[]=new int[Bezier.bcum*4];
		 Surface surfdata[];
		 surfdata=new Surface[Bezier.bcum*4];
		 surf_deg[0]=4;
		 
		 for(i=0;i<(Bezier.bcum*4);i++){
			 surfdata[i] = new Surface();
			 surf_deg[i]=4;
			 for(j=0;j<4;j++){
				 for(k=0;k<4;k++){
					 x=Bezier.sdata[i][4*j+k][0]*100;
					 y=Bezier.sdata[i][4*j+k][1]*100;
					 z=Bezier.sdata[i][4*j+k][2]*100;
					 surfdata[i].p[j][k] = new Point3(x,y,z);
				 }
			 }
		 }
		 nface = Bez2pol(ndiv,nsurf, surf_deg, surfdata);
		 showStatus("No. of BezierPatches ="+ nsurf+ " faces="+nface);
	 }
	 
	 public void polygon_read() {
		 int nv, nf=0;
		 try {
			 InputStream is = new URL(getDocumentBase(), datafile).openStream();
			 DataInputStream dis = new DataInputStream(is);
			 StringTokenizer st;
			 double x, y, z;
			 Vector vec;
			 String comment;
			 st = new StringTokenizer(dis.readLine());
			 int nobjects = Integer.parseInt(st.nextToken());
			 zCanvas.setNumObject(nobjects);
			 comment = st.nextToken();
			 for(int k=0; k<nobjects; k++) {
				 st = new StringTokenizer(dis.readLine());
				 nv = Integer.parseInt(st.nextToken());
				 nf = Integer.parseInt(st.nextToken());
				 double r=Double.valueOf(st.nextToken()).doubleValue();
				 double g=Double.valueOf(st.nextToken()).doubleValue();
				 double b=Double.valueOf(st.nextToken()).doubleValue();
				 comment = st.nextToken();
				 zCanvas.object[k].SetUpObject(nv, nf, r, g, b);
				 for (int i = 0; i < nv; i++) {
					 st = new StringTokenizer(dis.readLine());
					 x = scale*Double.valueOf(st.nextToken()).doubleValue();
					 y = scale*Double.valueOf(st.nextToken()).doubleValue();
					 z = scale*Double.valueOf(st.nextToken()).doubleValue();
					 zCanvas.object[k].AddPoint(x,y,z);
				 }
				 for(int j=0; j<nf; j++) { 
					 st = new StringTokenizer(dis.readLine());
					 vec = new Vector();
					 while (st.hasMoreTokens()) {
						 int num = Integer.valueOf(st.nextToken(),10).intValue() - 1;
						 if(num >= 0)
							 vec.addElement(new Integer(num));
					 }
					 zCanvas.object[k].AddPlane(vec);
				 }
			 }
			 is.close();
			 showStatus("ReadEnd; No. of polygons ="+ nf);
		 }
		 catch (IOException e) {
			 System.err.println("Can't access datafile " + datafile);
		 }
	 }
	 
	 public void Bez_read(int ndiv) {
		 int nsurf=0;
		 int surf_deg[];
		 Surface surfdata[];
		 showStatus("Read Data-file Start! data_file="+datafile);
		 int nface =0;
		 try {
			 InputStream is = new URL(getDocumentBase(), datafile).openStream();
			 DataInputStream dis = new DataInputStream(is);
			 StringTokenizer st;
			 double x, y, z;
			 st = new StringTokenizer(dis.readLine());
			 nsurf = Integer.parseInt(st.nextToken());
			 showStatus("ReadStart; No. of BezierPatches ="+ nsurf);
			 surfdata = new Surface[nsurf];
			 surf_deg = new int[nsurf];
			 dis.readLine();
			 for (int i = 0; i < nsurf; i++) {
				 dis.readLine();
				 st = new StringTokenizer(dis.readLine());
				 st.nextToken();
				 surf_deg[i] = Integer.parseInt(st.nextToken());
				 surfdata[i] = new Surface();
				 for(int j = 0; j < surf_deg[i] ;j++){
					 for(int k = 0; k < surf_deg[i]; k++){
						 st = new StringTokenizer(dis.readLine());
						 x = Double.valueOf(st.nextToken()).doubleValue()*scale;
						 y = Double.valueOf(st.nextToken()).doubleValue()*scale;
						 z = Double.valueOf(st.nextToken()).doubleValue()*scale;
						 surfdata[i].p[j][k] = new Point3(x,y,z);
					 }
				 }
			 } // end nsurf
			 is.close();
			 nface = Bez2pol(ndiv,nsurf, surf_deg, surfdata);
		 }
		 catch (IOException e) {
			 System.err.println("Can't access datafile " + datafile);
		 }
		 showStatus("No. of BezierPatches ="+ nsurf+ " faces="+nface);
	 }
	 
	 public int Bez2pol(int mdiv,int nsurf, int surf_deg[],Surface surfdata[]) {
		 Point3 plt[][];
		 double u;
		 Point3[] pnt1 = new Point3[11];
		 Point3[] pnt = new Point3[11];
		 Vector vec;
		 int nv, nf ,k,l,m,ndiv,nface;
		 int[] face = new int[5];
		 
		 plt = new Point3[11][11];
		 zCanvas.setNumObject(nsurf);
		 System.err.println("nsurf="+nsurf);
		 nface =0; nf = 0;
		 for(int i_surf=0;i_surf<nsurf;i_surf++){
			 int ndeg = surf_deg[i_surf];
			 if(ndeg<3) {
				 ndiv=2;
				 zCanvas.object[i_surf].SetUpObject(8, 1, 0.8, .8, 1.);
			 }
			 else {
				 ndiv = mdiv;
				 nf = (ndiv-1)*(ndiv-1); nv =(ndiv)*(ndiv);
				 zCanvas.object[i_surf].SetUpObject(nv, nf, 1.0, 1., 0.);
			 }
			 nf = 0; nv =0;
			 for( k=0;k<ndiv; k++) {
				 u = (double)k/(double)(ndiv-1);
				 for(int i=0;i<ndeg;i++){
					 for(int j=0;j<ndeg;j++){
						 pnt1[j] = new Point3(surfdata[i_surf].p[i][j].x,
							 surfdata[i_surf].p[i][j].y,surfdata[i_surf].p[i][j].z);
					 }
					 pnt[i]= castljau(u,ndeg-1,pnt1);
				 }
				 for( l=0;l<ndiv; l++) {
					 u = (double)l/(double)(ndiv-1);
					 plt[k][l]= castljau(u,ndeg-1,pnt);
					 zCanvas.object[i_surf].AddPoint(plt[k][l].x,
						 plt[k][l].y,plt[k][l].z);
					 nv++;
				 }
			 }
			 for( k=0;k<ndiv-1; k++) {
				 int kk= k*ndiv;
				 for( l=0;l<ndiv-1; l++) {
					 vec = new Vector();
					 int ll = l+kk;
					 face[0]=ll; face[1]=ll+1;
					 face[2]=ll+1+ndiv; face[3]= ll+ndiv;
					 face[4]=face[0];
					 for( m=0; m < 4; m++) {
						 double dx = zCanvas.object[i_surf].point[face[m]].x-zCanvas.object[i_surf].point[face[m+1]].x;
						 double dy = zCanvas.object[i_surf].point[face[m]].y-zCanvas.object[i_surf].point[face[m+1]].y;
						 double dz = zCanvas.object[i_surf].point[face[m]].z-zCanvas.object[i_surf].point[face[m+1]].z;
						 double dist = (dx*dx +dy*dy+dz*dz);
						 if(dist > 0.2)  vec.addElement(new Integer(face[m]));
					 }
					 zCanvas.object[i_surf].AddPlane(vec);
					 nface++;
				 }
			 }
		 } // end of i_surf
         System.err.println("No. of BezierPatches ="+ nsurf+ " faces="+nface);
         return nface;
	 }
	 
	 /* ----------------------------------*/
	 public Point3 castljau(double u, int ndeg, Point3 cpnt[]){
		 double[] wx = new double[10];
		 double[] wy = new double[10];
		 double[] wz = new double[10];
		 
		 for (int i=0; i <=ndeg; i++){
			 wx[i] = cpnt[i].x;
			 wy[i] = cpnt[i].y;
			 wz[i] = cpnt[i].z;
		 }
		 for (int m=1; m <= ndeg; m++) {
			 for (int j=0; j <= ndeg - m; j++){
				 wx[j] += (wx[j+1]-wx[j])*u ;
				 wy[j] += (wy[j+1]-wy[j])*u ;
				 wz[j] += (wz[j+1]-wz[j])*u ;
			 }
		 }
		 return new Point3(wx[0],wy[0],wz[0]);    
	 }
} // end of class

class ZbufCanvas extends Canvas implements Runnable{
	Dimension appsize;
	Image gs;
	Graphics gr;
	Obj    object[];
	int    nobjects;
	Point3 ptViewRef = new Point3(0, 0, 0);   // view reference point
	double theta, phi, R, cos_theta, cos_phi, sin_theta, sin_phi;
	double ltheta, lphi, amb = 0.42; //nis
	
	Hashtable ht;
	Point prev = new Point(150,185);
	
	Polygon poly;
    int     depth[];
	EdgeTable et;
	Point3 light_vect = new Point3();
	Zbuffer zbuf;  //z-buffer
	//nis
	Point origin;
	int   linedraw = 0;
	int   drag = 0;
	public Thread kick = null;//double buffer
    
	public ZbufCanvas() {}
	
/*	public void paint(Graphics g) {
		computePlane();
		render();
		g.drawImage(gs, 0, 0, this);
	}
*/
	 public void paint(Graphics g) {
		 update(g);
	 }
	 
	 public void update(Graphics g) {
		 computePlane();
		 render();
		 g.drawImage(gs, 0, 0, this);
	 }

	public void setImageBuffer(Image b, Graphics g) {
		gs = b;
		gr = g;
	}
	
	public void setSize(Dimension s) {
		appsize = s;
		origin = new Point(appsize.width/2, appsize.height/2+5);//nis
		zbuf = new Zbuffer(appsize);
		zbuf.clearBuffer();
		resize(appsize);
	}
	
	public void setNumObject(int n) {
		nobjects = n;
		object = new Obj[nobjects];
		for(int i=0; i<nobjects; i++) object[i] = new Obj();
	}
	
	public void setLightSource(double th, double ph) {
		ltheta = th; lphi = ph;
		lightdata_init();
	}
	
	public void setViewpoint(double r, double th, double ph) {
		R=r;
		theta = th;
		phi = ph;
	}
	
	public void setShadeMode() { linedraw = 0;}
	
	public void setLineMode() { linedraw = 1;}
	
	public boolean mouseDown(Event ev, int x, int y) {
		prev = new Point(x,y);
		return true;
	}
	
	public boolean mouseDrag(Event ev, int x, int y) {
		if(linedraw==1 || drag == 1){
			theta -= (x-prev.x);
			phi += (y-prev.y);
			repaint();
			prev.move(x, y);
		} else {
			theta -= (x-prev.x);
			phi += (y-prev.y);
			drag = 1;
			repaint();
		}
		return true;
	}
	
	public boolean mouseUp(Event ev, int x, int y) {
		if(drag == 1) {
			drag = 0;
			repaint();
		}
		return true;
	}

    /**
     * Draw visible planes without redandunce.
     */
	public void render() {
		ht = new Hashtable();
		RGB color = new RGB();
		int red, grn, blu;
		Point3 co = new Point3();//, norm_vect = new Point3();
		ATT attrib = new ATT();
		
		if(linedraw == 0 && drag == 0) {
			zbuf.clearBuffer();
		}
		gr.setColor(Color.darkGray); //nis
		gr.fillRect(0,0,appsize.width,appsize.height);
		attrib.spc.r = 0.9; attrib.spc.g = 0.9; attrib.spc.b = 0.9;
		attrib.power = 55;
		for(int k=0; k<nobjects; k++) {
			for (int i = 0; i < object[k].nplanes; i++) {
				poly = new Polygon();
				if (object[k].plane[i].visible) {
					depth = new int[object[k].plane[i].npoints+1]; //DOBA
					co.x = 0; co.y = 0; co.z = 0;
					for (int j = 0; j < object[k].plane[i].npoints; j++) {
						int index1 = object[k].plane[i].set[j];
						poly.addPoint((int)object[k].tPoint[index1].x + origin.x,
							origin.y - (int)object[k].tPoint[index1].y);
						depth[j] = (int)(R - object[k].tPoint[index1].z);
						co.x += object[k].point[index1].x;
						co.y += object[k].point[index1].y;
						co.z += object[k].point[index1].z;
					}
					if(linedraw == 0 && drag == 0) {
						co.x /= object[k].plane[i].npoints;
						co.y /= object[k].plane[i].npoints;
						co.z /= object[k].plane[i].npoints;
						
						// シェーディングにより色を得る
						attrib.dif.r = object[k].col.r;
						attrib.dif.g = object[k].col.g;
						attrib.dif.b = object[k].col.b;
						attrib.amb.r = attrib.dif.r * amb;
						attrib.amb.g = attrib.dif.g * amb;
						attrib.amb.b = attrib.dif.b * amb;
						color = shading(co, object[k].plane[i].norm_vect, attrib);
						red = (int)(color.r * 255);
						grn = (int)(color.g * 255);
						blu = (int)(color.b * 255);
						gr.setColor(new Color( red, grn, blu));
						poly.addPoint(poly.xpoints[0], poly.ypoints[0]);
						depth[object[k].plane[i].npoints] = depth[0];
						et = new EdgeTable(poly, depth, zbuf);
						et.paint(gr);
					} else {
						gr.setColor(Color.white);		//jie.color
						for(int j=0; j<object[k].plane[i].npoints; j++) {
							int jj = j+1;
							if(j == object[k].plane[i].npoints-1) jj=0;
							gr.drawLine(poly.xpoints[j],poly.ypoints[j],
								poly.xpoints[jj],poly.ypoints[jj]);
						}
					}
				}
				poly = null;  //nis
				et = null;
			} // loop for polygon
		}  // loop for object
		gr.setColor(Color.blue);
		gr.drawString("theta = " + theta, 95,12); 
		gr.drawString("phi = " + phi, 185, 12); 
		gr.drawString("R  = " + R, 29, 12);
		gr.drawString("Light: theta = " + ltheta, 29, 25); 
		gr.drawString("phi= " + lphi, 120, 25); 
	}
	
	public void run (){
		repaint();
	} 
	
	public void start() {
		if(kick == null){
			kick = new Thread(this);
		}
		kick.start();
	}
	
    /**
     * Compute perspective transformation and plane visibility.
     */
	void computePlane() {
		//nis
		double pi2rad = Math.PI/180.;
		cos_theta = Math.cos(theta*pi2rad);
		sin_theta = Math.sin(theta*pi2rad);
		cos_phi = Math.cos(phi*pi2rad);
		sin_phi = Math.sin(phi*pi2rad);
		for(int k=0; k<nobjects; k++) {
			for (int i = 0; i < object[k].npoints; i++) {
				object[k].tPoint[i] = tranfrm(object[k].point[i]);
			}
			for (int i = 0; i < object[k].nplanes; i++) {
				object[k].plane[i].setFront_or_Back(object[k].tPoint);
			}
		}
	}

    /**
     * Transforms world coordinate-system to viewpoint coordinate-system.
     */
	Point3 tranfrm(Point3 point) {
		Point3 point1 = new Point3();
		Point3 point2 = new Point3();
		Point3 point3 = new Point3();
		double temp;
		point1.x = point.x - ptViewRef.x;
		point1.y = point.y - ptViewRef.y;
		point1.z = point.z - ptViewRef.z;
		temp = point1.x*cos_theta + point1.y*sin_theta;
		point2.x = -point1.x*sin_theta + point1.y*cos_theta;
		point2.y = -temp*sin_phi + point1.z*cos_phi;
		point3.z = temp*cos_phi + point1.z*sin_phi;
		double dd=R/(R - point3.z);
		point3.x = point2.x * dd;
		point3.y = point2.y * dd;
		return point3;
	}

    /**
     * A line is drawn only once.
     * @return true if the line hasn't drawn yet.
     */
     boolean ctrlDrawn(int index1, int index2) {
		 Integer integer;
		 if (index1 < index2) {
			 integer = new Integer(index2*object[0].npoints+index1);
		 } else {
			 integer = new Integer(index1*object[0].npoints+index2);
		 }
		 Boolean bool = (Boolean)ht.get(integer);
		 if (bool == null) {
			 ht.put(integer, Boolean.TRUE);
			 return true;
		 } else {
			 return false;
		 }
	 }

     /**
     *　シェーディングによりカレントピクセルにおける色(RGB)を得る
     */
	 RGB shading(Point3 co, Point3 nv, ATT att){
		 int i;
		 double bright1, bright2;
		 RGB shading_color = new RGB();
		 RGB diffuse = new RGB();
		 RGB specular = new RGB();
		 diffuse.r = 0; diffuse.g = 0; diffuse.b = 0;
		 specular.r = 0; specular.g = 0; specular.b = 0;
		 
		 // ディフューズの輝度を関数lambertから得る
		 bright1 = lambert(nv)*0.7;      //nis
		 diffuse.r = att.dif.r * bright1;
		 diffuse.g = att.dif.g * bright1;
		 diffuse.b = att.dif.b * bright1;
		 shading_color.r  = diffuse.r + att.amb.r;
		 shading_color.g  = diffuse.g + att.amb.g;
		 shading_color.b  = diffuse.b + att.amb.b;
		 
		 // スペキュラーの輝度を関数phongから得る

/*
         bright2 = phong(co, nv, att);
		 
		   specular.r = att.spc.r * bright2;
		   specular.g = att.spc.g * bright2;
		   specular.b = att.spc.b * bright2;
		   
			 // ディフューズ+スペキュラーの色
			 shading_color.r = diffuse.r + specular.r;
			 shading_color.g = diffuse.g + specular.g;
			 shading_color.b = diffuse.b + specular.b;
*/
		 if(shading_color.r > 1.0) shading_color.r = 1.0;
		 if(shading_color.g > 1.0) shading_color.g = 1.0;
		 if(shading_color.b > 1.0) shading_color.b = 1.0;
		 
		 return(shading_color); 
	 }

     /**
     *　ディフューズの輝度を得る
     */
     double lambert(Point3 nv){
		 double bright;
		 bright = nv.x * light_vect.x + nv.y * light_vect.y + nv.z * light_vect.z;
		 if(bright < 0)
			 bright = 0;
		 return(bright);
	 }

     /**
     *　スペキュラーの輝度を得る（フォンモデル）                       
     */
     double phong(Point3 co, Point3 nv, ATT att){
		 Point3  v_vect = new Point3();
		 Point3  l_vect = new Point3();
		 double vsize, l_n_cos, bright;
		 vsize = Math.sqrt(co.x * co.x + co.y * co.y + co.z * co.z);
		 v_vect.x = co.x / vsize;
		 v_vect.y = co.y / vsize;
		 v_vect.z = co.z / vsize;
		 
		 l_n_cos = light_vect.x * nv.x + light_vect.y * nv.y + light_vect.z * nv.z;
		 l_vect.x = 2 * l_n_cos * nv.x - light_vect.x;
		 l_vect.y = 2 * l_n_cos * nv.y - light_vect.y;
		 l_vect.z = 2 * l_n_cos * nv.z - light_vect.z;
		 bright = -(v_vect.x * l_vect.x + v_vect.y * l_vect.y + v_vect.z * l_vect.z);
		 if(bright < 0)
			 bright = 0;
		 else
			 bright = Math.pow(bright, att.power);
		 
		 return(bright);
	 }

     /**
     * 光源を極座標からワールド座標系に変換
     */
	 void lightdata_init() {
		 light_vect.x = -Math.cos(lphi*Math.PI/180) * Math.cos(ltheta*Math.PI/180);
		 light_vect.y = -Math.cos(lphi*Math.PI/180) * Math.sin(ltheta*Math.PI/180);
		 light_vect.z = -Math.sin(lphi*Math.PI/180);
	 }
}//End of class

class Obj {
    int     nplanes;
    int     npoints;
    Point3  point[], tPoint[];
    Plane   plane[];
    RGB   col;

    public Obj() { 
        nplanes = npoints = 0;
        col = new RGB();
    }

    public void SetUpObject(int nv, int np, double r, double g, double b) {
        nplanes = npoints = 0;
        col = new RGB(r,g,b);
        point = new Point3[nv];
        tPoint = new Point3[nv];
        plane = new Plane[np];
    }

    public void AddPoint(double x, double y, double z) {
        point[npoints] = new Point3(x,y,z);
        tPoint[npoints] = new Point3(x,y,z);
        npoints++;
    }

    public void AddPlane(Vector v) {
        plane[nplanes] = new Plane(v);
        int top_point0 = plane[nplanes].set[0];
        int top_point1 = plane[nplanes].set[1];
        int top_point2 = plane[nplanes].set[2];
        double nsize,xn,yn,zn;

        xn = (point[top_point1].y-point[top_point0].y)*(point[top_point2].z-point[top_point1].z) -
                      (point[top_point1].z-point[top_point0].z)*(point[top_point2].y-point[top_point1].y);
        yn = (point[top_point1].z-point[top_point0].z)*(point[top_point2].x-point[top_point1].x) -
                      (point[top_point1].x-point[top_point0].x)*(point[top_point2].z-point[top_point1].z);
        zn = (point[top_point1].x-point[top_point0].x)*(point[top_point2].y-point[top_point1].y) -
                      (point[top_point1].y-point[top_point0].y)*(point[top_point2].x-point[top_point1].x);
        nsize = Math.sqrt(xn * xn + yn * yn + zn * zn);
        if(nsize<0.001) {
                 System.out.println("Err nsize:"+nsize);
        }
        else {
        xn /= nsize;
        yn /= nsize;
        zn /= nsize;}

        plane[nplanes].norm_vect.x=xn;
        plane[nplanes].norm_vect.y=yn;
        plane[nplanes].norm_vect.z=zn;

        nplanes++;
    }
    public void MoveObject(double dx, double dy, double dz) {
        for(int i=0; i<npoints; i++) {
            tPoint[i].x = point[i].x += dx;
            tPoint[i].y = point[i].y += dy;
            tPoint[i].z = point[i].z += dz;
        }
    }

    public void ScaleObject(double cx, double cy, double cz
                           ,double sx, double sy, double sz) {
        for(int i=0; i<npoints; i++) {
            tPoint[i].x = point[i].x = (point[i].x - cx) * sx + cx;
            tPoint[i].y = point[i].y = (point[i].y - cy) * sy + cy;
            tPoint[i].z = point[i].z = (point[i].z - cz) * sz + cz;
        }
    }

    public void ZRevolveObject(double cx, double cy, double cz, double the) {
        double ct = Math.cos(the);
        double st = Math.sin(the);
        for(int i=0; i<npoints; i++) {
            double x = (point[i].x - cx) * ct - (point[i].y - cy) * st;
            double y = (point[i].x - cx) * st + (point[i].y - cy) * ct;
            tPoint[i].x = point[i].x = x + cx;
            tPoint[i].y = point[i].y = y + cy;
        }
    }
}

/**
 * Plane class of a polygon
 */
class Plane {
	public int set[];
	public int npoints;
	public boolean visible;
	public Point3 norm_vect;
	
	Plane(Vector vec) {
		npoints = vec.size();
		set = new int[npoints];
		norm_vect = new Point3();
		for (int i = 0; i < npoints; i++) {
			set[i] = ((Integer)vec.elementAt(i)).intValue();
		}
	}

    /**
    * Set true to visible flag if front face.
    */
	public void setFront_or_Back(Point3 point[]) {
		double det = point[set[2]].x*(point[set[1]].y-point[set[0]].y)+
			point[set[0]].x*(point[set[2]].y-point[set[1]].y)+
			point[set[1]].x*(point[set[0]].y-point[set[2]].y);
		if (det >= 3.5) {    //nis
			visible = true;
		} else {
			visible = false;
		}
	}
}

/**
   Z-Buffer Class
**/
class Zbuffer {

    Dimension size;
    int buffer[];
    double far;

    public Zbuffer(Dimension s) {
        size = s; far = 5000.;
        buffer = new int[size.width * size.height];
    }

    public void clearBuffer() {
        for(int i=0; i<size.width*size.height; i++) 
            buffer[i] = Integer.MAX_VALUE;
    }

    public boolean checkDepth(int ix, int iy, double z) {

        if(size.height > iy && size.width > ix &&
           iy > -1 && ix > -1) {

            int index = iy*size.width+ix;
            double zz=Integer.MAX_VALUE*(z/far);
            int iz = (int)(Integer.MAX_VALUE*(z/far));

            if(iz < buffer[index]) {
                buffer[index] = iz;
                return true;
            }
        }
        return false;
    }
}

/**
 * Edge table for y-sort.
 */
class EdgeTable {
	public int xmin[], ymin[], ymax[],zmin[];
	double invM[];
	double gradZ[];
	Zbuffer zbuf;
	public int nsize = 0;
	
	static final int MIN = 0;
	static final int MID = 1;
	static final int MAX = 2;
	
	EdgeTable(Polygon poly, int depth[], Zbuffer zb) {
		xmin = new int[poly.npoints-1];
		ymin = new int[poly.npoints-1];
		ymax = new int[poly.npoints-1];
		zmin = new int[poly.npoints-1];
		invM = new double[poly.npoints-1];
		gradZ = new double[poly.npoints-1];
		zbuf = zb;
		for (int i = 0; i < poly.npoints-1; i++) {
			if (poly.ypoints[i] < poly.ypoints[i+1]) {
				xmin[nsize] = poly.xpoints[i];
				ymin[nsize] = poly.ypoints[i];
				ymax[nsize] = poly.ypoints[i+1];
				zmin[nsize] = depth[i];
			} else {
				xmin[nsize] = poly.xpoints[i+1];
				ymin[nsize] = poly.ypoints[i+1];
				ymax[nsize] = poly.ypoints[i];
				zmin[nsize] = depth[i+1];
			}
			if (poly.ypoints[i] != poly.ypoints[i+1]) {
				if(Math.abs(poly.ypoints[i]-poly.ypoints[i+1])<0.1) {
					invM[nsize] = 0.; //nis
				}
				else {
					invM[nsize] = (double)(poly.xpoints[i]-poly.xpoints[i+1])/
						(poly.ypoints[i]-poly.ypoints[i+1]);
				}
				if(Math.abs(poly.ypoints[i]-poly.ypoints[i+1])<0.1) {
					gradZ[nsize] = 0.; //nis
				}
				else {gradZ[nsize] = (double)(depth[i]-depth[i+1])/
					(poly.ypoints[i]-poly.ypoints[i+1]);
				}
				nsize++;
			}
		}
		ySort();
	}

    /**
    * Y-sort
    */
    void ySort() {
        for (int i = 0; i < nsize; i++) {
			for (int j = 0; j < nsize-i-1; j++) {
				if (ymin[j] > ymin[j+1]) {
					swap(j, j+1);
				}
			}
		}
	}

	/**
	* Swaps table contents.
	*/
	void swap(int i, int j) {
		int temp;
		double tempd;
		
		temp = xmin[i];
		xmin[i] = xmin[j];
		xmin[j] = temp;
		
		temp = ymin[i];
		ymin[i] = ymin[j];
		ymin[j] = temp;

        temp = ymax[i];
        ymax[i] = ymax[j];
        ymax[j] = temp;

        temp = zmin[i];
        zmin[i] = zmin[j];
        zmin[j] = temp;

        tempd = invM[i];
        invM[i] = invM[j];
        invM[j] = tempd;

        tempd = gradZ[i];
        gradZ[i] = gradZ[j];
        gradZ[j] = tempd;
	}
	
	/**
	* Paint clipped polygon
	*/
	public void paint(Graphics g) {
		double xpoints[] = new double[nsize];
		double zpoints[] = new double[nsize];
		int vertex[] = new int[nsize];
		double x[] = new double[nsize];
		double z[] = new double[nsize];
		
		for (int i = 0; i < nsize; i++) {
			x[i] = xmin[i];
			z[i] = zmin[i];
		}
		for (int scanline = ymin[0]; ; scanline++) {
			int npoint = 0;
			for (int i = 0; i < nsize; i++) {
				if (scanline > ymin[i] && scanline < ymax[i]) {
					if (insert(xpoints, zpoints, vertex, x[i], z[i], MID, npoint)) {
						npoint++;
					}
					x[i] += invM[i];
					z[i] += gradZ[i];
				} else if (scanline == ymin[i]) {
					if (insert(xpoints, zpoints, vertex, x[i], z[i], MIN, npoint)) {
						npoint++;
					}
					x[i] += invM[i];
					z[i] += gradZ[i];
				} else if (scanline == ymax[i]) {
					if (insert(xpoints, zpoints, vertex, x[i], z[i], MAX, npoint)) {
						npoint++;
					}
					x[i] += invM[i];
					z[i] += gradZ[i];
				}
			}
			if (npoint == 0) {
				break;
			}
			for (int i = 0; i < npoint; i += 2) {
				int ix1 = (int)xpoints[i];
				int ix2 = (int)xpoints[i+1];
				double dz = 0.;
				if((ix2-ix1)<1) {
					//                        System.err.println("ix1="+ix1+" ix2="+ix2);
				}
				else { dz = (zpoints[i+1]-zpoints[i])/(ix2-ix1);}
				double zz = zpoints[i];
				for(int ix=ix1; ix<ix2; ix++) {
					if(zbuf.checkDepth(ix,scanline,zz)){
						g.drawLine(ix,scanline,ix,scanline);
					}
					zz+=dz;
				}
			}
		}
		xpoints = null;
		zpoints = null;
	}

    /**
	* Inserts xmin in xpoints[] and attr (MAX,MID,MIN) in vertex[].
	* Return true if success an insertion.
	*/
	boolean insert(double xpoints[], double zpoints[], int vertex[], double xmin, double zmin, int attr,int npoint) {
		int i = 0;
		double EPS = 0.00001;
		
		while (i < npoint) {
            if (Math.abs(xpoints[i] - xmin) < EPS) {
				if ((vertex[i] == MAX && attr == MIN) ||
					(vertex[i] == MIN && attr == MAX)) {
					return false;
				}
            }
            if (xpoints[i] >= xmin) {
				for (int j = npoint-1; j >= i; j--) {
					xpoints[j+1] = xpoints[j];
					zpoints[j+1] = zpoints[j];
					vertex[j+1] = vertex[j];
				}
				break;
			}
			i++;
        }
        xpoints[i] = xmin;
        zpoints[i] = zmin;
        vertex[i] = attr;     
        return true;
  }
}

/**
 * 3D real point class
 */
class Point3 {
	public double x, y, z;
	
	Point3() {
	}
	Point3(double ox, double oy, double oz) {
        x = ox;
        y = oy;
        z = oz;
	}
}

class ATT {
	public RGB dif, amb, spc;
	public double power;
	public int shade,side,smooth;
	ATT() {
		dif = new RGB();
		amb = new RGB();
		spc = new RGB();
	}
}

class RGB {
	public double r, g, b;
	
	RGB() {
	}

    RGB(double rr, double gg, double bb) {
		r=rr;
		g=gg;
		b=bb;
	}
}
class Surface {
	public Point3 p[][];
	
	Surface(){
		p = new Point3[4][4];
		for (int i = 0; i < 4;i++){
			for (int j =0; j< 4;j++){
				p[i][j]=new Point3(0,0,0);
			}
		}
	}       
}

class BezierApplet3 extends Frame{
  Dimension d;
  BezierCurve bcurve;
  BezierSurface bsurface[];
  Bezier_read Bezier_R;
  Graphics graph;
  Image offImage;
  boolean modeEdit;
  Choice changeMode;
  Choice changeMode2;
  Button con;
  double sdata[][][];
  int bcum;

 BezierApplet3(){
 	 super("Bezier");
//	 setBackground(new Color(75,86,97));//) darkGray);
//	 setForeground(new Color(75,86,97));//Color.red);
//	 setLayout(new BorderLayout(0,0));
    changeMode = new Choice();
    changeMode.addItem("Editing Mode");
    changeMode.addItem("Browsing Mode");
	 changeMode2 = new Choice();
    changeMode2.addItem("4");
    changeMode2.addItem("5");
	 changeMode2.addItem("6");
	 changeMode2.addItem("7");
	 con = new Button("draw");
	 Bezier_R= new Bezier_read();
    modeEdit = true;
 }

 public  void  BezierApplet4(){	 
    System.out.println("Yes!!");

    d = size();
	d.width=500;
	d.height=550;
	show();
	setBackground(new Color(112,128,144));
	resize(d.width,d.height);
	changeMode.select(0);
	changeMode2.select(0);
	add(changeMode);	
	changeMode.reshape(150,30,100,80);
	add(changeMode2);
	changeMode2.reshape(300,30,40,80);

//	add(con);
//	con.reshape(360,30,40,20);

   offImage = createImage(d.width, d.height);
	graph = offImage.getGraphics();
	
	Getcontnum(3);
  }

 public void Getcontnum(int n){
	 bcurve = new BezierCurve(n);
	 bsurface = new BezierSurface[4*bcurve.cnum];
	 for (int i=0; i<bcurve.cnum; i++)
		 for (int j=0; j<4; j++)
		 bsurface[4*i+j] = new BezierSurface(bcurve.get3DPatch(i, j));
 }

  public void paint(Graphics g){
    int i;
    
   graph.clearRect(0, 0, d.width, d.height);
	graph.setColor(new Color(112,128,144));
	graph.fillRect(0, 0, d.width, d.height);
	graph.setColor(Color.blue);
	graph.drawString("Mode",100,22);
	graph.drawString("Point",260,22);
    if(modeEdit){
		graph.setColor(new Color(103,118,132));
		for(int a=50;a<=450;a=a+25){
			graph.drawLine(a, 50, a, 450);
			graph.drawLine(50, a, 450, a);
		}
		graph.setColor(Color.magenta);
		graph.drawLine(250, 50, 250, 450);
		graph.drawLine(251, 50, 251, 450);
		graph.setColor(Color.blue);
		bcurve.draw(graph);
    }else{
      for (i=0; i<bsurface.length; i++){
        bsurface[i].draw(graph);
      }
    }
    g.drawImage(offImage, 0, 0, this);
  }

  public boolean handleEvent(Event event){
	  boolean ret;
	  int n;
	  ret=false;
	  if (event.id == Event.WINDOW_DESTROY) {
		  dispose();
		  System.exit(1);
		  return true;
	  } else if(event.target==changeMode) {
		  switch(changeMode.getSelectedIndex()){
		        case 0:
					modeEdit = true;
					break;
				case 1:
					if (modeEdit)
						reload();
					modeEdit = false;
					break;
		  }
		  repaint();
		  ret = true;
		  return super.handleEvent(event);
	  } else if(event.target==changeMode2) {
		  switch(changeMode2.getSelectedIndex()){
		        case 0:
					n=3;
					Getcontnum(n);
					break;
				case 1:
					n=4;
					Getcontnum(n);
					break;
				case 2:
					n=5;
					Getcontnum(n);
					break;
				case 3:
					n=6;
					Getcontnum(n);
					break;
		  }
//	  } else if(event.target==con) {
//		  Bezier_R.bez_read2();
	  }else if (modeEdit)
		  ret = editerEvent(event);
	  else
		  ret = browserEvent(event);
	  return(ret);
//	  return super.handleEvent(event);
//	  return(ret);
  }

/*  public boolean action(Event event, Object obj) {
	  if (event.target == con){
		  System.out.println("sss");
		  Bezier_R.bez_read2();
		  return true;
	  }
	  else return super.action(event,obj);// return true;
  }*/

  boolean editerEvent(Event event){
    int i;

    switch (event.id){
    case Event.MOUSE_DOWN:
      bcurve.findControlPoint(event.x, event.y);
      repaint();
      break;
    case Event.MOUSE_DRAG:
      if (bcurve.select>=0){
        bcurve.setControlPoint(event.x, event.y);
        repaint();
      }
      break;
    }
    return true;
  }


  boolean browserEvent(Event event){
    int i;
	 
	 if (event.target == con){
		  System.out.println("sss");
		  Bezier_R.bez_read2();
		  return true;
	  }
    
    switch (event.id){
    case Event.MOUSE_DOWN:
      double theta, delta, dx, dy;
      
      dx = event.x - d.width/2;
      dy = d.height/2 - event.y;
      if (dx==0){
        if (dy>0){
          theta = Math.PI/2;
        }else{
          theta = -Math.PI/2;
        }
      }else{
        theta = Math.atan(dy/dx);
      }
      
      delta = Math.PI/12;
      if (dx<0)
        delta = -delta;
      
      for (i=0; i<bsurface.length; i++){
        bsurface[i].rotate(delta, theta);
      }
      
      repaint();
      break;
    }
    
    return true;
  }

  public void reload(){
    int i, j;
	bcum=bcurve.cnum;
	sdata=new double[4*bcurve.cnum][16][3];

    bsurface = new BezierSurface[4*bcurve.cnum];
    for (i=0; i<bcurve.cnum; i++){
		for (j=0; j<4; j++){
			bsurface[4*i+j] = new BezierSurface(bcurve.get3DPatch(i, j));
			for(int a=0;a<16;a++){
				for(int b=0;b<3;b++){
					sdata[4*i+j][a][b]=bcurve.pp[a][b];
				}
//				System.out.println("x="+sdata[4*i+j][a][0]);
			}
		}
	}
	System.out.println("cnum="+bcurve.cnum);
  }



  public void update(Graphics g){
    paint(g);
  }
  
}//End of class



class BezierCurve
{
  int cnum;
  public int select;
  ControlPoint controls[];
  double pp[][];


  public BezierCurve(int n){
    int i;

    cnum = n;
    controls = new ControlPoint[cnum+1];
    for (i=0; i<controls.length; i++){
      int x, y, size;

//      x = 250;
		x = 325;										//jie
      y = (int)400*i/(controls.length-1)+50;
      size = 20;
      controls[i] = new ControlPoint(x, y, size);
    }
    select = -1;
  }


  public void findControlPoint(int x, int y){
    int i;

    select = -1;
    for (i=0; i<controls.length; i++){
      if (controls[i].findPoint(x, y)){
        select = i;
        break;
      }
    }
  }

  public void setControlPoint(int x, int y){
    if (select>=0)
      if (x>0 && x<500 && y>0 && y<500)
        controls[select].setPoint(x, y);
  }

  

  public void draw(Graphics g){
    int i;
    double t;
    int currP[], nextP[];
    double ctrlP[][];

    currP = new int[2];
    nextP = new int[2];
    ctrlP = new double[4][2];
    // Drawing Control Point and Lines
    for (i=0; i<controls.length; i++){
      if (i==select)
        controls[i].drawSelect(g);
      else
        controls[i].draw(g);
    }
    
    // Drawing Bezier Curves
// g.setColor(Color.black);
	g.setColor(Color.white);
    for (i=0; i<controls.length-1; i++){
      ctrlP[0][0] = controls[i].point[1][0];
      ctrlP[0][1] = controls[i].point[1][1];
      ctrlP[1][0] = controls[i].point[2][0];
      ctrlP[1][1] = controls[i].point[2][1];
      ctrlP[2][0] = controls[i+1].point[0][0];
      ctrlP[2][1] = controls[i+1].point[0][1];
      ctrlP[3][0] = controls[i+1].point[1][0];
      ctrlP[3][1] = controls[i+1].point[1][1];
      
      currP[0] = (int)ctrlP[0][0];
      currP[1] = (int)ctrlP[0][1];
      t=0.01;
      while (t<=1.0){
        nextP[0] = (int)(Math.pow(1-t, 3)*ctrlP[0][0]+
                     3*t*Math.pow(1-t, 2)*ctrlP[1][0]+
                   3*Math.pow(t, 2)*(1-t)*ctrlP[2][0]+
                           Math.pow(t, 3)*ctrlP[3][0]);
        nextP[1] = (int)(Math.pow(1-t, 3)*ctrlP[0][1]+
                     3*t*Math.pow(1-t, 2)*ctrlP[1][1]+
                   3*Math.pow(t, 2)*(1-t)*ctrlP[2][1]+
                           Math.pow(t, 3)*ctrlP[3][1]);
        g.drawLine(currP[0], currP[1], nextP[0], nextP[1]);
        t += 0.01;
        currP[0] = nextP[0];
        currP[1] = nextP[1];
      }
    }
  }



  public double[][] get3DPatch(int i, int j){
//  double pp[][];
    double data[][];
    int k, l;

    double mat[][] = 
    {{ 1.000,  1.000,  0.552,  0.000},
     { 0.000, -0.552, -1.000, -1.000},
     {-1.000, -1.000, -0.552,  0.000}, 
     { 0.000,  0.552,  1.000,  1.000}};


    pp = new double[16][3];
    data = new double[4][2];
   
    data[0][0] = (controls[i].point[1][0]-50.0)/400.0;			//jie-50.0)/400
    data[1][0] = (controls[i].point[2][0]-50.0)/400.0;
    data[2][0] = (controls[i+1].point[0][0]-50.0)/400.0;
    data[3][0] = (controls[i+1].point[1][0]-50.0)/400.0;
    data[0][1] = (controls[i].point[1][1]-50.0)/400.0;
    data[1][1] = (controls[i].point[2][1]-50.0)/400.0;
    data[2][1] = (controls[i+1].point[0][1]-50.0)/400.0;
    data[3][1] = (controls[i+1].point[1][1]-50.0)/400.0;
    
    for (k=0; k<4; k++){
//		System.out.println("k="+k);
      for (l=0; l<4; l++){
        pp[4*k+l][0] = mat[(j+1)%4][k]*data[l][0]*0.55;
        pp[4*k+l][1] = 1.0-2*data[l][1];
        pp[4*k+l][2] = mat[j % 4][k]*data[l][0];
//		System.out.println(""+pp[4*k+l][0]+" "+pp[4*k+l][1]+" "+pp[4*k+l][2]);
      }
    }

    return pp;
  }
}



class ControlPoint
{
  double point[][];
  int kind;
  double bdist, fdist;

  public ControlPoint(int x, int y, int size){
    point = new double[3][2];
    kind = -1;
    bdist = fdist = (double)size;
    point[0][0] = x;
    point[0][1] = y-size;
    point[1][0] = x;
    point[1][1] = y;
    point[2][0] = x;
    point[2][1] = y+size;
  }


  public boolean findPoint(int x, int y){
    int i;
    int dx, dy, dist;
    boolean ret;

    ret = false;
    kind = -1;
    for (i=0; i<3; i++){
      dx = x - (int)point[i][0];
      dy = y - (int)point[i][1];
      dist = dx*dx + dy*dy;
      if (dist<25){
        kind = i;
        ret = true;
        break;
      }
    }
    return(ret);
  }


  public void setPoint(int x, int y){
    int bx, by, fx, fy;

    if (kind>=0){
      switch(kind){
      case 0:
        bx = x - (int)point[1][0];
        by = y - (int)point[1][1];
        point[0][0] = x;
        point[0][1] = y;
        bdist = Math.sqrt(bx*bx+by*by);
        point[2][0] = point[1][0] - bx*fdist/bdist;
        point[2][1] = point[1][1] - by*fdist/bdist;
        break;
      case 1:
        bx = (int)point[0][0]-(int)point[1][0];
        by = (int)point[0][1]-(int)point[1][1];
        fx = (int)point[2][0]-(int)point[1][0];
        fy = (int)point[2][1]-(int)point[1][1];
        point[1][0] = x;
        point[1][1] = y;
        point[0][0] = x+bx;
        point[0][1] = y+by;
        point[2][0] = x+fx;
        point[2][1] = y+fy;
        break;
      case 2:
        fx = x - (int)point[1][0];
        fy = y - (int)point[1][1];
        point[2][0] = x;
        point[2][1] = y;
        fdist = Math.sqrt(fx*fx+fy*fy);
        point[0][0] = point[1][0] - fx*bdist/fdist;
        point[0][1] = point[1][1] - fy*bdist/fdist;
        break;
      }
    }
  }

  

  public void draw(Graphics g){
    g.setColor(Color.green);
    //Drawing Control Line
    g.drawLine((int)point[0][0], (int)point[0][1],
               (int)point[1][0], (int)point[1][1]);
    g.drawLine((int)point[1][0], (int)point[1][1],
               (int)point[2][0], (int)point[2][1]);

    // Drawing Control Point
    g.drawOval((int)point[0][0] - 3, (int)point[0][1] - 3, 6, 6);
    g.drawRect((int)point[1][0] - 3, (int)point[1][1] - 3, 6, 6);
    g.drawOval((int)point[2][0] - 3, (int)point[2][1] - 3, 6, 6);
  }



  public void drawSelect(Graphics g){
    g.setColor(Color.green);
    //Drawing Control Line
    g.drawLine((int)point[0][0], (int)point[0][1],
               (int)point[1][0], (int)point[1][1]);
    g.drawLine((int)point[1][0], (int)point[1][1],
               (int)point[2][0], (int)point[2][1]);
    // Drawing Control Point
    if (kind==0||kind==1)
      g.fillOval((int)point[0][0] - 3, (int)point[0][1] - 3, 6, 6);
    else
      g.drawOval((int)point[0][0] - 3, (int)point[0][1] - 3, 6, 6);
    if (kind==1)
      g.fillRect((int)point[1][0] - 3, (int)point[1][1] - 3, 6, 6);
    else
      g.drawRect((int)point[1][0] - 3, (int)point[1][1] - 3, 6, 6);
    if (kind==1||kind==2)
      g.fillOval((int)point[2][0] - 3, (int)point[2][1] - 3, 6, 6);
    else
      g.drawOval((int)point[2][0] - 3, (int)point[2][1] - 3, 6, 6);
  }
}



class BezierSurface
{
  int dnum;
  int point[][][];
  double patch[][][];
  double weight1[], weight2[], weight3[], weight4[];
  
  public BezierSurface(double pp[][]){
    int i, j, k;
    patch = new double[4][4][3];

    for(i=0; i<4; i++){
		for (j=0; j<4; j++){
			for (k=0; k<3; k++){
				patch[i][j][k] = pp[4*i+j][k];				
			}
		}
	}
    setDivideNum(8);
  }


  public void setDivideNum(int num){
    dnum = num+1;
    weight1 = new double[dnum];
    weight2 = new double[dnum];
    weight3 = new double[dnum];
    weight4 = new double[dnum];
    point = new int[dnum][dnum][2];

    calcWeight();
  }


  void calcWeight(){
    int i;

    for (i=0; i<dnum; i++){
      double u = (double)i/(dnum-1);
      weight1[i] = Math.pow((1-u), 3);
      weight2[i] = 3*u*Math.pow((1-u), 2);
      weight3[i] = 3*Math.pow(u, 2)*(1-u);
      weight4[i] = Math.pow(u, 3);
    }
  }


  public void draw(Graphics g){
    int u, v;
    int currP[] = new int[2];
    int nextP[] = new int[2];

//  g.setColor(Color.black);
	 g.setColor(Color.white);

    projectSurface(250, 250, 200);

    for (u=0; u<dnum; u++)
      for (v=0; v<dnum; v++){
        if (v==0){
          currP[0] = point[u][v][0];
          currP[1] = point[u][v][1];
        }else{
          nextP[0] = point[u][v][0];
          nextP[1] = point[u][v][1];
          g.drawLine(currP[0], currP[1], nextP[0], nextP[1]);
          currP[0] = nextP[0];
          currP[1] = nextP[1];
        }
      }
    
    for (v=0; v<dnum; v++)
      for (u=0; u<dnum; u++){
        if (u==0){
          currP[0] = point[u][v][0];
          currP[1] = point[u][v][1];
        }else{
          nextP[0] = point[u][v][0];
          nextP[1] = point[u][v][1];
          g.drawLine(currP[0], currP[1], nextP[0], nextP[1]);
          currP[0] = nextP[0];
          currP[1] = nextP[1];
        }
      }
  }


  void projectSurface(int sx, int sy, int size){
    int i, j;
    int u, v;

    for (u=0; u<dnum; u++)
      for (v=0; v<dnum; v++){
        double x, y, z;

        x = (weight1[u]*patch[0][0][0]+weight2[u]*patch[0][1][0]
            +weight3[u]*patch[0][2][0]+weight4[u]*patch[0][3][0])*weight1[v]+
            (weight1[u]*patch[1][0][0]+weight2[u]*patch[1][1][0]
            +weight3[u]*patch[1][2][0]+weight4[u]*patch[1][3][0])*weight2[v]+
            (weight1[u]*patch[2][0][0]+weight2[u]*patch[2][1][0]
            +weight3[u]*patch[2][2][0]+weight4[u]*patch[2][3][0])*weight3[v]+
            (weight1[u]*patch[3][0][0]+weight2[u]*patch[3][1][0]
            +weight3[u]*patch[3][2][0]+weight4[u]*patch[3][3][0])*weight4[v];
        y = (weight1[u]*patch[0][0][1]+weight2[u]*patch[0][1][1]
            +weight3[u]*patch[0][2][1]+weight4[u]*patch[0][3][1])*weight1[v]+
            (weight1[u]*patch[1][0][1]+weight2[u]*patch[1][1][1]
            +weight3[u]*patch[1][2][1]+weight4[u]*patch[1][3][1])*weight2[v]+
            (weight1[u]*patch[2][0][1]+weight2[u]*patch[2][1][1]
            +weight3[u]*patch[2][2][1]+weight4[u]*patch[2][3][1])*weight3[v]+
            (weight1[u]*patch[3][0][1]+weight2[u]*patch[3][1][1]
            +weight3[u]*patch[3][2][1]+weight4[u]*patch[3][3][1])*weight4[v];
        z = (weight1[u]*patch[0][0][2]+weight2[u]*patch[0][1][2]
            +weight3[u]*patch[0][2][2]+weight4[u]*patch[0][3][2])*weight1[v]+
            (weight1[u]*patch[1][0][2]+weight2[u]*patch[1][1][2]
            +weight3[u]*patch[1][2][2]+weight4[u]*patch[1][3][2])*weight2[v]+
            (weight1[u]*patch[2][0][2]+weight2[u]*patch[2][1][2]
            +weight3[u]*patch[2][2][2]+weight4[u]*patch[2][3][2])*weight3[v]+
            (weight1[u]*patch[3][0][2]+weight2[u]*patch[3][1][2]
            +weight3[u]*patch[3][2][2]+weight4[u]*patch[3][3][2])*weight4[v];
            
        point[u][v][0] = sx + (int)(size*x);    
        point[u][v][1] = sy - (int)(size*y);
      }
  }


  public void rotate(double delta, double theta){
    int i, j;
    double st, ct, sd, cd;
    double ctcd, stcd, ctsd, stsd;

    st = Math.sin(theta);
    ct = Math.cos(theta);
    sd = Math.sin(delta);
    cd = Math.cos(delta);

    for (i=0; i<4; i++)
      for (j=0; j<4; j++){
        double x0, y0, z0, x1, y1, z1, x2, y2, z2;

        x0 = patch[i][j][0];
        y0 = patch[i][j][1];
        z0 = patch[i][j][2];

        x1 = ct * x0 + st * y0;
        y1 = -st* x0 + ct * y0;
        z1 = z0;

        x2 = cd * x1 +          sd * z1;
        y2 =              y1;
        z2 = -sd* x1 +          cd * z1;

        patch[i][j][0] = ct * x2 - st * y2;
        patch[i][j][1] = st * x2 + ct * y2;
        patch[i][j][2] =                     z2;
      }
  }


}

class Bezier_read extends ZbufSurf{
	Bezier_read(){
//		BezierApplet3 Bezier2=new BezierApplet3();
	}
	
	public void bez_read2(){         //jie
		System.out.println("aaa");
//		Bezier = new BezierApplet3();
		int i, j, k;
		double x,y,z;
		int ndiv=4;
		System.out.println("bcnum="+Bezier.bcum);
		int nsurf=Bezier.bcum*4;
		int nface=0;
		int surf_deg[]=new int[Bezier.bcum*4];
		Surface surfdata[];
		surfdata=new Surface[Bezier.bcum*4];
		surf_deg[0]=4;
		 
		for(i=0;i<(Bezier.bcum*4);i++){
			surfdata[i] = new Surface();
			surf_deg[i]=4;
			for(j=0;j<4;j++){
				for(k=0;k<4;k++){
					x=Bezier.sdata[i][4*j+k][0]*100;
					y=Bezier.sdata[i][4*j+k][1]*100;
					z=Bezier.sdata[i][4*j+k][2]*100;
					surfdata[i].p[j][k] = new Point3(x,y,z);
				}
			}
		}
		System.out.println("bbb");
		nface = Bez2pol(ndiv,nsurf, surf_deg, surfdata);
		showStatus("No. of BezierPatches ="+ nsurf+ " faces="+nface);
	}

}