import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
import java.awt.geom.*;
import java.math.*;


/**This routine defines additional routines for boxes that are not used in the proof.
These other routines are used either for graphical purposes, or as components of
sanity checks for various routines used in the proof.**/

public class XtraBox {

    /**This routine finds a dyadic box of the given size that contains the given
       point */


    /**for squares**/

    public static Box dyadic0(Complex z,int kk) {
	Box B=new Box(new Complex(0,0),-2,0,1);
	Box C=new Box(B);
	for(int q=0;q<kk+2;++q) {
                      int used=0;
	    for(int i=0;i<4;++i) {
	         C=B.subdivide0(i);
	         if((used==0)&&(contains(C,z)==1)) {	 
	             used=1;
                               B=new Box(C);
	         }
	    }
	}
	return(B);
    }

    /**for segments**/

    public static Box dyadic1(Complex z,int kk) {
	Box B=new Box(new Complex(2,0),-1,1,1);
	Box C=new Box(B);
	for(int q=0;q<kk+1;++q) {
                      int used=0;
	    for(int i=0;i<2;++i) {
	         C=B.subdivide1(i);
	         if((used==0)&&(contains(C,z)==1)) {	 
	             used=1;
                               B=new Box(C);
	         }
	    }
	}
	return(B);
    }


    /**This is an averaging routine.  It gets a certain convex average of the vertices.  The
       point in question maps to (a,b) if the box is mapped to the unit square by a similarity.**/

    public static Vector getPoint(Box B,double a,double b) {
	Vector[] V=B.toVectors();
	Vector W03=XtraVector.interpolate(V[0],V[3],a);
	Vector W12=XtraVector.interpolate(V[1],V[2],a);
	Vector X=XtraVector.interpolate(W03,W12,b);
	return(X);
    }


    public static int intersect(Box B1,Box B2) {
	Complex[] Z2=B2.toVertices();
	for(int i=0;i<Z2.length;++i) {
	    if(contains(B1,Z2[i])==1) return(1);
	}	
                  Complex[] Z1=B1.toVertices();
	for(int i=0;i<Z1.length;++i) {
	    if(contains(B2,Z1[i])==1) return(1);
	}
	return(0);
    }

    public static int intersect(BoxConfiguration X1,BoxConfiguration X2) {
	for(int i=0;i<4;++i) {
	    if(intersect(X1.B[i],X2.B[i])==0) return(0);
	}
	return(1);
    }


    /**This routine computes a rough numerical approximation to the radius of a spherical patch.
       It is meant as a sanity check.**/

    public static double crudeRadius(Box B) {

	Vector V1=B.getCenter();
	double rad=0;
	Vector[] V2=B.toVectors();
	for(int i=0;i<4;++i) {
	    double test=Vector.dist(V1,V2[i]);
	    if(rad<test) rad=test;
	}
	return(rad);
    }


    /**This routine gets a point in the middle of a box**/

     public static Complex getPointPlain(Box B,double s,double t) {
	 Complex[] Z=B.toVertices();
	 Complex W1=new Complex((1-s)*Z[0].x+s*Z[3].x,(1-s)*Z[0].y+s*Z[3].y);
	 Complex W2=new Complex((1-s)*Z[1].x+s*Z[2].x,(1-s)*Z[1].y+s*Z[2].y);
	 Complex W3=new Complex((1-t)*W1.x+t*W2.x,(1-t)*W1.y+t*W2.y);
	 return(W3);
     }


    /**Tests the distance between a pair of points inside a pair of boxes**/

    public static double testDistance(Box B1,Box B2,double s1,double t1,double s2,double t2) {
	Complex Z1=getPointPlain(B1,s1,t1);
	Complex Z2=getPointPlain(B2,s2,t2);
	Vector V1=Stereo.inverseStereo(Z1);
	Vector V2=Stereo.inverseStereo(Z2);
	double d=Vector.dist(V1,V2);
	return(d);
    }


    /**Converts a box to a graphics object**/

    public static GeneralPath toGeneralPath(Box X) {
	Complex[] Z=X.toVertices();
	GeneralPath gp=new GeneralPath();
	for(int i=0;i<Z.length;++i) {
	    if(i==0) gp.moveTo((float)(Z[i].x),(float)(Z[i].y));
	    if(i>0) gp.lineTo((float)(Z[i].x),(float)(Z[i].y));
	}
	gp.closePath();
	return(gp);
    }


    /**Checks whether a box contains a point**/

    public static int contains(Box B,Complex w) {
	if(B.type==0) return(contains0(B,w));
	return(contains1(B,w));
    }


    public static int contains0(Box B,Complex w) {
	Complex[] Z=B.toVertices();
	if(w.x<Z[0].x) return(0);
	if(w.x>Z[2].x) return(0);
	if(w.y<Z[0].y) return(0);
	if(w.y>Z[2].y) return(0);
	return(1);
    }

    public static int contains1(Box B,Complex w) {
	Complex[] Z=B.toVertices();
	if(w.x<Z[0].x) return(0);
	if(w.x>Z[1].x) return(0);
	return(1);
    }



}