Changeset 6963


Ignore:
Timestamp:
09/14/10 14:51:23 (9 years ago)
Author:
rlentz
Message:
 
Location:
OpenCLIterative3DDeconvolution
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • OpenCLIterative3DDeconvolution/.classpath

    r6961 r6963  
    1010        </classpathentry> 
    1111        <classpathentry kind="lib" path="lib/ij.jar" sourcepath="/home/loci/workspace/imagej/src/ij"/> 
    12         <classpathentry kind="lib" path="lib/jocl.jar"> 
     12        <classpathentry kind="lib" path="lib/jocl.jar" sourcepath="/home/loci/workspace/jogamp/jocl"> 
    1313                <attributes> 
    1414                        <attribute name="org.eclipse.jdt.launching.CLASSPATH_ATTR_LIBRARY_PATH_ENTRY" value="OpenCLIterative3DDeconvolution/native"/> 
  • OpenCLIterative3DDeconvolution/src/publication/SobelFilterExample.java

    r6962 r6963  
    1717 
    1818import javax.imageio.ImageIO; 
    19 import javax.swing.ImageIcon; 
    20 import javax.swing.JFrame; 
    21 import javax.swing.JLabel; 
     19 
    2220 
    2321import com.jogamp.opencl.CLBuffer; 
     
    3230public class SobelFilterExample { 
    3331        static boolean DEBUG = true; 
     32        static boolean COMPARERESULTS = true; 
    3433        static boolean DISPLAYIMAGE = true; 
    3534        static CLProgram program; 
     
    4645        static int localWorkSize; 
    4746 
    48          
     47 
    4948        public void release() 
    5049        { 
     
    7776 
    7877                if( DEBUG )  System.out.println( "get a command queue" ); 
    79                 queue = context.getMaxFlopsDevice().createCommandQueue( CLCommandQueue.Mode.PROFILING_MODE ); 
    80  
    81                 if( DEBUG ) 
    82                 { 
    83                         System.out.println( "Max work group size is " + queue.getDevice().getMaxWorkGroupSize() ); 
    84                         System.out.println( "Max work item dimensions is " + queue.getDevice().getMaxWorkItemDimensions() ); 
    85                         System.out.println( "Max parameter size is " + queue.getDevice().getMaxParameterSize() ); 
    86                         for(int i = 0; i < queue.getDevice().getMaxWorkItemDimensions(); i++) 
    87                         System.out.println( "Max work item size is " + queue.getDevice().getMaxWorkItemSizes()[i] ); 
    88                          
    89                 } 
    90                  
     78                queue = context.getMaxFlopsDevice().createCommandQueue( ); 
     79 
    9180                if( DEBUG )  System.out.println( "find the max compute unites"); 
    9281                maxComputeUnits = queue.getDevice().getMaxComputeUnits(); 
     
    135124 
    136125                //if( DEBUG ) { System.out.println("Enqueing the kernel w...");} 
    137                 queue.put2DRangeKernel(kernel, 0, 0, imageWidth, imageHeight, 0, 0 ); 
     126                queue.put2DRangeKernel(kernel, 0, 0, imageWidth, imageHeight, 0, 0); 
    138127 
    139128                //if( DEBUG ) { System.out.println("Waiting for CLFinish to return...");} 
     
    152141        { 
    153142                final int numVariables = 4; 
    154                 final int numIterations = 1; 
     143                final int numIterations = 50; 
    155144                long[] times = new long[numVariables]; 
    156                  
     145 
    157146                //run test 
    158147                runTest( numIterations, times ); 
    159                  
     148 
    160149                System.out.println("The average OpenCL set up time is " + times[0]/numIterations); 
    161150                System.out.println("The average OpenCL IO transfer time is " + times[1]/numIterations); 
     
    168157                int r = (c&0xff0000) >> 16; 
    169158                int g = (c&0xff00) >> 8; 
    170                 int b = c&0xff; 
    171                 return (r + g + b)/3; 
     159                        int b = c&0xff; 
     160                        return (r + g + b)/3; 
    172161        } 
    173162 
     
    194183                } 
    195184 
    196                  
    197                  
     185 
     186 
    198187                for(int iteration = 0; iteration < numIterations; iteration++) 
    199188                { 
    200189                        try { 
    201                         System.out.println("Starting iteration... " + iteration ); 
    202                          
    203                         //Convert Image to float 
    204                         float[] testImage = new float[testWidth*testHeight]; 
    205                         for( int i = 0; i < testWidth; i++ ) 
    206                                 for( int j = 0; j < testHeight; j++ ) 
    207                                         testImage[ i*testHeight+j ] = getAvg( inputImage[ i*testHeight+j ]); 
    208  
    209                         //Clone the input data 
    210                         float[] testImageCopy = testImage.clone(); 
    211                          
    212                         //Start the performance timer 
    213                         long time = System.currentTimeMillis(); 
    214  
    215                         //setup OpenCL 
    216                         SobelFilterExample generateSobelFilterData = new SobelFilterExample( testWidth, testHeight ); 
    217  
    218                         //Stop the performance timer 
    219                         time = System.currentTimeMillis() - time; 
    220                         System.out.println("It took...  " + time + " nanoseconds to set up OpenCL."); 
    221  
    222                         totalTime[0] += time; 
    223                          
    224                         //Start the performance timer 
    225                         time = System.currentTimeMillis(); 
    226  
    227                         long executionTime = generateSobelFilterData.run( testImage ); 
    228  
    229                         //Stop the performance timer 
    230                         time = System.currentTimeMillis() - time; 
    231                         System.out.println("It took...  " + executionTime + " nanoseconds to execute sobel filter in OpenCL for image size " + testHeight + " x " + testWidth + " and " + time + " mSec total time." ); 
    232  
    233                         totalTime[1] += time; 
    234                         totalTime[2] += executionTime; 
    235                          
    236                         //Start the performance timer 
    237                         time = System.currentTimeMillis(); 
    238  
    239                         filter3x3( testImageCopy, testWidth, testHeight ); 
    240  
    241                         //Stop the performance timer 
    242                         time = System.currentTimeMillis() - time; 
    243                         totalTime[3] += time; 
    244                         System.out.println("It took...  " + time + " nanoseconds to execute sobel filter in Java for image size " + testHeight + " x " + testWidth ); 
    245                          
    246                         //Compare the results 
    247                         int success = 0, failed = 0; 
    248                         for( int i = 0; i < testWidth; i++ ) 
    249                                 for( int j = 0; j < testHeight; j++ ) 
    250                                         if (testImage[ i*testHeight+j ] == testImageCopy[ i*testHeight+j ] ) 
    251                                         { 
    252                                                 success++; 
    253                                         }       else { failed++;  
    254                                         if (failed < 100) 
    255                                                 System.out.println("Reference value " + testImageCopy[ i*testHeight+j ] + " not equal " + testImage[ i*testHeight+j ] + " for index " + (i*testHeight+j) );} 
    256                         System.out.println("The test passed " + success + " values and failed " + failed + " of " + testWidth*testHeight + " values."); 
    257                          
    258                          
    259                         //free the OpenCL resources and wait 10 seconds... 
    260                         generateSobelFilterData.release(); 
    261                         generateSobelFilterData = null; 
    262                         System.gc(); 
    263                         Thread.sleep(10000);  //sleep for 10 seconds 
    264                          
     190                                System.out.println("Starting iteration... " + iteration ); 
     191 
     192                                //Convert Image to float 
     193                                float[] testImage = new float[testWidth*testHeight]; 
     194                                for( int i = 0; i < testWidth; i++ ) 
     195                                        for( int j = 0; j < testHeight; j++ ) 
     196                                                testImage[ i*testHeight+j ] = getAvg( inputImage[ i*testHeight+j ]); 
     197 
     198                                //Clone the input data 
     199                                float[] testImageCopy = testImage.clone(); 
     200 
     201                                //Start the performance timer 
     202                                long time = System.currentTimeMillis(); 
     203 
     204                                //setup OpenCL 
     205                                SobelFilterExample generateSobelFilterData = new SobelFilterExample( testWidth, testHeight ); 
     206 
     207                                //Stop the performance timer 
     208                                time = System.currentTimeMillis() - time; 
     209                                System.out.println("It took...  " + time + " milliseconds to set up OpenCL."); 
     210 
     211                                totalTime[0] += time; 
     212 
     213                                //Start the performance timer 
     214                                time = System.currentTimeMillis(); 
     215 
     216                                long executionTime = generateSobelFilterData.run( testImage ); 
     217 
     218                                //Stop the performance timer 
     219                                time = System.currentTimeMillis() - time; 
     220                                System.out.println("It took...  " + executionTime + " milliseconds to execute sobel filter in OpenCL for image size " + testHeight + " x " + testWidth + " and " + time + " mSec total time." ); 
     221 
     222                                totalTime[1] += time; 
     223                                totalTime[2] += executionTime; 
     224 
     225                                //Start the performance timer 
     226                                time = System.currentTimeMillis(); 
     227 
     228                                filter3x3( testImageCopy, testWidth, testHeight ); 
     229 
     230                                //Stop the performance timer 
     231                                time = System.currentTimeMillis() - time; 
     232                                totalTime[3] += time; 
     233                                System.out.println("It took...  " + time + " milliseconds to execute sobel filter in Java for image size " + testHeight + " x " + testWidth ); 
     234 
     235                                //Compare the results 
     236                                if (COMPARERESULTS) 
     237                                { 
     238                                        int success = 0, failed = 0; 
     239                                        for( int i = 0; i < testWidth; i++ ) 
     240                                                for( int j = 0; j < testHeight; j++ ) 
     241                                                { 
     242                                                        int index = i*testHeight+j; 
     243                                                        float diff = testImage[ index ] - testImageCopy[ index ]; 
     244 
     245                                                        if ( Math.abs(diff) < 0.0001 ) 
     246                                                        { 
     247                                                                success++; 
     248                                                        }       else  
     249                                                        {  
     250                                                                failed++;  
     251                                                                //if (failed < 5000*5) 
     252                                                                System.out.println("Reference value " + testImageCopy[ index ] + " not equal " + testImage[ index ] + " for index " + index ); 
     253                                                        } 
     254                                                } 
     255                                        System.out.println("The test passed " + success + " values and failed " + failed + " of " + testWidth*testHeight + " values."); 
     256                                } 
     257 
     258                                //free the OpenCL resources and wait 10 seconds... 
     259                                generateSobelFilterData.release(); 
     260                                generateSobelFilterData = null; 
     261                                System.gc(); 
     262                                Thread.sleep(10000);  //sleep for 10 seconds 
     263 
    265264                        } catch (Exception e) 
    266265                        { 
     
    275274 
    276275        static void filter3x3(float[] pixels, int width, int height ) { 
    277                 float v1, v2, v3;           //input pixel values around the current pixel 
    278                 float v4, v5, v6; 
    279                 float v7, v8, v9; 
    280  
    281276                //create a copy 
    282277                float[] pixelsCopy = pixels.clone(); 
    283278 
     279                float p0, p1, p2, p3, p5, p6, p7, p8 = 0; 
     280 
     281 
    284282                for (int y=0; y<height; y++) { 
    285                         int p  = y*width;            //points to current pixel 
    286                         int p6 = p;      //will point to v6, currently lower 
    287                         int p3 = p6 - (y>0 ? width : 0);    //will point to v3, currently lower 
    288                         int p9 = p6 + (y<height-1 ? width : 0); // ...  to v9, currently lower 
    289                         v2 = pixelsCopy[p3]; 
    290                         v5 = pixelsCopy[p6]; 
    291                         v8 = pixelsCopy[p9]; 
    292                         v3 = pixelsCopy[p3]; 
    293                         v6 = pixelsCopy[p6]; 
    294                         v9 = pixelsCopy[p9]; 
    295  
    296                         for (int x=0; x<width; x++,p++)  
     283                        for (int x=0; x<width; x++)  
    297284                        { 
    298                                 if (x<width-1) { p3++; p6++; p9++; } 
    299                                 v1 = v2; v2 = v3; 
    300                                 v3 = pixelsCopy[p3]; 
    301                                 v4 = v5; v5 = v6; 
    302                                 v6 = pixelsCopy[p6]; 
    303                                 v7 = v8; v8 = v9; 
    304                                 v9 = pixelsCopy[p9]; 
    305                                 float sum1 = v1 + 2*v2 + v3 - v7 - 2*v8 - v9; 
    306                                 float sum2 = v1  + 2*v4 + v7 - v3 - 2*v6 - v9; 
    307                                 pixels[p] = (float)Math.sqrt(sum1*sum1 + sum2*sum2); 
     285                                int offset = y * width + x; 
     286 
     287                                if( x < 1 || y < 1 || x > width - 2 || y > height - 2 ) 
     288                                { 
     289                                        pixels[offset] = 0;  
     290                                } 
     291                                else 
     292                                { 
     293                                        p0 = pixelsCopy[offset - width - 1] ; 
     294                                        p1 = pixelsCopy[offset - width] ; 
     295                                        p2 = pixelsCopy[offset - width + 1] ; 
     296                                        p3 = pixelsCopy[offset - 1]; 
     297                                        p5 = pixelsCopy[offset + 1]; 
     298                                        p6 = pixelsCopy[offset + width - 1] ; 
     299                                        p7 = pixelsCopy[offset + width] ; 
     300                                        p8 = pixelsCopy[offset + width + 1] ; 
     301 
     302                                        double sum1 = p0 + 2*p1 + p2 - p6 - 2*p7 - p8;  //GY 
     303                                        double sum2 = p0 + 2*p3 + p6 - p2 - 2*p5 - p8;  //GX 
     304 
     305                                        pixels[offset] = (float) Math.sqrt(  sum1*sum1 + sum2*sum2 ); 
     306                                } 
    308307                        } 
    309308                } 
  • OpenCLIterative3DDeconvolution/src/publication/sobel.cl

    r6962 r6963  
     1#pragma OPENCL EXTENSION cl_khr_fp64: enable 
    12__kernel void sobel( __global float* input, 
    23        __global float* output, 
     
    67    int x = get_global_id(0); 
    78    int y = get_global_id(1); 
    8     float p0, p1, p2, p3, p4, p5, p6, p7, p8 = 0; 
     9    float p0, p1, p2, p3, p5, p6, p7, p8 = 0; 
    910    int offset = y * width + x; 
    10 if( x < 1 || y < 1 || x > width - 2 || y > height - 2 ) 
    11 { 
    12   output[offset] = 0;  
     11     
     12        if( x < 1 || y < 1 || x > width - 2 || y > height - 2 ) 
     13        { 
     14          output[offset] = 0;  
     15        } 
     16        else 
     17        { 
     18            p0 = input[offset - width - 1] ; 
     19            p1 = input[offset - width] ; 
     20            p2 = input[offset - width + 1] ; 
     21            p3 = input[offset - 1] ; 
     22            p5 = input[offset + 1] ; 
     23            p6 = input[offset + width - 1] ; 
     24            p7 = input[offset + width] ; 
     25            p8 = input[offset + width + 1] ; 
     26         
     27            double sum1 = p0 + 2*p1 + p2 - p6 - 2*p7 - p8;  //GY 
     28            double sum2 = p0 + 2*p3 + p6 - p2 - 2*p5 - p8;  //GX 
     29            
     30            output[offset] = sqrt(  sum1*sum1 + sum2*sum2 ); 
     31        } 
    1332} 
    14 else 
    15 { 
    16     p0 = input[offset - width - 1] ; 
    17     p1 = input[offset - width] ; 
    18     p2 = input[offset - width + 1] ; 
    19     p3 = input[offset - 1] ; 
    20     p4 = input[offset] ; 
    21     p5 = input[offset + 1] ; 
    22     p6 = input[offset + width - 1] ; 
    23     p7 = input[offset + width] ; 
    24     p8 = input[offset + width + 1] ; 
    25  
    26     float sum1 = p0 + 2*p1 + p2 - p6 - 2*p7 - p8;  //GY 
    27     float sum2 = p0 + 2*p3 + p6 - p2 - 2*p5 - p8;  //GX 
    28     
    29     output[offset] = sqrt(  sum1*sum1 + sum2*sum2 ); 
    30 } 
    31 } 
Note: See TracChangeset for help on using the changeset viewer.