Introduction

A cube is an organized way of holding data in x, y and z direction. The dimension of the cube is the number_of_elements_in_a_row x number_of_elements_in_a_column x number_of_layers. The first two parts is the definition of a grid. Thus a cube is consisting of a certain set of grids stacked upon each other to form the layers in the cube.

The text deals with a simple form of cube manipulation that is valuable in a certain context. Although there are many menus attached to cube generation and the cube, there is also a need for creating and manipulating the cube through commands that are scripted. Below are some basic script commands used for cube manipulation.

Velocity cube displayed in two ways in a viewport presentation

On this page:

Basic script commands for manipulating a cube

The commands are taken from the shell command reference.

Basic commands for manipulating a cube

gen 'number_in_rows' 'number_in_colums' 'number_of_layers' ;# generate a dummy cube within the grid window 
set nrow [gvar nrow] ;# Tcl syntax to assign the numbers in a row into a variable. 
set ncol [gvar ncol] ;# Tcl syntax to assign the numbers in a column into a variable. 
set nlay [gvar nlay] ;# Tcl syntax to assign the numbers of layers into a variable. 
ima sla 'layer_number' ;# select grid layer 'layer_number' from cube in active workspace. 
ima ins 'layer_number' 'cube_in_workspace' ;# insert a grid into 'cube_in_workspace' at layer 'layer_number'. 
pro 'cube_in_workspace' ;# probe (sample) values from the cube into the scalar part of a polydata.

The cube commands make it possible to change and update the interior of a cube.

The interior of a velocity cube displayed by the cube manipulator

Converting a time velocity cube into a time depth cube

A time velocity cube is a cube where the cube dimensions are in time values while the cube nodes are in velocity. The script below will transform such a cube into a time depth cube, i.e. a cube that has dimensions in time while the node values are in depth.

The cube is supposed to be in active. This is achieved when the script is placed in the main part of a command object and the CO is executed on the cube.

Converting a time velocity cube into a time depth cube

        mhi cubegrid            ;# the cube is saved in workspace cubegrid
        set nlay [gvar nlay]    ;# get number of layers in the cube
        for {set i 0} {$i < $nlay} {incr i} {
           mlo cubegrid         ;# move low the cubegrid to active
           ima sla $i           ;# getting layer i from the cubegrid
           set time [gvar zval] ;# the time value is taken form the zval variable
           mul $time            ;# velocity values are multiplied with time values getting depth values
           div 2000             ;# divide by 2000 if the time is in two_way_travel_time
           ima ins $i cubegrid  ;# the grid is inserted back into the cubegrid
        }

After running the script loop the updated cube is in workspace cubegrid according to the script. Assign the cube back into the project from cubegrid.

One idea with a cube format is that it is a convenient way to probe values (or sample values) directly to some dataset that has the form x y time scalar. The time in this context is placed in the z values.

For a time velocity cube the input to probing has to be: x y time scalar. After probing the result is x y time velocity.

For a time depth cube the input to probing has to be: x y time scalar. After probing the result is x y time depth.

Geocap will generate the scalars if they are not present in the input dataset. A convenient way to generate scalars manually is to use the command mak sca.

Generating a cube by single grids

A technique for cube generation is to generate all the individual grids in the cube layers one by one, then insert them into the cube. In this way the user has completely control if there is a need for working out grids in this style. Below is a sketch of the procedure.

Assume there is a folder with 82 files of that represents values laying above each other. Then generate a command object for gridding all the data into individual grids and place it into a cube. The command object shall be executed on the folder containing all the datasets.

Generating a cube by single grids

        # Place this part in prestep
        # Do Scale window to data in folder first to get the grid window
        gen 100 100 82  ;# generate a cube of dimension 100 * 100 * 82 inside the grid window.
        mhi cubegrid    ;# save the cube into workspace cubegrid
      
        # Place this part in main       
        for {set i 0} {$i < 82} {incr i} {
           grp mav 100 100     ;# grid the points using moving average interpolator
           ima ins $i cubegrid ;# insert layer grid into layer i in the cube
        }
        
        # Place this part in poststep
        mlo cubegrid  ;# move to active from cubegrid in workspace
        dis           ;# display the cube in default mode. 
        # The cube can now be added back into an appropriate folder in the project.

Smoothing a cube by smoothing each layer

The menu for smoothing a cube is found under cube_data->Smoothing cube. The menu has option for smoothing the cube in all xyz direction (Gaussian 3D) or lateral smoothing where each planes is smoothed individually.

The script below tells how to perform the individual cube layer smoothing thus enabling the user to take full control of any 2D smooth technique and optionally vary the smoothing for z plane location.

The cube is supposed to be in active. This is achieved when the script is placed in the main part of a command object and the CO is executed on the cube.

Smoothing a cube by smoothing each layer

       
        # To smooth a cube by smoothing each layer
        mhi cubeorg                 ;# the original cube is saved in workspace cubeorg
        mak csd                     ;# csd: copy same data, makes a new copy of the cube
        mhi cubesmooth              ;# the new cube is saved in workspace cubesmooth
        set nlay [gvar nlay]        ;# get number of layers in the cube
        ssc                         ;# scale cube to grid window
        for {set i 0} {$i < $nlay} {incr i} {
           mlo cubesmooth           ;# move low the cube to active
           ima sla $i               ;# getting layer i from the cube
           grp exc exrad 8 nod 16   ;# regrid and exclude 8 nodes and use 16 nodes
           ima ins $i cubesmooth    ;# the grid is inserted back into cubesmooth
        }
        # To generate the difference between the original cube and the smoothed cube
        mlo cubeorg                 ;# move low the original cube
        sub lo cubesmooth           ;# subtract the smoothed cube
        mhi cubediff                ;# save the difference cube as cubediff
        # The new cubes: cubesmooth and cubediff can be added to the project

The scripts above shows how easy it is to manipulate a cube by individual cube layer control. The option of saving the original cube and generating a difference cube can be dropped if of no interest or if the cube is so large that memory space requires a minimum of cubes involved.

Browser not supported