X
12064 Rate this article:
3.0

OpenGL shader example

Anonym

OpenGL shader programming has been supported in IDL since version 6.4. The IDLgrShader functionality can be used to program a wide range of display manipulation functions that run on the graphics processor instead of the CPU, and frees up the CPU to work on other things. A great upside is that the graphics processor will be able to run very many threads in parallel which is great for dealing with image data where pixels can be treated independently. I will show an example here of how to perform a calculation where every output pixel depends on a neighborhood of 5x5 pixels in the input image as opposed to the simpler examples where each pixel is manipulated without influence from neighboring pixels. This makes use of a so called "sampler", which is a built in type in the shader language and allows for fast interpolation (nearest neighbor, linear) in an image.

There are some considerations not included in this example. The first is if the image is larger than the maximum texture dimensions (which can be queried), then the image is tiled internally. Using the TILE_BORDER_SIZE keyword is then necessary in order to make an example like this one work properly. The other consideration for large images is that code needs to be written to handle resolution levels and tile requests.

Note that this example requires a physical graphics card in order to run the shader code, virtual environments typically will not have access to a graphics card. In the IDL code you can query what version of the shader language (GLSL) is available at runtime and write the code to be prepared for different possibilities.

This example uses a convolution kernel in a way that allows filling in missing data (set to zero) very effectively. The hole filling is done on the fly at the time of display, so the pixel data still reflect the zero's where data is missing. There are ways to read back out the outputs from the shader code, but that is not included in this example.

Image on the left is the original input pixels with 0's for the missing data. The image on the right is the display of the same image data run though the 5x5 filter.

The following lists the complete source code that produced the images.

pro shader_tricks

  compile_opt idl2, logical_predicate
 
  im = read_image(filepath('elev_t.jpg', subdir=['examples','data']), /order)
  im = total(float(im),1)
  if min(im) eq 0 then im++
 
  help, im
 
  ; simulate random missing data, half of the pixels are missing
  im[floor(randomu(1, n_elements(im)/2)*n_elements(im))] = 0
 
  dim = size(im, /dimension)
 
  w = where(im ne 0, n)
  ord = sort(im[w])
  p0 = im[w[ord[n/50]]]
  p1 = im[w[ord[-n/50]]]
  print, p0, p1
 
  tlb = widget_base(title='Shader example', /row)
  w1 = widget_draw(tlb, xsize=dim[0], ysize=dim[1], retain=2)
  w2 = widget_draw(tlb, xsize=dim[0], ysize=dim[1], $
    graphics_level=2, retain=0, renderer=0)
 
  widget_control, tlb, /realize
  widget_control, w1, get_value=winid
  wset, winid
  tv, bytscl(im, min=p0, max=p1)
  widget_control, w2, get_value=win
 
  vertexProgram = $
    [ 'void main (void) {', $
    '  gl_TexCoord[0] = gl_MultiTexCoord0;', $
    '  gl_Position = ftransform();', $
    '  gl_ClipVertex = gl_ModelViewMatrix * gl_Vertex;', $
    '}' ]
  fragProgram = $
    ['uniform sampler2D _IDL_ImageTexture;' $
    ,'uniform float min;' $
    ,'uniform float max;' $
    ,'uniform float kernel[25];' $
    ,'uniform vec2 _IDL_ImageStep;' $
    ,'void main(void)' $
    ,'{' $
    ,'vec2 adj = vec2(2*_IDL_ImageStep.x,2*_IDL_ImageStep.y);' $
    ,'vec2 tc = gl_TexCoord[0].st - adj;' $
    ,'float sum = 0.0;' $
    ,'float nsum = 0.0;' $
    ,'for (int i=0; i<4; i++) {' $
    , 'adj.y = i * _IDL_ImageStep.y;' $
    ,' for (int j=0; j<4; j++) {' $
    ,'   adj.x = j * _IDL_ImageStep.x;' $
    ,'   float p = texture2D(_IDL_ImageTexture, tc + adj).r;' $
    ,'   float k = kernel[j+i*5];' $
    ,'   sum += p*k;' $
    ,'   nsum += (p != 0)*k;' $
    ,'  }' $
    ,'}' $
    ,'nsum += (nsum == 0);' $
    ,'sum = (sum/nsum - min) / (max - min);' $
    ,'gl_FragColor = vec4(sum,sum,sum,1.0);' $
    ,'}' $
    ]
 
 
  g = gaussian_function([0.5,0.5],width=5,maximum=1)
  shader = IDLgrShader()
  shader->SetProperty, $
    fragment_program_string=strjoin(fragProgram, string(10b)), $
    vertex_program_string=strjoin(vertexProgram, string(10b))
  shader->SetUniformVariable, 'min', float(p0)
  shader->SetUniformVariable, 'max', float(p1)
  shader->SetUniformVariable, 'kernel', float(g)
  view = IDLgrView(viewplane_rect=[0,0,dim])
  model = IDLgrModel()
  img = IDLgrImage(float(im), internal_data_type=3, shader=shader)
 
  view->Add, model
  model->Add, img
  win->Draw, view
  xmanager, 'shader_tricks', tlb, /no_block
 
end