Not All Supernovae Are Created Equal: Rethinking the Universe’s Measuring Tools

6/3/2025

Rethinking the Reliability of Type 1a Supernovae How do astronomers measure the universe? It all starts with distance. From gauging the size of a galaxy to calculating how fast the universe is expanding, measuring cosmic distances is essential to understanding everything in the sky. For nearby stars, astronomers use... Read More >

Using LLMs To Research Remote Sensing Software: Helpful, but Incomplete

5/26/2025

Whether you’re new to remote sensing or a seasoned expert, there is no doubt that large language models (LLMs) like OpenAI’s ChatGPT or Google’s Gemini can be incredibly useful in many aspects of research. From exploring the electromagnetic spectrum to creating object detection models using the latest deep learning... Read More >

From Image to Insight: How GEOINT Automation Is Changing the Speed of Decision-Making

4/28/2025

When every second counts, the ability to process geospatial data rapidly and accurately isn’t just helpful, it’s critical. Geospatial Intelligence (GEOINT) has always played a pivotal role in defense, security, and disaster response. But in high-tempo operations, traditional workflows are no longer fast enough. Analysts are... Read More >

Thermal Infrared Echoes: Illuminating the Last Gasp of a Dying Star

4/24/2025

This blog was written by Eli Dwek, Emeritus, NASA Goddard Space Flight Center, Greenbelt, MD and Research Fellow, Center for Astrophysics, Harvard & Smithsonian, Cambridge, MA. It is the fifth blog in a series showcasing our IDL® Fellows program which supports passionate retired IDL users who may need support to continue their work... Read More >

A New Era of Hyperspectral Imaging with ENVI® and Wyvern’s Open Data Program

2/25/2025

This blog was written in collaboration with Adam O’Connor from Wyvern. As hyperspectral imaging (HSI) continues to grow in importance, access to high-quality satellite data is key to unlocking new insights in environmental monitoring, agriculture, forestry, mining, security, energy infrastructure management, and more.... Read More >

1 2 3 4 5 6 7 8 9 10 Next Last

«

June 2025

»

Sun

Mon

Tue

Wed

Thu

Fri

Sat

25

26

27

28

29

30

31

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

1

2

3

4

5

13629 Rate this article:

3.0

OpenGL shader example

Anonym Thursday, December 17, 2015

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.

Using Recursive ENVIRaster Definitions in ESE 5.2 Batch processing with IDL

NV5 Geospatial Blog