boxcounting analysis problem
Hello!
I have this box counting algorithm code that I think pretty much works, however what I am trying to do is to get the code to import data in the form of a text file with two columns of numbers, and run the data through the box counting analysis. Would anyone be able to help me out with this?
Best
Code:
import java.lang.*;
import java.awt.*;
/**
* Calculates dimesion of 2D maps by box counting algorithm, uisng a fast
* sort algorithm to arrange array of finest boxes and then successively
* coarsening and weeding the array.<br>
* Stores number of boxes to cover points in divIndex[nDiv+1]
*/
public class boxCalculate extends Panel implements Runnable {
/* private variables */
private int[] index; // array of current boxes in index form
private int[] x; // array of current boxes in x,y form
private int number; // numebr of current boxes
private int divisions; // Number of current boxes across axis
private int nDiv=6; // Highest number of subdivisions
private int[] copy; // Working array
private int[] copy1;
private int nOld; // Position to write in output array
private boolean stopRequested;
private Button b1;
private TextField status;
private int[] occupancy;
private int q=0;
private TextField t1;
private TextField t2;
private alertDialog alert;
/* Public varibales */
/**
* Array of size nDiv+1 containing number of boxes covering attractor at each division scale
*/
public int[] divIndex;
/**
* Total nuber of points
*/
public int total;
/**
* Array contining box locations:
* <UL><LI>0 to divIndex[0]-1 for finest subdivision
* <LI>divIndex[0] to divIndex[1]-1 for next etc.
* </UL>
* Position (i,j) is stored as i+j*N where there are N boxes across one direction of map at
* this scale, and i and j run from 0 to N-1.
*/
public int[] output;
/**
* Array contining number of points in boxes:
* <UL><LI>0 to divIndex[0]-1 for finest subdivision
* <LI>divIndex[0] to divIndex[1]-1 for next etc.
* </UL>
* stored as in output.
*/
public int[] boxCount;
/**
* True if calculation of box coverage is complete
*/
public boolean completed=false;
// public int updateCount=10;
/** Default constructor
* lays out button and textBox controls
*/
public boxCalculate() {
GridBagLayout gridbag = new GridBagLayout();
GridBagConstraints constraints = new GridBagConstraints();
setLayout(gridbag);
constraints.weightx = 1.0;
constraints.weighty = 1.0;
constraints.gridwidth=1;
constraints.insets = new Insets(5,5,5,5);
b1 = new Button(" Stop ");
gridbag.setConstraints(b1, constraints);
add(b1);
b1.disable();
t1 = new TextField("6",3);
Label l1 = new Label("Div",Label.RIGHT);
Panel p1 = new Panel();
p1.setLayout(new FlowLayout(FlowLayout.RIGHT));
gridbag.setConstraints(p1, constraints);
add(p1);
p1.add(l1);
p1.add(t1);
t2 = new TextField("0",3);
Label l2 = new Label(" q ",Label.RIGHT);
Panel p2 = new Panel();
p2.setLayout(new FlowLayout(FlowLayout.RIGHT));
constraints.gridwidth=GridBagConstraints.REMAINDER;
gridbag.setConstraints(p2, constraints);
add(p2);
p2.add(l2);
p2.add(t2);
status = new TextField(30);
constraints.fill=GridBagConstraints.HORIZONTAL;
gridbag.setConstraints(status, constraints);
add(status);
}
/**
* Sets up calculation. Must be called before calculation thread is started.
* @param in_x Array of data in x,y pairs of ints given by box number on finest (2^nDiv)
* scale
* @param in_nDiv Number of subdivisions to make (from 0 to nDiv)
*/
public void setup (int[] in_x) {
q=parseTextField(t2,q);
nDiv=parseTextField(t1,nDiv,true);
stopRequested=false;
number = in_x.length/2;
total = number;
x= new int[2*number];
System.arraycopy(in_x,0,x,0,2*number);
divIndex = new int[nDiv+1];
nOld=0;
index = new int[number];
output = new int[1];
divisions=(int) (Math.pow(2.,(double)nDiv));
divIndex[nDiv]=0;
if(q!=0) {
occupancy = new int[number];
for(int i=0;i<number;i++) occupancy[i]=1;
}
}
/**
* Thread to perform calculation
*/
public void run() {
if(q!=0) boxCount= new int[1];
stopRequested=false;
completed=false;
b1.enable();
status.setText("Calculating dimension....");
int i;
// System.out.println("nDiv= "+nDiv+" divisions= "+divisions);
for(int iDiv=nDiv-1; iDiv>=0; iDiv--) {
// System.out.println("iDiv= "+iDiv+" Divisions= "+divisions);
toIndex();
// System.out.println("Unsorted");
// for(int j=0;j<number;j++) {
// System.out.println( index[j]+" "+occupancy[j]);
// }
if(q==0) sort(index,number);
else sort(index, occupancy, number);
// System.out.println("Sorted");
// for(int j=0;j<number;j++) {
// System.out.println( index[j]+" "+occupancy[j]);
// }
if(stopRequested) return;
if(q==0) weed(index);
else weed(index, occupancy);
// System.out.println("Weeded");
// for(int j=0;j<number;j++) {
// System.out.println( index[j]+" "+occupancy[j]);
// }
fromIndex();
// for(int j=0;j<number;j++) {
// System.out.println("x= "+x[2*j]+" y= "+x[2*j+1]);
// }
divIndex[iDiv]=divIndex[iDiv+1]+number;
copy = new int[2*nOld+2*number];
System.arraycopy(output,0,copy,0,2*nOld);
System.arraycopy(x,0,copy,2*nOld,2*number);
if(q!=0) {
copy1 = new int[nOld+number];
System.arraycopy(boxCount,0,copy1,0,nOld);
System.arraycopy(occupancy,0,copy1,nOld,number);
}
nOld=nOld+number;
output = new int[2*nOld];
System.arraycopy(copy,0,output,0,2*nOld);
if(q!=0) {
boxCount = new int[nOld];
System.arraycopy(copy1,0,boxCount,0,nOld);
}
for(i=0;i<number;i++) {
x[2*i]=x[2*i]/2;
x[2*i+1]=x[2*i+1]/2;
}
divisions = divisions/2;
}
completed=true;
status.setText("Dimension calculation done!");
b1.disable();
}
/**
* Converts x,y pair to index
*/
private void toIndex() {
for(int i=0;i<number;i++)
index[i]=x[2*i]+divisions*x[2*i+1];
}
/**
* Converts index to x,y pair
*/
private void fromIndex() {
for(int i=0;i<number;i++) {
x[2*i+1]=index[i]/divisions;
x[2*i]=index[i]-x[2*i+1]*divisions;
}
}
/**
* Sorts index array ra and associated array rb using method from Numerical Recipes
@ param ra index array
@ param rb second array
@ n number of entries in arrays to be sorted
*/
private void sort(int ra[], int rb[], int n) {
int i,ir,j,l;
int rra;
int rrb;
if (n<2) return;
l=n/2;
ir=n-1;
while(true) {
// System.out.println("l= "+l+" ir= "+ir);
if(l > 0) {
l=l-1;
rra=ra[l];
rrb=rb[l];
}
else {
rra=ra[ir];
rrb=rb[ir];
ra[ir]=ra[0];
rb[ir]=rb[0];
ir=ir-1;
if(ir == 0) {
ra[0]=rra;
rb[0]=rrb;
return;
}
}
i=l;
j=l+l+1;
while(j <=ir) {
if(j < ir && ra[j] < ra[j+1]) j++;
if(rra <ra[j]) {
ra[i]=ra[j];
rb[i]=rb[j];
i=j;
j=j+j+1;
}
else
j=ir+1;
}
ra[i]=rra;
rb[i]=rrb;
}
}
/**
* Sorts index array using method from Numerical Recipes
@ param ra index array
@ n number of entries in arrays to be sorted
*/
private void sort(int ra[], int n) {
int i,ir,j,l;
int rra;
if (n<2) return;
l=n/2;
ir=n-1;
while(true) {
// System.out.println("l= "+l+" ir= "+ir);
if(l > 0) {
l=l-1;
rra=ra[l];
}
else {
rra=ra[ir];
ra[ir]=ra[0];
ir=ir-1;
if(ir == 0) {
ra[0]=rra;
return;
}
}
i=l;
j=l+l+1;
while(j <=ir) {
if(j < ir && ra[j] < ra[j+1]) j++;
if(rra <ra[j]) {
ra[i]=ra[j];
i=j;
j=j+j+1;
}
else
j=ir+1;
}
ra[i]=rra;
}
}
/**
* Weeds out duplicate values and adds to count number
@ param a array to be weeded
@ param b array of counts
*/
private void weed(int a[], int b[]) {
int n=0;
int count=b[0];
for(int i=1;i<number;i++) {
if(a[i] != a[n]) {
b[n]=count;
n++;
count=b[i];
a[n]=a[i];
}
else count=count+b[i];
}
b[n]=count;
number=n+1;
}
/**
* Weeds out duplicate values
@ param a array to be weeded
*/
private void weed(int a[]) {
int n=0;
for(int i=1;i<number;i++) {
if(a[i] != a[n]) {
n++;
a[n]=a[i];
}
}
number=n+1;
}
/**
* stops calculation
*/
public void stopRequest() {
stopRequested=true;
}
/**
* Handles button event to stop calculation
*/
public boolean handleEvent(Event evt) {
if(evt.id==Event.ACTION_EVENT && evt.target == b1) {
status.setText("Calculation aborted!");
b1.disable();
stopRequested=true;
}
return super.handleEvent(evt);
}
/**
* Sets textBox contents
* @param text contents
*/
public void setText(String text) {
status.setText(text);
}
//*********************************************************************
/**
* Parses text field known to be integer of known sign.
* Resets old value of corresponding variable if input format
* is incorrect or wrong sign and brings up alertDialog warning box.
* @param t field to be parsed
* @param i old value of variable
* @param positive true if value should be positive, false if should be negative
* @return new value of parameter if textbox format is correct,
* and value of correct sign, otherwise old value.
* @see alertDialog
*/
//*********************************************************************
public int parseTextField(TextField t, int i, boolean positive) {
int iNew;
try {
iNew=(new Integer(t.getText())).intValue();
}
catch (NumberFormatException e) {
t.setText(String.valueOf(i));
alert = new alertDialog("Try an integer");
return i;
}
if(((iNew < 0) && positive) || ((iNew>0) && !positive)) {
t.setText(String.valueOf(i));
if(positive) alert = new alertDialog("Must be positive");
else alert = new alertDialog("Must be negative");
return i;
}
return iNew;
}
//*********************************************************************
/**
* Parses text field known to be integer.
* Resets old value of corresponding variable if input format
* is incorrect and brings up alertDialog warning box.
* @param t field to be parsed
* @param i old value of variable
* @return new value of parameter if textbox format is correct,
* otherwise old value.
* @see alertDialog
*/
//*********************************************************************
public int parseTextField(TextField t, int i) {
int iNew;
try {
iNew=(new Integer(t.getText())).intValue();
}
catch (NumberFormatException e) {
t.setText(String.valueOf(i));
alert = new alertDialog("Try an integer");
return i;
}
return iNew;
}
//*********************************************************************
/** returns value of dimension order
* @return dimension order q
*/
public int getQ() {
q=parseTextField(t2,q);
return q;
}
//*********************************************************************
/** sets value of dimension order
* @param in_q dimension order q
*/
public void setQ(int in_q) {
t2.setText(String.valueOf(in_q));
q=in_q;
}
//*********************************************************************
/** returns value of number of subdivisions
* @return number of subdivisions
*/
public int getNDiv() {
nDiv=parseTextField(t1,nDiv,true);
return nDiv;
}
//*********************************************************************
/** sets value of number of subdivisions
* @param in_nDiv number of subdivisions
*/
public void setNDiv(int in_nDiv) {
t1.setText(String.valueOf(in_nDiv));
nDiv=in_nDiv;
}
//*********************************************************************
/** enables TextFields */
public void textBoxEnable() {
t1.enable();
t2.enable();
}
//*********************************************************************
/** disables TextFields */
public void textBoxDisable() {
t1.disable();
t2.disable();
}
public static void main(String[] args){
//stores words read in the file
FileInputStream in = new FileInputStream("subject1.txt");
BufferedReader br = new BufferedReader(new InputStream(in));
String strLine;
String[] dataarray;
dataarray = new String[10000]
for(int j = 0; j<dataarray.length;j++){
dataarray[j] = br.readline();
}
in.close();
}
