//
//  Created by Steve Butler on 8 June 2009
//
//  Need to have window of size 915x690 for program
//

import java.text.DecimalFormat;
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.Polygon;
import java.awt.Graphics;

public class indicator extends Applet implements MouseListener, MouseMotionListener {

	boolean isDraggingSpat=false;
	boolean isDraggingCpat=false;
	boolean addCpushed=false;
	boolean addSpushed=false;
	boolean deleteCpushed=false;
	boolean deleteSpushed=false;
	int pointDragged=1;
	int numSpat=1;
	double[] Spat=new double[200];
	int numCpat=1;
	double[] Cpat=new double[25];
	double area;
	
	Image backbuffer;
	Graphics backg;

	public void init() {
		numSpat=(int)(15*Math.random()+10);
		for(int i=1; i<=numSpat; i++){
			Spat[i]=Math.random();
		}
		Cpat[1]=Math.random();
		sortpats();
		backbuffer = createImage( 1000, 690 );
		backg = backbuffer.getGraphics();
		newCoat();
		
		addMouseListener( this );
		addMouseMotionListener( this );
	}

	public void mouseEntered( MouseEvent e ) { }
	public void mouseExited( MouseEvent e ) { }
	public void mouseMoved( MouseEvent e ) { }
	public void mouseClicked( MouseEvent e ) { // GUI controls
		Point test = new Point (e.getX(),e.getY());
		if(test.x>15 && test.x<265 && test.y>30 && test.y<60) { // pushed in constellation bar
			if(addCpushed==true){
				numCpat++;
				Cpat[numCpat]=(double)(test.x-15)/(250.0);
				sortpats();
			}
			else if(deleteCpushed==true){
				double currentLoc=(double)(test.x-15)/(250.0);
				int nearest=1;
				double currentNearest=Math.abs(currentLoc-Cpat[1]);
				for(int i=2; i<=numCpat; i++){
					double testNear=Math.abs(currentLoc-Cpat[i]);
					if(testNear<currentNearest){
						nearest=i;
						currentNearest=testNear;
					}
				}
				numCpat--;
				for(int i=nearest; i<=numCpat; i++){
					Cpat[i]=Cpat[i+1];
				}
				sortpats();
			}
		}
		else if(test.x>300 && test.x<900 && test.y>30 && test.y<60) { // pushed in subdivision bar
			if(addSpushed==true){
				numSpat++;
				Spat[numSpat]=(double)(test.x-300)/(600.0);
				sortpats();
			}
			else if(deleteSpushed==true){
				double currentLoc=(double)(test.x-300)/(600.0);
				int nearest=1;
				double currentNearest=Math.abs(currentLoc-Spat[1]);
				for(int i=2; i<=numSpat; i++){
					double testNear=Math.abs(currentLoc-Spat[i]);
					if(testNear<currentNearest){
						nearest=i;
						currentNearest=testNear;
					}
				}
				numSpat--;
				for(int i=nearest; i<=numSpat; i++){
					Spat[i]=Spat[i+1];
				}
				sortpats();
			}
		}
		addCpushed=false;
		deleteCpushed=false;
		addSpushed=false;
		deleteSpushed=false;

		if(test.x>50 && test.x<250 && test.y>180 && test.y<565) { // check to see if pushed one of the configuration buttons
			if(test.x>50 && test.x<125 && test.y>180 && test.y<205) { // 3-AP pushed
				numCpat=1;
				numSpat=11;
				Cpat[1]=1.0/2.0;
				Spat[1]=0.0510948905;
				Spat[2]=0.0620437956;
				Spat[3]=0.113138686;
				Spat[4]=0.180656934;
				Spat[5]=0.288321168;
				Spat[6]=0.5;
				Spat[7]=0.711678832;
				Spat[8]=0.819343066;
				Spat[9]=0.886861314;
				Spat[10]=0.937956204;
				Spat[11]=0.948905109; 
			}
			else if(test.x>50 && test.x<125 && test.y>220 && test.y<245) { // 4-AP pushed
				numCpat=2;
				numSpat=35;
				Cpat[1]=1.0/3.0;
				Cpat[2]=2.0/3.0;
				Spat[1]=0.021737;
				Spat[2]=0.026187;
				Spat[3]=0.047997;
				Spat[4]=0.066123;
				Spat[5]=0.072830;
				Spat[6]=0.076611;
				Spat[7]=0.104935;
				Spat[8]=0.138764;
				Spat[9]=0.153632;
				Spat[10]=0.166719;
				Spat[11]=0.220410;
				Spat[12]=0.297795;
				Spat[13]=0.311423;
				Spat[14]=0.346633;
				Spat[15]=0.394504;
				Spat[16]=0.415361;
				Spat[17]=0.499054;
				Spat[18]=0.582465;
				Spat[19]=0.603437;
				Spat[20]=0.653221;
				Spat[21]=0.685805;
				Spat[22]=0.698567;
				Spat[23]=0.778429;
				Spat[24]=0.830346;
				Spat[25]=0.843386;
				Spat[26]=0.857735;
				Spat[27]=0.887938;
				Spat[28]=0.913284;
				Spat[29]=0.915262;
				Spat[30]=0.923270;
				Spat[31]=0.948637;
				Spat[32]=0.966231;
				Spat[33]=0.967195;
				Spat[34]=0.982432;
				Spat[35]=0.984716;
			}
			else if(test.x>50 && test.x<125 && test.y>260 && test.y<285) { // 5-AP pushed
				numCpat=3;
				numSpat=116;
				Cpat[1]=1.0/4.0;
				Cpat[2]=2.0/4.0;
				Cpat[3]=3.0/4.0;
				Spat[1]=0.003067;
				Spat[2]=0.008139;
				Spat[3]=0.009716;
				Spat[4]=0.018480;
				Spat[5]=0.020041;
				Spat[6]=0.023960;
				Spat[7]=0.024884;
				Spat[8]=0.026439;
				Spat[9]=0.033470;
				Spat[10]=0.036428;
				Spat[11]=0.040484;
				Spat[12]=0.041592;
				Spat[13]=0.045525;
				Spat[14]=0.055071;
				Spat[15]=0.059744;
				Spat[16]=0.060209;
				Spat[17]=0.063740;
				Spat[18]=0.069351;
				Spat[19]=0.069657;
				Spat[20]=0.074639;
				Spat[21]=0.076037;
				Spat[22]=0.083391;
				Spat[23]=0.099535;
				Spat[24]=0.104810;
				Spat[25]=0.105470;
				Spat[26]=0.109247;
				Spat[27]=0.109990;
				Spat[28]=0.113082;
				Spat[29]=0.119105;
				Spat[30]=0.128966;
				Spat[31]=0.132535;
				Spat[32]=0.133759;
				Spat[33]=0.147685;
				Spat[34]=0.152205;
				Spat[35]=0.158097;
				Spat[36]=0.179486;
				Spat[37]=0.206992;
				Spat[38]=0.213870;
				Spat[39]=0.233148;
				Spat[40]=0.234566;
				Spat[41]=0.236925;
				Spat[42]=0.258513;
				Spat[43]=0.264834;
				Spat[44]=0.278053;
				Spat[45]=0.280167;
				Spat[46]=0.286634;
				Spat[47]=0.311009;
				Spat[48]=0.318370;
				Spat[49]=0.323131;
				Spat[50]=0.343586;
				Spat[51]=0.351045;
				Spat[52]=0.365411;
				Spat[53]=0.371129;
				Spat[54]=0.396273;
				Spat[55]=0.431353;
				Spat[56]=0.443563;
				Spat[57]=0.461168;
				Spat[58]=0.468207;
				Spat[59]=0.501179;
				Spat[60]=0.533722;
				Spat[61]=0.540804;
				Spat[62]=0.558022;
				Spat[63]=0.566182;
				Spat[64]=0.567941;
				Spat[65]=0.570661;
				Spat[66]=0.591868;
				Spat[67]=0.593063;
				Spat[68]=0.606492;
				Spat[69]=0.631526;
				Spat[70]=0.637184;
				Spat[71]=0.651087;
				Spat[72]=0.658559;
				Spat[73]=0.679630;
				Spat[74]=0.684293;
				Spat[75]=0.691671;
				Spat[76]=0.716553;
				Spat[77]=0.721764;
				Spat[78]=0.724158;
				Spat[79]=0.737610;
				Spat[80]=0.744199;
				Spat[81]=0.766128;
				Spat[82]=0.767756;
				Spat[83]=0.770042;
				Spat[84]=0.788280;
				Spat[85]=0.795517;
				Spat[86]=0.824076;
				Spat[87]=0.845730;
				Spat[88]=0.850120;
				Spat[89]=0.854551;
				Spat[90]=0.868297;
				Spat[91]=0.870836;
				Spat[92]=0.873798;
				Spat[93]=0.882998;
				Spat[94]=0.885232;
				Spat[95]=0.886148;
				Spat[96]=0.889526;
				Spat[97]=0.890696;
				Spat[98]=0.892560;
				Spat[99]=0.900723;
				Spat[100]=0.903354;
				Spat[101]=0.904595;
				Spat[102]=0.919636;
				Spat[103]=0.922405;
				Spat[104]=0.925359;
				Spat[105]=0.937043;
				Spat[106]=0.939544;
				Spat[107]=0.943986;
				Spat[108]=0.948201;
				Spat[109]=0.956066;
				Spat[110]=0.966468;
				Spat[111]=0.968914;
				Spat[112]=0.972701;
				Spat[113]=0.978186;
				Spat[114]=0.982668;
				Spat[115]=0.993860;
				Spat[116]=0.995146;
			}
			else if(test.x>50 && test.x<125 && test.y>300 && test.y<325) { // [0,1/3,1] pushed
				numCpat=1;
				numSpat=17;
				Cpat[1]=1.0/3.0;
				Spat[1]=0.043985;
				Spat[2]=0.051705;
				Spat[3]=0.074750;
				Spat[4]=0.098053;
				Spat[5]=0.137570;
				Spat[6]=0.194955;
				Spat[7]=0.239525;
				Spat[8]=0.352758;
				Spat[9]=0.500000;
				Spat[10]=0.647242;
				Spat[11]=0.760475;
				Spat[12]=0.805045;
				Spat[13]=0.862430;
				Spat[14]=0.901947;
				Spat[15]=0.925250;
				Spat[16]=0.948295;
				Spat[17]=0.956015;
			}
			else if(test.x>50 && test.x<125 && test.y>340 && test.y<365) { // [0,1/4,1] pushed
				numCpat=1;
				numSpat=41;
				Cpat[1]=1.0/4.0;
				Spat[1]=0.012107;
				Spat[2]=0.012554;
				Spat[3]=0.016727;
				Spat[4]=0.018648;
				Spat[5]=0.024556;
				Spat[6]=0.028300;
				Spat[7]=0.035059;
				Spat[8]=0.042176;
				Spat[9]=0.048463;
				Spat[10]=0.062497;
				Spat[11]=0.067807;
				Spat[12]=0.092985;
				Spat[13]=0.105552;
				Spat[14]=0.132119;
				Spat[15]=0.157535;
				Spat[16]=0.178940;
				Spat[17]=0.222492;
				Spat[18]=0.257390;
				Spat[19]=0.312759;
				Spat[20]=0.399624;
				Spat[21]=0.500000;
				Spat[22]=0.600376;
				Spat[23]=0.687241;
				Spat[24]=0.742610;
				Spat[25]=0.777508;
				Spat[26]=0.821060;
				Spat[27]=0.842465;
				Spat[28]=0.867881;
				Spat[29]=0.894448;
				Spat[30]=0.907015;
				Spat[31]=0.932193;
				Spat[32]=0.937503;
				Spat[33]=0.951537;
				Spat[34]=0.957824;
				Spat[35]=0.964941;
				Spat[36]=0.971700;
				Spat[37]=0.975444;
				Spat[38]=0.981352;
				Spat[39]=0.983273;
				Spat[40]=0.987446;
				Spat[41]=0.987893;
			}
			else if(test.x>50 && test.x<125 && test.y>380 && test.y<405) { // [0,1/5,1] pushed
				numCpat=1;
				numSpat=37;
				Cpat[1]=1.0/5.0;
				Spat[1]=0.024710;
				Spat[2]=0.026146;
				Spat[3]=0.032621;
				Spat[4]=0.037313;
				Spat[5]=0.045515;
				Spat[6]=0.055332;
				Spat[7]=0.060820;
				Spat[8]=0.077164;
				Spat[9]=0.086540;
				Spat[10]=0.104015;
				Spat[11]=0.123552;
				Spat[12]=0.150075;
				Spat[13]=0.167612;
				Spat[14]=0.207979;
				Spat[15]=0.257347;
				Spat[16]=0.289225;
				Spat[17]=0.335508;
				Spat[18]=0.402457;
				Spat[19]=0.482759;
				Spat[20]=0.562698;
				Spat[21]=0.643929;
				Spat[22]=0.708149;
				Spat[23]=0.743132;
				Spat[24]=0.784668;
				Spat[25]=0.826665;
				Spat[26]=0.846544;
				Spat[27]=0.870853;
				Spat[28]=0.891135;
				Spat[29]=0.906739;
				Spat[30]=0.918708;
				Spat[31]=0.937814;
				Spat[32]=0.944305;
				Spat[33]=0.953595;
				Spat[34]=0.961653;
				Spat[35]=0.966464;
				Spat[36]=0.973058;
				Spat[37]=0.974285;
			}
			else if(test.x>50 && test.x<125 && test.y>420 && test.y<445) { // [0,1/6,1] pushed
				numCpat=1;
				numSpat=47;
				Cpat[1]=1.0/6.0;
				Spat[1]=0.023821;
				Spat[2]=0.026528;
				Spat[3]=0.030552;
				Spat[4]=0.034990;
				Spat[5]=0.037682;
				Spat[6]=0.044741;
				Spat[7]=0.049273;
				Spat[8]=0.056318;
				Spat[9]=0.066906;
				Spat[10]=0.078263;
				Spat[11]=0.086952;
				Spat[12]=0.103812;
				Spat[13]=0.110487;
				Spat[14]=0.129607;
				Spat[15]=0.149334;
				Spat[16]=0.175723;
				Spat[17]=0.199500;
				Spat[18]=0.216580;
				Spat[19]=0.252491;
				Spat[20]=0.280509;
				Spat[21]=0.309967;
				Spat[22]=0.365529;
				Spat[23]=0.433439;
				Spat[24]=0.500000;
				Spat[25]=0.566561;
				Spat[26]=0.634471;
				Spat[27]=0.690033;
				Spat[28]=0.719491;
				Spat[29]=0.747509;
				Spat[30]=0.783420;
				Spat[31]=0.800500;
				Spat[32]=0.824277;
				Spat[33]=0.850666;
				Spat[34]=0.870393;
				Spat[35]=0.889513;
				Spat[36]=0.896188;
				Spat[37]=0.913048;
				Spat[38]=0.921737;
				Spat[39]=0.933094;
				Spat[40]=0.943682;
				Spat[41]=0.950727;
				Spat[42]=0.955259;
				Spat[43]=0.962318;
				Spat[44]=0.965010;
				Spat[45]=0.969448;
				Spat[46]=0.973472;
				Spat[47]=0.976179;
			}
			else if(test.x>50 && test.x<125 && test.y>460 && test.y<485) { // [0,1/7,1] pushed
				numCpat=1;
				numSpat=61;
				Cpat[1]=1.0/7.0;
				Spat[1]=0.018138;
				Spat[2]=0.019036;
				Spat[3]=0.022200;
				Spat[4]=0.024390;
				Spat[5]=0.026590;
				Spat[6]=0.030777;
				Spat[7]=0.034455;
				Spat[8]=0.038067;
				Spat[9]=0.043436;
				Spat[10]=0.048339;
				Spat[11]=0.052513;
				Spat[12]=0.061434;
				Spat[13]=0.064470;
				Spat[14]=0.076306;
				Spat[15]=0.081752;
				Spat[16]=0.092009;
				Spat[17]=0.103778;
				Spat[18]=0.117218;
				Spat[19]=0.127020;
				Spat[20]=0.147651;
				Spat[21]=0.166546;
				Spat[22]=0.175748;
				Spat[23]=0.201397;
				Spat[24]=0.226968;
				Spat[25]=0.258146;
				Spat[26]=0.295574;
				Spat[27]=0.322328;
				Spat[28]=0.347822;
				Spat[29]=0.390992;
				Spat[30]=0.445650;
				Spat[31]=0.500000;
				Spat[32]=0.554350;
				Spat[33]=0.609008;
				Spat[34]=0.652178;
				Spat[35]=0.677672;
				Spat[36]=0.704426;
				Spat[37]=0.741854;
				Spat[38]=0.773032;
				Spat[39]=0.798603;
				Spat[40]=0.824252;
				Spat[41]=0.833454;
				Spat[42]=0.852349;
				Spat[43]=0.872980;
				Spat[44]=0.882782;
				Spat[45]=0.896222;
				Spat[46]=0.907991;
				Spat[47]=0.918248;
				Spat[48]=0.923694;
				Spat[49]=0.935530;
				Spat[50]=0.938566;
				Spat[51]=0.947487;
				Spat[52]=0.951661;
				Spat[53]=0.956564;
				Spat[54]=0.961933;
				Spat[55]=0.965545;
				Spat[56]=0.969223;
				Spat[57]=0.973410;
				Spat[58]=0.975610;
				Spat[59]=0.977800;
				Spat[60]=0.980964;
				Spat[61]=0.981862;				
			}
			else if(test.x>50 && test.x<125 && test.y>500 && test.y<525) { // [0,2/9,1] pushed
				numCpat=1;
				numSpat=41;
				Cpat[1]=2.0/9.0;
				Spat[1]=0.020586;
				Spat[2]=0.023457;
				Spat[3]=0.027923;
				Spat[4]=0.033048;
				Spat[5]=0.037936;
				Spat[6]=0.045466;
				Spat[7]=0.050053;
				Spat[8]=0.061489;
				Spat[9]=0.069306;
				Spat[10]=0.082267;
				Spat[11]=0.100462;
				Spat[12]=0.119507;
				Spat[13]=0.135506;
				Spat[14]=0.165839;
				Spat[15]=0.187728;
				Spat[16]=0.218103;
				Spat[17]=0.262590;
				Spat[18]=0.292844;
				Spat[19]=0.339203;
				Spat[20]=0.413426;
				Spat[21]=0.500000;
				Spat[22]=0.586574;
				Spat[23]=0.660797;
				Spat[24]=0.707156;
				Spat[25]=0.737410;
				Spat[26]=0.781897;
				Spat[27]=0.812272;
				Spat[28]=0.834161;
				Spat[29]=0.864494;
				Spat[30]=0.880493;
				Spat[31]=0.899538;
				Spat[32]=0.917733;
				Spat[33]=0.930694;
				Spat[34]=0.938511;
				Spat[35]=0.949947;
				Spat[36]=0.954534;
				Spat[37]=0.962064;
				Spat[38]=0.966952;
				Spat[39]=0.972077;
				Spat[40]=0.976543;
				Spat[41]=0.979414;
			}
			else if(test.x>50 && test.x<125 && test.y>540 && test.y<565) { // [0,2/11,1] pushed
				numCpat=1;
				numSpat=43;
				Cpat[1]=2.0/11.0;
				Spat[1]=0.022100;
				Spat[2]=0.023539;
				Spat[3]=0.028420;
				Spat[4]=0.032150;
				Spat[5]=0.037291;
				Spat[6]=0.045094;
				Spat[7]=0.048123;
				Spat[8]=0.063042;
				Spat[9]=0.069731;
				Spat[10]=0.083219;
				Spat[11]=0.096744;
				Spat[12]=0.110785;
				Spat[13]=0.123125;
				Spat[14]=0.146288;
				Spat[15]=0.164040;
				Spat[16]=0.188409;
				Spat[17]=0.229185;
				Spat[18]=0.257388;
				Spat[19]=0.294293;
				Spat[20]=0.355768;
				Spat[21]=0.428575;
				Spat[22]=0.500000;
				Spat[23]=0.571425;
				Spat[24]=0.644232;
				Spat[25]=0.705707;
				Spat[26]=0.742612;
				Spat[27]=0.770815;
				Spat[28]=0.811591;
				Spat[29]=0.835960;
				Spat[30]=0.853712;
				Spat[31]=0.876875;
				Spat[32]=0.889215;
				Spat[33]=0.903256;
				Spat[34]=0.916781;
				Spat[35]=0.930269;
				Spat[36]=0.936958;
				Spat[37]=0.951877;
				Spat[38]=0.954906;
				Spat[39]=0.962709;
				Spat[40]=0.967850;
				Spat[41]=0.971580;
				Spat[42]=0.976461;
				Spat[43]=0.977900;				
			}
			else if(test.x>175 && test.x<250 && test.y>180 && test.y<205) { // [0,3/7,1] pushed
				numCpat=1;
				numSpat=13;
				Cpat[1]=3.0/7.0;
				Spat[1]=0.039514;
				Spat[2]=0.053161;
				Spat[3]=0.102598;
				Spat[4]=0.166992;
				Spat[5]=0.279362;
				Spat[6]=0.465847;
				Spat[7]=0.500000;
				Spat[8]=0.534153;
				Spat[9]=0.720638;
				Spat[10]=0.833008;
				Spat[11]=0.897402;
				Spat[12]=0.946839;
				Spat[13]=0.960486;
			}
			else if(test.x>175 && test.x<250 && test.y>220 && test.y<245) { // [0,3/10,1] pushed
				numCpat=1;
				numSpat=31;
				Cpat[1]=3.0/10.0;
				Spat[1]=0.010533;
				Spat[2]=0.012185;
				Spat[3]=0.016020;
				Spat[4]=0.019496;
				Spat[5]=0.024758;
				Spat[6]=0.030520;
				Spat[7]=0.038347;
				Spat[8]=0.050116;
				Spat[9]=0.058353;
				Spat[10]=0.079356;
				Spat[11]=0.089734;
				Spat[12]=0.118452;
				Spat[13]=0.149460;
				Spat[14]=0.183717;
				Spat[15]=0.239164;
				Spat[16]=0.282867;
				Spat[17]=0.349922;
				Spat[18]=0.454952;
				Spat[19]=0.576842;
				Spat[20]=0.686775;
				Spat[21]=0.749219;
				Spat[22]=0.789199;
				Spat[23]=0.839514;
				Spat[24]=0.858452;
				Spat[25]=0.894839;
				Spat[26]=0.916570;
				Spat[27]=0.931750;
				Spat[28]=0.948177;
				Spat[29]=0.955145;
				Spat[30]=0.966624;
				Spat[31]=0.970806;
			}
			else if(test.x>175 && test.x<250 && test.y>260 && test.y<285) { // [0,3/14,1] pushed
				numCpat=1;
				numSpat=41;
				Cpat[1]=3.0/14.0;
				Spat[1]=0.020490;
				Spat[2]=0.021594;
				Spat[3]=0.026861;
				Spat[4]=0.030554;
				Spat[5]=0.036456;
				Spat[6]=0.042578;
				Spat[7]=0.049133;
				Spat[8]=0.060238;
				Spat[9]=0.065994;
				Spat[10]=0.080602;
				Spat[11]=0.097901;
				Spat[12]=0.116351;
				Spat[13]=0.132472;
				Spat[14]=0.163135;
				Spat[15]=0.181668;
				Spat[16]=0.214989;
				Spat[17]=0.259953;
				Spat[18]=0.286933;
				Spat[19]=0.336486;
				Spat[20]=0.412788;
				Spat[21]=0.500000;
				Spat[22]=0.587212;
				Spat[23]=0.663514;
				Spat[24]=0.713067;
				Spat[25]=0.740047;
				Spat[26]=0.785011;
				Spat[27]=0.818332;
				Spat[28]=0.836865;
				Spat[29]=0.867528;
				Spat[30]=0.883649;
				Spat[31]=0.902099;
				Spat[32]=0.919398;
				Spat[33]=0.934006;
				Spat[34]=0.939762;
				Spat[35]=0.950867;
				Spat[36]=0.957422;
				Spat[37]=0.963544;
				Spat[38]=0.969446;
				Spat[39]=0.973139;
				Spat[40]=0.978406;
				Spat[41]=0.979510;
			}
			else if(test.x>175 && test.x<250 && test.y>300 && test.y<325) { // [0,4/11,1] pushed
				numCpat=1;
				numSpat=23;
				Cpat[1]=4.0/11.0;
				Spat[1]=0.029374;
				Spat[2]=0.029760;
				Spat[3]=0.046363;
				Spat[4]=0.058441;
				Spat[5]=0.081483;
				Spat[6]=0.107292;
				Spat[7]=0.145166;
				Spat[8]=0.206895;
				Spat[9]=0.253433;
				Spat[10]=0.357684;
				Spat[11]=0.491245;
				Spat[12]=0.500000;
				Spat[13]=0.508755;
				Spat[14]=0.642316;
				Spat[15]=0.746567;
				Spat[16]=0.793105;
				Spat[17]=0.854834;
				Spat[18]=0.892708;
				Spat[19]=0.918517;
				Spat[20]=0.941559;
				Spat[21]=0.953637;
				Spat[22]=0.970240;
				Spat[23]=0.970626;
			}
			else if(test.x>175 && test.x<250 && test.y>340 && test.y<365) { // [0,4/17,1] pushed
				numCpat=1;
				numSpat=35;
				Cpat[1]=4.0/17.0;
				Spat[1]=0.018848;
				Spat[2]=0.022077;
				Spat[3]=0.026854;
				Spat[4]=0.034319;
				Spat[5]=0.038499;
				Spat[6]=0.050869;
				Spat[7]=0.058033;
				Spat[8]=0.070068;
				Spat[9]=0.086656;
				Spat[10]=0.101903;
				Spat[11]=0.129852;
				Spat[12]=0.154260;
				Spat[13]=0.184141;
				Spat[14]=0.235113;
				Spat[15]=0.271613;
				Spat[16]=0.321960;
				Spat[17]=0.403209;
				Spat[18]=0.500000;
				Spat[19]=0.596791;
				Spat[20]=0.678040;
				Spat[21]=0.728387;
				Spat[22]=0.764887;
				Spat[23]=0.815859;
				Spat[24]=0.845740;
				Spat[25]=0.870148;
				Spat[26]=0.898097;
				Spat[27]=0.913344;
				Spat[28]=0.929932;
				Spat[29]=0.941967;
				Spat[30]=0.949131;
				Spat[31]=0.961501;
				Spat[32]=0.965681;
				Spat[33]=0.973146;
				Spat[34]=0.977923;
				Spat[35]=0.981152;
			}
			else if(test.x>175 && test.x<250 && test.y>380 && test.y<405) { // [0,5/11,1] pushed
				numCpat=1;
				numSpat=11;
				Cpat[1]=5.0/11.0;
				Spat[1]=0.047425;
				Spat[2]=0.061988;
				Spat[3]=0.113867;
				Spat[4]=0.179539;
				Spat[5]=0.288756;
				Spat[6]=0.500000;
				Spat[7]=0.711244;
				Spat[8]=0.820461;
				Spat[9]=0.886133;
				Spat[10]=0.938012;
				Spat[11]=0.952575;
			}
			else if(test.x>175 && test.x<250 && test.y>420 && test.y<445) { // [0,6/19,1] pushed
				numCpat=1;
				numSpat=21;
				Cpat[1]=6.0/19.0;
				Spat[1]=0.021750;
				Spat[2]=0.024334;
				Spat[3]=0.038883;
				Spat[4]=0.045723;
				Spat[5]=0.072705;
				Spat[6]=0.092340;
				Spat[7]=0.133269;
				Spat[8]=0.185658;
				Spat[9]=0.232520;
				Spat[10]=0.355410;
				Spat[11]=0.500000;
				Spat[12]=0.644590;
				Spat[13]=0.767480;
				Spat[14]=0.814342;
				Spat[15]=0.866731;
				Spat[16]=0.907660;
				Spat[17]=0.927295;
				Spat[18]=0.954277;
				Spat[19]=0.961117;
				Spat[20]=0.975666;
				Spat[21]=0.978250;
			}
			else if(test.x>175 && test.x<250 && test.y>460 && test.y<485) { // [0,6/23,1] pushed
				numCpat=1;
				numSpat=45;
				Cpat[1]=6.0/23.0;
				Spat[1]=0.002408;
				Spat[2]=0.003066;
				Spat[3]=0.003915;
				Spat[4]=0.005131;
				Spat[5]=0.006252;
				Spat[6]=0.008329;
				Spat[7]=0.010062;
				Spat[8]=0.013376;
				Spat[9]=0.016791;
				Spat[10]=0.021745;
				Spat[11]=0.026481;
				Spat[12]=0.035724;
				Spat[13]=0.040171;
				Spat[14]=0.060257;
				Spat[15]=0.070500;
				Spat[16]=0.090947;
				Spat[17]=0.119468;
				Spat[18]=0.145296;
				Spat[19]=0.199323;
				Spat[20]=0.242666;
				Spat[21]=0.296767;
				Spat[22]=0.390318;
				Spat[23]=0.500000;
				Spat[24]=0.609682;
				Spat[25]=0.703233;
				Spat[26]=0.757334;
				Spat[27]=0.800677;
				Spat[28]=0.854704;
				Spat[29]=0.880532;
				Spat[30]=0.909053;
				Spat[31]=0.929500;
				Spat[32]=0.939743;
				Spat[33]=0.959829;
				Spat[34]=0.964276;
				Spat[35]=0.973519;
				Spat[36]=0.978255;
				Spat[37]=0.983209;
				Spat[38]=0.986624;
				Spat[39]=0.989938;
				Spat[40]=0.991671;
				Spat[41]=0.993748;
				Spat[42]=0.994869;
				Spat[43]=0.996085;
				Spat[44]=0.996934;
				Spat[45]=0.997592;
			}
			else if(test.x>175 && test.x<250 && test.y>500 && test.y<525) { // [0,7/18,1] pushed
				numCpat=1;
				numSpat=25;
				Cpat[1]=7.0/18.0;
				Spat[1]=0.017083;
				Spat[2]=0.017816;
				Spat[3]=0.028135;
				Spat[4]=0.034614;
				Spat[5]=0.048679;
				Spat[6]=0.062795;
				Spat[7]=0.086402;
				Spat[8]=0.113304;
				Spat[9]=0.148717;
				Spat[10]=0.211182;
				Spat[11]=0.263111;
				Spat[12]=0.358109;
				Spat[13]=0.500000;
				Spat[14]=0.641891;
				Spat[15]=0.736889;
				Spat[16]=0.788818;
				Spat[17]=0.851283;
				Spat[18]=0.886696;
				Spat[19]=0.913598;
				Spat[20]=0.937205;
				Spat[21]=0.951321;
				Spat[22]=0.965386;
				Spat[23]=0.971865;
				Spat[24]=0.982184;
				Spat[25]=0.982917;
			}
			else if(test.x>175 && test.x<250 && test.y>540 && test.y<565) { // random pushed
				numCpat=(int)(3*Math.random()+1);
				numSpat=(int)(25*Math.random()+12);
				for(int i=1; i<=numCpat; i++){
					Cpat[i]=Math.random();
				}
				for(int i=1; i<=numSpat; i++){
					Spat[i]=Math.random();
				}
			}
			sortpats();
		}

		if(test.y>4 && test.y<24){
			if(test.x>30 && test.x<80){ // add for constellations is pushed
				addCpushed=false;
				deleteCpushed=false;
				addSpushed=false;
				deleteSpushed=false;
				if(numCpat<20){ addCpushed=true; }
			}
			else if(test.x>95 && test.x<170){ // delete for constellations is pushed
				addCpushed=false;
				deleteCpushed=false;
				addSpushed=false;
				deleteSpushed=false;
				if(numCpat>1){ deleteCpushed=true; }
			}
			else if(test.x>185 && test.x<250){ // even for constellations is pushed
				addCpushed=false;
				deleteCpushed=false;
				addSpushed=false;
				deleteSpushed=false;
				for(int i=1; i<=numCpat; i++){
					Cpat[i]=(double)(i)/(double)(numCpat+1);
				}
				sortpats();
			}
			else if(test.x>502 && test.x<552){ // add for subdivision is pushed
				addCpushed=false;
				deleteCpushed=false;
				addSpushed=false;
				deleteSpushed=false;
				if(numSpat<100){ addSpushed=true; }
			}
			else if(test.x>567 && test.x<642){ // delete for subdivision is pushed
				addCpushed=false;
				deleteCpushed=false;
				addSpushed=false;
				deleteSpushed=false;
				if(numSpat>1){ deleteSpushed=true; }
			}
			else if(test.x>657 && test.x<722){ // even for subdivision is pushed
				addCpushed=false;
				deleteCpushed=false;
				addSpushed=false;
				deleteSpushed=false;
				for(int i=1; i<=numSpat; i++){
					Spat[i]=(double)(i)/(double)(numSpat+1);
				}
				sortpats();
			}
		}
		newCoat();
		e.consume();
	}
	public void mousePressed( MouseEvent e ) {  //used for only dragging
		Point test = new Point (e.getX(),e.getY());

		if(test.x>15&&test.x<265&&test.y>30&&test.y<60&&addCpushed==false&&deleteCpushed==false){ // start dragging in constellation bar
			double currentLoc=(double)(test.x-15)/(250.0);
			isDraggingCpat=true;
// find which one we are dragging
			pointDragged=1;
			double currentNearest=Math.abs(currentLoc-Cpat[1]);
			for(int i=2;i<=numCpat;i++){
				double testNear=Math.abs(currentLoc-Cpat[i]);
				if(testNear<currentNearest){
					pointDragged=i;
					currentNearest=testNear;
				}
			}
// update the point
			Cpat[pointDragged]=currentLoc+0.00001*Math.random();
			sortpats();
			newCoat();
		}
		if(test.x>300&&test.x<900&&test.y>30&&test.y<60&&addSpushed==false&&deleteSpushed==false){ // start dragging in constellation bar
			double currentLoc=(double)(test.x-300)/(600.0);
			isDraggingSpat=true;
// find which one we are dragging
			pointDragged=1;
			double currentNearest=Math.abs(currentLoc-Spat[1]);
			for(int i=2;i<=numSpat;i++){
				double testNear=Math.abs(currentLoc-Spat[i]);
				if(testNear<currentNearest){
					pointDragged=i;
					currentNearest=testNear;
				}
			}
// update the point
			Spat[pointDragged]=currentLoc+0.00001*Math.random();
			sortpats();
			newCoat();
		}
		e.consume();
	}
	public void mouseReleased( MouseEvent e ) {
		isDraggingSpat = false;
		isDraggingCpat = false;
		e.consume();
	}
	public void mouseDragged( MouseEvent e ) {
		Point test = new Point(e.getX(),e.getY());
		if(isDraggingCpat==true){
			if(test.x>15&&test.x<265){
				Cpat[pointDragged]=(double)(test.x-15)/(250.0)+0.00001*Math.random();
			}
			sortpats();
			newCoat();
		}
		else if(isDraggingSpat==true){
			if(test.x>300&&test.x<900){
				Spat[pointDragged]=(double)(test.x-300)/(600.0)+0.00001*Math.random();
			}
			sortpats();
			newCoat();
		}
		e.consume();
	}
	
//
//  The following two functions are to eliminate flicker; they do nothing else
//
	public void update( Graphics g ) {
		g.drawImage( backbuffer, 0, 0, this );
	}

	public void paint( Graphics g ) {
		update( g );
	}
	
	public void newCoat(){
		DecimalFormat df = new DecimalFormat("##0.00");
		DecimalFormat dff = new DecimalFormat("##0.0000");
// paint the back black
		backg.setColor(Color.black);
		backg.fillRect(0,0,915,690);

// paint the constellation pattern
		if(numCpat<6){
			for(int i=numCpat; i>=1; i--){
				backg.setColor(Color.darkGray);
				backg.drawLine((int)(250*Cpat[i])+15,60,(int)(250*Cpat[i])+15,60+i*15);
				backg.setColor(Color.white);
				backg.drawString(dff.format(Cpat[i]),(int)(250*Cpat[i])+15,60+i*15);
			}
		}
		for(int i=1; i<=numCpat; i++){
			int k=(int)(250*Cpat[i])+15;
			backg.setColor(Color.pink);
			backg.fillRect(k-1,30,3,30);
			backg.setColor(Color.cyan);
			backg.drawRect(k,30,0,30);
		}
		backg.setColor(Color.orange);
		backg.drawRect(15,30,250,30);

// paint the subdivision pattern
		for(int i=0; i<=numSpat;i++){
			if(i%2==0){ backg.setColor(Color.red); } else{ backg.setColor(Color.blue); }
			backg.fillRect((int)(Spat[i]*600)+300,30,(int)(Spat[i+1]*600.0)-(int)(Spat[i]*600.0),30);
		}
		for(int i=1; i<=numSpat; i++){
			int k=(int)(600*Spat[i])+300;
			backg.setColor(Color.cyan);
			backg.drawRect(k,30,0,30);
		}
		backg.setColor(Color.orange);
		backg.drawRect(300,30,600,30);

// paint the GUI
		backg.setColor(Color.white);
		if(addCpushed==false){ 
			backg.drawRect(30,4,50,20);
			backg.drawString("Add",43,19);
		}
		else{
			backg.fillRect(30,4,50,20);
			backg.setColor(Color.black);
			backg.drawString("Add",43,19);
			backg.setColor(Color.white);
		}
		if(deleteCpushed==false){
			backg.drawRect(95,4,75,20);
			backg.drawString("Delete",113,19);
		}
		else{
			backg.fillRect(95,4,75,20);
			backg.setColor(Color.black);	
			backg.drawString("Delete",113,19);
			backg.setColor(Color.white);
		}
		backg.drawString("Even",205,19);
		backg.drawRect(185,4,65,20);

		backg.setColor(Color.white);
		if(addSpushed==false){ 
			backg.drawRect(502,4,50,20);
			backg.drawString("Add",515,19);
		}
		else{
			backg.fillRect(502,4,50,20);
			backg.setColor(Color.black);
			backg.drawString("Add",515,19);
			backg.setColor(Color.white);
		}
		if(deleteSpushed==false){
			backg.drawRect(567,4,75,20);
			backg.drawString("Delete",585,19);
		}
		else{
			backg.fillRect(567,4,75,20);
			backg.setColor(Color.black);	
			backg.drawString("Delete",585,19);
			backg.setColor(Color.white);
		}
		backg.drawString("Even",677,20);
		backg.drawRect(662,4,65,20);

//draw in  lines
		backg.setColor(Color.darkGray);
		for (int i=1; i<=numSpat; i++){
			backg.drawLine(300,675-(int)(600.0*Spat[i]),900,675-(int)(600.0*Spat[i]));
			backg.drawLine(300+(int)(600.0*Spat[i]),75,300+(int)(600.0*Spat[i]),675);
			for (int j=1; j<=numCpat; j++){
				double xA=0.0;
				double yA=Spat[i]/(1-Cpat[j]);
				if(yA>1.0){
					yA=1.0;
					xA=(Spat[i]+Cpat[j]-1)/Cpat[j];
				}
				double xB=1.0;
				double yB=(Spat[i]-Cpat[j])/(1-Cpat[j]);
				if(yB<0.0){
					yB=0.0;
					xB=Spat[i]/Cpat[j];
				}
				backg.drawLine(300+(int)(600*xA),675-(int)(600.0*yA),300+(int)(600*xB),675-(int)(600.0*yB));
			}
		}


// load up the polygons!
		area=0.0;
		for(int i=1; i<numSpat+2; i=i+2){
			for(int j=1; j<numSpat+2; j=j+2){
				double[][] poly=new double[4][2];
				poly[3][0]=Spat[i-1]; poly[3][1]=Spat[j-1];
				poly[0][0]=Spat[i]; poly[0][1]=Spat[j-1];
				poly[1][0]=Spat[i]; poly[1][1]=Spat[j];
				poly[2][0]=Spat[i-1]; poly[2][1]=Spat[j];
				RECURSE(poly, 4, 1, 0);
			}
		}
		for(int i=2; i<numSpat+2; i=i+2){
			for(int j=2; j<numSpat+2; j=j+2){
				double[][] poly=new double[4][2];
				poly[3][0]=Spat[i-1]; poly[3][1]=Spat[j-1];
				poly[0][0]=Spat[i]; poly[0][1]=Spat[j-1];
				poly[1][0]=Spat[i]; poly[1][1]=Spat[j];
				poly[2][0]=Spat[i-1]; poly[2][1]=Spat[j];
				RECURSE(poly, 4, 1, 1);
			}
		}
		
		for(int i=1; i<=numCpat+1; i++){
			area=2.0*area;
		}
		backg.setColor(Color.white);
		backg.drawString("Subdivision pattern uses "+(numSpat+1)+" blocks",25,652);
		backg.drawString("Achieves "+df.format(100.0*area)+"% of random",25,670);

// outline of square
		backg.setColor(Color.yellow);
		backg.drawRect(300,75,600,600);

// buttons for various configurations
		backg.setColor(Color.white);
		backg.drawRect(50,180,75,25);
		backg.drawString("3-AP",72,198);
		backg.drawRect(50,220,75,25);
		backg.drawString("4-AP",72,238);
		backg.drawRect(50,260,75,25);
		backg.drawString("5-AP",72,278);
		backg.drawRect(50,300,75,25);
		backg.drawString("[0,1/3,1]",60,318);
		backg.drawRect(50,340,75,25);
		backg.drawString("[0,1/4,1]",60,358);
		backg.drawRect(50,380,75,25);
		backg.drawString("[0,1/5,1]",60,398);
		backg.drawRect(50,420,75,25);
		backg.drawString("[0,1/6,1]",60,438);
		backg.drawRect(50,460,75,25);
		backg.drawString("[0,1/7,1]",60,478);
		backg.drawRect(50,500,75,25);
		backg.drawString("[0,2/9,1]",60,518);
		backg.drawRect(50,540,75,25);
		backg.drawString("[0,2/11,1]",56,558);

		backg.drawRect(175,180,75,25);
		backg.drawString("[0,3/7,1]",185,198);
		backg.drawRect(175,220,75,25);
		backg.drawString("[0,3/10,1]",181,238);
		backg.drawRect(175,260,75,25);
		backg.drawString("[0,3/14,1]",181,278);
		backg.drawRect(175,300,75,25);
		backg.drawString("[0,4/11,1]",181,318);
		backg.drawRect(175,340,75,25);
		backg.drawString("[0,4/17,1]",181,358);
		backg.drawRect(175,380,75,25);
		backg.drawString("[0,5/11,1]",181,398);
		backg.drawRect(175,420,75,25);
		backg.drawString("[0,6/19,1]",181,438);
		backg.drawRect(175,460,75,25);
		backg.drawString("[0,6/23,1]",181,478);
		backg.drawRect(175,500,75,25);
		backg.drawString("[0,7/18,1]",181,518);
		backg.drawRect(175,540,75,25);
		backg.drawString("random",190,558);
		
// output the picture
		repaint();
	}

	public void sortpats(){ // sort all the points (using worst sorting algorithm possible!)
		double temp;
		for(int i=1; i<numSpat; i++){
			for(int j=i+1; j<=numSpat; j++){
				if(Spat[i]>Spat[j])
				{
					temp=Spat[j];
					Spat[j]=Spat[i];
					Spat[i]=temp;
					if((pointDragged==i) && (isDraggingSpat==true)){ pointDragged=j; }
					else if((pointDragged==j) && (isDraggingSpat==true)){ pointDragged=i; }
				}
			}
		}
		Spat[0]=0.0;
		Spat[numSpat+1]=1.0;
		for(int i=1; i<numCpat; i++){
			for(int j=i+1; j<=numCpat; j++){
				if(Cpat[i]>Cpat[j])
				{
					temp=Cpat[j];
					Cpat[j]=Cpat[i];
					Cpat[i]=temp;
					if((pointDragged==i) && (isDraggingCpat==true)){ pointDragged=j; }
					else if((pointDragged==j) && (isDraggingCpat==true)){ pointDragged=i; }
				}
			}
		}
		Cpat[0]=0.0;
		Cpat[numCpat+1]=1.0;
	}
	
	public static double AREATRIANGLE(double[] A, double[] B, double[] C){
		double[] AA, BB, CC;
		if (A[0]<=B[0] && B[0]<=C[0]){
			AA=A; BB=B; CC=C;
		}
		else if (A[0]<=C[0] && C[0]<=B[0]){
			AA=A; BB=C; CC=B;
		}
		else if (B[0]<=A[0] && A[0]<=C[0]){
			AA=B; BB=A; CC=C;
		}
		else if (B[0]<=C[0] && C[0]<=A[0]){
			AA=B; BB=C; CC=A;
		}
		else if (C[0]<=A[0] && A[0]<=B[0]){
			AA=C; BB=A; CC=B;
		}
		else{
			AA=C; BB=B; CC=A;
		}
		if (AA[1]<=BB[1] && BB[1]<=CC[1]){
			if ((BB[1]-AA[1])*(CC[0]-AA[0])>(CC[1]-AA[1])*(BB[0]-AA[0])){
				return (CC[0]-AA[0])*(CC[1]-AA[1])/2-(BB[0]-AA[0])*(CC[1]-BB[1])-(CC[0]-BB[0])*(CC[1]-BB[1])/2-(BB[0]-AA[0])*(BB[1]-AA[1])/2;
			}
			else{
				return (CC[0]-AA[0])*(CC[1]-AA[1])/2-(CC[0]-BB[0])*(BB[1]-AA[1])-(CC[0]-BB[0])*(CC[1]-BB[1])/2-(BB[0]-AA[0])*(BB[1]-AA[1])/2;
			}
		}
  		else if (AA[1]<=CC[1] && CC[1]<=BB[1]){
			return (CC[0]-AA[0])*(BB[1]-AA[1])-(BB[0]-AA[0])*(BB[1]-AA[1])/2-(CC[0]-BB[0])*(BB[1]-CC[1])/2-(CC[0]-AA[0])*(CC[1]-AA[1])/2;
		}
		else if (BB[1]<=AA[1] && AA[1]<=CC[1]){
			return (CC[0]-AA[0])*(CC[1]-BB[1])-(BB[0]-AA[0])*(AA[1]-BB[1])/2-(CC[0]-BB[0])*(CC[1]-BB[1])/2-(CC[0]-AA[0])*(CC[1]-AA[1])/2;
		}
		else if (BB[1]<=CC[1] && CC[1]<=AA[1]){
			return (CC[0]-AA[0])*(AA[1]-BB[1])-(BB[0]-AA[0])*(AA[1]-BB[1])/2-(CC[0]-BB[0])*(CC[1]-BB[1])/2-(CC[0]-AA[0])*(AA[1]-CC[1])/2;
		}
		else if (CC[1]<=AA[1] && AA[1]<=BB[1]){
			return (CC[0]-AA[0])*(BB[1]-CC[1])-(BB[0]-AA[0])*(BB[1]-AA[1])/2-(CC[0]-BB[0])*(BB[1]-CC[1])/2-(CC[0]-AA[0])*(AA[1]-CC[1])/2;
		}
		else{
			if ((AA[1]-BB[1])*(AA[0]-CC[0])>(AA[1]-CC[1])*(AA[0]-BB[0])){
				return (CC[0]-AA[0])*(AA[1]-CC[1])/2-(CC[0]-BB[0])*(AA[1]-BB[1])-(CC[0]-BB[0])*(BB[1]-CC[1])/2-(BB[0]-AA[0])*(AA[1]-BB[1])/2;
			}
			else{
				return (CC[0]-AA[0])*(AA[1]-CC[1])/2-(BB[0]-AA[0])*(BB[1]-CC[1])-(CC[0]-BB[0])*(BB[1]-CC[1])/2-(BB[0]-AA[0])*(AA[1]-BB[1])/2;
			}
		}
	}
	
	public void RECURSE(double[][] P, int numpoints, int iterate, int mod){
		if(iterate==numCpat+1){ // ready to draw the polygon and add up the area!
			int[] xcoords=new int[numpoints];
			int[] ycoords=new int[numpoints];
			for(int i=1; i<=numpoints; i++){
				xcoords[i-1]=300+(int)(P[i-1][0]*600.0);
				ycoords[i-1]=675-(int)(P[i-1][1]*600.0);
			}
			if(mod==0){ backg.setColor(Color.red); } else{ backg.setColor(Color.blue); }
			backg.fillPolygon(xcoords,ycoords,numpoints);
			for(int i=1; i<numpoints-1;i++){
				area=area+AREATRIANGLE(P[0],P[i],P[i+1]);
			}
		}
		else{ // recurse (the hard part!)
			double[][] Q= new double[numpoints+4][2];
			for(int i=1;i<=numpoints;i++){ Q[i-1]=P[i-1]; }
			int numptsQ=numpoints;
			boolean done=false;
			int[] intersect=new int[numpoints+4];
			for(int i=2; i<=numSpat+2 && done==false; i++){
				for(int j=0;j<numptsQ;j++){ intersect[j]=0; }
				int numABOVE=0; int numBELOW=0;
				for(int j=1; j<=numptsQ; j++){
					if((Q[j-1][1]*(1.0-Cpat[iterate]))<(Spat[i-1]-Cpat[iterate]*Q[j-1][0])){
						numBELOW++;
						intersect[j-1]=-1;
					}
					else{
						numABOVE++;
						intersect[j-1]=1;
					}
				}
				if(numBELOW>0){ // we can do something
					if(numABOVE==0){ // everything is between previous and current line
						done=true;
						if((i-mod)%2==0){
							RECURSE(Q,numptsQ,iterate+1,mod);
						}
					}
					else{ // ugh.  Have to slice off part of Q
						boolean ptAfound=false;  // our first step is to find how the current line slices and dices Q
						int ptAlocation=0;
						int ptBlocation=0;
						double[] ptA=new double[2];
						double[] ptB=new double[2];
						for(int k=0;k<=numptsQ-2;k++){
							if (intersect[k]*intersect[k+1]==-1){
								if(ptAfound==false){
									ptAfound=true;
									ptAlocation=k;
									ptA=INTERSECT(Q[k],Q[k+1],Cpat[iterate]/(Cpat[iterate]-1),Spat[i-1]/(1-Cpat[iterate]));
								}
								else{
									ptBlocation=k;
									ptB=INTERSECT(Q[k],Q[k+1],Cpat[iterate]/(Cpat[iterate]-1),Spat[i-1]/(1-Cpat[iterate]));
								}
							}
						}
						if(intersect[numptsQ-1]*intersect[0]==-1){
							ptBlocation=numptsQ-1;
							ptB=INTERSECT(Q[0],Q[numptsQ-1],Cpat[iterate]/(Cpat[iterate]-1),Spat[i-1]/(1-Cpat[iterate]));
						}
						double[][] R= new double[numpoints+4][2];
						double[][] S= new double[numpoints+4][2];
						int counter;
						int numptsR;
						int numptsS;
						counter=0;
						for(int k=0;k<=ptAlocation;k++){
							R[counter]=Q[k];
							counter++;
						}
						R[counter]=ptA;
						counter++;
						R[counter]=ptB;
						counter++;
						for(int k=ptBlocation+1;k<=numptsQ-1;k++){
							R[counter]=Q[k];
							counter++;
						}
						numptsR=counter;
						counter=0;
						for(int k=ptAlocation+1;k<=ptBlocation;k++){
							S[counter]=Q[k];
							counter++;
						}
						S[counter]=ptB;
						counter++;
						S[counter]=ptA;
						counter++;
						numptsS=counter;
						if(intersect[ptAlocation+1]==1){ // keep S, recurse R
							numptsQ=numptsS;
							for(int k=1;k<=numptsQ;k++){
								Q[k-1]=S[k-1];
							}
							if((i-mod)%2==0){
								RECURSE(R,numptsR,iterate+1,mod);
							}
						}
						else{ // keep R, recurse S
							numptsQ=numptsR;
							for(int k=1;k<=numptsQ;k++){
								Q[k-1]=R[k-1];
							}
							if((i-mod)%2==0){
								RECURSE(S,numptsS,iterate+1,mod);
							}
						}
					}
				}
			} 
		} 
	}

	public static double[] INTERSECT(double[] A, double[] B, double m, double b){
		double mm, bb;
		double[] U=new double[2];
		if(A[0]==B[0]){
			U[0]=A[0];
			U[1]=m*A[0]+b;
		}
		else{
			mm=(B[1]-A[1])/(B[0]-A[0]);
			bb=A[1]-mm*A[0];
			U[0]=(bb-b)/(m-mm);
			U[1]=m*U[0]+b;
		}
		return U;
	}
}