// PAJ spatial point analysis in Java V 1.0 Oct 2007
//Barry Condron, Dept of Biology, University of Virginia, VA 22903, USA condron@virginia.edu
//V. Nagaradjane of Pondicherry, India nagaradjanev@rediffmail.com provided critical help in getting the paste buffer to work with excel on mac's.

import javax.swing.*;
import java.awt.event.KeyEvent;
import java.beans.*;
import javax.swing.border.*;

import javax.swing.table.*;
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import java.lang.Double;
import java.applet.Applet;
import java.lang.Math;
import java.awt.event.*;
import java.util.*;
import java.awt.*;           
import java.awt.geom.*;  
import javax.swing.*;
import java.awt.dnd.*;
import java.awt.datatransfer.*;
import java.util.*;
import java.awt.*;
import javax.swing.JScrollPane;


public class PAJ extends JTable /*implements Runnable*/ {
//global variables
public static int number_of_points=0;
public static boolean data_3D=true;
public static double[] rank_data_average=new double[50];
public static double[] coordinates_x=new double[10000];
public static double[] coordinates_y=new double[10000];
public static double[] coordinates_z=new double[10000];

public static double[] r_coordinates_x=new double[10000];
public static double[] r_coordinates_y=new double[10000];
public static double[] r_coordinates_z=new double[10000];

public static double[] c_coordinates_x=new double[10000];
public static double[] c_coordinates_y=new double[10000];
public static double[] c_coordinates_z=new double[10000];



 double[] mc_coordinates_x=new double[10000];
double[] mc_coordinates_y=new double[10000];
  double[] mc_coordinates_z=new double[10000];
int[] mc_coordinates_branch=new int[10000];
int[] coordinates_branch=new int[10000];

public static double[] rank_average=new double[100];
public static double[] rank_cov=new double[100];
//mst
int[] k1_mstVertex_1=new int[10000];
int[] k1_mstVertex_2=new int[10000];
int[] k1_mstVertex_3=new int[10000];

int[] k2_mstVertex_1=new int[10000];
int[] k2_mstVertex_2=new int[10000];
int[] k2_mstVertex_3=new int[10000];

int[] p1_mstVertex_1=new int[10000];
int[] p1_mstVertex_2=new int[10000];
int[] p1_mstVertex_3=new int[10000];

int[] p2_mstVertex_1=new int[10000];
int[] p2_mstVertex_2=new int[10000];
int[] p2_mstVertex_3=new int[10000];

//rank
public static double[] rank_plot_data_average=new double[100];
public static double[] r_rank_plot_data_average=new double[100];
public static double[] c_rank_plot_data_average=new double[100];
public static double[] rank_plot_MC_min=new double[100];
public static double[] rank_plot_MC_max=new double[100];
public static double[] rank_plot_data_cov=new double[100];
public static double[] r_rank_plot_data_cov=new double[100];
public static double[] c_rank_plot_data_cov=new double[100];
public static double[] rank_plot_MC_cov_min=new double[100];
public static double[] rank_plot_MC_cov_max=new double[100];
//density
public static double[] density_plot_data_average=new double[100];
public static double[] r_density_plot_data_average=new double[100];
public static double[] c_density_plot_data_average=new double[100];
public static double[] density_plot_MC_min=new double[100];
public static double[] density_plot_MC_max=new double[100];
public static double[] density_plot_data_cov=new double[100];
public static double[] r_density_plot_data_cov=new double[100];
public static double[] c_density_plot_data_cov=new double[100];
public static double[] density_plot_MC_cov_min=new double[100];
public static double[] density_plot_MC_cov_max=new double[100];
//lacunarity
public static double[] lacunarity_plot_data_average=new double[100];
public static double[] r_lacunarity_plot_data_average=new double[100];
public static double[] c_lacunarity_plot_data_average=new double[100];
public static double[] lacunarity_plot_MC_min=new double[100];
public static double[] lacunarity_plot_MC_max=new double[100];
public static double[] lacunarity_plot_data_cov=new double[100];
public static double[] r_lacunarity_plot_data_cov=new double[100];
public static double[] c_lacunarity_plot_data_cov=new double[100];
public static double[] lacunarity_plot_MC_cov_min=new double[100];
public static double[] lacunarity_plot_MC_cov_max=new double[100];
//voronoi
public static double[] voronoi_plot_data_average=new double[1000];
public static double[] r_voronoi_plot_data_average=new double[1000];
public static double[] c_voronoi_plot_data_average=new double[1000];
public static double[] voronoi_plot_MC_min=new double[1000];
public static double[] voronoi_plot_MC_max=new double[1000];
public static double[] voronoi_plot_data_cov=new double[1000];
public static double[] voronoi_plot_MC_cov_min=new double[1000];
public static double[] voronoi_plot_MC_cov_max=new double[1000];

public static double scale_factor=0;

public static double vor_data_r=0;
public static double vor_data_mc_min=0;
public static double vor_data_mc_max=0;

public static double confidence_limit=100;



Random rand = new Random();
public static boolean montecarlo=false;
public  double r =  rand.nextFloat();

public static double min_x = 0;
public static double max_x = 0;
public static double min_y = 0;
public static double max_y =0;
public static double min_z = 0;
public static double max_z =0;

public static class  JGraphCanvas extends JComponent  {
 public void JGraphCanvas()
{
//setDoubleBuffered(true);
//setOpaque(true);
}
 public void paintComponent(Graphics g)
{
//super.paintComponent(g);


//***rank graph
//draw graph
g.setColor(Color.black);
g.drawRect(1,1,200,200);
g.drawLine(20,190,190,190);
g.drawLine(20,20,20,190);
g.drawString("Rank Average",15,15);
g.drawRect(1,200,200,200);
g.drawLine(20,390,190,390);
g.drawLine(20,220,20,390);
g.drawString("Rank Variation",15,215);
//end draw graph

//**rank graph

//top graph
//scale data
double max_point=rank_plot_data_average[1];
double min_point=rank_plot_data_average[1];
if (montecarlo){
for (int i=0;i<40;i++)
 {
 if (rank_plot_data_average[i]>max_point){max_point=rank_plot_data_average[i];}
  if (rank_plot_data_average[i]<min_point){min_point=rank_plot_data_average[i];}
   if (r_rank_plot_data_average[i]>max_point){max_point=r_rank_plot_data_average[i];}
  if (r_rank_plot_data_average[i]<min_point){min_point=r_rank_plot_data_average[i];}
     if (c_rank_plot_data_average[i]>max_point){max_point=c_rank_plot_data_average[i];}
  if (c_rank_plot_data_average[i]<min_point){min_point=c_rank_plot_data_average[i];}
  
  if (rank_plot_MC_max[i]<min_point){min_point=rank_plot_MC_max[i];}
    if (rank_plot_MC_max[i]>max_point){max_point=rank_plot_MC_max[i];}
  if (rank_plot_MC_min[i]<min_point){min_point=rank_plot_MC_min[i];}
    if (rank_plot_MC_min[i]>max_point){max_point=rank_plot_MC_min[i];}
}
}
if (!montecarlo){
for (int i=0;i<40;i++)
 {
     if (c_rank_plot_data_average[i]>max_point){max_point=c_rank_plot_data_average[i];}
  if (c_rank_plot_data_average[i]<min_point){min_point=c_rank_plot_data_average[i];}
    if (r_rank_plot_data_average[i]>max_point){max_point=r_rank_plot_data_average[i];}
  if (r_rank_plot_data_average[i]<min_point){min_point=r_rank_plot_data_average[i];}
 if (rank_plot_data_average[i]>max_point){max_point=rank_plot_data_average[i];}
  if (rank_plot_data_average[i]>max_point){max_point=rank_plot_data_average[i];}
} }

//we want the data to span 370 pixels
double draw_scale_factor = 170/(max_point-min_point);
 for (int i=0;i<40;i++)
 {
rank_plot_data_average[i]=180-(rank_plot_data_average[i]-min_point)*draw_scale_factor;
r_rank_plot_data_average[i]=180-(r_rank_plot_data_average[i]-min_point)*draw_scale_factor;
c_rank_plot_data_average[i]=180-(c_rank_plot_data_average[i]-min_point)*draw_scale_factor;

//end scale data
}
//draw MC max
for (int i=0;i<40;i++)
 {
rank_plot_MC_max[i]=180-(rank_plot_MC_max[i]-min_point)*draw_scale_factor;
if (rank_plot_MC_max[i]>180){rank_plot_MC_max[i]=180;}
if (rank_plot_MC_max[i]<0){rank_plot_MC_max[i]=0;}
//end scale data
}
//draw data
 for (int i=0;i<40;i++)
 {
rank_plot_MC_min[i]=180-(rank_plot_MC_min[i]-min_point)*draw_scale_factor;
if (rank_plot_MC_min[i]>180){rank_plot_MC_min[i]=180;}
if (rank_plot_MC_min[i]<0){rank_plot_MC_min[i]=0;}
//end scale data
}

 for (int i=1;i<40;i++)
 {
  Polygon p;
  p= new Polygon();
	    p.addPoint((int)(18*(i-1)*0.25)+20, (int) rank_plot_MC_min[i-1]);
		p.addPoint((int)(18*i*0.25)+20, (int) rank_plot_MC_min[i]);
		p.addPoint((int)(18*i*0.25)+20, (int) rank_plot_MC_max[i]);
		p.addPoint((int)(18*(i-1)*0.25)+20, (int) rank_plot_MC_max[i-1]);
	    p.addPoint((int)(18*(i-1)*0.25)+20, (int) rank_plot_MC_min[i-1]);
g.setColor(Color.red);
g.fillPolygon(p);

}

//draw data
g.setColor(Color.blue);

 for (int i=0;i<40;i++)
 {
g.fillRect((int)(18*i*0.25)+20,(int)(rank_plot_data_average[i]),2,2); 
}

g.setColor(Color.green);

 for (int i=0;i<40;i++)
 {
//g.fillRect((int)(18*i*0.25)+20,(int)(r_rank_plot_data_average[i]),2,2); 
}
g.setColor(Color.yellow);

 for (int i=0;i<40;i++)
 {
//g.fillRect((int)(18*i*0.25)+20,(int)(c_rank_plot_data_average[i]),2,2); 
}
//lower graph
//scale data
 max_point=rank_plot_data_cov[1];
 min_point=rank_plot_data_cov[1];
if (montecarlo){
for (int i=0;i<40;i++)
 {
 if (rank_plot_data_cov[i]>max_point){max_point=rank_plot_data_cov[i];}
  if (rank_plot_data_cov[i]<min_point){min_point=rank_plot_data_cov[i];}
   if (r_rank_plot_data_cov[i]>max_point){max_point=r_rank_plot_data_cov[i];}
  if (r_rank_plot_data_cov[i]<min_point){min_point=r_rank_plot_data_cov[i];}
     if (c_rank_plot_data_cov[i]>max_point){max_point=c_rank_plot_data_cov[i];}
  if (c_rank_plot_data_cov[i]<min_point){min_point=c_rank_plot_data_cov[i];}
  if (rank_plot_MC_cov_max[i]<min_point){min_point=rank_plot_MC_cov_max[i];}
    if (rank_plot_MC_cov_max[i]>max_point){max_point=rank_plot_MC_cov_max[i];}
  if (rank_plot_MC_cov_min[i]<min_point){min_point=rank_plot_MC_cov_min[i];}
    if (rank_plot_MC_cov_min[i]>max_point){max_point=rank_plot_MC_cov_min[i];}
}
}
if (!montecarlo){
for (int i=0;i<40;i++)
 {

 if (rank_plot_data_cov[i]>max_point){max_point=rank_plot_data_cov[i];}
  if (rank_plot_data_cov[i]<min_point){min_point=rank_plot_data_cov[i];}
      if (r_rank_plot_data_cov[i]>max_point){max_point=r_rank_plot_data_cov[i];}
  if (r_rank_plot_data_cov[i]<min_point){min_point=r_rank_plot_data_cov[i];}
       if (c_rank_plot_data_cov[i]>max_point){max_point=c_rank_plot_data_cov[i];}
  if (c_rank_plot_data_cov[i]<min_point){min_point=c_rank_plot_data_cov[i];}
}
}
//we want the data to span 370 pixels
 draw_scale_factor = 170/(max_point-min_point);
 for (int i=0;i<40;i++)
 {
rank_plot_data_cov[i]=380-(rank_plot_data_cov[i]-min_point)*draw_scale_factor;
r_rank_plot_data_cov[i]=380-(r_rank_plot_data_cov[i]-min_point)*draw_scale_factor;
c_rank_plot_data_cov[i]=380-(c_rank_plot_data_cov[i]-min_point)*draw_scale_factor;

//end scale data
}


//draw MC max
 for (int i=0;i<40;i++)
 {
rank_plot_MC_cov_max[i]=380-(rank_plot_MC_cov_max[i]-min_point)*draw_scale_factor;
if (rank_plot_MC_cov_max[i]>380){rank_plot_MC_cov_max[i]=380;}
if (rank_plot_MC_cov_max[i]<200){rank_plot_MC_cov_max[i]=200;}
//end scale data
}
//draw data
 for (int i=0;i<40;i++)
 {
rank_plot_MC_cov_min[i]=380-(rank_plot_MC_cov_min[i]-min_point)*draw_scale_factor;
if (rank_plot_MC_cov_min[i]>380){rank_plot_MC_cov_min[i]=380;}
if (rank_plot_MC_cov_min[i]<200){rank_plot_MC_cov_min[i]=200;}
//end scale data
}

 for (int i=1;i<40;i++)
 {
  Polygon cv;
  cv= new Polygon();
	    cv.addPoint((int)(18*(i-1)*0.25)+20, (int) rank_plot_MC_cov_min[i-1]);
		cv.addPoint((int)(18*i*0.25)+20, (int) rank_plot_MC_cov_min[i]);
		cv.addPoint((int)(18*i*0.25)+20, (int) rank_plot_MC_cov_max[i]);
		cv.addPoint((int)(18*(i-1)*0.25)+20, (int) rank_plot_MC_cov_max[i-1]);
	    cv.addPoint((int)(18*(i-1)*0.25)+20, (int) rank_plot_MC_cov_min[i-1]);
g.setColor(Color.red);
g.fillPolygon(cv);

}

//draw data
g.setColor(Color.blue);

 for (int i=0;i<40;i++)
 {
g.fillRect((int)(18*i*0.25)+20,(int)(rank_plot_data_cov[i]),2,2); 
}
g.setColor(Color.green);

 for (int i=0;i<40;i++)
 {
//g.fillRect((int)(18*i*0.25)+20,(int)(r_rank_plot_data_cov[i]),2,2); 
}
g.setColor(Color.yellow);

 for (int i=0;i<40;i++)
 {
//g.fillRect((int)(18*i*0.25)+20,(int)(c_rank_plot_data_cov[i]),2,2); 
}
//***density graph
//draw graph
g.setColor(Color.black);
g.drawRect(201,1,200,200);
g.drawLine(220,190,390,190);
g.drawLine(220,20,220,190);
g.drawString("Density Average",215,15);
g.drawRect(201,200,200,200);
g.drawLine(220,390,390,390);
g.drawLine(220,220,220,390);
g.drawString("Density Variation",215,215);
//end draw graph


//top graph
//scale data
 max_point=density_plot_data_average[1];
 min_point=density_plot_data_average[1];
if (montecarlo){
for (int i=0;i<40;i++)
 {
 if (density_plot_data_average[i]>max_point){max_point=density_plot_data_average[i];}
  if (density_plot_data_average[i]<min_point){min_point=density_plot_data_average[i];}
   if (r_density_plot_data_average[i]>max_point){max_point=r_density_plot_data_average[i];}
//  if (c_density_plot_data_average[i]<min_point){min_point=c_density_plot_data_average[i];}
//     if (c_density_plot_data_average[i]>max_point){max_point=c_density_plot_data_average[i];}
  if (r_density_plot_data_average[i]<min_point){min_point=r_density_plot_data_average[i];}
  if (density_plot_MC_max[i]<min_point){min_point=density_plot_MC_max[i];}
    if (density_plot_MC_max[i]>max_point){max_point=density_plot_MC_max[i];}
  if (density_plot_MC_min[i]<min_point){min_point=density_plot_MC_min[i];}
    if (density_plot_MC_min[i]>max_point){max_point=density_plot_MC_min[i];}
}
}
if (!montecarlo){
for (int i=0;i<40;i++)
 {
//   if (c_density_plot_data_average[i]<min_point){min_point=c_density_plot_data_average[i];}
//     if (c_density_plot_data_average[i]>max_point){max_point=c_density_plot_data_average[i];}
 if (density_plot_data_average[i]>max_point){max_point=density_plot_data_average[i];}
  if (density_plot_data_average[i]<min_point){min_point=density_plot_data_average[i];}
     if (r_density_plot_data_average[i]>max_point){max_point=r_density_plot_data_average[i];}
  if (r_density_plot_data_average[i]<min_point){min_point=r_density_plot_data_average[i];}
}
}

//we want the data to span 370 pixels
 draw_scale_factor = 170/(max_point-min_point);
 for (int i=0;i<40;i++)
 {
density_plot_data_average[i]=180-(density_plot_data_average[i]-min_point)*draw_scale_factor;
r_density_plot_data_average[i]=180-(r_density_plot_data_average[i]-min_point)*draw_scale_factor;
c_density_plot_data_average[i]=180-(c_density_plot_data_average[i]-min_point)*draw_scale_factor;

//end scale data
}
//draw MC max
for (int i=0;i<40;i++)
 {
density_plot_MC_max[i]=180-(density_plot_MC_max[i]-min_point)*draw_scale_factor;
if (density_plot_MC_max[i]>180){density_plot_MC_max[i]=180;}
if (density_plot_MC_max[i]<0){density_plot_MC_max[i]=0;}
//end scale data
}
//draw data
 for (int i=0;i<40;i++)
 {
density_plot_MC_min[i]=180-(density_plot_MC_min[i]-min_point)*draw_scale_factor;
if (density_plot_MC_min[i]>180){density_plot_MC_min[i]=180;}
if (density_plot_MC_min[i]<0){density_plot_MC_min[i]=0;}
//end scale data
}

 for (int i=1;i<40;i++)
 {
  Polygon p;
  p= new Polygon();
	    p.addPoint((int)(18*(i-1)*0.25)+220, (int) density_plot_MC_min[i-1]);
		p.addPoint((int)(18*i*0.25)+220, (int) density_plot_MC_min[i]);
		p.addPoint((int)(18*i*0.25)+220, (int) density_plot_MC_max[i]);
		p.addPoint((int)(18*(i-1)*0.25)+220, (int) density_plot_MC_max[i-1]);
	    p.addPoint((int)(18*(i-1)*0.25)+220, (int) density_plot_MC_min[i-1]);
g.setColor(Color.red);
g.fillPolygon(p);

}

//draw data
g.setColor(Color.blue);

 for (int i=0;i<40;i++)
 {
g.fillRect((int)(18*i*0.25)+220,(int)(density_plot_data_average[i]),2,2); 
}
g.setColor(Color.green);

 for (int i=0;i<40;i++)
 {
//g.fillRect((int)(18*i*0.25)+220,(int)(r_density_plot_data_average[i]),2,2); 
}
g.setColor(Color.yellow);

 for (int i=0;i<40;i++)
 {
//g.fillRect((int)(18*i*0.25)+220,(int)(c_density_plot_data_average[i]),2,2); 
}
//lower graph
//scale data
 max_point=density_plot_data_cov[1];
 min_point=density_plot_data_cov[1];
if (montecarlo){
for (int i=0;i<40;i++)
 {
 if (density_plot_data_cov[i]>max_point){max_point=density_plot_data_cov[i];}
  if (density_plot_data_cov[i]<min_point){min_point=density_plot_data_cov[i];}
//   if (r_density_plot_data_cov[i]>max_point){max_point=r_density_plot_data_cov[i];}
//  if (r_density_plot_data_cov[i]<min_point){min_point=r_density_plot_data_cov[i];}
  if (density_plot_MC_cov_max[i]<min_point){min_point=density_plot_MC_cov_max[i];}
    if (density_plot_MC_cov_max[i]>max_point){max_point=density_plot_MC_cov_max[i];}
  if (density_plot_MC_cov_min[i]<min_point){min_point=density_plot_MC_cov_min[i];}
    if (density_plot_MC_cov_min[i]>max_point){max_point=density_plot_MC_cov_min[i];}
}
}
if (!montecarlo){
for (int i=0;i<40;i++)
 {

 if (density_plot_data_cov[i]>max_point){max_point=density_plot_data_cov[i];}
  if (density_plot_data_cov[i]<min_point){min_point=density_plot_data_cov[i];}
// if (r_density_plot_data_cov[i]>max_point){max_point=r_density_plot_data_cov[i];}
//  if (r_density_plot_data_cov[i]<min_point){min_point=r_density_plot_data_cov[i];}
}
}

//we want the data to span 370 pixels
 draw_scale_factor = 170/(max_point-min_point);
 for (int i=0;i<40;i++)
 {
density_plot_data_cov[i]=380-(density_plot_data_cov[i]-min_point)*draw_scale_factor;
r_density_plot_data_cov[i]=380-(r_density_plot_data_cov[i]-min_point)*draw_scale_factor;
c_density_plot_data_cov[i]=380-(c_density_plot_data_cov[i]-min_point)*draw_scale_factor;

//end scale data
}


//draw MC max
 for (int i=0;i<40;i++)
 {
density_plot_MC_cov_max[i]=380-(density_plot_MC_cov_max[i]-min_point)*draw_scale_factor;
if (density_plot_MC_cov_max[i]>380){density_plot_MC_cov_max[i]=380;}
if (density_plot_MC_cov_max[i]<200){density_plot_MC_cov_max[i]=200;}
//end scale data
}
//draw data
 for (int i=0;i<40;i++)
 {
density_plot_MC_cov_min[i]=380-(density_plot_MC_cov_min[i]-min_point)*draw_scale_factor;
if (density_plot_MC_cov_min[i]>380){density_plot_MC_cov_min[i]=380;}
if (density_plot_MC_cov_min[i]<200){density_plot_MC_cov_min[i]=200;}
//end scale data
}

 for (int i=1;i<40;i++)
 {
  Polygon cv;
  cv= new Polygon();
	    cv.addPoint((int)(18*(i-1)*0.25)+220, (int) density_plot_MC_cov_min[i-1]);
		cv.addPoint((int)(18*i*0.25)+220, (int) density_plot_MC_cov_min[i]);
		cv.addPoint((int)(18*i*0.25)+220, (int) density_plot_MC_cov_max[i]);
		cv.addPoint((int)(18*(i-1)*0.25)+220, (int) density_plot_MC_cov_max[i-1]);
	    cv.addPoint((int)(18*(i-1)*0.25)+220, (int) density_plot_MC_cov_min[i-1]);
g.setColor(Color.red);
g.fillPolygon(cv);

}

//draw data
g.setColor(Color.blue);

 for (int i=0;i<40;i++)
 {
g.fillRect((int)(18*i*0.25)+220,(int)(density_plot_data_cov[i]),2,2); 
}
g.setColor(Color.green);

 for (int i=0;i<40;i++)
 {
//g.fillRect((int)(18*i*0.25)+220,(int)(r_density_plot_data_cov[i]),2,2); 
}
g.setColor(Color.yellow);

 for (int i=0;i<40;i++)
 {
//g.fillRect((int)(18*i*0.25)+220,(int)(c_density_plot_data_cov[i]),2,2); 
}
//**lacunarity graph
g.setColor(Color.black);
g.drawRect(1,400,200,200);
g.drawLine(20,590,190,590);
g.drawLine(20,420,20,590);
g.drawString("Lacunarity Average",15,415);
g.drawRect(1,600,200,200);
g.drawLine(20,790,190,790);
g.drawLine(20,620,20,790);
g.drawString("Lacunarity Variation",15,615);
//top graph
//scale data
 max_point=lacunarity_plot_data_average[1];
 min_point=lacunarity_plot_data_average[1];
if (montecarlo){
for (int i=0;i<40;i++)
 {
 if (lacunarity_plot_data_average[i]>max_point){max_point=lacunarity_plot_data_average[i];}
  if (lacunarity_plot_data_average[i]<min_point){min_point=lacunarity_plot_data_average[i];}
   if (r_lacunarity_plot_data_average[i]>max_point){max_point=r_lacunarity_plot_data_average[i];}
  if (r_lacunarity_plot_data_average[i]<min_point){min_point=r_lacunarity_plot_data_average[i];}
     if (c_lacunarity_plot_data_average[i]>max_point){max_point=c_lacunarity_plot_data_average[i];}
  if (c_lacunarity_plot_data_average[i]<min_point){min_point=c_lacunarity_plot_data_average[i];}
  if (lacunarity_plot_MC_max[i]<min_point){min_point=lacunarity_plot_MC_max[i];}
    if (lacunarity_plot_MC_max[i]>max_point){max_point=lacunarity_plot_MC_max[i];}
  if (lacunarity_plot_MC_min[i]<min_point){min_point=lacunarity_plot_MC_min[i];}
    if (lacunarity_plot_MC_min[i]>max_point){max_point=lacunarity_plot_MC_min[i];}
}
}
if (!montecarlo){
for (int i=0;i<40;i++)
 {
      if (c_lacunarity_plot_data_average[i]>max_point){max_point=c_lacunarity_plot_data_average[i];}
  if (c_lacunarity_plot_data_average[i]<min_point){min_point=c_lacunarity_plot_data_average[i];}
 if (lacunarity_plot_data_average[i]>max_point){max_point=lacunarity_plot_data_average[i];}
  if (lacunarity_plot_data_average[i]<min_point){min_point=lacunarity_plot_data_average[i];}
   if (r_lacunarity_plot_data_average[i]>max_point){max_point=r_lacunarity_plot_data_average[i];}
  if (r_lacunarity_plot_data_average[i]<min_point){min_point=r_lacunarity_plot_data_average[i];}
}
}

//we want the data to span 370 pixels
 draw_scale_factor = 170/(max_point-min_point);
 for (int i=0;i<40;i++)
 {
lacunarity_plot_data_average[i]=580-(lacunarity_plot_data_average[i]-min_point)*draw_scale_factor;
r_lacunarity_plot_data_average[i]=580-(r_lacunarity_plot_data_average[i]-min_point)*draw_scale_factor;
c_lacunarity_plot_data_average[i]=580-(c_lacunarity_plot_data_average[i]-min_point)*draw_scale_factor;

//end scale data
}
//draw MC max
for (int i=0;i<40;i++)
 {
lacunarity_plot_MC_max[i]=580-(lacunarity_plot_MC_max[i]-min_point)*draw_scale_factor;
if (lacunarity_plot_MC_max[i]>580){lacunarity_plot_MC_max[i]=580;}
if (lacunarity_plot_MC_max[i]<400){lacunarity_plot_MC_max[i]=400;}
//end scale data
}
//draw data
 for (int i=0;i<40;i++)
 {
lacunarity_plot_MC_min[i]=580-(lacunarity_plot_MC_min[i]-min_point)*draw_scale_factor;
if (lacunarity_plot_MC_min[i]>580){lacunarity_plot_MC_min[i]=580;}
if (lacunarity_plot_MC_min[i]<400){lacunarity_plot_MC_min[i]=400;}
//end scale data
}

 for (int i=1;i<40;i++)
 {
  Polygon p;
  p= new Polygon();
	    p.addPoint((int)(18*(i-1)*0.25)+20, (int) lacunarity_plot_MC_min[i-1]);
		p.addPoint((int)(18*i*0.25)+20, (int) lacunarity_plot_MC_min[i]);
		p.addPoint((int)(18*i*0.25)+20, (int) lacunarity_plot_MC_max[i]);
		p.addPoint((int)(18*(i-1)*0.25)+20, (int) lacunarity_plot_MC_max[i-1]);
	    p.addPoint((int)(18*(i-1)*0.25)+20, (int) lacunarity_plot_MC_min[i-1]);
g.setColor(Color.red);
g.fillPolygon(p);

}

//draw data
g.setColor(Color.blue);

 for (int i=0;i<40;i++)
 {
g.fillRect((int)(18*i*0.25)+20,(int)(lacunarity_plot_data_average[i]),2,2); 
}
g.setColor(Color.green);

 for (int i=0;i<40;i++)
 {
//g.fillRect((int)(18*i*0.25)+20,(int)(r_lacunarity_plot_data_average[i]),2,2); 
}
g.setColor(Color.yellow);

 for (int i=0;i<40;i++)
 {
//g.fillRect((int)(18*i*0.25)+20,(int)(c_lacunarity_plot_data_average[i]),2,2); 
}

//lower graph
//scale data
 max_point=lacunarity_plot_data_cov[1];
 min_point=lacunarity_plot_data_cov[1];
if (montecarlo){
for (int i=0;i<40;i++)
 {
 if (lacunarity_plot_data_cov[i]>max_point){max_point=lacunarity_plot_data_cov[i];}
  if (lacunarity_plot_data_cov[i]<min_point){min_point=lacunarity_plot_data_cov[i];}
//   if (r_lacunarity_plot_data_cov[i]>max_point){max_point=r_lacunarity_plot_data_cov[i];}
//  if (r_lacunarity_plot_data_cov[i]<min_point){min_point=r_lacunarity_plot_data_cov[i];}
  if (lacunarity_plot_MC_cov_max[i]<min_point){min_point=lacunarity_plot_MC_cov_max[i];}
    if (lacunarity_plot_MC_cov_max[i]>max_point){max_point=lacunarity_plot_MC_cov_max[i];}
  if (lacunarity_plot_MC_cov_min[i]<min_point){min_point=lacunarity_plot_MC_cov_min[i];}
    if (lacunarity_plot_MC_cov_min[i]>max_point){max_point=lacunarity_plot_MC_cov_min[i];}
}
}
if (!montecarlo){
for (int i=4;i<40;i++)
 {
 if (lacunarity_plot_data_cov[i]>max_point){max_point=lacunarity_plot_data_cov[i];}
  if (lacunarity_plot_data_cov[i]<min_point){min_point=lacunarity_plot_data_cov[i];}
//   if (r_lacunarity_plot_data_cov[i]>max_point){max_point=r_lacunarity_plot_data_cov[i];}
//  if (r_lacunarity_plot_data_cov[i]<min_point){min_point=r_lacunarity_plot_data_cov[i];}
}
}
//we want the data to span 370 pixels
 draw_scale_factor = 170/(max_point-min_point);
 for (int i=0;i<40;i++)
 {
lacunarity_plot_data_cov[i]=780-(lacunarity_plot_data_cov[i]-min_point)*draw_scale_factor;
r_lacunarity_plot_data_cov[i]=780-(r_lacunarity_plot_data_cov[i]-min_point)*draw_scale_factor;
c_lacunarity_plot_data_cov[i]=780-(c_lacunarity_plot_data_cov[i]-min_point)*draw_scale_factor;

//end scale data
}


//draw MC max
 for (int i=0;i<40;i++)
 {
lacunarity_plot_MC_cov_max[i]=780-(lacunarity_plot_MC_cov_max[i]-min_point)*draw_scale_factor;
if (lacunarity_plot_MC_cov_max[i]>780){lacunarity_plot_MC_cov_max[i]=780;}
if (lacunarity_plot_MC_cov_max[i]<600){lacunarity_plot_MC_cov_max[i]=600;}
//end scale data
}
//draw data
 for (int i=0;i<40;i++)
 {
lacunarity_plot_MC_cov_min[i]=780-(lacunarity_plot_MC_cov_min[i]-min_point)*draw_scale_factor;
if (lacunarity_plot_MC_cov_min[i]>780){lacunarity_plot_MC_cov_min[i]=780;}
if (lacunarity_plot_MC_cov_min[i]<600){lacunarity_plot_MC_cov_min[i]=600;}
//end scale data
}

 for (int i=1;i<40;i++)
 {
  Polygon cv;
  cv= new Polygon();
	    cv.addPoint((int)(18*(i-1)*0.25)+20, (int) lacunarity_plot_MC_cov_min[i-1]);
		cv.addPoint((int)(18*i*0.25)+20, (int) lacunarity_plot_MC_cov_min[i]);
		cv.addPoint((int)(18*i*0.25)+20, (int) lacunarity_plot_MC_cov_max[i]);
		cv.addPoint((int)(18*(i-1)*0.25)+20, (int) lacunarity_plot_MC_cov_max[i-1]);
	    cv.addPoint((int)(18*(i-1)*0.25)+20, (int) lacunarity_plot_MC_cov_min[i-1]);
g.setColor(Color.red);
g.fillPolygon(cv);

}

//draw data
g.setColor(Color.blue);

 for (int i=4;i<40;i++)
 {
g.fillRect((int)(18*i*0.25)+20,(int)(lacunarity_plot_data_cov[i]),2,2); 
}
g.setColor(Color.green);

 for (int i=0;i<40;i++)
 {
//g.fillRect((int)(18*i*0.25)+20,(int)(r_lacunarity_plot_data_cov[i]),2,2); 
}
g.setColor(Color.yellow);

 for (int i=0;i<40;i++)
 {
//g.fillRect((int)(18*i*0.25)+20,(int)(c_lacunarity_plot_data_cov[i]),2,2); 
}
//***voronoi graph
//draw graph
g.setColor(Color.black);
g.drawRect(201,400,200,200);
g.drawLine(220,590,390,590);
g.drawLine(220,420,220,590);
g.drawString("Voronoi Distribution",215,415);
/*g.drawRect(201,600,200,200);
g.drawLine(220,790,390,790);
g.drawLine(220,620,220,790);
g.drawString("Density Variation",215,615);*/
//end draw graph

//top graph
//scale data
 max_point=voronoi_plot_data_average[1];
 min_point=voronoi_plot_data_average[1];
if (montecarlo){
for (int i=0;i<100;i++)
 {
 if (voronoi_plot_data_average[i]>max_point){max_point=voronoi_plot_data_average[i];}
  if (voronoi_plot_data_average[i]<min_point){min_point=voronoi_plot_data_average[i];}
   if (r_voronoi_plot_data_average[i]>max_point){max_point=r_voronoi_plot_data_average[i];}
  if (r_voronoi_plot_data_average[i]<min_point){min_point=r_voronoi_plot_data_average[i];}
     if (c_voronoi_plot_data_average[i]>max_point){max_point=c_voronoi_plot_data_average[i];}
  if (c_voronoi_plot_data_average[i]<min_point){min_point=c_voronoi_plot_data_average[i];}
  if (voronoi_plot_MC_max[i]<min_point){min_point=voronoi_plot_MC_max[i];}
    if (voronoi_plot_MC_max[i]>max_point){max_point=voronoi_plot_MC_max[i];}
  if (voronoi_plot_MC_min[i]<min_point){min_point=voronoi_plot_MC_min[i];}
    if (voronoi_plot_MC_min[i]>max_point){max_point=voronoi_plot_MC_min[i];}
}
}
if (!montecarlo){
for (int i=0;i<100;i++)
 {

 if (voronoi_plot_data_average[i]>max_point){max_point=voronoi_plot_data_average[i];}
  if (voronoi_plot_data_average[i]<min_point){min_point=voronoi_plot_data_average[i];}
      if (r_voronoi_plot_data_average[i]>max_point){max_point=r_voronoi_plot_data_average[i];}
  if (r_voronoi_plot_data_average[i]<min_point){min_point=r_voronoi_plot_data_average[i];}
     if (c_voronoi_plot_data_average[i]>max_point){max_point=c_voronoi_plot_data_average[i];}
  if (c_voronoi_plot_data_average[i]<min_point){min_point=c_voronoi_plot_data_average[i];}
}
}

//we want the data to span 370 pixels
 draw_scale_factor = 170/(max_point-min_point);
 for (int i=0;i<100;i++)
 {
voronoi_plot_data_average[i]=580-(voronoi_plot_data_average[i]-min_point)*draw_scale_factor;
r_voronoi_plot_data_average[i]=580-(r_voronoi_plot_data_average[i]-min_point)*draw_scale_factor;
c_voronoi_plot_data_average[i]=580-(c_voronoi_plot_data_average[i]-min_point)*draw_scale_factor;

//end scale data
}
//draw MC max
for (int i=0;i<100;i++)
 {
voronoi_plot_MC_max[i]=580-(voronoi_plot_MC_max[i]-min_point)*draw_scale_factor;
if (voronoi_plot_MC_max[i]>580){voronoi_plot_MC_max[i]=580;}
if (voronoi_plot_MC_max[i]<400){voronoi_plot_MC_max[i]=400;}
//end scale data
}
//draw data
 for (int i=0;i<100;i++)
 {
voronoi_plot_MC_min[i]=580-(voronoi_plot_MC_min[i]-min_point)*draw_scale_factor;
if (voronoi_plot_MC_min[i]>580){voronoi_plot_MC_min[i]=580;}
if (voronoi_plot_MC_min[i]<400){voronoi_plot_MC_min[i]=400;}
//end scale data
}

 for (int i=1;i<40;i++)
 {
  Polygon p;
  p= new Polygon();
	    p.addPoint((int)(18*(i-1)*0.25*1)+220, (int) voronoi_plot_MC_min[i-1]);
		p.addPoint((int)(18*i*0.25*1)+220, (int) voronoi_plot_MC_min[i]);
		p.addPoint((int)(18*i*0.25*1)+220, (int) voronoi_plot_MC_max[i]);
		p.addPoint((int)(18*(i-1)*0.25*1)+220, (int) voronoi_plot_MC_max[i-1]);
	    p.addPoint((int)(18*(i-1)*0.25*1)+220, (int) voronoi_plot_MC_min[i-1]);
g.setColor(Color.red);
g.fillPolygon(p);

}

//draw data
g.setColor(Color.blue);
 for (int i=0;i<40;i++)
 {
g.fillRect((int)(18*i*0.25*1)+220,(int)(voronoi_plot_data_average[i]),2,2); 
}
g.setColor(Color.green);
 for (int i=0;i<40;i++)
 {
//g.fillRect((int)(18*i*0.25*1)+220,(int)(r_voronoi_plot_data_average[i]),2,2); 
}
g.setColor(Color.yellow);
 for (int i=0;i<40;i++)
 {
//g.fillRect((int)(18*i*0.25*1)+220,(int)(c_voronoi_plot_data_average[i]),2,2); 
}




}
}


public PAJ() {
super(10000, 100);
this.setToolTipText("Use Menu cut and paste to transplant data from Excel");
this.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
this.setCellSelectionEnabled(true);
  for (int i=0;i<10000;i++)
  {  
 coordinates_x[i]=0; //x
 coordinates_y[i]=0; //y
 coordinates_z[i]=0; //z
 
}  
  
}

 
  


public static void main(String arg[])  {

 initPAJ();


}

 void regularizeData(double local_max_x, double local_min_x,double local_max_y,double local_min_y,double local_max_z,double local_min_z) {
double r =  rand.nextFloat();
double min_distance=0;

// algorithm:start from a random position: then place next varicoity so that it is at a maxiumal spacing from last one - look at 100 candidates and choose furthest
//first one
r =  rand.nextFloat();
r_coordinates_x[0]=r*(local_max_x-local_min_x) + local_min_x;
r =  rand.nextFloat();
r_coordinates_y[0]=r*(local_max_y-local_min_y) + local_min_y;
r =  rand.nextFloat();
r_coordinates_z[0]=r*(local_max_z-local_min_z) + local_min_z;







 for (int i=1;i<number_of_points;i++)
	{
	double min_distance1=local_max_x;
	double min_distance2=0;

		 for (int j=0;j<500;j++)
		{
		double test_x=rand.nextFloat()*(local_max_x-local_min_x) + local_min_x;
		double test_y=rand.nextFloat()*(local_max_y-local_min_y) + local_min_y;
		double test_z=rand.nextFloat()*(local_max_z-local_min_z) + local_min_z;
		min_distance1=local_max_x;
					 for (int d=0;d<i;d++)
					{
					double distance=Math.sqrt ((r_coordinates_x[d]-test_x)*(r_coordinates_x[d]-test_x)+(r_coordinates_y[d]-test_y)*(r_coordinates_y[d]-test_y)+(r_coordinates_z[d]-test_z)*(r_coordinates_z[d]-test_z));
					if (distance<min_distance1)
						{
						min_distance1=distance;
						}
					}
			if (min_distance1>min_distance2)
				{
				r_coordinates_x[i]=test_x;
				r_coordinates_y[i]=test_y;
				r_coordinates_z[i]=test_z;
				min_distance2=min_distance1;
				} //end point assignment

		} //end d
	}

}

 void clusterizeData(double local_max_x, double local_min_x,double local_max_y,double local_min_y,double local_max_z,double local_min_z) {
double r =  rand.nextFloat();
double min_distance=0;

// algorithm:start from a random position: then place next varicoity so that it is at a maxiumal spacing from last one - look at 100 candidates and choose furthest
//first one

c_coordinates_x[0]=0.25*(local_max_x-local_min_x) + local_min_x;
c_coordinates_y[0]=0.25*(local_max_y-local_min_y) + local_min_y;
c_coordinates_z[0]=0.5*(local_max_z-local_min_z) + local_min_z;

c_coordinates_x[1]=0.25*(local_max_x-local_min_x) + local_min_x;
c_coordinates_y[1]=0.75*(local_max_y-local_min_y) + local_min_y;
c_coordinates_z[1]=0.5*(local_max_z-local_min_z) + local_min_z;

c_coordinates_x[2]=0.75*(local_max_x-local_min_x) + local_min_x;
c_coordinates_y[2]=0.25*(local_max_y-local_min_y) + local_min_y;
c_coordinates_z[2]=0.5*(local_max_z-local_min_z) + local_min_z;

c_coordinates_x[3]=0.75*(local_max_x-local_min_x) + local_min_x;
c_coordinates_y[3]=0.75*(local_max_y-local_min_y) + local_min_y;
c_coordinates_z[3]=0.5*(local_max_z-local_min_z) + local_min_z;






 for (int i=4;i<number_of_points;i++)
	{
	double min_distance1=local_max_x;
	double min_distance2=local_max_x;

		 for (int j=0;j<50;j++)
		{
		double test_x=rand.nextFloat()*(local_max_x-local_min_x) + local_min_x;
		double test_y=rand.nextFloat()*(local_max_y-local_min_y) + local_min_y;
		double test_z=rand.nextFloat()*(local_max_z-local_min_z) + local_min_z;
		min_distance1=local_max_x;
					 for (int d=0;d<i;d++)
					{
					double distance=Math.sqrt ((c_coordinates_x[d]-test_x)*(c_coordinates_x[d]-test_x)+(c_coordinates_y[d]-test_y)*(c_coordinates_y[d]-test_y)+(c_coordinates_z[d]-test_z)*(c_coordinates_z[d]-test_z));
					if (distance<min_distance1)
						{
						min_distance1=distance;
						}
					}
			if (min_distance1<min_distance2)
				{
				c_coordinates_x[i]=test_x;
				c_coordinates_y[i]=test_y;
				c_coordinates_z[i]=test_z;
				min_distance2=min_distance1;
				} //end point assignment

		} //end d
	}

}



 void generateModelData(PAJ dt, TableModel dm, String[][] data) {
double r =  rand.nextFloat();

int local_max_x=25;
int local_min_x=0;
int local_max_y=25;
int local_min_y=0;
int local_max_z=25;
int local_min_z=0;

 for (int i=0;i<500;i++)
// make random set

{
r =  25*rand.nextFloat();
coordinates_x[i]=r;
dm.setValueAt(String.valueOf(r), i, 0);
r =  25*rand.nextFloat();
coordinates_y[i]=r;
dm.setValueAt(String.valueOf(r), i,1);
r =  25*rand.nextFloat();
coordinates_z[i]=r;
dm.setValueAt(String.valueOf(r), i,2);
}

}




 void generateMCData(double local_max_x, double local_min_x,double local_max_y,double local_min_y,double local_max_z,double local_min_z) {
double r =  rand.nextFloat();

//random data
 for (int i=0;i<number_of_points;i++)
{
r =  rand.nextFloat();
mc_coordinates_x[i]=r*(local_max_x-local_min_x) + local_min_x;
r =  rand.nextFloat();
mc_coordinates_y[i]=r*(local_max_y-local_min_y) + local_min_y;
r =  rand.nextFloat();
mc_coordinates_z[i]=r*(local_max_z-local_min_z) + local_min_z;

} //end i



}// end method


 void generatefractalData(PAJ dt, TableModel dm, String[][] data) {
double r =  rand.nextFloat();

coordinates_x[0]=1000;
dm.setValueAt(String.valueOf(1000), 0, 0);
coordinates_y[0]=1000;
dm.setValueAt(String.valueOf(1000), 0,1);
coordinates_z[0]=1000;
dm.setValueAt(String.valueOf(1000), 0,2);

 for (int i=1;i<500;i++)
// make random set
{
				r =  8*rand.nextFloat();
				r=4-r;coordinates_x[i]=coordinates_x[i-1]+r;
dm.setValueAt(String.valueOf(coordinates_x[i]), i, 0);
				r =  8*rand.nextFloat();
				r=4-r;coordinates_y[i]=coordinates_y[i-1]+r;
dm.setValueAt(String.valueOf(coordinates_y[i]), i,1);
				r =  8*rand.nextFloat();
				r=4-r;coordinates_z[i]=coordinates_z[i-1]+r;
dm.setValueAt(String.valueOf(coordinates_z[i]), i,2);
} //end i


}

void generategwData(PAJ dt, TableModel dm, String[][] data) {
double r =  rand.nextFloat();

int local_max_x=25;
int local_min_x=0;
int local_max_y=25;
int local_min_y=0;
int local_max_z=25;
int local_min_z=0;






 int[] terminal=new int[1000]; //for laoding all of the terminals



double closest_approach=0;
double min_distance=0;
int count=0;
double test_x=0;
double test_y=0;
double test_z=0;
double spacing_constant=3;
double spacing_constant_min=1;

boolean good_branch=false;
boolean good_x=false;
boolean good_y=false;
boolean good_z=false;
boolean not_too_close=false;
int primary_varicosities=20;
//first build initial points
number_of_points=500;
r =  5;
coordinates_x[0]=r;
dm.setValueAt(String.valueOf(r), 0, 0);
r =  5;
coordinates_y[0]=r;
dm.setValueAt(String.valueOf(r), 0,1);
r =  5;
coordinates_z[0]=r;
dm.setValueAt(String.valueOf(r), 0,2);

//end primary points



//now initiate secondaries


//lastley, at points to secondaries
	 for (int n=1;n<number_of_points;n++)  //start n loop; initial secondaries: second varicosity

		{
		
//put loop in here to
	 for (int k=1;k<100;k++)  //start n loop; initial secondaries: second varicosity

		{	
			
	int mother_point =  (int)(((n))*rand.nextFloat()); //random point
	//code to stop branching
	
		good_branch=false;			
		if 	((rand.nextFloat()<0.05)&(coordinates_branch[mother_point]==1)) //33% branching at en passent site - make 0 to stop branching
		{ 
		good_branch=true;
		}//end found good point
		if 	(coordinates_branch[mother_point]==0) //66% chance of growth at terminal
		{ 
		good_branch=true;
		}//end found good point	
	if 	(coordinates_x[mother_point]==0) //66% chance of growth at terminal
		{ 
		good_branch=false;
		}//end found good point	

	for (int j=0;j<100;j++)
			{
			//first choose one of the random

				r =  spacing_constant_min+spacing_constant*rand.nextFloat();
				if(rand.nextFloat()>0.5) {r=-1*r;}
			 test_x=coordinates_x[mother_point]+r;
			 			r =  spacing_constant_min+spacing_constant*rand.nextFloat();
				if(rand.nextFloat()>0.5) {r=-1*r;}
			 test_y=coordinates_y[mother_point]+r;
			 			r =  spacing_constant_min+spacing_constant*rand.nextFloat();
				if(rand.nextFloat()>0.5) {r=-1*r;}
			 test_z=coordinates_z[mother_point]+r;
			// see if this point is in bounds
			good_x=false;
				if ((test_x<local_max_x) & (test_x>local_min_x)){good_x=true;}
			good_y=false;
				if ((test_y<local_max_y) & (test_y>local_min_y)){good_y=true;}
			good_z=false;
				if ((test_z<local_max_z) & (test_z>local_min_z)){good_z=true;}
			//check spacing
			
					 min_distance=local_max_x;
			 not_too_close=false;
						 for (int d=0;d<n;d++)
						{
						double distance= Math.sqrt ((coordinates_x[d]-test_x)*(coordinates_x[d]-test_x)+(coordinates_y[d]-test_y)*(coordinates_y[d]-test_y)+(coordinates_z[d]-test_z)*(coordinates_z[d]-test_z));
									if ((distance<min_distance)&(d!=mother_point)){min_distance=distance;}
						} //end d loop
						if (min_distance>2){not_too_close=true;}	
			
			
							if (good_x&good_y&good_z&not_too_close) 
							{
						min_distance=local_max_x;
						double overall_min_distance=local_max_x;
						 for (int d=0;d<20;d++) //look at primary varicosities
						{
						double distance= Math.sqrt ((coordinates_x[d]-test_x)*(coordinates_x[d]-test_x)+(coordinates_y[d]-test_y)*(coordinates_y[d]-test_y)+(coordinates_z[d]-test_z)*(coordinates_z[d]-test_z));
									if ((distance<min_distance)){min_distance=distance;}
						} //end d loop
						if (overall_min_distance>min_distance){
																overall_min_distance=min_distance;
																coordinates_x[n]=test_x;
																coordinates_y[n]=test_y;
																coordinates_z[n]=test_z;
																coordinates_branch[mother_point]=coordinates_branch[mother_point]+1;
																dm.setValueAt(String.valueOf(test_x), n, 0);
																dm.setValueAt(String.valueOf(test_y), n,1);
																dm.setValueAt(String.valueOf(test_z), n,2);
																j=1000;
																k=1000;
																}
							}//end in boundary loop

			}//end j loop; making a new point
		
		}//end k loop; making a new point

		
		}



//end realistic model



}




 void generateSpecialData(PAJ dt, TableModel dm, String[][] data) {
double rx =  rand.nextFloat();
double ry =  rand.nextFloat();
double rz =  rand.nextFloat();
double x1=0;
double x2=0;
double y1=0;
double y2=0;
double z1=0;
double z2=0;
double point_to_point_distance=0;
 for (int i=0;i<1000;i++)
// make random set
{
//then check if too close to all other coordinates - get 100 tries to make sure that we are more than 4 units from nearest
 for (int j=0;j<100000;j++)
 {
 //now go through all i  points generated so far and make sure all distances are over 4
//first make random coordinates
rx =  25*rand.nextFloat();
ry =  25*rand.nextFloat();
rz =  25*rand.nextFloat();
 for (int k=0;k<i;k++)  //scan through points made so far
{
 x1=rx;
 x2=coordinates_x[k];
 y1=ry;
 y2=coordinates_y[k];
 z1=rz;
 z2=coordinates_z[k];
 point_to_point_distance=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2))+((z1-z2)*(z1-z2)));
if (point_to_point_distance<2) {k=i;}
if (k==i-1)
{
coordinates_x[i]=rx;
dm.setValueAt(String.valueOf(rx), i, 0);
coordinates_y[i]=ry;
dm.setValueAt(String.valueOf(ry), i,1);
coordinates_z[i]=rz;
dm.setValueAt(String.valueOf(rz), i,2);
}//end if
if (i==0) //for first point
{
coordinates_x[i]=rx;
dm.setValueAt(String.valueOf(rx), i, 0);
coordinates_y[i]=ry;
dm.setValueAt(String.valueOf(ry), i,1);
coordinates_z[i]=rz;
dm.setValueAt(String.valueOf(rz), i,2);
k=i;
}//end if 2
}//end k
}//end j
} // end i

}

 void generateRegularData(PAJ dt, TableModel dm, String[][] data) {
int point_counter=0;
double rx =  rand.nextFloat();
double ry =  rand.nextFloat();
double rz =  rand.nextFloat();

 for (int i=1;i<11;i++) //x coordinate
{
 for (int j=1;j<11;j++) //y coordinate
{
 for (int k=1;k<11;k++) //z coordinate
{
rx =  0.5-rand.nextFloat();
ry =  0.5-rand.nextFloat();
rz =  0.5-rand.nextFloat();
coordinates_x[i]=4*i+rx;
dm.setValueAt(String.valueOf(4*i+rx/5), point_counter, 0);
coordinates_y[j]=4*j+ry;
dm.setValueAt(String.valueOf(4*j+ry/5), point_counter,1);
coordinates_z[k]=4*k+rz;
dm.setValueAt(String.valueOf(4*k+rz/5), point_counter,2);
point_counter=point_counter+1;
} //end k
} //end j
} //end i

}

 void clearData(PAJ dt, TableModel dm, String[][] data) {
double r =  rand.nextFloat();
 for (int i=0;i<10000;i++)
// make random set
{

coordinates_x[i]=0;
dm.setValueAt(String.valueOf(""), i, 0);

coordinates_y[i]=0;
dm.setValueAt(String.valueOf(""), i,1);

coordinates_z[i]=0;
dm.setValueAt(String.valueOf(""), i,2);
}
}

 void densityMeasures(PAJ dt, TableModel dm, String[][] data) {
double r =  rand.nextFloat();
double[] point_to_point_distance=new double[number_of_points];
double[][] density=new double[number_of_points][40];
double[] density_mc_average=new double[40];
double[] density_mc_cov=new double[40];
double x1=0;
double x2=0;
double y1=0;
double y2=0;
double z1=0;
double z2=0;
double local_min_x=0;
double local_max_x=0;
double local_min_y=0;
double local_max_y=0;
double local_min_z=0;
double local_max_z=0;
double max_distance =0;
 double[] density_average=new double[40];
 double[] density_cov=new double[40];
double rd=0; //radius
//measure local max/mins

local_min_x=min_x*scale_factor;
local_max_x=max_x*scale_factor;
local_min_y=min_y*scale_factor;
local_max_y=max_y*scale_factor;
local_min_z=min_z*scale_factor;
local_max_z=max_z*scale_factor;
//take each point and measure it's distance to all others
//first choose a point
 for (int i=0;i<number_of_points;i++)
{
//now measures distance to all others
 for (int j=0;j<number_of_points;j++)
{
//these have already been scaled
x1=coordinates_x[i];
x2=coordinates_x[j];
y1=coordinates_y[i];
y2=coordinates_y[j];
z1=coordinates_z[i];
z2=coordinates_z[j];
if(data_3D)
{
point_to_point_distance[j]=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2))+((z1-z2)*(z1-z2)));
}
else
{
point_to_point_distance[j]=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)));
}
} //end getting all the distance
//now step out 1 um from each point

//now step out 1 in one unit steps
 for (int l=0;l<40;l++)
{
density[i][l]=0;
rd=l*0.25*scale_factor+scale_factor; //determine working radius
//now go through distances
 for (int k=0;k<number_of_points;k++)
{
if ((point_to_point_distance[k]<rd) & (point_to_point_distance[k]>(rd-1*scale_factor))) 
{
density[i][l]=density[i][l]+1;
}//end if
}//end k
double semi_sphere_volume=(4*3.149*rd*rd*rd/3)-(4*3.149*(rd-1*scale_factor)*(rd-1*scale_factor)*(rd-1*scale_factor)/3);
density[i][l]=density[i][l]/semi_sphere_volume;
} //end j
}  //end point scan i

//now determine average 
  for (int j=0;j<40;j++)
{
density_average[j]=0;
  for (int i=0;i<number_of_points;i++)
{
density_average[j]=density[i][j]+density_average[j];
}

density_average[j]=density_average[j]/number_of_points;
density_plot_data_average[j]=density_average[j]/0.02;
if (Double.isNaN(density_plot_data_average[j])){density_plot_data_average[j]=0;}
}

//now determine cov 
  for (int j=0;j<40;j++)
{
  for (int i=0;i<number_of_points;i++)
{
density_cov[j]=density_cov[j]+Math.sqrt((density[i][j]-density_average[j])*(density[i][j]-density_average[j]));
}
density_cov[j]=density_cov[j]/(number_of_points*density_average[j]);
density_plot_data_cov[j]=density_cov[j];
if (Double.isNaN(density_plot_data_cov[j])){density_plot_data_cov[j]=0;}

}

//now do Monte Carlo

//do the below 100 times
if (montecarlo)
{
 for (int m=0;m<confidence_limit;m++)
{
// make random set
generateMCData(local_max_x,local_min_x,local_max_y,local_min_y,local_max_z,local_min_z);


 for (int i=0;i<number_of_points;i++)
{
//now measures distance to all others
 for (int j=0;j<number_of_points;j++)
{
x1=mc_coordinates_x[i];
x2=mc_coordinates_x[j];
y1=mc_coordinates_y[i];
y2=mc_coordinates_y[j];
z1=mc_coordinates_z[i];
z2=mc_coordinates_z[j];
if(data_3D)
{
point_to_point_distance[j]=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2))+((z1-z2)*(z1-z2)));
}
else
{
point_to_point_distance[j]=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)));
}
} //end getting all the distance (j)

//now step out 1 in one unit steps
 for (int l=0;l<40;l++)
{
density[i][l]=0;
rd=l*0.25*scale_factor+scale_factor; //determine working radius
//now go through distances
 for (int k=0;k<number_of_points;k++)
{
if ((point_to_point_distance[k]<rd) & (point_to_point_distance[k]>(rd-1*scale_factor))) 
{
density[i][l]=density[i][l]+1;
}//end if
}//end k
double semi_sphere_volume=(4*3.149*rd*rd*rd/3)-(4*3.149*(rd-1*scale_factor)*(rd-1*scale_factor)*(rd-1*scale_factor)/3);
density[i][l]=density[i][l]/semi_sphere_volume;
} //end j
}  //end point scan i

//now determine average and cov of each  point
//now determine average 
  for (int j=0;j<40;j++)
{
density_mc_average[j]=0;
  for (int i=0;i<number_of_points;i++)
{
density_mc_average[j]=density[i][j]+density_mc_average[j];
}

density_mc_average[j]=density_mc_average[j]/number_of_points;
density_mc_average[j]=density_mc_average[j]/0.02;

if(m==0){density_plot_MC_max[j]=density_mc_average[j];}
if(m==0){density_plot_MC_min[j]=density_mc_average[j];}
if (density_mc_average[j]>density_plot_MC_max[j]){density_plot_MC_max[j]=density_mc_average[j];}
if (density_mc_average[j]<density_plot_MC_min[j]){density_plot_MC_min[j]=density_mc_average[j];}
if (Double.isNaN(density_plot_MC_min[j])){density_plot_MC_min[j]=0;}
if (Double.isNaN(density_plot_MC_max[j])){density_plot_MC_max[j]=0;}
}

//now determine  cov of each  point
  for (int j=0;j<40;j++)
{
density_mc_cov[j]=0;
  for (int i=0;i<number_of_points;i++)
{
density_mc_cov[j]=density_mc_cov[j]+Math.sqrt((density[i][j]-density_mc_average[j]*0.02)*(density[i][j]-density_mc_average[j]*0.02));
}
density_mc_cov[j]=density_mc_cov[j]/(number_of_points*density_mc_average[j]*0.02);
if(m==0){density_plot_MC_cov_max[j]=density_mc_cov[j];}
if(m==0){density_plot_MC_cov_min[j]=density_mc_cov[j];}
if (density_mc_cov[j]>density_plot_MC_cov_max[j]){density_plot_MC_cov_max[j]=density_mc_cov[j];}
if (density_mc_cov[j]<density_plot_MC_cov_min[j]){density_plot_MC_cov_min[j]=density_mc_cov[j];}
if (Double.isNaN(density_plot_MC_cov_max[j])){density_plot_MC_cov_max[j]=0;}
if (Double.isNaN(density_plot_MC_cov_min[j])){density_plot_MC_cov_min[j]=0;}
}

}//end l 100 loop
}//end montecarlo



//draw data into table
  for (int j=0;j<40;j++)
{
dm.setValueAt(String.valueOf((scale_factor*j*0.25+1*scale_factor)), j,12);
dm.setValueAt(String.valueOf(density_plot_data_average[j]), j,13);
dm.setValueAt(String.valueOf(density_plot_MC_min[j]), j,14);
dm.setValueAt(String.valueOf(density_plot_MC_max[j]), j,15);
dm.setValueAt(String.valueOf(density_plot_data_cov[j]), j,16);
dm.setValueAt(String.valueOf(density_plot_MC_cov_min[j]), j,17);
dm.setValueAt(String.valueOf(density_plot_MC_cov_max[j]), j,18);
}
//repaint(); 
 }


void voronoiMeasures(PAJ dt, TableModel dm, String[][] data) {
double r =  rand.nextFloat();
double x=0;
double y=0;
double z=0;
double voronoi_bin=5;
int voronoi_volume[]=new int[number_of_points];
boolean voronoi_edge[]=new boolean[number_of_points];
int voronoi_dist[]=new int[10000];

int mc_voronoi_volume[]=new int[number_of_points];
boolean mc_voronoi_edge[]=new boolean[number_of_points];
int mc_voronoi_dist[]=new int[10000];
int mc_voronoi_dist_min[]=new int[10000];
int mc_voronoi_dist_max[]=new int[10000];

double vor_data_mc=0;
double vor_data_min=0;
double vor_data_max=0;

double local_min_x=0;
double local_max_x=0;
double local_min_y=0;
double local_max_y=0;
double local_min_z=0;
double local_max_z=0;
int counter=0;
int min_point=0;
double p_distance=0;
double min_p_distance=0;


local_min_x=min_x*scale_factor;
local_max_x=max_x*scale_factor;
local_min_y=min_y*scale_factor;
local_max_y=max_y*scale_factor;
local_min_z=min_z*scale_factor;
local_max_z=max_z*scale_factor;
//first setup voronoi bins - one for each point
//reset voronoi volumes
 for (int p=0;p<number_of_points;p++) {
voronoi_volume[p]=0;
voronoi_dist[p]=0;
}
//scan from min to max through x, y, and z 
//look for nearest point and add one to its bin
 for (int i=(int)local_min_x;i<(int)local_max_x;i++)
{
 for (int j=(int)local_min_y;j<(int)local_max_y;j++)
{
 for (int k=(int)local_min_z;k<(int)local_max_z;k++)
{
//the coordinates for our point are i,j,k; now go through and find nearest point

 for (int p=0;p<number_of_points;p++) {
//measure distance from i,j,k to coordinates p

p_distance=Math.sqrt((i-coordinates_x[p])*(i-coordinates_x[p])+(j-coordinates_y[p])*(j-coordinates_y[p])+(k-coordinates_z[p])*(k-coordinates_z[p]));
if (p==0){ min_p_distance=p_distance;}

if ( min_p_distance>p_distance){
min_p_distance=p_distance;
 min_point=p;
}
 }//end p point search
 //now add to appropriate voronoi

 voronoi_volume[min_point]= voronoi_volume[min_point]+1;
//remove those volumes close to edge
//check to see if our test point is near edge ie if it picks up a i,j,k at edge
voronoi_edge[min_point]=false;
if (i<(int)(local_min_x+3)){voronoi_edge[min_point]=true;}
if (i>(int)(local_max_x-3)){voronoi_edge[min_point]=true;}
if (j<(int)(local_min_y+3)){voronoi_edge[min_point]=true;}
if (j>(int)(local_max_y-3)){voronoi_edge[min_point]=true;}
if (k<(int)(local_min_z+3)){voronoi_edge[min_point]=true;}
if (k>(int)(local_max_z-3)){voronoi_edge[min_point]=true;}
}//end z
}//end y
}//end x
//now work out distribution
//dist scale
//first calculate total volume
/*int total_volume=0;
for (int v=0; v<number_of_points; v++)
{
if (( voronoi_volume[v]>0)&(!voronoi_edge[v])){total_volume=total_volume+1;}
}
*/


for (int v=0; v<1000; v++)
		{
voronoi_dist[v]=0;
 for (int p=0;p<number_of_points;p++) 
			{
if (( voronoi_volume[p]<=v*voronoi_bin)&( voronoi_volume[p]>v*voronoi_bin-voronoi_bin)&(!voronoi_edge[p])) {voronoi_dist[v]=voronoi_dist[v]+1;}
			}//end point scan
//voronoi_dist[v]=voronoi_dist[v]*100/total_volume;
if (Double.isNaN(voronoi_dist[v])){voronoi_dist[v]=0;}
voronoi_plot_data_average[v]=voronoi_dist[v];
		}//end distribution calculation


//r^2 calculation: 15-100, step 5
//use model r^2=ssp*ssp/ssx*ssy
double ssx=0;
double ssy=0;
double sx=0;
double sy=0;
double ssp=0;
double mean_x=0;
double mean_y=0;
//first determine means
int r_bin=10;
for (int count =3; count<21; count++)
{
r_bin=r_bin+5;
mean_x=mean_x+Math.log10(r_bin*r_bin*r_bin);
if(voronoi_dist[count]>0){mean_y=mean_y+Math.log10(voronoi_dist[count]);}
}
mean_x=mean_x/18;
mean_y=mean_y/18;

r_bin=10;
for (int count =3; count<21; count++)
{
r_bin=r_bin+5;
sx=Math.log10(r_bin*r_bin*r_bin)-mean_x;
if(voronoi_dist[count]>0){sy=Math.log10(voronoi_dist[count])-mean_y;}
if(voronoi_dist[count]==0){sy=0-mean_y;}

ssx=ssx+(sx*sx);
ssy=ssy+(sy*sy);
ssp=ssp+(sy*sx);

}
vor_data_r=(ssp*ssp)/(ssx*ssy);

//write voronoi volume to spreasheet
 for (int p=0;p<number_of_points;p++) {
if (!voronoi_edge[p]) {dm.setValueAt(String.valueOf( voronoi_volume[p]), p,26);}
}



//now do Monte Carlo

//do the below 100 times
if (montecarlo)

{
 for (int m=0;m<confidence_limit;m++)
{
// make random set
counter=0;
min_point=0;
min_p_distance=0;

generateMCData(local_max_x,local_min_x,local_max_y,local_min_y,local_max_z,local_min_z);
/*local_max_x=mc_coordinates_x[0];
local_min_x=mc_coordinates_x[0];
local_max_y=mc_coordinates_y[0];
local_min_y=mc_coordinates_y[0];
local_max_z=mc_coordinates_z[0];
local_min_z=mc_coordinates_z[0];
 for (int i=0;i<number_of_points;i++)
{
if (mc_coordinates_x[i]>local_max_x){local_max_x=mc_coordinates_x[i];}
if (mc_coordinates_x[i]<local_min_x){local_min_x=mc_coordinates_x[i];}
if (mc_coordinates_y[i]>local_max_y){local_max_y=mc_coordinates_y[i];}
if (mc_coordinates_y[i]<local_min_y){local_min_y=mc_coordinates_y[i];}
if (mc_coordinates_z[i]>local_max_z){local_max_z=mc_coordinates_z[i];}
if (mc_coordinates_z[i]<local_min_z){local_min_z=mc_coordinates_z[i];}
}//end max/min i
*/
//reset voronoi volumes
 for (int p=0;p<number_of_points;p++) {
mc_voronoi_volume[p]=0;
mc_voronoi_dist[p]=0;
}

//code

//scan from min to max through x, y, and z 
//look for nearest point and add one to its bin
 for (int i=(int)local_min_x;i<(int)local_max_x;i++)
{
 for (int j=(int)local_min_y;j<(int)local_max_y;j++)
{
 for (int k=(int)local_min_z;k<(int)local_max_z;k++)
{
//the coordinates for our point are i,j,k; now go through and find nearest point

 for (int p=0;p<number_of_points;p++) {
//measure distance from i,j,k to coordinates p

p_distance=Math.sqrt((i-mc_coordinates_x[p])*(i-mc_coordinates_x[p])+(j-mc_coordinates_y[p])*(j-mc_coordinates_y[p])+(k-mc_coordinates_z[p])*(k-mc_coordinates_z[p]));
if (p==0){ min_p_distance=p_distance;}

if ( min_p_distance>p_distance){
min_p_distance=p_distance;
 min_point=p;
}
 }//end p point search
 //now add to appropriate voronoi

 mc_voronoi_volume[min_point]= mc_voronoi_volume[min_point]+1;
//remove those volumes close to edge
//check to see if our test point is near edge ie if it picks up a i,j,k at edge
mc_voronoi_edge[min_point]=false;
if (i<(int)(local_min_x+3)){mc_voronoi_edge[min_point]=true;}
if (i>(int)(local_max_x-3)){mc_voronoi_edge[min_point]=true;}
if (j<(int)(local_min_y+3)){mc_voronoi_edge[min_point]=true;}
if (j>(int)(local_max_y-3)){mc_voronoi_edge[min_point]=true;}
if (k<(int)(local_min_z+3)){mc_voronoi_edge[min_point]=true;}
if (k>(int)(local_max_z-3)){mc_voronoi_edge[min_point]=true;}
}//end z
}//end y
}//end x
//now work out distribution
//dist scale
//total_volume=-0;

for (int v=0; v<1000; v++)
{
 for (int p=0;p<number_of_points;p++) {
if (( mc_voronoi_volume[p]<=v*voronoi_bin)&( mc_voronoi_volume[p]>v*voronoi_bin-voronoi_bin)&(!mc_voronoi_edge[p])) {mc_voronoi_dist[v]=mc_voronoi_dist[v]+1;}
 }//end point scan
//mc_voronoi_dist[v]=mc_voronoi_dist[v]*100/total_volume;

}//end distribution calculation







//determine max and min of dist
for (int v=0; v<1000; v++)
{


if (m==0) //initialize min and max
{
mc_voronoi_dist_min[v]=mc_voronoi_dist[v];
mc_voronoi_dist_max[v]=mc_voronoi_dist[v];
}


if(mc_voronoi_dist[v]<mc_voronoi_dist_min[v]){mc_voronoi_dist_min[v]=mc_voronoi_dist[v];}
if(mc_voronoi_dist[v]>mc_voronoi_dist_max[v]){mc_voronoi_dist_max[v]=mc_voronoi_dist[v];}


voronoi_plot_MC_max[v]=mc_voronoi_dist_max[v];
voronoi_plot_MC_min[v]=mc_voronoi_dist_min[v];

}



//r^2 calculation: 15-100, step 5
//use model r^2=ssp*ssp/ssx*ssy
ssx=0;
ssy=0;
ssp=0;
sx=0;
sy=0;
mean_x=0;
mean_y=0;
//first determine means
r_bin=10;
for (int count =3; count<21; count++)
{
r_bin=r_bin+5;
mean_x=mean_x+Math.log10(r_bin*r_bin*r_bin);
if(mc_voronoi_dist[count]>0){mean_y=mean_y+Math.log10(mc_voronoi_dist[count]);}
}
mean_x=mean_x/18;
mean_y=mean_y/18;
r_bin=10;
for (int count =3; count<21; count++)
{
r_bin=r_bin+5;
sx=Math.log10(r_bin*r_bin*r_bin)-mean_x;
if(mc_voronoi_dist[count]>0){sy=Math.log10(mc_voronoi_dist[count])-mean_y;}
if(mc_voronoi_dist[count]==0){sy=0-mean_y;}

ssx=ssx+(sx*sx);
ssy=ssy+(sy*sy);
ssp=ssp+(sy*sx);
}

vor_data_mc=(ssp*ssp)/(ssx*ssy);
if (m==0) //initialize min and max
{
vor_data_mc_min=vor_data_mc;
vor_data_mc_max=vor_data_mc;
}


if(vor_data_mc<vor_data_mc_min){vor_data_mc_min=vor_data_mc;}
if(vor_data_mc>vor_data_mc_max){vor_data_mc_max=vor_data_mc;}



}//end m

}//end monte carlo

/*
//regular test
if (r_coordinates_x[0]==0)
{regularizeData(local_max_x,local_min_x,local_max_y,local_min_y,local_max_z,local_min_z);}
//first setup voronoi bins - one for each point
//reset voronoi volumes
 for (int p=0;p<number_of_points;p++) {
voronoi_volume[p]=0;
voronoi_dist[p]=0;
}
//scan from min to max through x, y, and z 
//look for nearest point and add one to its bin
 for (int i=(int)local_min_x;i<(int)local_max_x;i++)
{
 for (int j=(int)local_min_y;j<(int)local_max_y;j++)
{
 for (int k=(int)local_min_z;k<(int)local_max_z;k++)
{
//the coordinates for our point are i,j,k; now go through and find nearest point

 for (int p=0;p<number_of_points;p++) {
//measure distance from i,j,k to coordinates p

p_distance=Math.sqrt((i-r_coordinates_x[p])*(i-r_coordinates_x[p])+(j-r_coordinates_y[p])*(j-r_coordinates_y[p])+(k-r_coordinates_z[p])*(k-r_coordinates_z[p]));
if (p==0){ min_p_distance=p_distance;}

if ( min_p_distance>p_distance){
min_p_distance=p_distance;
 min_point=p;
}
 }//end p point search
 //now add to appropriate voronoi

 voronoi_volume[min_point]= voronoi_volume[min_point]+1;
//remove those volumes close to edge
//check to see if our test point is near edge ie if it picks up a i,j,k at edge
voronoi_edge[min_point]=false;
if (i<(int)(local_min_x+3)){voronoi_edge[min_point]=true;}
if (i>(int)(local_max_x-3)){voronoi_edge[min_point]=true;}
if (j<(int)(local_min_y+3)){voronoi_edge[min_point]=true;}
if (j>(int)(local_max_y-3)){voronoi_edge[min_point]=true;}
if (k<(int)(local_min_z+3)){voronoi_edge[min_point]=true;}
if (k>(int)(local_max_z-3)){voronoi_edge[min_point]=true;}
}//end z
}//end y
}//end x



for (int v=0; v<1000; v++)
		{
voronoi_dist[v]=0;
 for (int p=0;p<number_of_points;p++) 
			{
if (( voronoi_volume[p]<=v*voronoi_bin)&( voronoi_volume[p]>v*voronoi_bin-voronoi_bin)&(!voronoi_edge[p])) {voronoi_dist[v]=voronoi_dist[v]+1;}
			}//end point scan
//voronoi_dist[v]=voronoi_dist[v]*100/total_volume;
if (Double.isNaN(voronoi_dist[v])){voronoi_dist[v]=0;}
r_voronoi_plot_data_average[v]=voronoi_dist[v];
		}//end distribution calculation
		
//cluster test
if (c_coordinates_x[0]==0)
{clusterizeData(local_max_x,local_min_x,local_max_y,local_min_y,local_max_z,local_min_z);}
//first setup voronoi bins - one for each point
//reset voronoi volumes
 for (int p=0;p<number_of_points;p++) {
voronoi_volume[p]=0;
voronoi_dist[p]=0;
}
//scan from min to max through x, y, and z 
//look for nearest point and add one to its bin
 for (int i=(int)local_min_x;i<(int)local_max_x;i++)
{
 for (int j=(int)local_min_y;j<(int)local_max_y;j++)
{
 for (int k=(int)local_min_z;k<(int)local_max_z;k++)
{
//the coordinates for our point are i,j,k; now go through and find nearest point

 for (int p=0;p<number_of_points;p++) {
//measure distance from i,j,k to coordinates p

p_distance=Math.sqrt((i-c_coordinates_x[p])*(i-c_coordinates_x[p])+(j-c_coordinates_y[p])*(j-c_coordinates_y[p])+(k-c_coordinates_z[p])*(k-c_coordinates_z[p]));
if (p==0){ min_p_distance=p_distance;}

if ( min_p_distance>p_distance){
min_p_distance=p_distance;
 min_point=p;
}
 }//end p point search
 //now add to appropriate voronoi

 voronoi_volume[min_point]= voronoi_volume[min_point]+1;
//remove those volumes close to edge
//check to see if our test point is near edge ie if it picks up a i,j,k at edge
voronoi_edge[min_point]=false;
if (i<(int)(local_min_x+3)){voronoi_edge[min_point]=true;}
if (i>(int)(local_max_x-3)){voronoi_edge[min_point]=true;}
if (j<(int)(local_min_y+3)){voronoi_edge[min_point]=true;}
if (j>(int)(local_max_y-3)){voronoi_edge[min_point]=true;}
if (k<(int)(local_min_z+3)){voronoi_edge[min_point]=true;}
if (k>(int)(local_max_z-3)){voronoi_edge[min_point]=true;}
}//end z
}//end y
}//end x



for (int v=0; v<1000; v++)
		{
voronoi_dist[v]=0;
 for (int p=0;p<number_of_points;p++) 
			{
if (( voronoi_volume[p]<=v*voronoi_bin)&( voronoi_volume[p]>v*voronoi_bin-voronoi_bin)&(!voronoi_edge[p])) {voronoi_dist[v]=voronoi_dist[v]+1;}
			}//end point scan
//voronoi_dist[v]=voronoi_dist[v]*100/total_volume;
if (Double.isNaN(voronoi_dist[v])){voronoi_dist[v]=0;}
c_voronoi_plot_data_average[v]=voronoi_dist[v];
		}//end distribution calculation
		
*/


 for (int p=0;p<1000;p++) {
 dm.setValueAt(String.valueOf( p*voronoi_bin*scale_factor), p,27);
 dm.setValueAt(String.valueOf( voronoi_dist[p]), p,28);
  dm.setValueAt(String.valueOf( mc_voronoi_dist_min[p]), p,29);
   dm.setValueAt(String.valueOf( mc_voronoi_dist_max[p]), p,30);
dm.setValueAt(String.valueOf(vor_data_r), 12,4);
dm.setValueAt(String.valueOf(vor_data_mc_min), 13,4);
dm.setValueAt(String.valueOf(vor_data_mc_max), 14,4);
 }
}//end voronoi

 
void lacunarityMeasures(PAJ dt, TableModel dm, String[][] data) {
double r =  rand.nextFloat();
int x=0;
int y=0;
int z=0;
double bin_size=0;
int lcount=0;
double average_density[]=new double[50];
double cov_density[]=new double[50];
double mc_average_density[]=new double[50];
double mc_cov_density[]=new double[50];
double local_min_x=0;
double local_max_x=0;
double local_min_y=0;
double local_max_y=0;
double local_min_z=0;
double local_max_z=0;
double lac_data_mc=0;
double lac_data_r=0;
double min_lac_data=0;
double max_lac_data=0;
int counter=0;
int lacunarity_number =10000;
double density[]=new double[lacunarity_number];


//measure local max/mins
local_max_x=coordinates_x[0];
local_min_x=coordinates_x[0];
local_max_y=coordinates_y[0];
local_min_y=coordinates_y[0];
local_max_z=coordinates_z[0];
local_min_z=coordinates_z[0];
 for (int i=0;i<number_of_points;i++)
{
if (coordinates_x[i]>local_max_x){local_max_x=coordinates_x[i];}
if (coordinates_x[i]<local_min_x){local_min_x=coordinates_x[i];}
if (coordinates_y[i]>local_max_y){local_max_y=coordinates_y[i];}
if (coordinates_y[i]<local_min_y){local_min_y=coordinates_y[i];}
if (coordinates_z[i]>local_max_z){local_max_z=coordinates_z[i];}
if (coordinates_z[i]<local_min_z){local_min_z=coordinates_z[i];}
}//end max/min i

//for random

//scan through the bins and measure density
bin_size=0.75;
//bin_size=0.0;

 for (int i=0;i<50;i++)
{
//bin size = scale times i
bin_size=bin_size+0.25;
//now look at many of these bins
//first choose position of bin:  choose a random position


 for (int j=0;j<lacunarity_number;j++)
{
r =  rand.nextFloat();
x=(int)(local_min_x+r*(local_max_x-local_min_x-bin_size));
r =  rand.nextFloat();
y=(int)(local_min_y+r*(local_max_y-local_min_y-bin_size));
r =  rand.nextFloat();
z=(int)(local_min_z+r*(local_max_z-local_min_z-bin_size));


//no go through points and ask for those within the bin
counter=0;
//density[j]=0;
 for (int k=0;k<number_of_points;k++)
{
if ((coordinates_x[k]>x)&(coordinates_x[k]<x+bin_size)&(coordinates_y[k]>y)&(coordinates_y[k]<y+bin_size)&(coordinates_z[k]>z)&(coordinates_z[k]<z+bin_size)) 
{counter=counter+1;}
}//end k
double bin_volume=bin_size*bin_size*bin_size;
density[j]=counter/bin_volume;
}//end j

//now determine average density
average_density[i]=0;
 for (int j=0;j<lacunarity_number;j++) {average_density[i]=density[j]+average_density[i];}
average_density[i]=average_density[i]/lacunarity_number;

lacunarity_plot_data_average[i]=average_density[i];
//if (Double.isNaN(lacunarity_plot_data_average[i])){lacunarity_plot_data_average[i]=0;}

//now determine cov density
cov_density[i]=0;
 for (int j=0;j<lacunarity_number;j++)
{
cov_density[i]=cov_density[i]+((density[j]-average_density[i])*(density[j]-average_density[i]));
}
cov_density[i]=cov_density[i]/lacunarity_number;
cov_density[i]=1+cov_density[i]/(average_density[i]*average_density[i]);
lacunarity_plot_data_cov[i]=cov_density[i];
if (Double.isNaN(lacunarity_plot_data_cov[i])){lacunarity_plot_data_cov[i]=0;}

//r^2 calculation: 1.25-12, step 0.25
//use model r^2=ssp*ssp/ssx*ssy
double ssx=0;
double ssy=0;
double sx=0;
double sy=0;
double ssp=0;
double mean_x=0;
double mean_y=0;
//first determine means
double r_bin=1;
for (int count =1; count<45; count++)
{
r_bin=r_bin+0.25;
mean_x=mean_x+Math.log10(r_bin*r_bin*r_bin);
if(cov_density[count]>0){mean_y=mean_y+Math.log10(cov_density[count]);}
}
mean_x=mean_x/44;
mean_y=mean_y/44;

r_bin=1;
for (int count =1; count<45; count++)
{
r_bin=r_bin+0.25;
sx=Math.log10(r_bin*r_bin*r_bin)-mean_x;
if(cov_density[count]>0){sy=Math.log10(cov_density[count])-mean_y;}
if(cov_density[count]==0){sy=0-mean_y;}

ssx=ssx+(sx*sx);
ssy=ssy+(sy*sy);
ssp=ssp+(sy*sx);

}
lac_data_r=(ssp*ssp)/(ssx*ssy);



}//end i

//start montecarlo

if (montecarlo){
//do the below 100 times
 for (int m=0;m<confidence_limit;m++)
{
// make random set
generateMCData(local_max_x,local_min_x,local_max_y,local_min_y,local_max_z,local_min_z);
/*
//measure local max/mins
local_max_x=mc_coordinates_x[0];
local_min_x=mc_coordinates_x[0];
local_max_y=mc_coordinates_y[0];
local_min_y=mc_coordinates_y[0];
local_max_z=mc_coordinates_z[0];
local_min_z=mc_coordinates_z[0];
 for (int i=0;i<number_of_points;i++)
{
if (mc_coordinates_x[i]>local_max_x){local_max_x=mc_coordinates_x[i];}
if (mc_coordinates_x[i]<local_min_x){local_min_x=mc_coordinates_x[i];}
if (mc_coordinates_y[i]>local_max_y){local_max_y=mc_coordinates_y[i];}
if (mc_coordinates_y[i]<local_min_y){local_min_y=mc_coordinates_y[i];}
if (mc_coordinates_z[i]>local_max_z){local_max_z=mc_coordinates_z[i];}
if (mc_coordinates_z[i]<local_min_z){local_min_z=mc_coordinates_z[i];}
}//end max/min i
*/
//for random

//scan through the bins and measure density
bin_size=0.75;
//bin_size=0.0;

 for (int i=0;i<50;i++)
{
//bin size = scale times i
bin_size=bin_size+0.25;
//now look at many of these bins
//first choose position of bin:  choose a random position


 for (int j=0;j<lacunarity_number;j++)
{
r =  rand.nextFloat();
x=(int)(local_min_x+r*(local_max_x-local_min_x-bin_size));
r =  rand.nextFloat();
y=(int)(local_min_y+r*(local_max_y-local_min_y-bin_size));
r =  rand.nextFloat();
z=(int)(local_min_z+r*(local_max_z-local_min_z-bin_size));


//no go through points and ask for those within the bin
counter=0;
//density[j]=0;
 for (int k=0;k<number_of_points;k++)
{
if ((mc_coordinates_x[k]>x)&(mc_coordinates_x[k]<x+bin_size)&(mc_coordinates_y[k]>y)&(mc_coordinates_y[k]<y+bin_size)&(mc_coordinates_z[k]>z)&(mc_coordinates_z[k]<z+bin_size)) 
{counter=counter+1;}
}//end k
double bin_volume=bin_size*bin_size*bin_size;
density[j]=counter/bin_volume;
}//end j

//now determine average density
average_density[i]=0;
 for (int j=0;j<lacunarity_number;j++) {average_density[i]=density[j]+average_density[i];}
average_density[i]=average_density[i]/lacunarity_number;
if (m==0){
lacunarity_plot_MC_max[i]=average_density[i];
lacunarity_plot_MC_min[i]=average_density[i];
		}
if (average_density[i]>lacunarity_plot_MC_max[i]) {lacunarity_plot_MC_max[i]=average_density[i];}
if (average_density[i]<lacunarity_plot_MC_min[i]) {lacunarity_plot_MC_min[i]=average_density[i];}
//now determine cov density
cov_density[i]=0;
 for (int j=0;j<lacunarity_number;j++)
{
cov_density[i]=cov_density[i]+((density[j]-average_density[i])*(density[j]-average_density[i]));
}
cov_density[i]=cov_density[i]/lacunarity_number;
cov_density[i]=1+cov_density[i]/(average_density[i]*average_density[i]);


if (m==0){
		lacunarity_plot_MC_cov_min[i]=cov_density[i];
		lacunarity_plot_MC_cov_max[i]=cov_density[i];
		}
if (cov_density[i]>lacunarity_plot_MC_cov_max[i]) {lacunarity_plot_MC_cov_max[i]=cov_density[i];}
if (cov_density[i]<lacunarity_plot_MC_cov_min[i]) {lacunarity_plot_MC_cov_min[i]=cov_density[i];}





}//end i bin

//r^2 calculation: 1.25-12, step 0.25
//use model r^2=ssp*ssp/ssx*ssy
double ssx=0;
double ssy=0;
double sx=0;
double sy=0;
double ssp=0;
double mean_x=0;
double mean_y=0;
//first determine means
double r_bin=1;
for (int count =1; count<45; count++)
{
r_bin=r_bin+0.25;
mean_x=mean_x+Math.log10(r_bin*r_bin*r_bin);
if(cov_density[count]>0){mean_y=mean_y+Math.log10(cov_density[count]);}
}
mean_x=mean_x/44;
mean_y=mean_y/44;

r_bin=1;
for (int count =1; count<45; count++)
{
r_bin=r_bin+0.25;
sx=Math.log10(r_bin*r_bin*r_bin)-mean_x;
if(cov_density[count]>0){sy=Math.log10(cov_density[count])-mean_y;}
if(cov_density[count]==0){sy=0-mean_y;}

ssx=ssx+(sx*sx);
ssy=ssy+(sy*sy);
ssp=ssp+(sy*sx);

}
lac_data_mc=(ssp*ssp)/(ssx*ssy);



if (m==0) {
min_lac_data=lac_data_mc;
max_lac_data=lac_data_mc;
}
if (m>0) {
if (lac_data_mc>max_lac_data) {max_lac_data=lac_data_mc;}
if (lac_data_mc<min_lac_data) {min_lac_data=lac_data_mc;}
		}

}//end mc 100 loop m


}//end montecarlo
/*
//regular data
if (r_coordinates_x[0]==0)
{regularizeData(local_max_x,local_min_x,local_max_y,local_min_y,local_max_z,local_min_z);}


//scan through the bins and measure density
bin_size=0.75;
//bin_size=0.0;

 for (int i=0;i<50;i++)
{
//bin size = scale times i
bin_size=bin_size+0.25;
//now look at many of these bins
//first choose position of bin:  choose a random position


 for (int j=0;j<lacunarity_number;j++)
{
r =  rand.nextFloat();
x=(int)(local_min_x+r*(local_max_x-local_min_x-bin_size));
r =  rand.nextFloat();
y=(int)(local_min_y+r*(local_max_y-local_min_y-bin_size));
r =  rand.nextFloat();
z=(int)(local_min_z+r*(local_max_z-local_min_z-bin_size));


//no go through points and ask for those within the bin
counter=0;
//density[j]=0;
 for (int k=0;k<number_of_points;k++)
{
if ((r_coordinates_x[k]>x)&(r_coordinates_x[k]<x+bin_size)&(r_coordinates_y[k]>y)&(r_coordinates_y[k]<y+bin_size)&(r_coordinates_z[k]>z)&(r_coordinates_z[k]<z+bin_size)) 
{counter=counter+1;}
}//end k
double bin_volume=bin_size*bin_size*bin_size;
density[j]=counter/bin_volume;
}//end j

//now determine average density
average_density[i]=0;
 for (int j=0;j<lacunarity_number;j++) {average_density[i]=density[j]+average_density[i];}
average_density[i]=average_density[i]/lacunarity_number;

r_lacunarity_plot_data_average[i]=average_density[i];
//if (Double.isNaN(lacunarity_plot_data_average[i])){lacunarity_plot_data_average[i]=0;}

//now determine cov density
cov_density[i]=0;
 for (int j=0;j<lacunarity_number;j++)
{
cov_density[i]=cov_density[i]+((density[j]-average_density[i])*(density[j]-average_density[i]));
}
cov_density[i]=cov_density[i]/lacunarity_number;
cov_density[i]=1+cov_density[i]/(average_density[i]*average_density[i]);
r_lacunarity_plot_data_cov[i]=cov_density[i];
if (Double.isNaN(r_lacunarity_plot_data_cov[i])){r_lacunarity_plot_data_cov[i]=0;}





}//end i

//cluster data
if (c_coordinates_x[0]==0)
{clusterizeData(local_max_x,local_min_x,local_max_y,local_min_y,local_max_z,local_min_z);}


//scan through the bins and measure density
bin_size=0.75;
//bin_size=0.0;

 for (int i=0;i<50;i++)
{
//bin size = scale times i
bin_size=bin_size+0.25;
//now look at many of these bins
//first choose position of bin:  choose a random position


 for (int j=0;j<lacunarity_number;j++)
{
r =  rand.nextFloat();
x=(int)(local_min_x+r*(local_max_x-local_min_x-bin_size));
r =  rand.nextFloat();
y=(int)(local_min_y+r*(local_max_y-local_min_y-bin_size));
r =  rand.nextFloat();
z=(int)(local_min_z+r*(local_max_z-local_min_z-bin_size));


//no go through points and ask for those within the bin
counter=0;
//density[j]=0;
 for (int k=0;k<number_of_points;k++)
{
if ((c_coordinates_x[k]>x)&(c_coordinates_x[k]<x+bin_size)&(c_coordinates_y[k]>y)&(c_coordinates_y[k]<y+bin_size)&(c_coordinates_z[k]>z)&(c_coordinates_z[k]<z+bin_size)) 
{counter=counter+1;}
}//end k
double bin_volume=bin_size*bin_size*bin_size;
density[j]=counter/bin_volume;
}//end j

//now determine average density
average_density[i]=0;
 for (int j=0;j<lacunarity_number;j++) {average_density[i]=density[j]+average_density[i];}
average_density[i]=average_density[i]/lacunarity_number;

c_lacunarity_plot_data_average[i]=average_density[i];
//if (Double.isNaN(lacunarity_plot_data_average[i])){lacunarity_plot_data_average[i]=0;}

//now determine cov density
cov_density[i]=0;
 for (int j=0;j<lacunarity_number;j++)
{
cov_density[i]=cov_density[i]+((density[j]-average_density[i])*(density[j]-average_density[i]));
}
cov_density[i]=cov_density[i]/lacunarity_number;
cov_density[i]=1+cov_density[i]/(average_density[i]*average_density[i]);
c_lacunarity_plot_data_cov[i]=cov_density[i];
if (Double.isNaN(c_lacunarity_plot_data_cov[i])){c_lacunarity_plot_data_cov[i]=0;}





}//end i

*/
//now load data
bin_size=1;
  for (int j=0;j<100;j++)
{
bin_size=bin_size+0.25;
dm.setValueAt(String.valueOf((bin_size)/scale_factor), j,19);
dm.setValueAt(String.valueOf(lacunarity_plot_data_average[j]), j,20);
dm.setValueAt(String.valueOf(lacunarity_plot_MC_min[j]), j,21);
dm.setValueAt(String.valueOf(lacunarity_plot_MC_max[j]), j,22);
dm.setValueAt(String.valueOf(lacunarity_plot_data_cov[j]), j,23);
dm.setValueAt(String.valueOf(lacunarity_plot_MC_cov_min[j]), j,24);
dm.setValueAt(String.valueOf(lacunarity_plot_MC_cov_max[j]), j,25);
dm.setValueAt(String.valueOf(lac_data_r), 15,4);
dm.setValueAt(String.valueOf(min_lac_data), 16,4);
dm.setValueAt(String.valueOf(max_lac_data), 17,4);
 for (int p=0;p<number_of_points;p++) {

dm.setValueAt(String.valueOf( mc_coordinates_x[p]), p,31);
dm.setValueAt(String.valueOf( mc_coordinates_y[p]), p,32);
dm.setValueAt(String.valueOf( mc_coordinates_z[p]), p,33);

 }

}





}

 void rankMeasures(PAJ dt, TableModel dm, String[][] data) {
double r =  rand.nextFloat();
double[] point_to_point_distance=new double[5*number_of_points];
double[][] rank=new double[5*number_of_points][40];

 double[] rank_mc_average=new double[40];
 double[] rank_mc_cov=new double[40];
//static double r =  rand.nextFloat();
double local_min_x=0;
double local_max_x=0;
double local_min_y=0;
double local_max_y=0;
double local_min_z=0;
double local_max_z=0;
double x1=0;
double x2=0;
double y1=0;
double y2=0;
double z1=0;
double z2=0;
 double max_distance =0;

//measure local max/mins
local_max_x=coordinates_x[0];
local_min_x=coordinates_x[0];
local_max_y=coordinates_y[0];
local_min_y=coordinates_y[0];
local_max_z=coordinates_z[0];
local_min_z=coordinates_z[0];
 for (int i=0;i<number_of_points;i++)
{
if (coordinates_x[i]>local_max_x){local_max_x=coordinates_x[i];}
if (coordinates_x[i]<local_min_x){local_min_x=coordinates_x[i];}
if (coordinates_y[i]>local_max_y){local_max_y=coordinates_y[i];}
if (coordinates_y[i]<local_min_y){local_min_y=coordinates_y[i];}
if (coordinates_z[i]>local_max_z){local_max_z=coordinates_z[i];}
if (coordinates_z[i]<local_min_z){local_min_z=coordinates_z[i];}
}//end max/min i



//take each point and measure it's distance to all others
//first choose a point
 for (int i=0;i<number_of_points;i++)
{
//now measures distance to all others
 for (int j=0;j<number_of_points;j++)
{
x1=coordinates_x[i];
x2=coordinates_x[j];
y1=coordinates_y[i];
y2=coordinates_y[j];
z1=coordinates_z[i];
z2=coordinates_z[j];
if(data_3D)
{
point_to_point_distance[j]=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2))+((z1-z2)*(z1-z2)));
}
else
{
point_to_point_distance[j]=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)));
}
} //end getting all the distance

//now rank and find top 10
//first  determine max distance
max_distance =0;
 for (int j=0;j<number_of_points;j++)
{
if ( point_to_point_distance[j]>max_distance){max_distance=point_to_point_distance[j];}
}//end max distance
//set self referening distance to max
point_to_point_distance[i]=max_distance;
//first load all ranks with max distance
 for (int j=0;j<40;j++)
{
rank[i][j]=max_distance;
}

//now go through 10 cyles of  finding minimum distance - for each find, replace distance with max_distance
int point_index=0;

 for (int k=0;k<40;k++)
{

 for (int j=0;j<number_of_points;j++)
{
if (point_to_point_distance[j]<rank[i][k])
{
point_index=j;
rank[i][k]=point_to_point_distance[j];
}
}//end j scan
point_to_point_distance[point_index]=max_distance;  //now replace distance

}//end 10  scan

} //end point scan i

//now determine average 
  for (int j=0;j<40;j++)
{
  for (int i=0;i<number_of_points;i++)
{
rank_average[j]=rank[i][j]+rank_average[j];
}

rank_average[j]=rank_average[j]/number_of_points;
rank_plot_data_average[j]=rank_average[j];
if (Double.isNaN(rank_plot_data_average[j])){rank_plot_data_average[j]=0;}

}

//now determine cov 
  for (int j=0;j<40;j++)
{
  for (int i=0;i<number_of_points;i++)
{
rank_cov[j]=rank_cov[j]+Math.sqrt((rank[i][j]-rank_average[j])*(rank[i][j]-rank_average[j]));
}

rank_cov[j]=rank_cov[j]/(number_of_points*rank_average[j]);
rank_plot_data_cov[j]=rank_cov[j];
if (Double.isNaN(rank_plot_data_cov[j])){rank_plot_data_cov[j]=0;}

}



//now do Monte Carlo

if (montecarlo){
//do the below 100 times
 for (int l=0;l<10;l++)
{
// make random set
generateMCData(local_max_x,local_min_x,local_max_y,local_min_y,local_max_z,local_min_z);

 for (int i=0;i<number_of_points;i++)
{
//now measures distance to all others
 for (int j=0;j<number_of_points;j++)
{
x1=mc_coordinates_x[i];
x2=mc_coordinates_x[j];
y1=mc_coordinates_y[i];
y2=mc_coordinates_y[j];
z1=mc_coordinates_z[i];
z2=mc_coordinates_z[j];
if(data_3D)
{
point_to_point_distance[j]=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2))+((z1-z2)*(z1-z2)));
}
else
{
point_to_point_distance[j]=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)));
}
} //end getting all the distance (j)

//now rank and find top 10
//first  determine max distance
max_distance =0;
 for (int j=0;j<number_of_points;j++)
{
if ( point_to_point_distance[j]>max_distance){max_distance=point_to_point_distance[j];}
}//end max distance
//set self referening distance to max
point_to_point_distance[i]=max_distance;
//first load all ranks with max distance
 for (int j=0;j<40;j++)
{
rank[i][j]=max_distance;
}
//now go through 10 cyles of  finding minimum distance - for each find, replace distance with max_distance
int point_index=0;

 for (int k=0;k<40;k++)
{

 for (int j=0;j<number_of_points;j++)
{
if (point_to_point_distance[j]<rank[i][k])
{
point_index=j;
rank[i][k]=point_to_point_distance[j];
}
}//end j scan
point_to_point_distance[point_index]=max_distance;  //now replace distance

}//end 10  scan (k)

} //end point scan i

//now determine average and cov of each  point
  for (int j=0;j<40;j++)
{
  for (int i=0;i<number_of_points;i++)
{
rank_mc_average[j]=rank[i][j]+rank_mc_average[j];
}

rank_mc_average[j]=rank_mc_average[j]/number_of_points;
if (Double.isNaN(rank_mc_average[j])){rank_mc_average[j]=0;}

if (rank_mc_average[j]>rank_plot_MC_max[j]){rank_plot_MC_max[j]=rank_mc_average[j];}
if (rank_mc_average[j]<rank_plot_MC_min[j]){rank_plot_MC_min[j]=rank_mc_average[j];}


if(l==1){rank_plot_MC_max[j]=rank_mc_average[j];}
if(l==1){rank_plot_MC_min[j]=rank_mc_average[j];}
}

//now determine  cov of each  point
  for (int j=0;j<40;j++)
{
  for (int i=0;i<number_of_points;i++)
{
rank_mc_cov[j]=rank_mc_cov[j]+Math.sqrt((rank[i][j]-rank_mc_average[j])*(rank[i][j]-rank_mc_average[j]));
}

rank_mc_cov[j]=rank_mc_cov[j]/(number_of_points*rank_mc_average[j]);
if (Double.isNaN(rank_mc_cov[j])){rank_mc_cov[j]=0;}

if (rank_mc_cov[j]>rank_plot_MC_cov_max[j]){rank_plot_MC_cov_max[j]=rank_mc_cov[j];}
if (rank_mc_cov[j]<rank_plot_MC_cov_min[j]){rank_plot_MC_cov_min[j]=rank_mc_cov[j];}
if(l==1){rank_plot_MC_cov_max[j]=rank_mc_cov[j];}
if(l==1){rank_plot_MC_cov_min[j]=rank_mc_cov[j];}
}



}//end l 100 loop
}//end montecarlo

/*
 //regular model
 regularizeData(local_max_x,local_min_x,local_max_y,local_min_y,local_max_z,local_min_z);

 //take each point and measure it's distance to all others
//first choose a point
 for (int i=0;i<number_of_points;i++)
{
//now measures distance to all others
 for (int j=0;j<number_of_points;j++)
{
x1=r_coordinates_x[i];
x2=r_coordinates_x[j];
y1=r_coordinates_y[i];
y2=r_coordinates_y[j];
z1=r_coordinates_z[i];
z2=r_coordinates_z[j];
if(data_3D)
{
point_to_point_distance[j]=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2))+((z1-z2)*(z1-z2)));
}
else
{
point_to_point_distance[j]=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)));
}
} //end getting all the distance

//now rank and find top 10
//first  determine max distance
max_distance =0;
 for (int j=0;j<number_of_points;j++)
{
if ( point_to_point_distance[j]>max_distance){max_distance=point_to_point_distance[j];}
}//end max distance
//set self referening distance to max
point_to_point_distance[i]=max_distance;
//first load all ranks with max distance
 for (int j=0;j<40;j++)
{
rank[i][j]=max_distance;
}

//now go through 10 cyles of  finding minimum distance - for each find, replace distance with max_distance
int point_index=0;

 for (int k=0;k<40;k++)
{

 for (int j=0;j<number_of_points;j++)
{
if (point_to_point_distance[j]<rank[i][k])
{
point_index=j;
rank[i][k]=point_to_point_distance[j];
}
}//end j scan
point_to_point_distance[point_index]=max_distance;  //now replace distance

}//end 10  scan

} //end point scan i

//now determine average 
  for (int j=0;j<40;j++)
{
  for (int i=0;i<number_of_points;i++)
{
rank_average[j]=rank[i][j]+rank_average[j];
}

rank_average[j]=rank_average[j]/number_of_points;
r_rank_plot_data_average[j]=rank_average[j];
if (Double.isNaN(r_rank_plot_data_average[j])){r_rank_plot_data_average[j]=0;}

}

//now determine cov 
  for (int j=0;j<40;j++)
{
  for (int i=0;i<number_of_points;i++)
{
rank_cov[j]=rank_cov[j]+Math.sqrt((rank[i][j]-rank_average[j])*(rank[i][j]-rank_average[j]));
}

rank_cov[j]=rank_cov[j]/(number_of_points*rank_average[j]);
r_rank_plot_data_cov[j]=rank_cov[j];
if (Double.isNaN(r_rank_plot_data_cov[j])){r_rank_plot_data_cov[j]=0;}

}

 //cluster model
 clusterizeData(local_max_x,local_min_x,local_max_y,local_min_y,local_max_z,local_min_z);

 //take each point and measure it's distance to all others
//first choose a point
 for (int i=0;i<number_of_points;i++)
{
//now measures distance to all others
 for (int j=0;j<number_of_points;j++)
{
x1=c_coordinates_x[i];
x2=c_coordinates_x[j];
y1=c_coordinates_y[i];
y2=c_coordinates_y[j];
z1=c_coordinates_z[i];
z2=c_coordinates_z[j];
if(data_3D)
{
point_to_point_distance[j]=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2))+((z1-z2)*(z1-z2)));
}
else
{
point_to_point_distance[j]=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)));
}
} //end getting all the distance

//now rank and find top 10
//first  determine max distance
max_distance =0;
 for (int j=0;j<number_of_points;j++)
{
if ( point_to_point_distance[j]>max_distance){max_distance=point_to_point_distance[j];}
}//end max distance
//set self referening distance to max
point_to_point_distance[i]=max_distance;
//first load all ranks with max distance
 for (int j=0;j<40;j++)
{
rank[i][j]=max_distance;
}

//now go through 10 cyles of  finding minimum distance - for each find, replace distance with max_distance
int point_index=0;

 for (int k=0;k<40;k++)
{

 for (int j=0;j<number_of_points;j++)
{
if (point_to_point_distance[j]<rank[i][k])
{
point_index=j;
rank[i][k]=point_to_point_distance[j];
}
}//end j scan
point_to_point_distance[point_index]=max_distance;  //now replace distance

}//end 10  scan

} //end point scan i

//now determine average 
  for (int j=0;j<40;j++)
{
  for (int i=0;i<number_of_points;i++)
{
rank_average[j]=rank[i][j]+rank_average[j];
}

rank_average[j]=rank_average[j]/number_of_points;
c_rank_plot_data_average[j]=rank_average[j];
if (Double.isNaN(c_rank_plot_data_average[j])){c_rank_plot_data_average[j]=0;}

}

//now determine cov 
  for (int j=0;j<40;j++)
{
  for (int i=0;i<number_of_points;i++)
{
rank_cov[j]=rank_cov[j]+Math.sqrt((rank[i][j]-rank_average[j])*(rank[i][j]-rank_average[j]));
}

rank_cov[j]=rank_cov[j]/(number_of_points*rank_average[j]);
c_rank_plot_data_cov[j]=rank_cov[j];
if (Double.isNaN(c_rank_plot_data_cov[j])){c_rank_plot_data_cov[j]=0;}

}

*/

//draw data into table
  for (int j=0;j<40;j++)
{
dm.setValueAt(String.valueOf(j+1), j,5);
dm.setValueAt(String.valueOf(rank_plot_data_average[j]), j,6);
dm.setValueAt(String.valueOf(rank_plot_MC_min[j]), j,7);
dm.setValueAt(String.valueOf(rank_plot_MC_max[j]), j,8);
dm.setValueAt(String.valueOf(rank_plot_data_cov[j]), j,9);
dm.setValueAt(String.valueOf(rank_plot_MC_cov_min[j]), j,10);
dm.setValueAt(String.valueOf(rank_plot_MC_cov_max[j]), j,11);
}


//draw in example of MC data

 for (int p=0;p<number_of_points;p++) {

dm.setValueAt(String.valueOf( mc_coordinates_x[p]), p,31);
dm.setValueAt(String.valueOf( mc_coordinates_y[p]), p,32);
dm.setValueAt(String.valueOf( mc_coordinates_z[p]), p,33);

 }
 
 
 
 
} //end rankMeasures method


//Minimal spanning tree code
 void mstMeasures(PAJ dt, TableModel dm, String[][] data) {
double r =  rand.nextFloat();
double[] point_to_point_distance=new double[5*number_of_points];
double[][] vertex=new double[number_of_points][number_of_points];
int[] root=new int[number_of_points];

int[][][] maps=new int[number_of_points][5][2]; //this store 5 connectors: first is connector and second is % occurance
int[][] maps_store=new int[5][2]; //this store 5 connectors: first is connector and second is % occurance

//static double r =  rand.nextFloat();
double local_min_x=0;
double local_max_x=0;
double local_min_y=0;
double local_max_y=0;
double local_min_z=0;
double local_max_z=0;
double x1=0;
double x2=0;
double y1=0;
double y2=0;
double z1=0;
double z2=0;
 double max_distance =0;

int loop_num=100;
//measure local max/mins
local_max_x=coordinates_x[0];
local_min_x=coordinates_x[0];
local_max_y=coordinates_y[0];
local_min_y=coordinates_y[0];
local_max_z=coordinates_z[0];
local_min_z=coordinates_z[0];
 for (int i=0;i<number_of_points;i++)
{
if (coordinates_x[i]>local_max_x){local_max_x=coordinates_x[i];}
if (coordinates_x[i]<local_min_x){local_min_x=coordinates_x[i];}
if (coordinates_y[i]>local_max_y){local_max_y=coordinates_y[i];}
if (coordinates_y[i]<local_min_y){local_min_y=coordinates_y[i];}
if (coordinates_z[i]>local_max_z){local_max_z=coordinates_z[i];}
if (coordinates_z[i]<local_min_z){local_min_z=coordinates_z[i];}
}//end max/min i



//take each point and measure it's distance to all others
//first choose a point
 for (int i=0;i<number_of_points;i++)
{
//now measures distance to all others
 for (int j=0;j<number_of_points;j++)
{
x1=coordinates_x[i];
x2=coordinates_x[j];
y1=coordinates_y[i];
y2=coordinates_y[j];
z1=coordinates_z[i];
z2=coordinates_z[j];
if(data_3D)
{
point_to_point_distance[j]=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2))+((z1-z2)*(z1-z2)));
vertex[i][j]=point_to_point_distance[j];
}
else
{
point_to_point_distance[j]=Math.sqrt(((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2)));
vertex[i][j]=point_to_point_distance[j];
}
} //end getting all the distance
}




//for each point, we have 1-10 ranked clostest points 
//for MST, use  Kruskal's/Prim's Algorithm
//choose clostest pair and assign vertex as per 3 conditions
//		a) go through point by point; making sure our point has an opening
//		b) find clostest point to each making sure targetpoint has opening and connection does not form loop
//		c) make connection and assignments

//0 the concenus map
 for (int i=0;i<number_of_points;i++)
{

maps[i][0][0]=-1;
maps[i][1][0]=-1;
maps[i][2][0]=-1;
maps[i][3][0]=-1;
maps[i][4][0]=-1;


}

 //find shorest span
 for (int loop=0;loop<loop_num;loop++)
{

 for (int i=0;i<number_of_points;i++)
{
//now measures distance to all others
k1_mstVertex_1[i]=-1;
k1_mstVertex_2[i]=-1;
k1_mstVertex_3[i]=-1;
root[i]=(-2*i)-2;

}


int[] temp_points=new int[number_of_points]; //store for random point selection
int[] temp_points_heap=new int[number_of_points]; //store for random point selection heap
//first laod the heap
 for (int i=0;i<number_of_points;i++)
{
temp_points_heap[i]=i;
}


 for (int i=0;i<number_of_points;i++)
{
int num=(int)((number_of_points-i)*rand.nextFloat());
temp_points[i]=temp_points_heap[num];
//now re-stack the heap in temp_num
	 for (int j=num;j<number_of_points-1;j++)
	{
	temp_points_heap[j]=temp_points_heap[j+1];
	}
}

 for (int g=0;g<number_of_points-1;g++) //step through and assign a connector to each point
{

int shortest_index_reference=0;
int shortest_pointer_reference=0;
double shortest_vertex_distance=2*local_max_x;
int n=-1;

  n=temp_points[g];

//first make sure we can make a vertex to this point


 for (int i=0;i<number_of_points;i++) //second, step through and find the shorest vertex for this point
{

if ((vertex[n][i]<shortest_vertex_distance) & (k1_mstVertex_3[i]==-1)  & (i!=n)  & (k1_mstVertex_1[i]!=n) & (k1_mstVertex_2[i]!=n) & (k1_mstVertex_3[i]!=n) & (root[n]!=root[i])) //smallest distance and room here to make a branch - also not on same root
	{
	shortest_vertex_distance=vertex[n][i];
	shortest_pointer_reference=i;
	}

}//end finding shorest vertex - which is point #n and connects to point i; assign root[n] to root[i]

			// now make our new vertex


														k1_mstVertex_1[n]=shortest_pointer_reference;
											
														if ((root[n]<0) & (root[shortest_pointer_reference]>-1)) {root[n]=root[shortest_pointer_reference];}
														if ((root[n]<0) & (root[shortest_pointer_reference]<0)) {root[n]=n; root[shortest_pointer_reference]=n;}
														if ((root[n]>-1) & (root[shortest_pointer_reference]<0)) {root[shortest_pointer_reference]=root[n];}
														if ((root[n]>-1) & (root[shortest_pointer_reference]>-1)) {
																													int reference=root[shortest_pointer_reference];
																													root[shortest_pointer_reference]=root[n];
																													//merge trees - convert one to other
																													 for (int k=0;k<number_of_points;k++)
																														{
																														if(root[k]==reference) {root[k]=root[n];}
																														}
																													}

															//now assign back references
															if (k1_mstVertex_2[shortest_pointer_reference]!=-1) {k1_mstVertex_3[shortest_pointer_reference]=n;}
															if ((k1_mstVertex_2[shortest_pointer_reference]==-1)) {k1_mstVertex_2[shortest_pointer_reference]=n;}

	
												


//now draw in dendogram							

		

}//end n
//assign last point
if(k1_mstVertex_3[number_of_points-1]<0) {k1_mstVertex_1[number_of_points-1]=k1_mstVertex_2[number_of_points-1]; k1_mstVertex_2[number_of_points-1]=-1;}
if(k1_mstVertex_3[number_of_points-1]>0) {k1_mstVertex_1[number_of_points-1]=k1_mstVertex_2[number_of_points-1]; k1_mstVertex_2[number_of_points-1]=k1_mstVertex_3[number_of_points-1];k1_mstVertex_3[number_of_points-1]=-1;}

//load concensus array
 for (int p=0;p<number_of_points;p++) {



//first load in old data in temp store
maps_store[0][0]=maps[p][0][0];
maps_store[0][1]=maps[p][0][1];
maps_store[1][0]=maps[p][1][0];
maps_store[1][1]=maps[p][1][1];
maps_store[2][0]=maps[p][2][0];
maps_store[2][1]=maps[p][2][1];
maps_store[3][0]=maps[p][3][0];
maps_store[3][1]=maps[p][3][1];
maps_store[4][0]=maps[p][4][0];
maps_store[4][1]=maps[p][4][1];

//now add new hits

 for (int i=0;i<5;i++) {
if 	((maps_store[i][0]==k1_mstVertex_1[p]+1 ) & (k1_mstVertex_1[p]+1>0)) {maps_store[i][1]=maps_store[i][1]+1;}
if 	((maps_store[i][0]==k1_mstVertex_2[p]+1 ) & (k1_mstVertex_2[p]+1>0)) {maps_store[i][1]=maps_store[i][1]+1;}
if 	((maps_store[i][0]==k1_mstVertex_3[p]+1 ) & (k1_mstVertex_3[p]+1>0)) {maps_store[i][1]=maps_store[i][1]+1;}

											
						}
//now check new points

//step through each vertex and see if it is new - then assign spot
//vertex_1
 boolean new_point=true;
 for (int k=0;k<5;k++)    {
						    if 	((maps_store[k][0]==k1_mstVertex_1[p]+1 )& (k1_mstVertex_1[p]+1>0)){new_point=false;}
						  }
if ((new_point)& (k1_mstVertex_1[p]+1>0)) {
				 for (int i=0;i<5;i++) {
										if (maps_store[i][0]==-1){
																maps_store[i][0]=k1_mstVertex_1[p]+1;
																maps_store[i][1]=1;
																i=5;
																}
										}
			}

//vertex_1
new_point=true;
 for (int k=0;k<5;k++)    {
						    if 	((maps_store[k][0]==k1_mstVertex_2[p]+1 ) & (k1_mstVertex_2[p]+1>0)){new_point=false;}
						  }
if ((new_point)& (k1_mstVertex_2[p]+1>0)) {
				 for (int i=0;i<5;i++) {
										if (maps_store[i][0]==-1){
																maps_store[i][0]=k1_mstVertex_2[p]+1;
																maps_store[i][1]=1;
																i=5;
																}
										}
			}
			

//vertex_1
new_point=true;
 for (int k=0;k<5;k++)    {
						    if 	((maps_store[k][0]==k1_mstVertex_3[p]+1 )& (k1_mstVertex_3[p]+1>0)) {new_point=false;}
						  }
if ((new_point)& (k1_mstVertex_3[p]+1>0)) {
				 for (int i=0;i<5;i++) {
										if (maps_store[i][0]==-1){
																maps_store[i][0]=k1_mstVertex_3[p]+1;
																maps_store[i][1]=1;
																i=5;
																}
										}
			}
			

				
//now load up maps
 for (int i=0;i<5;i++) {
maps[p][i][0]=maps_store[i][0];
maps[p][i][1]=maps_store[i][1];
		}
	
}//end p for loading concensus

//draw in example of MC data
if (loop<5) {
 for (int j=0;j<number_of_points;j++) {
 dm.setValueAt(String.valueOf( j+1), j,69);
dm.setValueAt(String.valueOf( j+1), j,49+loop*4);
dm.setValueAt(String.valueOf( k1_mstVertex_1[j]+1), j,50+loop*4);
if ( k1_mstVertex_1[j]==-1) {dm.setValueAt("", j,50+loop*4);}
dm.setValueAt(String.valueOf( k1_mstVertex_2[j]+1), j,51+loop*4);
if ( k1_mstVertex_2[j]==-1) {dm.setValueAt("", j,51+loop*4);}
dm.setValueAt(String.valueOf( k1_mstVertex_3[j]+1), j,52+loop*4);
if ( k1_mstVertex_3[j]==-1) {dm.setValueAt("", j,52+loop*4);}
 }
 }//end p for loop<5





 
//now derive concenus map and draw into table for editing
//first read in maps
//get  data and determine number if points

}//end 5 loop


//order concensus
//first load in old data in temp store
 for (int p=0;p<number_of_points;p++) {
maps_store[0][0]=maps[p][0][0];
maps_store[0][1]=maps[p][0][1];
maps_store[1][0]=maps[p][1][0];
maps_store[1][1]=maps[p][1][1];
maps_store[2][0]=maps[p][2][0];
maps_store[2][1]=maps[p][2][1];
maps_store[3][0]=maps[p][3][0];
maps_store[3][1]=maps[p][3][1];
maps_store[4][0]=maps[p][4][0];
maps_store[4][1]=maps[p][4][1];
//first position
int top_point=-1;
		 for (int k=0;k<5;k++) {
								int top_percentage=0;
															 for (int i=0;i<5;i++) {
												if ((maps_store[i][1]>top_percentage)&(maps_store[i][1]>0)) {top_percentage=maps_store[i][1]; top_point=i;}
																					}
																					maps[p][k][0]=maps_store[top_point][0];
																					maps[p][k][1]=maps_store[top_point][1];
																					maps_store[top_point][1]=0;

																					
	 
											  }

									}

//now draw in concensus
 for (int j=0;j<number_of_points;j++) {
 dm.setValueAt(String.valueOf( j+1), j,73);
dm.setValueAt(String.valueOf( maps[j][0][0]), j,74);
if ( maps[j][0][0]==-1) {dm.setValueAt("", j,74);}
dm.setValueAt(String.valueOf( (int)(maps[j][0][1]*100/loop_num)), j,75);
if ( maps[j][0][0]==-1) {dm.setValueAt("", j,75);}

dm.setValueAt(String.valueOf( maps[j][1][0]), j,76);
if ( maps[j][1][0]==-1) {dm.setValueAt("", j,76);}
dm.setValueAt(String.valueOf( (int)(maps[j][1][1])*100/loop_num), j,77);
if ( maps[j][1][0]==-1) {dm.setValueAt("", j,77);}

dm.setValueAt(String.valueOf( maps[j][2][0]), j,78);
if ( maps[j][2][0]==-1) {dm.setValueAt("", j,78);}
dm.setValueAt(String.valueOf( (int)(maps[j][2][1])*100/loop_num), j,79);
if ( maps[j][2][0]==-1) {dm.setValueAt("", j,79);}

dm.setValueAt(String.valueOf( maps[j][3][0]), j,80);
if ( maps[j][3][0]==-1) {dm.setValueAt("", j,80);}
dm.setValueAt(String.valueOf( (int)(maps[j][3][1])*100/loop_num), j,81);
if ( maps[j][3][0]==-1) {dm.setValueAt("", j,81);}

dm.setValueAt(String.valueOf( maps[j][4][0]), j,82);
if ( maps[j][4][0]==-1) {dm.setValueAt("", j,82);}
dm.setValueAt(String.valueOf( (int)(maps[j][4][1])*100/loop_num), j,83);
if ( maps[j][4][0]==-1) {dm.setValueAt("", j,83);}
 }


//now pick best points
 for (int j=0;j<number_of_points;j++) {
 dm.setValueAt(String.valueOf( j+1), j,84);
 dm.setValueAt(String.valueOf( j+1), j,92);
//100% section
// first most confident point
// find back connector
int back_connector=-1;
int conn= maps[j][0][0]; 
 for (int k=0;k<5;k++) { if (maps[conn-1][k][0]==j+1){back_connector=k;}}
if (back_connector>-1){
						if ((maps[j][0][1]==100) & (maps[conn-1][back_connector][1]==100))
							{dm.setValueAt(String.valueOf( conn), j,85);dm.setValueAt(String.valueOf( conn), j,93);}
							
							}
		

// second most confident point
// find back connector
 back_connector=-1;
 conn= maps[j][1][0]; 
 for (int k=0;k<5;k++) { if (maps[conn-1][k][0]==j+1){back_connector=k;}}
if (back_connector>-1){
						if ((maps[j][1][1]==100) & (maps[conn-1][back_connector][1]==100))
							{dm.setValueAt(String.valueOf( conn), j,86);dm.setValueAt(String.valueOf( conn), j,94);}
							
							}

//>50% section
// first most confident point
// find back connector
back_connector=-1;
conn= maps[j][0][0]; 
 for (int k=0;k<5;k++) { if (maps[conn-1][k][0]==j+1){back_connector=k;}}
if (back_connector>-1){
						if ((maps[j][0][1]>50) & (maps[conn-1][back_connector][1]>50)&(maps[j][0][1]<100) & (maps[conn-1][back_connector][1]<100))
							{dm.setValueAt(String.valueOf( conn), j,87);dm.setValueAt(String.valueOf( conn), j,95);}
						

							}
// first most confident point
// find back connector
back_connector=-1;
conn= maps[j][1][0]; 
 for (int k=0;k<5;k++) { if (maps[conn-1][k][0]==j+1){back_connector=k;}}
if (back_connector>-1){
						if ((maps[j][1][1]>50) & (maps[conn-1][back_connector][1]>50)&(maps[j][1][1]<100) & (maps[conn-1][back_connector][1]<100))
							{dm.setValueAt(String.valueOf( conn), j,88);}
							}

// first most confident point
// find back connector
back_connector=-1;
conn= maps[j][2][0]; 
 for (int k=0;k<5;k++) { if (maps[conn-1][k][0]==j+1){back_connector=k;}}
if (back_connector>-1){
						if ((maps[j][2][1]>50) & (maps[conn-1][back_connector][1]>50)&(maps[j][2][1]<100) & (maps[conn-1][back_connector][1]<100))
							{dm.setValueAt(String.valueOf( conn), j,89);}
							}
							
// first most confident point
// find back connector
back_connector=-1;
conn= maps[j][3][0]; 
 for (int k=0;k<5;k++) { if (maps[conn-1][k][0]==j+1){back_connector=k;}}
if (back_connector>-1){
						if ((maps[j][3][1]>50) & (maps[conn-1][back_connector][1]>50)&(maps[j][3][1]<100) & (maps[conn-1][back_connector][1]<100))
							{dm.setValueAt(String.valueOf( conn), j,90);}
							}
// first most confident point
// find back connector
back_connector=-1;
conn= maps[j][4][0]; 
 for (int k=0;k<5;k++) { if (maps[conn-1][k][0]==j+1){back_connector=k;}}
if (back_connector>-1){
						if ((maps[j][4][1]>50) & (maps[conn-1][back_connector][1]>50)&(maps[j][4][1]<100) & (maps[conn-1][back_connector][1]<100))
							{dm.setValueAt(String.valueOf( conn), j,91);}
							}







								}//j loop





} //end mstMeasures method




static void pajMeasures(PAJ dt, TableModel dm, String[][] data) {

//get  data and determine number if points
  for (int i=0;i<10000;i++)
  {  
  data[i][0]=dm.getValueAt(i, 0).toString(); //x
  data[i][1]=dm.getValueAt(i, 1).toString();//y
  data[i][2]=dm.getValueAt(i, 2).toString();//z 
  if  (data[i][0]=="")
  {
  number_of_points=i;
  i=10000;
    }
}

if (number_of_points<1){	dm.setValueAt("Data format error", 9,4);}

  if  (data[0][2]=="")
  {
data_3D=false;
  }
  else
    {
data_3D=true;
  }
  



try {
if (number_of_points>0){
 min_x = Double.valueOf(data[1][0].trim()).doubleValue();
 max_x = Double.valueOf(data[1][0].trim()).doubleValue();
 min_y = Double.valueOf(data[1][1].trim()).doubleValue();
 max_y = Double.valueOf(data[1][1].trim()).doubleValue();
if (data_3D)
{
 min_z = Double.valueOf(data[1][2].trim()).doubleValue();
 max_z = Double.valueOf(data[1][2].trim()).doubleValue();
 }
}

	} catch(Exception ex) {
	dm.setValueAt("Data format error", 9,4);
number_of_points=0;
//	  System.out.println("Data format error");
//	  System.exit(2);
	}
	

 for (int i=0;i<number_of_points;i++)
  {  
double x =  Double.valueOf(data[i][0].trim()).doubleValue(); //x
double y =  Double.valueOf(data[i][1].trim()).doubleValue(); //x

double z = 0;

coordinates_x[i]=x;
coordinates_y[i]=y;

if (data_3D)

{
 z =  Double.valueOf(data[i][2].trim()).doubleValue(); 
 coordinates_z[i]=z;
}
  if (x<min_x){min_x=x;}
    if (x>max_x){max_x=x;}
  if (y<min_y){min_y=y;}
    if (y>max_y){max_y=y;} 
	 if (z<min_z){min_z=z;}
    if (z>max_z){max_z=z;}
}

double area = (max_x-min_x)*(max_y-min_y);
double volume = (max_x-min_x)*(max_y-min_y)*(max_z-min_z);
double density=number_of_points/volume;
scale_factor=density/0.02;
//now change scale to multiplier for each side
double power=1;
power=power/3;
scale_factor=Math.pow(scale_factor,power);
//determine scale and scale coordinates to be 20/1000

//scale_factor=1;//*****REMOVE THIS****

if (data_3D& (number_of_points>0))
{
  for (int i=0;i<number_of_points;i++)
{
coordinates_x[i]=coordinates_x[i]*scale_factor;
coordinates_y[i]=coordinates_y[i]*scale_factor;
coordinates_z[i]=coordinates_z[i]*scale_factor;
}
}
if (!data_3D& (number_of_points>0))
{
//2d data needed here
}

dm.setValueAt(String.valueOf(min_x), 0,4);
dm.setValueAt(String.valueOf(max_x), 1,4);
dm.setValueAt(String.valueOf(min_y), 2,4);
dm.setValueAt(String.valueOf(max_y), 3,4);
dm.setValueAt(String.valueOf(min_z), 4,4);
dm.setValueAt(String.valueOf(max_z), 5,4);
dm.setValueAt(String.valueOf(area), 6,4);
dm.setValueAt(String.valueOf(volume), 7,4);
dm.setValueAt(String.valueOf(number_of_points), 8,4);
if (number_of_points>0) {dm.setValueAt("2D data", 9,4);}
if (data_3D& (number_of_points>0))
{
dm.setValueAt("3D data", 9,4);
}
double scaled_density=number_of_points/((max_x-min_x)*scale_factor*(max_y-min_y)*scale_factor*(max_z-min_z)*scale_factor );
dm.setValueAt(String.valueOf(scale_factor), 10,4);
dm.setValueAt(String.valueOf(density), 11,4);





}

static void initPAJ() {
//frame title
final JFrame fr = new JFrame("PAJ version0");

final PAJ dt = new PAJ();
 
final String[][] data=new String[10000][100];

 data[9999][99]=new String("");
  for (int i=0;i<10000;i++)
  {  
  data[i][0]=""; //x
  data[i][1]="";//y
  data[i][2]="";//z 
}


final TableModel dm = new TableModel();
dt.setModel(dm);
//dm.setDataVector(data);
dm.setValueAt("Min X",0,3);
dm.setValueAt("1",0,0);
dm.setValueAt("Max X",1,3);
dm.setValueAt("Min Y",2,3);
dm.setValueAt("Max Y",3,3);
dm.setValueAt("Min Z",4,3);
dm.setValueAt("Max Z",5,3);
dm.setValueAt("Area",6,3);
dm.setValueAt("Volume",7,3);
dm.setValueAt("Number",8,3);
dm.setValueAt("3D data",9,3);
dm.setValueAt("scale factor",10,3);
dm.setValueAt("density",11,3);
dm.setValueAt("Vororoni r^2 data",12,3);
dm.setValueAt("Vororoni r^2 MC-min",13,3);
dm.setValueAt("Vororoni r^2 MC-max",14,3);
dm.setValueAt("Lacunarity r^2 data",15,3);
dm.setValueAt("Lacunarity r^2 MC-min",16,3);
dm.setValueAt("Lacunarity r^2 MC-max",17,3);

  for (int i=0;i<10000;i++)
  { 
   dm.setValueAt((data[i][0]),i,0); 
   dm.setValueAt((data[i][1]),i,1); 
   dm.setValueAt((data[i][2]),i,2); 
}


fr.setLayout(new BorderLayout());
	 
fr.getContentPane().add(new JScrollPane(dt),BorderLayout.WEST);

JMenuBar mb = new JMenuBar();
JButton gwBranchButton=new JButton("GW Branched Data");
JButton regularButton=new JButton("Regular Data");
JButton fractalButton=new JButton("Fractal Data");
JButton randomButton=new JButton("Random Data");
JButton measuresButton=new JButton("Load Data");
JButton clearButton=new JButton("Clear Data");
JButton rankButton=new JButton("Rank");
JButton densityButton=new JButton("Density-map");
JButton lacunarityButton=new JButton("Lacunarity");
JButton voronoiButton=new JButton("Voronoi");
JButton mstButton=new JButton("MST");

JButton montecarloButton=new JButton("Monte Carlo");
JButton allButton=new JButton("Run all");
JPanel buttonPanel = new JPanel();
buttonPanel.setPreferredSize(new Dimension(50, 200));
fr.getContentPane().add(buttonPanel,BorderLayout.SOUTH);
buttonPanel.setLayout(new FlowLayout());
buttonPanel.add(clearButton,BorderLayout.NORTH);
buttonPanel.add(randomButton,BorderLayout.SOUTH);
buttonPanel.add(regularButton,BorderLayout.SOUTH);
buttonPanel.add(fractalButton,BorderLayout.SOUTH);
buttonPanel.add(gwBranchButton,BorderLayout.SOUTH);
buttonPanel.add(measuresButton,BorderLayout.NORTH);
buttonPanel.add(rankButton,BorderLayout.SOUTH);
buttonPanel.add(densityButton,BorderLayout.NORTH);
buttonPanel.add(lacunarityButton,BorderLayout.NORTH);
buttonPanel.add(voronoiButton,BorderLayout.NORTH);
//buttonPanel.add(mstButton,BorderLayout.NORTH);

buttonPanel.add(allButton,BorderLayout.NORTH);
buttonPanel.add(montecarloButton,BorderLayout.NORTH);


JGraphCanvas graphPanel = new JGraphCanvas();
graphPanel.setPreferredSize(new Dimension(500, 900));
graphPanel.setBackground(Color.white);
JScrollPane scrollPane = new JScrollPane(graphPanel);
fr.getContentPane().add(scrollPane,BorderLayout.CENTER);
       // fr.setDefaultLookAndFeelDecorated(true);

randomButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
dt.generateModelData(dt, dm, data);
	pajMeasures(dt, dm, data);

    }
});
regularButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
dt.generateRegularData(dt, dm, data);
	pajMeasures(dt, dm, data);

    }
});

gwBranchButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
dt.clearData(dt, dm, data);
dt.generategwData(dt, dm, data);
pajMeasures(dt, dm, data);
    }
});

fractalButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
dt.generatefractalData(dt, dm, data);
	pajMeasures(dt, dm, data);

    }
});

rankButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
	pajMeasures(dt, dm, data);

dt.rankMeasures(dt, dm, data);
    }
});

measuresButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
pajMeasures(dt, dm, data);
    }
});

clearButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
dt.clearData(dt, dm, data);
    }
});

densityButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
	pajMeasures(dt, dm, data);

dt.densityMeasures(dt, dm, data);
    }
});

lacunarityButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
	pajMeasures(dt, dm, data);

dt.lacunarityMeasures(dt, dm, data);
    }
});

voronoiButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
	pajMeasures(dt, dm, data);
dt.voronoiMeasures(dt, dm, data);
    }
});

mstButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
	pajMeasures(dt, dm, data);

dt.mstMeasures(dt, dm, data);
    }
});



montecarloButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
dt.montecarlo=true;
    }
});

allButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
pajMeasures(dt, dm, data);
dt.rankMeasures(dt, dm, data);
dt.densityMeasures(dt, dm, data);
dt.lacunarityMeasures(dt, dm, data);
dt.voronoiMeasures(dt, dm, data);

    }
});
    
//dt.generateModelData(dt, dm, data);
dt.pajMeasures(dt, dm, data);
	
//Following lines make the JTable sensitive to drag & drop and clip board operations
new TableDropManager(dt);
ClipBoardTransfer cbt = new ClipBoardTransfer(dt);
mb.add(cbt.getEditMenu());
fr.setJMenuBar(mb);
fr.pack();
fr.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
fr.setVisible(true);

}


}



 class TableDropManager extends DropTargetAdapter {
JTable tab = null;

public TableDropManager(JTable tab) {
this.tab = tab;
tab.setDragEnabled(true);
tab.setDropTarget(new DropTarget(tab, DnDConstants.ACTION_COPY, this, true));
tab.getDropTarget().setActive(true);
}

public void drop(DropTargetDropEvent de) {
de.acceptDrop(DnDConstants.ACTION_COPY);
Transferable trans = de.getTransferable();
Point p = de.getLocation();
int row = tab.rowAtPoint(p), col = tab.columnAtPoint(p);
try {
String str = (String)trans.getTransferData(DataFlavor.stringFlavor);
ValueLoader.loadValuesIntoTable(tab, str, row, col);
tab.repaint();
}
catch(Exception ex) { ex.printStackTrace(); }
de.dropComplete(true);
}
}


class TableModel extends AbstractTableModel {
private String[] columnNames = {"X","Y","Z","Measures","","Rank:order","Rank:Average","Rank:Min","Rank:Max","Rank:cov","Rank:Min","Rank:Max","Density:order","Density:Average","Density:Min","Density:Max","Density:cov","Density:Min","Density:Max","Lacunarity:order","Lacunarity:Average","Lacunarity:Min","Lacunarity:Max","Lacunarity:cov","Lacunarity:Min","Lacunarity:Max","Point Voronoi Volume","Voronoi Scale","Voronoi Dist","Voronoi Min","Voronoi Max","MC x", "MC y", "MC z", "Rank-regular","Rank-regular","Rank-cluster","Rank-cov-regular","Rank-cov-cluster","Density-regular","Density-cluster","Density-cov-regular","Density-cov-cluster","Lacunarity-regular","Lacunarity-cluster","Lacunarity-cov-regular","Lacunarity-cov-cluster","voronoi-regular","voronoi-cluster","point","MST 1-1","MST 1-2","MST 1-3","point","MST 2-1","MST 2-2","MST 2-3","point","MST 3-1","MST 3-2","MST 3-3","point","MST 4-1","MST 4-2","MST 4-3","point","MST 5-1","MST 5-2","MST 5-3","point","MST con-1","MST con-2","MST con-3","point","con-1","freq-1","con-1","freq-1","con-1","freq-1","con-1","freq-1","con-1","freq-1","point","100%","100%","50%","50%","50%","50%","50%","point","final-1","final-2","final-3","final-4"};
private Object[][] data=new Object[10000][100];

        public int getColumnCount() {
            return columnNames.length;
        }

        public int getRowCount() {
            return data.length;
        }

        public String getColumnName(int col) {
            return columnNames[col];
        }

        public Object getValueAt(int row, int col) {
            return data[row][col];
        }

        /*
         * JTable uses this method to determine the default renderer/
         * editor for each cell.  If we didn't implement this method,
         * then the last column would contain text ("true"/"false"),
         * rather than a check box.
         */
/*        public Class getColumnClass(int c) {
            return getValueAt(0, c).getClass();
        }*/

        /*
         * Don't need to implement this method unless your table's
         * editable.
         */
/*      public boolean isCellEditable(int row, int col) {
            //Note that the data/cell address is constant,
            //no matter where the cell appears onscreen.
            if (col < 2) {
                return false;
            } else {
                return true;
            }
        }
*/

   public boolean isCellEditable(int row, int col) {
      return true;
    }
	
        /*
         * Don't need to implement this method unless your table's
         * data can change.
         */
        public void setValueAt(Object value, int row, int col) {
          
  /*              System.out.println("Setting value at " + row + "," + col
                                   + " to " + value
                                   + " (an instance of "
                                   + value.getClass() + ")");*/
           

            data[row][col] = value;
            fireTableCellUpdated(row, col);

   /*         
                System.out.println("New value of data:");
                printDebugData();*/
            
        }

        private void printDebugData() {
                }
				}



class ClipBoardTransfer implements ActionListener, FlavorListener
{
JTable tab = null;
Clipboard cb = java.awt.Toolkit.getDefaultToolkit().getSystemClipboard();
JMenu edit = new JMenu("Edit");
JMenuItem paste = null;

public ClipBoardTransfer(JTable tab) {
	this.tab = tab;
	cb.addFlavorListener(this);
	createEditMenu();
	}

private void createEditMenu() {
	JMenuItem mi[] = { new JMenuItem("Copy"), new JMenuItem("Cut"),
		(paste = new JMenuItem("Paste")), new JMenuItem("Select All"),
		new JMenuItem("Delete Selection") };
	char m[] = {'O','U','P','A','D'};
	int ke[] = { KeyEvent.VK_C, KeyEvent.VK_X, KeyEvent.VK_V,
		KeyEvent.VK_A, KeyEvent.VK_DELETE };
	edit.setMnemonic('E');
	for(int i	= 0; i<mi.length; i++) {
		mi[i].setMnemonic(m[i]);
		mi[i].setAccelerator(KeyStroke.getKeyStroke(ke[i], KeyEvent.CTRL_MASK));
		mi[i].addActionListener(this);
		edit.add(mi[i]);
		if(i==1 || i == 2 || i == 3)
			edit.add(new JSeparator());		
		}
	paste.setEnabled(cb.isDataFlavorAvailable(DataFlavor.stringFlavor));	
	}

public JMenu getEditMenu() { return edit; }
public  void actionPerformed(ActionEvent ae) {
	String com = ae.getActionCommand().toLowerCase();
	if(com.equals("copy"))
		sendToClipBoard(false);
	else if(com.equals("cut"))
		sendToClipBoard(true);
	else if(com.equals("paste"))
		pasteData();
	else if(com.equals("select all"))
		tab.selectAll();
	else if(com.equals("delete selection"))
		deleteSelection();
	}

public void flavorsChanged(FlavorEvent fe) {
	paste.setEnabled(cb.isDataFlavorAvailable(DataFlavor.stringFlavor));
	}
private void sendToClipBoard(boolean cut) {
	if(tab.getCellEditor() != null)
		tab.getCellEditor().stopCellEditing();
	StringBuffer sb = new StringBuffer();
	int c1 = tab.getSelectedColumn(), c2 = tab.getSelectedColumnCount(),
		r1 = tab.getSelectedRow(), r2 = tab.getSelectedRowCount();
	c2 += c1;
	r2 += r1;
	Object tmp = null;
	for(int i=r1; i<r2; i++) {
		for(int j=c1; j<c2; j++) {
			tmp = tab.getValueAt(i, j);
			sb.append((tmp != null ? tmp:"")+(j!=c2-1?"\t":"\n"));
			if(cut) tab.setValueAt("", i, j);
			}
		}
	if(cut) tab.repaint();
	StringSelection ss = new StringSelection(sb.toString());
	cb.setContents(ss, ss);
	}

private void pasteData() {
	if(tab.getCellEditor() != null)
		tab.getCellEditor().stopCellEditing();
	try {
		String data = (String) cb.getData(DataFlavor.stringFlavor);
		int r = tab.getSelectedRow(), c = tab.getSelectedColumn();
		if(data != null)
			ValueLoader.loadValuesIntoTable(tab, data, r<0?0:r, c<0?0:c);		
		}
	catch(Exception ex) { ex.printStackTrace(); }
	}

private void deleteSelection() {
	if(tab.getCellEditor() != null)
		tab.getCellEditor().stopCellEditing();
	int c1 = tab.getSelectedColumn(), c2 = tab.getSelectedColumnCount(),
		r1 = tab.getSelectedRow(), r2 = tab.getSelectedRowCount();
	c2 += c1;
	r2 += r1;
	for(int i=r1; i<r2; i++)
		for(int j=c1; j<c2; j++)
			tab.setValueAt("", i, j);
	tab.repaint();
	}
}
class ValueLoader
{
private static String os = System.getProperty("os.name").toLowerCase();
public static void loadValuesIntoTable(JTable tab, String str, int row, int col) {

System.out.println("OS Name: "+os);
	StringTokenizer rowData = new StringTokenizer(str, "\r\n", true);
	StringTokenizer colData = null;
	final int rowCount = tab.getRowCount(), colCount = tab.getColumnCount();
	int column = col;
	String tmp = null;
	while(rowData.hasMoreTokens()) {
		tmp = rowData.nextToken();
		if(tmp.equals("\r")) {
			if((os.startsWith("windows") || os.startsWith("linux") || os.startsWith("unix"))) 
				continue;
			else { //This portion is true on MAC system
				row++;
				continue;
				}
			}
		if(tmp.equals("\n")) {
			row++;
			continue;
			}
//Uncomment the line below if columns are separated by spaces instead of TABS
//		tmp = removeGroupsOfSpace(tmp);		
		colData = new StringTokenizer(tmp, "\t", true);
		if(row >= rowCount) break;
		while(colData.hasMoreTokens()) {
			if(column >= colCount) break;
			tmp = colData.nextToken();
			if(tmp.equals("\t"))
				tab.setValueAt("", row, column++);
			else {
				tab.setValueAt(tmp, row, column++);
				if(colData.hasMoreTokens())
					colData.nextToken();
				}
			}
		column = col;
		}
	}

private static String removeGroupsOfSpace(String s) {
	StringBuffer sb = new StringBuffer();
	char c;
	for(int i=0, n=s.length(); i<n; i++) {
		if((c = s.charAt(i)) != ' ')
			sb.append(c);
		else {
			while(s.charAt(i++) == ' ');
			i-=2;
			sb.append('\t');
			}
		}
	return sb.toString();
	}
}