Changeset 1636 for branches/3.0-Beta2

Timestamp:

06/13/07 10:20:37 (15 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
  

Location:

branches/3.0-Beta2/components/rendering/src/omeis/providers/re

Files:

• GreyScaleStrategy.java (modified) (5 diffs)
• data/Plane2D.java (modified) (2 diffs)
• metadata/StatsFactory.java (modified) (6 diffs)

branches/3.0-Beta2/components/rendering/src/omeis/providers/re/GreyScaleStrategy.java

@@ -16 +16 @@
 
 // Application-internal dependencies
-import ome.conditions.ResourceError;
 import ome.io.nio.PixelBuffer;
 import ome.model.core.Pixels;
 import ome.model.display.ChannelBinding;
-import ome.model.display.Color;
 import omeis.providers.re.codomain.CodomainChain;
 import omeis.providers.re.data.PlaneFactory;
@@ -44 +42 @@
     /** The logger for this particular class */
     private static Log log = LogFactory.getLog(Renderer.class);
-
+    
+    /** The channel we're operating on */
+    private int channel;
+    
+    /** The channel binding we're using */
+    private ChannelBinding channelBinding;
+    
     /**
      * Initializes the <code>sizeX1</code> and <code>sizeX2</code> fields
@@ -76 +80 @@
 
     /**
-     * Renders the specified wavelength (channel).
-     * 
-     * @param dataBuf
-     *            The buffer to hold the output image's data.
-     * @param plane
-     *            Defines the plane to render.
-     * @param qs
-     *            Knows how to quantize a pixel intensity value.
-     * @param color
-     *            The color components used when mapping a quantized value onto
-     *            the color space.
-     * @throws QuantizationException
-     *             If an error occurs while quantizing a pixels intensity value.
-     */
-    private void renderWave(RGBBuffer dataBuf, Plane2D plane, Color color,
-            QuantumStrategy qs) throws QuantizationException {
-        CodomainChain cc = renderer.getCodomainChain();
-        int x1, x2, discreteValue, pixelIndex;
-
-        // Perform optimised pixel settings for integer arrays
-        if (dataBuf instanceof RGBIntBuffer) {
-            int alpha = color.getAlpha();
-            int[] buf = ((RGBIntBuffer) dataBuf).getDataBuffer();
-            for (x2 = 0; x2 < sizeX2; ++x2) {
-                int index = sizeX1 * x2;
-                for (x1 = 0; x1 < sizeX1; ++x1) {
-                    discreteValue = qs.quantize(plane.getPixelValue(x1, x2));
-                    discreteValue = cc.transform(discreteValue);
-                    buf[index + x1] = alpha << 24 | discreteValue << 16
-                            | discreteValue << 8 | discreteValue;
-                }
-            }
-        } else // We have just a plain RGBBuffer
-        {
-            byte value;
-            float alpha = color.getAlpha().floatValue() / 255;
-            byte[] r = dataBuf.getRedBand();
-            byte[] g = dataBuf.getBlueBand();
-            byte[] b = dataBuf.getGreenBand();
-            for (x2 = 0; x2 < sizeX2; ++x2) {
-                for (x1 = 0; x1 < sizeX1; ++x1) {
-                    pixelIndex = sizeX1 * x2 + x1;
-                    discreteValue = qs.quantize(plane.getPixelValue(x1, x2));
-                    discreteValue = cc.transform(discreteValue);
-                    value = (byte) (discreteValue * alpha);
-                    r[pixelIndex] = value;
-                    g[pixelIndex] = value;
-                    b[pixelIndex] = value;
-                }
-            }
-        }
-    }
-
-    /**
      * Implemented as specified by the superclass.
      * 
@@ -139 +89 @@
         // Set the context and retrieve objects we're gonna use.
         renderer = ctx;
+        findFirstActiveChannelBinding();
+        PixelBuffer pixels = renderer.getPixels();
         Pixels metadata = renderer.getMetadata();
+        RenderingStats performanceStats = renderer.getStats();
+        QuantumStrategy qs = 
+                renderer.getQuantumManager().getStrategyFor(channel);
+        CodomainChain cc = renderer.getCodomainChain();
+        
+        // Retrieve the planar data to render
+        performanceStats.startIO(channel);
+        Plane2D plane =
+                PlaneFactory.createPlane(planeDef, channel, metadata, pixels);
+        performanceStats.endIO(channel);
 
         // Initialize sizeX1 and sizeX2 according to the plane definition and
@@ -145 +107 @@
         initAxesSize(planeDef, metadata);
         RGBBuffer buf = getRgbBuffer();
-
-        render(buf, planeDef);
+        
+        byte value;
+        float alpha = channelBinding.getColor().getAlpha().floatValue() / 255;
+
+        int x1, x2, discreteValue, pixelIndex;
+        byte[] r = buf.getRedBand();
+        byte[] g = buf.getBlueBand();
+        byte[] b = buf.getGreenBand();
+        if (plane.isXYPlanar())
+        {
+                int planeSize = sizeX1 * sizeX2;
+            for (int i = 0; i < planeSize; i++)
+            {
+                for (x1 = 0; x1 < sizeX1; ++x1)
+                {
+                    discreteValue = qs.quantize(plane.getPixelValue(i));
+                    discreteValue = cc.transform(discreteValue);
+                    value = (byte) (discreteValue * alpha);
+                    r[i] = value;
+                    g[i] = value;
+                    b[i] = value;
+                }
+            }
+        }
+        else
+        {
+                for (x2 = 0; x2 < sizeX2; ++x2) {
+                        for (x1 = 0; x1 < sizeX1; ++x1) {
+                                pixelIndex = sizeX1 * x2 + x1;
+                                discreteValue = qs.quantize(plane.getPixelValue(x1, x2));
+                                discreteValue = cc.transform(discreteValue);
+                                value = (byte) (discreteValue * alpha);
+                                r[pixelIndex] = value;
+                                g[pixelIndex] = value;
+                                b[pixelIndex] = value;
+                        }
+                }
+        }
         return buf;
     }
-
-    /**
-     * Implemented as specified by the superclass.
-     * 
-     * @see RenderingStrategy#render(Renderer ctx, PlaneDef planeDef)
-     */
-    @Override
-    RGBIntBuffer renderAsPackedInt(Renderer ctx, PlaneDef planeDef)
-            throws IOException, QuantizationException {
+    
+    /**
+         * Implemented as specified by the superclass.
+         * 
+         * @see RenderingStrategy#render(Renderer ctx, PlaneDef planeDef)
+         */
+        @Override
+        RGBIntBuffer renderAsPackedInt(Renderer ctx, PlaneDef planeDef)
+                throws IOException, QuantizationException {
         // Set the context and retrieve objects we're gonna use.
         renderer = ctx;
-        Pixels metadata = renderer.getMetadata();
-
-        // Initialize sizeX1 and sizeX2 according to the plane definition and
-        // create the RGB buffer.
-        initAxesSize(planeDef, metadata);
-        RGBIntBuffer buf = getIntBuffer();
-
-        render(buf, planeDef);
-        return buf;
-    }
-
-    /**
-     * Implemented as specified by the superclass.
-     * 
-     * @see RenderingStrategy#render(Renderer ctx, PlaneDef planeDef)
-     */
-    private void render(RGBBuffer buf, PlaneDef planeDef) throws IOException,
-            QuantizationException {
-        QuantumManager qManager = renderer.getQuantumManager();
+        findFirstActiveChannelBinding();
         PixelBuffer pixels = renderer.getPixels();
         Pixels metadata = renderer.getMetadata();
-        ChannelBinding[] cBindings = renderer.getChannelBindings();
         RenderingStats performanceStats = renderer.getStats();
-
-        // Process the first active wavelength.
-        Plane2D wData;
-        for (int i = 0; i < cBindings.length; i++) {
-            if (cBindings[i].getActive().booleanValue()) {
-                // Get the raw data.
-                performanceStats.startIO(i);
-                wData = PlaneFactory.createPlane(planeDef, i, metadata, pixels);
-                performanceStats.endIO(i);
-
-                try { // Transform it into an RGB image.
-                    performanceStats.startRendering();
-                    renderWave(buf, wData, cBindings[i].getColor(), qManager
-                            .getStrategyFor(i));
-                    performanceStats.endRendering();
-                } catch (QuantizationException e) {
-                    e.setWavelength(i);
-                    throw e;
-                }
-                break;
-            }
-        }
-        // Make sure that the pixel buffer is cleansed properly.
-        try {
-            pixels.close();
-        } catch (IOException e) {
-            log.error("IOException caught, throwing ResourceError", e.getCause());
-            throw new ResourceError(
-                    e.getMessage() + " Please check server log.");
-        }
-    }
+        QuantumStrategy qs = 
+                renderer.getQuantumManager().getStrategyFor(channel);
+        CodomainChain cc = renderer.getCodomainChain();
+        
+        // Retrieve the planar data to render
+        performanceStats.startIO(channel);
+        Plane2D plane =
+                PlaneFactory.createPlane(planeDef, channel, metadata, pixels);
+        performanceStats.endIO(channel);
+        
+            // Initialize sizeX1 and sizeX2 according to the plane definition and
+            // create the RGB buffer.
+            initAxesSize(planeDef, metadata);
+            RGBIntBuffer dataBuf = getIntBuffer();
+            
+        int alpha = channelBinding.getColor().getAlpha();
+        int[] buf = ((RGBIntBuffer) dataBuf).getDataBuffer();
+        int x1, x2, discreteValue, pixelIndex;
+        if (plane.isXYPlanar())
+        {
+                int planeSize = sizeX1 * sizeX2;
+                for (int i = 0; i < planeSize; i++)
+                {
+                discreteValue = qs.quantize(plane.getPixelValue(i));
+                discreteValue = cc.transform(discreteValue);
+                buf[i] = alpha << 24 | discreteValue << 16
+                        | discreteValue << 8 | discreteValue;                           
+                }
+        }
+        else
+        {
+                for (x2 = 0; x2 < sizeX2; ++x2) {
+                        pixelIndex = sizeX1 * x2;
+                        for (x1 = 0; x1 < sizeX1; ++x1) {
+                                discreteValue = qs.quantize(plane.getPixelValue(x1, x2));
+                                discreteValue = cc.transform(discreteValue);
+                                buf[pixelIndex + x1] = alpha << 24 | discreteValue << 16
+                                | discreteValue << 8 | discreteValue;
+                        }
+                }
+        }
+            return dataBuf;
+        }
+
+        /**
+         * Initializes the first active channel binding for the current rendering
+         * context.
+         */
+        private void findFirstActiveChannelBinding()
+        {
+                ChannelBinding[] channelBindings = renderer.getChannelBindings();
+                for (int i = 0; i < channelBindings.length; i++)
+                {
+                        if (channelBindings[i].getActive())
+                        {
+                                channel = i;
+                                channelBinding = channelBindings[i];
+                                return;
+                        }
+                }
+                throw new IllegalArgumentException("No active channel bindings found.");
+        }
 
     /**

branches/3.0-Beta2/components/rendering/src/omeis/providers/re/data/Plane2D.java

@@ -132 +132 @@
      */
     public double getPixelValue(int x1, int x2) {
-        int offset = calculateOffset(x1, x2);
-
+        return getPixelValueDirect(calculateOffset(x1, x2));
+    }
+    
+    
+    /**
+     * Returns the pixel intensity value of the pixel at a given offset within
+     * the backing buffer. This method takes into account bytes per pixel. So
+     * the number of offsets is equal to the buffer size / 
+     * <code>bytesPerPixel</code>.
+     * 
+     * @param offset The relative offset (taking into account the number of 
+     * bytes per pixel) within the backing buffer.
+     * @return The intensity value.
+     */
+    public double getPixelValue(int offset)
+    {
+        return getPixelValueDirect(offset * bytesPerPixel);
+    }
+    
+    /**
+     * Returns the pixel intensity value of the pixel at a given offset within
+     * the backing buffer. This method does not take into account bytes per
+     * pixel.
+     * 
+     * @param offset The absolute offset within the backing buffer.
+     * @return The intensity value.
+     */
+    private double getPixelValueDirect(int offset)
+    {
         if (signed) {
             switch (javaType) {
@@ -160 +187 @@
     }
 
+    /**
+     * Returns <code>true</code> if the plane is an <code>XY-plane</code>,
+     * <code>false</code> otherwise.
+     * 
+     * @return See above.
+     */
+    public boolean isXYPlanar()
+    {
+        return (planeDef.getSlice() == PlaneDef.XY);
+    }
 }

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;
+        }
+        
+    }
+    
 }