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!



Mapping Earthquake Deformation in Taiwan With ENVI

Mapping Earthquake Deformation in Taiwan With ENVI

12/15/2025

Unlocking Critical Insights With ENVI® Tools Taiwan sits at the junction of major tectonic plates and regularly experiences powerful earthquakes. Understanding how the ground moves during these events is essential for disaster preparedness, public safety, and building community resilience. But traditional approaches like field... Read More >

Comparing Amplitude and Coherence Time Series With ICEYE US GTR Data and ENVI SARscape

Comparing Amplitude and Coherence Time Series With ICEYE US GTR Data and ENVI SARscape

12/3/2025

Large commercial SAR satellite constellations have opened a new era for persistent Earth monitoring, giving analysts the ability to move beyond simple two-image comparisons into robust time series analysis. By acquiring SAR data with near-identical geometry every 24 hours, Ground Track Repeat (GTR) missions minimize geometric decorrelation,... Read More >

Empowering D&I Analysts to Maximize the Value of SAR

Empowering D&I Analysts to Maximize the Value of SAR

12/1/2025

Defense and intelligence (D&I) analysts rely on high-resolution imagery with frequent revisit times to effectively monitor operational areas. While optical imagery is valuable, it faces limitations from cloud cover, smoke, and in some cases, infrequent revisit times. These challenges can hinder timely and accurate data collection and... Read More >

Easily Share Workflows With the Analytics Repository

Easily Share Workflows With the Analytics Repository

10/27/2025

With the recent release of ENVI® 6.2 and the Analytics Repository, it’s now easier than ever to create and share image processing workflows across your organization. With that in mind, we wrote this blog to: Introduce the Analytics Repository Describe how you can use ENVI’s interactive workflows to... Read More >

Deploy, Share, Repeat: AI Meets the Analytics Repository

Deploy, Share, Repeat: AI Meets the Analytics Repository

10/13/2025

The upcoming release of ENVI® Deep Learning 4.0 makes it easier than ever to import, deploy, and share AI models, including industry-standard ONNX models, using the integrated Analytics Repository. Whether you're building deep learning models in PyTorch, TensorFlow, or using ENVI’s native model creation tools, ENVI... Read More >

1345678910Last
18113 Rate this article:
1.7

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.