Changeset 1587

Timestamp:

06/04/07 11:23:33 (18 months ago)

Author:

callan

Message:

Updating to new StatsFactory? mechanisms that Jean-Marie has implemented. Helps #725 a little more. New Plane2D should help even further, Jean-Marie is going to synchronize the StatsFactory with the new Plane2D.

Location:

trunk/components/rendering/src/omeis/providers/re

Files:

• data/Plane2D.java (modified) (1 diff)
• metadata/StatsFactory.java (modified) (7 diffs)

trunk/components/rendering/src/omeis/providers/re/data/Plane2D.java

@@ -132 +132 @@
      */
     public double getPixelValue(int x1, int x2) {
-        int offset = calculateOffset(x1, x2);
-
+        return getPixelValue(calculateOffset(x1, x2));
+    }
+    
+    /**
+     * Returns the pixel intensity value of the pixel at a given offset.
+     * 
+     * @param offset The offset.
+     * @return The intensity value.
+     */
+    public double getPixelValue(int offset)
+    {
         if (signed) {
             switch (javaType) {

trunk/components/rendering/src/omeis/providers/re/metadata/StatsFactory.java

@@ -82 +82 @@
         int[] totals = new int[NB_BIN];
         locationStats = new double[NB_BIN];
+        /*
         Segment[] segments = new Segment[NB_BIN];
         for (int i = 0; i < NB_BIN; i++) {
@@ -88 +89 @@
                         gMin + (i + 1) * sizeBin, 0);
         }
-
-        // check segment [o,e]
-        double pointX1;
-        double pointX2 = 0;
+                */
+        BasicSegment[] segments = new BasicSegment[NB_BIN];
+        for (int i = 0; i < NB_BIN; i++) {
+            segments[i] = new BasicSegment(
+                        gMin + i * sizeBin, gMin + (i + 1) * sizeBin);
+        }
+        // check segment [o,e[
+        double v;
+        BasicSegment segment;
         for (int x2 = 0; x2 < sizeX2; ++x2) {
             for (int x1 = 0; x1 < sizeX1; ++x1) {
+                v = p2D.getPixelValue(x1, x2);
                 for (int i = 0; i < segments.length; i++) {
-                        pointX1 = p2D.getPixelValue(x1, x2);
+                        segment = segments[i];
+                        if (v >= segment.x1 && v < segment.x2) {
+                                totals[i]++;
+                        break;
+                        }
+                        /*
                     if (!segments[i].equals(1, pointX1, pointX2)
                         && segments[i].lies(pointX1, pointX2))
@@ -102 +114 @@
                         break;
                     }
+                    */
                 } // end i
             } // end x1
@@ -111 +124 @@
         }
         // Default, we assume that we have at least 3 sub-intervals.
-        inputStart = segments[0].getPoint(1).x1;
-        inputEnd = segments[NB_BIN - 1].getPoint(1).x1;
+        inputStart = segments[0].x1;//segments[0].getPoint(1).x1;
+        inputEnd = segments[NB_BIN - 1].x1;//segments[NB_BIN - 1].getPoint(1).x1;
         total = total - totals[0] - totals[NB_BIN - 1];
         if (totals[0] >= totals[NB_BIN - 1]) {
@@ -144 +157 @@
      * closed to the min.
      */
-    private double accumulateCloseToMin(int[] totals, Segment[] segments,
+    private double accumulateCloseToMin(int[] totals, BasicSegment[] segments,
             double total, double epsilon) {
-        double e = segments[NB_BIN - 1].getPoint(1).x1, sum = 0;
+        double e = segments[NB_BIN - 1].x1, sum = 0;
         for (int i = 1; i < totals.length - 1; i++) {
             sum += totals[i];
             if (sum / total > THRESHOLD) {
-                e = segments[i].getPoint(1).x1 + epsilon;
+                e = segments[i].x1 + epsilon;
                 break;
             }
@@ -161 +174 @@
      * closed to the max.
      */
-    private double accumulateCloseToMax(int[] totals, Segment[] segments,
+    private double accumulateCloseToMax(int[] totals, BasicSegment[] segments,
             double total, double epsilon) {
-        double s = segments[0].getPoint(1).x1, sum = 0;
+        double s = segments[0].x1, sum = 0;
         for (int i = totals.length - 2; i > 0; i--) {
             sum += totals[i];
             if (sum / total > THRESHOLD) {
-                s = segments[i].getPoint(1).x1 - epsilon;
+                s = segments[i].x1 - epsilon;
                 break;
             }
@@ -216 +229 @@
         return inputEnd;
     }
-
+    
+    //inner class
+    class BasicSegment {
+        
+        /** Left bound of the segment. */
+        double x1;
+        
+        /** Right bound of the segment. */
+        double x2;
+        
+        /**
+         * Creates a new instance.
+         * 
+         * @param x1 The left bound of the segment.
+         * @param x2 The right bound of the segment.
+         */
+        BasicSegment(double x1, double x2)
+        {
+                if (x2 < x1)
+                        throw new IllegalArgumentException("Segment not valid.");
+                this.x2 = x2;
+                this.x1 = x1;
+        }
+        
+    }
+    
 }