X

NV5 Geospatial Blog

Each month, NV5 Geospatial posts new blog content across a variety of categories. Browse our latest posts below to learn about important geospatial information or use the search bar to find a specific topic or author. Stay informed of the latest blog posts, events, and technologies by joining our email list!



13785 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

Please login or register to post comments.
«July 2025»
SunMonTueWedThuFriSat
293012345
6789101112
13141516171819
20212223242526
272829303112
3456789
Digital Number, Radiance, and...

Number of views (172339)

Push Broom and Whisk Broom Sensors

Number of views (154544)

The Many Band Combinations of Landsat 8

Number of views (121671)

What Type of Loop Should I Use?

Number of views (80327)

Mapping Coastal Erosion Using LiDAR

Number of views (59041)