2. 
   
3. import peasy.*;
4. import org.openkinect.*;
5. import org.openkinect.processing.*;
6. //import superCAD.*;
7.  
8. boolean record = false;
9.  
10. float zscale = 3;
11. float zskew = 100;
12.  
13. int inputWidth = 640;
14. int inputHeight = 480;
15.  
16. PeasyCam cam;
17.  
18. PVector[][] gray = new PVector[inputHeight][inputWidth];
19.  
20. // We'll use a lookup table so that we don't have to repeat the math over and over
21. float[] depthLookUp = new float[2048];
22.  
23.  
24. PImage depth;
25.  
26. static final int gray(color value) {
27.   return max((value >> 16) & 0xff, (value >> 8 ) & 0xff, value & 0xff);
28. }
29.  
30. Kinect kinect;
31.  
32.  
33. void setup() {
34.   size(inputWidth, inputHeight, P3D);
35.   background(0);
36.   ///frameRate (60);
37.   cam = new PeasyCam(this, width*2.5);
38.   kinect = new Kinect(this);
39.   kinect.start();
40.   kinect.enableDepth(true);
41.   //depth = createImage(640, 480, RGB);
42.   stroke(255);
43.   // Lookup table for all possible depth values (0 - 2047)
44.   for (int i = 0; i < depthLookUp.length; i++) {
45.     depthLookUp[i] = rawDepthToMeters(i);
46.   }
47. }
48.  
49. int counter = 0;
50.  
51. void draw () {
52.   background(0);
53.   if (record == true) {
54.    // beginRaw("superCAD.ObjFile", "objExporter" + counter + ".obj"); //Start recording to the file
55.   }
56.  
57.   //depth.pixels = NativeKinect.getDepthMap();
58.   //depth.updatePixels();
59.   //depth = kinect.getDepthImage();
60.   int[] depth = kinect.getRawDepth();
61.  
62.   for (int y = 0; y < inputHeight; y++) {
63.     for (int x = 0; x < inputWidth; x++) {
64.       int offset = x+y*inputWidth;
65.       // Convert kinect data to world xyz coordinate
66.       int rawDepth = depth[offset];
67.       PVector v = depthToWorld(x,y,rawDepth);
68.       gray[y][x] = v;
69.     }
70.   }
71.  
72.  
73.   float scaling = 400;
74.  
75.   // Kyle McDonald’s original source used here
76.   translate(-inputWidth / 2, -inputHeight / 2,100);
77.   int step = 2;
78.   for (int y = step; y < inputHeight; y += step) {
79.     float planephase = 0.5 - (y-(inputHeight / 2)) / zskew;
80.     for (int x = step; x < inputWidth; x += step)
81.     {
82.       stroke(255);
83.       //point(x, y, (gray[y][x] - planephase) * zscale);
84.  
85.       PVector v = PVector.mult(gray[y][x],200);
86.  
87.       if (v.z > 100 && v.z < 200) {
88.         line(v.x,v.y,v.z,v.x,v.y,v.z);
89.         //line(gray[y][x].x,gray[y][x].y, gray[y][x].z,gray[y][x].x,gray[y][x].y, gray[y][x].z);
90.       }
91.     }
92.   }
93.  
94.   if (record == true) {
95.     endRaw();
96.     record = false; // Stop recording to the file
97.   }
98.   
99.    if (key == 'R' || key == 'r') {
100.     // Press R to save the file
101.     record = true;
102.     counter++;  //Thanks to Dr. Rhazes Spell for putting the counter in adding functionality.
103.   }
104. }
105.  
106. 
     
107.  
108. // These functions come from: http://graphics.stanford.edu/~mdfisher/Kinect.html
109. float rawDepthToMeters(int depthValue) {
110.   if (depthValue < 2047) {
111.     return (float)(1.0 / ((double)(depthValue) * -0.0030711016 + 3.3309495161));
112.   }
113.   return 0.0f;
114. }
115.  
116. PVector depthToWorld(int x, int y, int depthValue) {
117.  
118.   final double fx_d = 1.0 / 5.9421434211923247e+02;
119.   final double fy_d = 1.0 / 5.9104053696870778e+02;
120.   final double cx_d = 3.3930780975300314e+02;
121.   final double cy_d = 2.4273913761751615e+02;
122.  
123.   PVector result = new PVector();
124.   double depth =  depthLookUp[depthValue];//rawDepthToMeters(depthValue);
125.   result.x = (float)((x - cx_d) * depth * fx_d);
126.   result.y = (float)((y - cy_d) * depth * fy_d);
127.   result.z = (float)(depth);
128.   return result;
129. }

1. function f=fd(x,fs)
   x=(x-mean(x))/std(x);
   n = length(x);
   t=(0:1/fs:(n-1)/fs);
   t=t';
   x1=[t x'];
   for i=1:n-1
   d(i)=sqrt(abs(x1(i+1,1)-x1(i,1))^2+abs(x1(i+1,2)-x1(i,2))^2);
   dmax(i)=sqrt((abs(x1(i+1,1)-x1(1,1))^2+abs(x1(i+1,2)-x1(1,2))^2));
   end
   totlen=sum(d);
   avglen=mean(d);
   maxdist=max(dmax);
   numstep=double(totlen/avglen);
   den=double(maxdist/totlen);
   

   f=(log(numstep))/((log(den)+log(numstep))); 

2. import java.util.*;
3. import java.lang.*;
4. 
   
5. 
   
6. package ij.plugin.filter;
7. import java.awt.*;
8. import java.awt.image.*;
9. import java.util.*;
10. import ij.*;
11. import ij.process.*;
12. import ij.gui.*;
13. import ij.measure.*;
14. import ij.util.*;
15. 
    
16. /**
17. Calculate the so-called "capacity" fractal dimension.  The algorithm
18. is called, in fractal parlance, the "box counting" method.  In the
19. simplest terms, the routine counts the number of boxes of a given size
20. needed to cover a one pixel wide, binary (black on white) border.
21. The procedure is repeated for boxes that are 2 to 64 pixels wide. 
22. The output consists of two columns labeled "size" and "count". A plot 
23. is generated with the log of size on the x-axis and the log of count on
24. the y-axis and the data is fitted with a straight line. The slope (S) 
25. of the line is the negative of the fractal dimension, i.e. D=-S.
26. 
    
27. A full description of the technique can be found in T. G. Smith,
28. Jr., G. D. Lange and W. B. Marks, Fractal Methods and Results in Cellular Morphology,
29. which appeared in J. Neurosci. Methods, 69:1123-126, 1996.
30. 
    
31. ---
32. 12/Jun/2006 G. Landini added "set is white" option, otherwise the plugin
33. assumes that the object is always low-dimensional (i.e. the phase with
34. the smallest number of pixels). Now it works fine for sets with D near to 2.0
35. 
    
36. */
37. public class FractalBoxCounter implements PlugInFilter {
38.   static String sizes = "2,3,4,6,8,12,16,32,64";
39.   static boolean blackBackground;
40.   int[] boxSizes;
41.   float[] boxCountSums;
42.   int maxBoxSize;
43.   int[] counts;
44.   Rectangle roi;
45.   int foreground;
46.   ImagePlus imp;
47. 
    
48.   public int setup(String arg, ImagePlus imp) {
49.     this.imp = imp;
50.     return DOES_8G+NO_CHANGES;
51.   }
52. 
    
53.   public void run(ImageProcessor ip) {
54. 
    
55.     GenericDialog gd = new GenericDialog("Fractal Box Counter", IJ.getInstance());
56.     gd.addStringField("Box Sizes:", sizes, 20);
57.     gd.addCheckbox("Black Background", blackBackground);
58. 
    
59.     gd.showDialog();
60.     if (gd.wasCanceled())
61.       return;
62. 
    
63.     String s = gd.getNextString();
64. 
    
65.     blackBackground = gd.getNextBoolean ();
66. 
    
67.     if (s.equals(""))
68.       return;
69.     boxSizes = s2ints(s);
70.     if (boxSizes==null || boxSizes.length<1)
71.       return;
72.     boxCountSums = new float[boxSizes.length];
73.     sizes = s;
74.     for (int i=0; i<boxSizes.length; i++)
75.       maxBoxSize = Math.max(maxBoxSize, boxSizes[i]);
76.     counts = new int[maxBoxSize*maxBoxSize+1];
77.     imp.deleteRoi();
78.     if (!ip.isBinary()) {
79.       IJ.error("8-bit binary image (0 and 255) required.");
80.       return;
81.     }
82.     if (blackBackground)
83.       foreground = 255;
84.     else
85.       foreground = 0;
86.     if (ip.isInvertedLut())
87.       foreground = 255 - foreground;
88.     doBoxCounts(ip);
89.     IJ.register(FractalBoxCounter.class);  // keeps this class from being GC'd on 1.1 JVMs
90.     return;
91.   }
92. 
    
93.   /** Breaks the specified string into an array
94.    of ints. Returns null if there is an error.*/
95.   public int[] s2ints(String s) {
96.     StringTokenizer st = new StringTokenizer(s, ", \t");
97.     int nInts = st.countTokens();
98.     int[] ints = new int[nInts];
99.     for(int i=0; i<nInts; i++) {
100.       try {ints[i] = Integer.parseInt(st.nextToken());}
101.       catch (NumberFormatException e) {IJ.log(""+e); return null;}
102.     }
103.     return ints;
104.   }
105. 
     
106.   boolean FindMargins(ImageProcessor ip) {
107.     if (IJ.debugMode) IJ.log("FindMargins");
108.     int[] histogram = new int[256];
109.     int width = imp.getWidth();
110.     int height = imp.getHeight();
111.     int left, right, top, bottom;
112. 
     
113.     //Find left edge
114.      left = -1;
115.     do {
116.       left++;
117.       if (left>=width) {
118.         IJ.error("No non-backround pixels found.");
119.         return false;
120.       }
121.       ip.setRoi(left, 0, 1, height);
122.       histogram = ip.getHistogram();
123.     } while (histogram[foreground]==0);
124. 
     
125.     //Find top edge
126.     top = -1;
127.     do {
128.       top++;
129.       ip.setRoi(left, top, width-left, 1);
130.       histogram = ip.getHistogram();
131.     } while (histogram[foreground]==0);
132. 
     
133.     //Find right edge
134.     right =width+1;
135.     do {
136.       right--;
137.       ip.setRoi(right-1, top, 1, height-top);
138.       histogram = ip.getHistogram();
139.     } while (histogram[foreground]==0);
140. 
     
141.     //Find bottom edge
142.     bottom =height+1;
143.     do {
144.       bottom--;
145.       ip.setRoi(left, bottom-1, right-left, 1);
146.       histogram = ip.getHistogram();
147.     } while (histogram[foreground]==0);
148. 
     
149.     roi = new Rectangle(left, top, right-left, bottom-top);
150.     return true;
151.   }
152. 
     
153.   int count(int size, ImageProcessor ip) {
154.     int[] histogram = new int[256];
155.     int count;
156.     int x = roi.x;
157.     int y = roi.y;
158.     int w = (size<=roi.width)?size:roi.width;
159.     int h = (size<=roi.height)?size:roi.height;
160.     int right = roi.x+roi.width;
161.     int bottom = roi.y+roi.height;
162.     int maxCount = size*size;
163.     
164.     for (int i=1; i<=maxCount; i++)
165.       counts[i] = 0;
166.     boolean done = false;
167.     do {
168.       ip.setRoi(x, y, w, h);
169.       histogram = ip.getHistogram();
170.       counts[histogram[foreground]]++;
171.       x+=size;
172.       if (x+size>=right) {
173.         w = right-x;
174.         if (x>=right) {
175.           w = size;
176.           x = roi.x;
177.           y += size;
178.           if (y+size>=bottom)
179.             h = bottom-y;
180.           done = y>=bottom;
181.         }
182.       }
183.     } while (!done);
184.     int boxSum = 0;
185.     int nBoxes;
186.     for (int i=1; i<=maxCount; i++) {
187.       nBoxes = counts[i];
188.       if (nBoxes!=0)
189.         boxSum += nBoxes;
190.     }
191.     return boxSum;
192.   }
193.   
194.   double plot() {
195.     int n = boxSizes.length;
196.     float[] sizes = new float[boxSizes.length];
197.     for (int i=0; i<n; i++)
198.       sizes[i] = (float)Math.log(boxSizes[i]);
199.     CurveFitter cf = new CurveFitter(Tools.toDouble(sizes), Tools.toDouble(boxCountSums));
200.     cf.doFit(CurveFitter.STRAIGHT_LINE);
201.     double[] p = cf.getParams();
202.     double D = -p[1];
203.     String label = "D="+IJ.d2s(D,4);
204.     float[] px = new float[100];
205.     float[] py = new float[100];
206.     double[] a = Tools.getMinMax(sizes);
207.     double xmin=a[0], xmax=a[1]; 
208.     a = Tools.getMinMax(boxCountSums);
209.     double ymin=a[0], ymax=a[1]; 
210.     double inc = (xmax-xmin)/99.0;
211.     double tmp = xmin;
212.     for (int i=0; i<100; i++) {
213.       px[i]=(float)tmp;
214.       tmp += inc;
215.     }
216.     for (int i=0; i<100; i++)
217.       py[i] = (float)cf.f(p, px[i]);
218.     a = Tools.getMinMax(py);
219.     ymin = Math.min(ymin, a[0]);
220.     ymax = Math.max(ymax, a[1]);
221.     Plot plot = new Plot("Plot", "log (box size)", "log (count)", px, py);
222.     plot.setLimits(xmin,xmax,ymin,ymax);
223.     plot.addPoints(sizes, boxCountSums, PlotWindow.CIRCLE);
224.     plot.addLabel(0.8, 0.2, label);
225.     plot.show();
226.     return D;      
227.   }
228. 
     
229.   void doBoxCounts(ImageProcessor ip) {
230.     if (!FindMargins(ip))
231.       return;
232.     ResultsTable rt=ResultsTable.getResultsTable();
233.     rt.incrementCounter();
234.     rt.setLabel(imp.getShortTitle(), rt.getCounter()-1);
235.     for (int i=0; i<boxSizes.length; i++) {
236.       int boxSum = count(boxSizes[i], ip);
237.       rt.addValue("C"+boxSizes[i], boxSum);
238.       boxCountSums[i] = (float)Math.log(boxSum);
239.     }
240.     double D = plot();
241.     rt.addValue("D", D);
242.     rt.show("Results");
243.     imp.deleteRoi();
244.   }
245. }

[ 1.92244 ,  ……………………………

1.9592291, 1.9729414, 1.9554538, 1.9625572, 1.9517543, 1.9695913, 1.963067, 

1.9592291, 1.9729414, 1.9554538, 1.9625572, 1.9517543, 1.9695913, 1.963067, 

1.9592291, 1.9729414, 1.9554538, 1.9625572, 1.9517543, 1.9695913, 1.963067,

 1.9592291, 1.9729414, 1.9554538, 1.9625572, 1.9517543, 1.9695913, 1.963067,

 1.9592291, 1.9729414, 1.9554538, 1.9625572, 1.9517543, 1.9695913, 1.963067, 

1.9592291, 1.9729414, 1.9554538, 1.9625572, 1.9517543, 1.9695913, 1.963067 ]

How can i detect the repetition of my last  7 elements of an ArrayList?

thanks in advance

T.

2. 
   
3. 
   
4. public static Double calculateShannonEntropy(List<String> values) {
5.   Map<String, Integer> map = new HashMap<String, Integer>();
6.   // count the occurrences of each value
7.   for (String sequence : values) {
8.     if (!map.containsKey(sequence)) {
9.       map.put(sequence, 0);
10.     }
11.     map.put(sequence, map.get(sequence) + 1);
12.   }
13. 
    
14.   // calculate the entropy
15.   Double result = 0.0;
16.   for (String sequence : map.keySet()) {
17.     Double frequency = (double) map.get(sequence) / values.size();
18.     result -= frequency * (Math.log(frequency) / Math.log(2));
19.   }
20. 
    
21.   return result;
22. }
23. 
    
24. 
    
25. 
    
26. 
    
27. void setup() {
28.   
29.   calculateShannonEntropy("asd das ds sfffs");
30.   
31. }
32. 
    
33. 
    
34.