Changeset 1048

Timestamp:

10/26/06 17:59:06 (2 years ago)

Author:

callan

Message:

Huge rendering engine optimization and patch that closes and/or implements #190, #260, #449, #450, #451 and #453. Further information on rendering engine optimization can be found on the RenderingEngine Wiki page.

Location:

trunk/components

Files:

• common/src/omeis/providers/re/RGBBuffer.java (modified) (3 diffs)
• common/src/omeis/providers/re/RGBIntBuffer.java (added)
• common/src/omeis/providers/re/RenderingEngine.java (modified) (1 diff)
• rendering/src/omeis/providers/re/GreyScaleStrategy.java (modified) (5 diffs)
• rendering/src/omeis/providers/re/HSBStrategy.java (modified) (6 diffs)
• rendering/src/omeis/providers/re/QuantumManager.java (modified) (4 diffs)
• rendering/src/omeis/providers/re/RGBStrategy.java (modified) (6 diffs)
• rendering/src/omeis/providers/re/RenderHSBRegionTask.java (added)
• rendering/src/omeis/providers/re/RenderHSBWaveTask.java (deleted)
• rendering/src/omeis/providers/re/RenderRGBWaveTask.java (modified) (2 diffs)
• rendering/src/omeis/providers/re/Renderer.java (modified) (6 diffs)
• rendering/src/omeis/providers/re/RenderingStrategy.java (modified) (1 diff)
• rendering/src/omeis/providers/re/RenderingTask.java (added)
• rendering/src/omeis/providers/re/data/PlaneFactory.java (modified) (1 diff)
• rendering/src/omeis/providers/re/quantum/Quantization_8_16_bit.java (modified) (2 diffs)
• rendering/src/omeis/providers/re/quantum/QuantumFactory.java (modified) (4 diffs)
• rendering/src/omeis/providers/re/quantum/QuantumStrategy.java (modified) (2 diffs)
• server/src/ome/logic/PixelsImpl.java (modified) (1 diff)
• server/src/ome/logic/ThumbImpl.java (modified) (9 diffs)
• server/src/ome/security/basic/CurrentDetails.java (modified) (1 diff)
• server/src/ome/services/RenderingBean.java (modified) (5 diffs)

trunk/components/common/src/omeis/providers/re/RGBBuffer.java

@@ -58 +58 @@
 
     /** The serial number. */
-        private static final long serialVersionUID = 5319594152389817322L;
+        private static final long serialVersionUID = 5319594152389817323L;
 
         /** Index of the red band in the image's data buffer. */
-    private static final int    R_BAND = 0;
+    public static final int    R_BAND = 0;
     
     /** Index of the green band in the image's data buffer. */
-    private static final int    G_BAND = 1;
+    public static final int    G_BAND = 1;
     
     /** Index of the blue band in the image's data buffer. */
-    private static final int    B_BAND = 2;
+    public static final int    B_BAND = 2;
     
     
@@ -93 +93 @@
     private int         sizeX2;
     
+    /**
+     * Simple constructor to avoid memory allocations.
+     *
+     */
+    protected RGBBuffer() {}
     
     /**
@@ -157 +162 @@
     public int getSizeX2() { return sizeX2; }
     
+    /**
+     * Sets the Red value for a particular pixel index.
+     * @param index The index in the band array.
+     * @param value The pixel value to set.
+     */
+    public synchronized void setRedValue(int index, int value)
+    {
+        bands[R_BAND][index] = (byte) value;
+    }
+    
+    /**
+     * Sets the Green value for a particular pixel index.
+     * @param index The index in the band array.
+     * @param value The pixel value to set.
+     */
+    public synchronized void setGreenValue(int index, int value)
+    {
+        bands[G_BAND][index] = (byte) value;
+    }
+    
+    /**
+     * Sets the Blue value for a particular pixel index.
+     * @param index The index in the band array.
+     * @param value The pixel value to set.
+     */
+    public synchronized void setBlueValue(int index, int value)
+    {
+        bands[B_BAND][index] = (byte) value;
+    }
+    
+    /**
+     * Retrieves the Red value for a particular pixel index.
+     * @param index The index in the band array.
+     * @return The pixel value at the index.
+     */
+    public byte getRedValue(int index)
+    {
+        return bands[R_BAND][index];
+    }
+    
+    /**
+     * Retrieves the Green value for a particular pixel index.
+     * @param index The index in the band array.
+     * @return The pixel value at the index.
+     */
+    public byte getGreenValue(int index)
+    {
+        return bands[G_BAND][index];
+    }
+    
+    /**
+     * Retrieves the Blue value for a particular pixel index.
+     * @param index The index in the band array.
+     * @return The pixel value at the index.
+     */
+    public byte getBlueValue(int index)
+    {
+        return bands[B_BAND][index];
+    }
 }

trunk/components/common/src/omeis/providers/re/RenderingEngine.java

@@ -99 +99 @@
     
     /**
+     * Renders the data selected by <code>pd</code> according to the current
+     * rendering settings.
+     * The passed argument selects a plane orthogonal to one of the <i>X</i>, 
+     * <i>Y</i>, or <i>Z</i> axes.  How many wavelengths are rendered and
+     * what color model is used depends on the current rendering settings.
+     * 
+     * @param pd Selects a plane orthogonal to one of the <i>X</i>, <i>Y</i>,
+     *           or <i>Z</i> axes.
+     * @return An <i>RGB</i> image ready to be displayed on screen.
+     * @throws ValidationException If <code>pd</code> is <code>null</code>.
+     * @see render()
+     */
+    public int[] renderAsPackedInt(PlaneDef pd) 
+        throws ValidationException;
+    
+    /**
      * Loads the <code>Pixels</code> set this Rendering Engine is for.
      * 

trunk/components/rendering/src/omeis/providers/re/GreyScaleStrategy.java

@@ -135 +135 @@
         throws QuantizationException
     {
-        System.err.println("Render wave.");
         CodomainChain cc = renderer.getCodomainChain();
         int x1, x2, discreteValue, pixelIndex;
-        byte value;
-        float alpha =  color.getAlpha().floatValue()/255;
-        byte[] red = dataBuf.getRedBand(), green = dataBuf.getGreenBand(),
-               blue = dataBuf.getBlueBand();
-        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);
-                red[pixelIndex] = value;
-                green[pixelIndex] = value;
-                blue[pixelIndex] = value;
-            } 
+        
+        // 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;
+                    }
+            }
+        }
     }
     
@@ -159 +179 @@
      * @see RenderingStrategy#render(Renderer ctx, PlaneDef planeDef)
      */
-        RGBBuffer render(Renderer ctx, PlaneDef planeDef)
+    RGBBuffer render(Renderer ctx, PlaneDef planeDef)
+        throws IOException, QuantizationException
+    {
+                //Set the context and retrieve objects we're gonna use.
+                renderer = ctx;
+        RenderingStats performanceStats = renderer.getStats();
+        Pixels metadata = renderer.getMetadata();
+        
+                //Initialize sizeX1 and sizeX2 according to the plane definition and
+                //create the RGB buffer.
+                initAxesSize(planeDef, metadata);
+        performanceStats.startMalloc();
+        log.info("Creating RGBBuffer of size " + sizeX1 + "x" + sizeX2);
+        RGBBuffer buf = new RGBBuffer(sizeX1, sizeX2);
+        performanceStats.endMalloc();
+        
+        render(buf, planeDef);
+        return buf;
+    }
+    
+    /**
+     * Implemented as specified by the superclass.
+     * @see RenderingStrategy#render(Renderer ctx, PlaneDef planeDef)
+     */
+    RGBIntBuffer renderAsPackedInt(Renderer ctx, PlaneDef planeDef)
                 throws IOException, QuantizationException
         {
                 //Set the context and retrieve objects we're gonna use.
                 renderer = ctx;
+        RenderingStats performanceStats = renderer.getStats();
+        Pixels metadata = renderer.getMetadata();
+        
+                //Initialize sizeX1 and sizeX2 according to the plane definition and
+                //create the RGB buffer.
+                initAxesSize(planeDef, metadata);
+        log.info("Creating RGBBuffer of size " + sizeX1 + "x" + sizeX2);
+        RGBIntBuffer buf = new RGBIntBuffer(sizeX1, sizeX2);
+        performanceStats.endMalloc();
+        
+        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();
                 PixelBuffer pixels = renderer.getPixels();
@@ -169 +234 @@
                 ChannelBinding[] cBindings = renderer.getChannelBindings();
         RenderingStats performanceStats = renderer.getStats();
-                
-                //Initialize sizeX1 and sizeX2 according to the plane definition and
-                //create the RGB buffer.
-                initAxesSize(planeDef, metadata);
-        performanceStats.startMalloc();
-        log.info("Creating RGBBuffer of size " + sizeX1 + "x" + sizeX2);
-        RGBBuffer renderedDataBuf = new RGBBuffer(sizeX1, sizeX2);
-        performanceStats.endMalloc();
         
                 //Process the first active wavelength. 
@@ -189 +246 @@
                                 try {  //Transform it into an RGB image.
                     performanceStats.startRendering();
-                    renderWave(renderedDataBuf, wData, cBindings[i].getColor(),
+                    renderWave(buf, wData, cBindings[i].getColor(),
                                qManager.getStrategyFor(i));
                     performanceStats.endRendering();
@@ -199 +256 @@
                         }
                 }
-
-                //Done.
-        return renderedDataBuf;
         }
     

trunk/components/rendering/src/omeis/providers/re/HSBStrategy.java

@@ -33 +33 @@
 import java.io.IOException;
 import java.util.ArrayList;
-import java.util.concurrent.ExecutorService;//j.m
-import java.util.concurrent.Executors;//j.m
-import java.util.concurrent.Future;//j.m
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
 
 //Third-party libraries
@@ -47 +49 @@
 import ome.model.core.Pixels;
 import ome.model.display.ChannelBinding;
+import ome.model.display.Color;
 
 //j.mimport omeis.env.Env;
@@ -54 +57 @@
 import omeis.providers.re.data.PlaneDef;
 import omeis.providers.re.quantum.QuantizationException;
+import omeis.providers.re.quantum.QuantumStrategy;
 
 /** 
@@ -101 +105 @@
     private Renderer    renderer;
     
+    /**
+     * The maximum number of tasks (regions to split the image up into) that
+     * we will be using.
+     */
+    private static final int maxTasks = 2;
     
     /** 
@@ -133 +142 @@
     
     /**
-     * Creates a rendering task for each active wavelength.
+     * Retrieves the maximum number of reasonable tasks to schedule based on
+     * image size and <i>maxTasks</i>.
+     * @return the number of tasks to schedule.
+     */
+    private int numTasks()
+    {
+        for (int i = maxTasks; i > 0; i--)
+        {
+                if ((sizeX2 % i) == 0)
+                        return i;
+        }
+        return 1;
+    }
+    
+    
+    /**
+     * Retrieves the wavelength data for all the active channels.
+     * @return the wavelength data.
+     */
+    private List<Plane2D> getWavelengthData(PlaneDef pDef)
+    {
+        ChannelBinding[] channelBindings = renderer.getChannelBindings();
+        Pixels metadata = renderer.getMetadata();
+        PixelBuffer pixels = renderer.getPixels();
+        RenderingStats performanceStats = renderer.getStats();
+        ArrayList<Plane2D> wData = new ArrayList<Plane2D>();
+        
+        for (int w = 0; w < channelBindings.length; w++)
+        {
+                if (channelBindings[w].getActive())
+                {
+                        performanceStats.startIO(w);
+                        wData.add(PlaneFactory.createPlane(pDef, w, metadata, pixels));
+                        performanceStats.endIO(w);
+                }
+        }
+        return wData;
+    }
+    
+    /**
+     * Retrieves the color for each active channels.
+     * @return the active channel color data.
+     */
+    private List<Color> getColors()
+    {
+        ChannelBinding[] channelBindings = renderer.getChannelBindings();
+        ArrayList<Color> colors = new ArrayList<Color>();
+        
+        for (int w = 0; w < channelBindings.length; w++)
+        {
+                if (channelBindings[w].getActive())
+                {
+                        colors.add(channelBindings[w].getColor());
+                }
+        }
+        return colors;
+    }
+    
+    /**
+     * Retrieves the quantum strategy for each active channels
+     * @return the active channel color data.
+     */
+    private List<QuantumStrategy> getStrategies()
+    {
+        ChannelBinding[] channelBindings = renderer.getChannelBindings();
+        QuantumManager qManager = renderer.getQuantumManager();
+        ArrayList<QuantumStrategy> strats = new ArrayList<QuantumStrategy>();
+        
+        for (int w = 0; w < channelBindings.length; w++)
+        {
+                if (channelBindings[w].getActive())
+                {
+                        strats.add(qManager.getStrategyFor(w));
+                }
+        }
+        return strats;
+    }
+    
+    /**
+     * Creates a set of rendering tasks for the image based on the calling
+     * buffer type.
      * 
      * @param planeDef The plane to render.
+     * @param buf The buffer to render into.
      * @return An array containing the tasks.
      */
-    private RenderHSBWaveTask[] makeRndTasks(PlaneDef planeDef)
-    {
-        ArrayList tasks = new ArrayList();
+    private RenderingTask[] makeRenderingTasks(PlaneDef def, RGBBuffer buf)
+    {
+        ArrayList<RenderHSBRegionTask> tasks =
+                new ArrayList<RenderHSBRegionTask>();
+
+        //Get all objects we need to create the tasks. 
+        CodomainChain cc = renderer.getCodomainChain();
+        RenderingStats performanceStats = renderer.getStats();
+        List<Plane2D> wData = getWavelengthData(def);
+        List<Color> colors = getColors();
+        List<QuantumStrategy> strategies = getStrategies();
+
+        //Create a number of rendering tasks.
+        int taskCount = numTasks();
+        int delta = sizeX2 / taskCount;
+        for (int i = 0; i < taskCount; i++)
+        {
+                //Allocate the RGB buffer for this wavelength.
+                performanceStats.startMalloc();
+                performanceStats.endMalloc();
+
+                int x1Start = 0;
+                int x1End = sizeX1;
+                int x2Start = i * delta;
+                int x2End = (i + 1) * delta;
+                tasks.add(
+                        new RenderHSBRegionTask(buf, wData, strategies, cc, colors,
+                                            x1Start, x1End, x2Start, x2End));
+        }
+
+        //Turn the list into an array an return it.
+        RenderingTask[] tArray = new RenderingTask[tasks.size()];
+        return tasks.toArray(tArray);
+    }
+
+    /**
+     * Implemented as specified by the superclass.
+     * @see RenderingStrategy#render(Renderer ctx, PlaneDef planeDef)
+     */
+    RGBBuffer render(Renderer ctx, PlaneDef planeDef)
+        throws IOException, QuantizationException
+    {
+                //Set the context and retrieve objects we're gonna use.
+                renderer = ctx;
+        RenderingStats performanceStats = renderer.getStats();
+        Pixels metadata = renderer.getMetadata();
+        
+                //Initialize sizeX1 and sizeX2 according to the plane definition and
+                //create the RGB buffer.
+                initAxesSize(planeDef, metadata);
+        performanceStats.startMalloc();
+        RGBBuffer buf = new RGBBuffer(sizeX1, sizeX2);
+        performanceStats.endMalloc();
         
-        //Get all objects we need to create the tasks. 
-        Plane2D wData;
-        ChannelBinding[] cBindings = 
-                renderer.getChannelBindings();
-        CodomainChain cc = renderer.getCodomainChain();
-        Pixels metadata = renderer.getMetadata();
-        PixelBuffer pixels = renderer.getPixels();
-        QuantumManager qManager = renderer.getQuantumManager();
-        RenderingStats performanceStats = renderer.getStats();
-        RGBBuffer channelBuf;
-        
-        //Create a task for each active wavelength.
-        for (int w = 0; w < cBindings.length; w++) {
-            if (cBindings[w].getActive().booleanValue()) {
-                //Allocate the RGB buffer for this wavelength.
-                performanceStats.startMalloc();
-                channelBuf = new RGBBuffer(sizeX1, sizeX2);
-                performanceStats.endMalloc();
-                
-                //Get the raw data.
-                performanceStats.startIO(w);
-                wData = PlaneFactory.createPlane(planeDef, w, metadata, pixels);
-                performanceStats.endIO(w);
-                
-                //Create a rendering task for this wavelength.
-                tasks.add(new RenderHSBWaveTask(channelBuf, wData, 
-                                                qManager.getStrategyFor(w), 
-                                                cc, cBindings[w].getColor(), 
-                                                sizeX1, sizeX2));
-            }
-        }
-        
-        //Turn the list into an array an return it.
-        RenderHSBWaveTask[] t = new RenderHSBWaveTask[tasks.size()];
-        return (RenderHSBWaveTask[]) tasks.toArray(t);
-    }
-    
-    /**
-     * Implemented as specified by superclass.
+        render(buf, planeDef);
+        return buf;
+    }
+    
+    /**
+     * Implemented as specified by the superclass.
      * @see RenderingStrategy#render(Renderer ctx, PlaneDef planeDef)
      */
-    RGBBuffer render(Renderer ctx, PlaneDef planeDef)
-        throws IOException, QuantizationException
-    {
-        //Set the rendering context for the current invocation.
-        renderer = ctx;
+    RGBIntBuffer renderAsPackedInt(Renderer ctx, PlaneDef planeDef)
+                throws IOException, QuantizationException
+        {
+                //Set the context and retrieve objects we're gonna use.
+                renderer = ctx;
+        RenderingStats performanceStats = renderer.getStats();
+        Pixels metadata = renderer.getMetadata();
+        
+                //Initialize sizeX1 and sizeX2 according to the plane definition and
+                //create the RGB buffer.
+                initAxesSize(planeDef, metadata);
+        performanceStats.startMalloc();
+        RGBIntBuffer buf = new RGBIntBuffer(sizeX1, sizeX2);
+        performanceStats.endMalloc();
+        
+        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
+        {
         RenderingStats performanceStats = renderer.getStats();
         
@@ -196 +324 @@
         //process N-1 async and one in the current thread.  If N = 1, 
         //just use the current thread.
-        RenderHSBWaveTask[] tasks = makeRndTasks(planeDef);
+        RenderingTask[] tasks = makeRenderingTasks(planeDef, buf);
         performanceStats.startRendering();
         int n = tasks.length;
         Future[] rndTskFutures = new Future[n];  //[0] unused.
-        //CmdProcessor processor = Env.getProcessor();
-        ExecutorService processor = Executors.newCachedThreadPool();//j.m
+        ExecutorService processor = Executors.newCachedThreadPool();
         
         while (0 < --n)
-            rndTskFutures[n] = processor.submit(tasks[n]); //j.m exec(tasks[n]);
-        RGBBuffer rndDataBuf = null;
-        byte[] red = null, green = null, blue = null;
-        if (n == 0) {
-            rndDataBuf = (RGBBuffer) tasks[0].call(); 
-            red = rndDataBuf.getRedBand();
-            green = rndDataBuf.getGreenBand();
-            blue = rndDataBuf.getBlueBand();
-        }
+            rndTskFutures[n] = processor.submit(tasks[n]);
+        
+        //Call the task in the current thread.
+        if (n == 0)
+                                tasks[0].call();
     
         //Wait for all forked tasks (if any) to complete.
-        //When a task completes, assemble its RGB buffer into rndDataBuf.
-        RGBBuffer taskBuffer;
-        int x1, x2, pix;
-        byte[] r, g, b;
         for (n = 1; n < rndTskFutures.length; ++n) {
             try {
-                taskBuffer = (RGBBuffer) rndTskFutures[n].get();//j.m getResult();
-                r = taskBuffer.getRedBand();
-                g = taskBuffer.getGreenBand();
-                b = taskBuffer.getBlueBand();
-                for (x2 = 0; x2 < sizeX2; ++x2) {
-                    for (x1 = 0; x1 < sizeX1; ++x1) {
-                        pix = sizeX1*x2+x1;
-                        red[pix] = (byte) (red[pix]+r[pix]);
-                        green[pix] = (byte) (green[pix]+g[pix]);
-                        blue[pix] = (byte) (blue[pix]+b[pix]);
-                    } 
-                } 
+                rndTskFutures[n].get();
             } catch (Exception e) {
                 if (e instanceof QuantizationException)
                     throw (QuantizationException) e;
-                throw (RuntimeException) e;  
-                //B/c call() only throws QuantizationException, it must be RE.
+                throw new RuntimeException(e);
             }
         }
         performanceStats.endRendering();
-        
-        if (rndDataBuf == null)  //No active channel, return a black image. 
-            return new RGBBuffer(sizeX1, sizeX2);
-        
-        //Done.
-        return rndDataBuf;
     }