Changeset 1636 for branches/3.0-Beta2/components/rendering/src/omeis/providers/re/metadata/StatsFactory.java

Timestamp:

06/13/07 10:20:37 (18 months ago)

Author:

callan

Message:

Merging trunk I/O fixes into the milestone:3.0-Beta2 branch:

• r1586:1587
  
• r1591:1592
  
• r1593:1594
  
• Manual merge of GreyScaleStrategy
  

Files:

• branches/3.0-Beta2/components/rendering/src/omeis/providers/re/metadata/StatsFactory.java (modified) (6 diffs)

branches/3.0-Beta2/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;
-        for (int x2 = 0; x2 < sizeX2; ++x2) {
-            for (int x1 = 0; x1 < sizeX1; ++x1) {
-                for (int i = 0; i < segments.length; i++) {
-                        pointX1 = p2D.getPixelValue(x1, x2);
-                    if (!segments[i].equals(1, pointX1, pointX2)
-                        && segments[i].lies(pointX1, pointX2))
-                    {
-                        totals[i]++;
+                */
+        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;
+        if (p2D.isXYPlanar()) {
+                //modified code
+                int size = sizeX1*sizeX2;
+                for (int j = 0; j < size; j++) {
+                                v = p2D.getPixelValue(j);
+                                for (int i = 0; i < segments.length; i++) {
+                        segment = segments[i];
+                        if (v >= segment.x1 && v < segment.x2) {
+                                totals[i]++;
                         break;
-                    }
+                        }
                 } // end i
-            } // end x1
-        }// end x2
+                        }
+        } else {
+                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++) {
+                        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))
+                        {
+                            totals[i]++;
+                            break;
+                        }
+                        */
+                    } // end i
+                } // end x1
+            }// end x2
+        }
+       
+        
 
         double total = sizeX2 * sizeX1;
@@ -111 +142 @@
         }
         // 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].x2;//segments[0].getPoint(1).x1;
+        inputEnd = segments[NB_BIN - 1].x2;//segments[NB_BIN - 1].getPoint(1).x1;
         total = total - totals[0] - totals[NB_BIN - 1];
         if (totals[0] >= totals[NB_BIN - 1]) {
@@ -144 +175 @@
      * 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].x2, 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 +192 @@
      * 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].x2, 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].x2 - epsilon;
                 break;
             }
@@ -216 +247 @@
         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;
+        }
+        
+    }
+    
 }