INTViewer

Jul 12 2018

Installing the Seismic Unix Library on Windows [Walkthrough]

*This post has been recently updated to reflect 2022 updates.

In our previous blog, Simplifying the Learning Curve of the Seismic Unix Library, we described how INTViewer can leverage the SU library. This library is typically meant for Linux, but it can also be used on Windows. This walkthrough describes how to install the SU Library on Windows 10 to use the Seismic Workbench plugin.

The installation of the Seismic Unix Library includes 3 steps:

Download the SU Library code and Cygwin
Install and configure Cygwin
Compile the SU Library code

For this walkthrough, we use SU Library 44R23 and Cygwin 2.881.

Downloading the SU Library Code

The SU Library code can be downloaded here: https://wiki.seismic-unix.org/doku.php

Extract the contents of the downloaded .tgz file to C:\apps\cwp_su_all_44R23

Downloading Cygwin

Cygwin can be downloaded here: https://cygwin.com/install.html

Choose the 32 bit version of Cygwin (not 64).

Installing and Configuring Cygwin

To install Cygwin, execute its installer (setup-x86.exe). This will install the Cygwin program, which when run, creates a POSIX shell window similar-looking to the Windows command window but which behaves in a more Unix-like way.

You will need to install several additional Cygwin components before your workflows can run. To get these, run the installer program (called Setup and represented by an icon with a black “C” shape enclosing a green arrow). Click Next →.

Click Next →.

Choose an installation directory and click Next →. This tutorial assumes that the default location is not used. Instead of “C:\cygwin64” use “C:\cygwin”. Installing Cygwin in the root of a drive in a folder named “cygwin” is good practice since it will be detected automatically by INTViewer in this configuration.

Choose a directory where Setup will store installation files. This directory can be reused for future installs so that the download doesn’t have to be repeated. Click Next →.

On this screen, you can choose your connection options. Click Next →.

Select a download site, preferably the one closest to you. Click Next →.

Now we need to select all of the packages required for compiling Seismic Unix. The Search field is a handy way to quickly find the packages. Just enter text to search, but do NOT press Enter, as this will cause the installer to move to the next page.

First, select gcc-core. To select a package, use the drop-down menu to select the version shown…

Next, select gcc-g++.

Next, select make.

Next, select libgcc1.

Next, select libgd-devel.

Next, select both libQtOpenGL4 packages.

Next, select libtiff-devel.

Next, select libXaw-devel.

Next, select rpcbind.

Next, select libnetpbm-devel.

Next, select tiff-opengl.

Finally, select libX11-devel. Click Next →.

The following screen will display any dependencies required for the selected packages. Click Next →. Cygwin will proceed to download and install all of the selected packages and required dependencies.

Create an icon on the desktop or start menu if desired. Click Next →.

Copy .bash_profile and .bashrc from C:\cygwin\etc\defaults\etc\skel and place them in your standard Windows user directory. (C:\Users\Josh for me)

Add the following lines to the end of each file:

# Setup for SU
export CWPROOT=/cygdrive/c/apps/cwp_SU_all_44R23
# Setup PATH to include SU
export PATH=$CWPROOT/bin:$PATH

Compiling the SU Library Code

Now that Cygwin is set up, we need to compile the Seismic Unix code. First, copy the file Makefile.config_Cygwin_32 located at C:\apps\cwp_su_all_44R23\src\configs to C:\apps\cwp_su_all_44R23\src\.

Replace Makefile.config located at C:\apps\cwp_su_all_44R23\src with the copied file.

Run Cygwin, and navigate to /cygdrive/c/apps/cwp_su_all_44R23/src. Once here, enter the make install command. This will compile the standard Seismic Unix code.

After the previous make file is finished, enter the make xtinstall command. This will compile the X-toolkit code.

Cygwin and the SU Library are now ready to use!

Testing the Installation

As a quick test, open the Cygwin command line, and enter the following command line, and enter the following command, modifying the paths to match your directory structure. A copy of the SEG-Y file should have been created if the installation was successful.

segyread tape=/cygdrive/d/data/Segy/Tony/stack-tony.sgy | segywrite tape=/cygdrive/d/data/Segy/Tony/stack-tony-out.sgy

For more information about INTViewer, visit the INTViewer product page, or contact us for a free trial.

Jun 21 2018

How the NetBeans Module System Helps Us Maintain Compatibility Between Releases

Most of the talk about Java 9 has been about the new module system. Two decades after its creation, the Java runtime has finally become modular. A modular approach not only makes dependency management easier, but it also makes applications more efficient as unused modules don’t need to be loaded.

The NetBeans Platform predates Java 9 and has been using its own module system for years. With INTViewer being a desktop application built on top of the NetBeans Platform, I have come to like this system and I’d like to talk about 3 aspects in which it is far superior to the Java 9 module system for my use cases.

Split Packages

One of the core aspects of both the NetBeans Platform and the Java 9 module system is that modules are identified uniquely by a root package name. Where they differ is that the Java 9 module system doesn’t allow two modules to have classes under the same root package name. The logic behind this is that the Java runtime can’t quickly resolve where to find each class if the rules to find the matching module are complex or even ambiguous. Java 9 doesn’t allow so-called “split packages.”

The NetBeans Platform doesn’t have this restriction, and over the 10 years that I have worked on INTViewer, this has helped us tremendously building INTViewer as a modular platform. Many times, we found ourselves realizing that one module was “too big” and needed to be split. If we had to follow the “no split packages” rule, we would have had to change the package of some classes, breaking class-level backward compatibility.

This “stable class-level API” is a very important concern for us. With customers and vendors building their own applications on top of INTViewer, we can’t afford to change the public API at each release. Our customers wouldn’t allow it: they can’t refactor their code so often. When we do need to split a module, customers are generally okay with changing the coarse-grained dependencies of their app; adding a new module to their dependencies is easy and doesn’t require any code change.

Module Versioning

It’s a simple feature, but very powerful. When INTViewer starts, the NetBeans Platform verifies every plugin before it gets loaded. If one of them relies on another module that is not present, this plugin doesn’t load. Similarly, if a plugin requires a module to be up-to-date and the NetBeans Platform finds that this requirement is not met, this plugin won’t load. Practically, this prevents mixing plugin versions. A plugin built for INTViewer 5.2 won’t load in INTViewer 5.1. The NetBeans Platform gives immediate feedback to the person performing the plugin installation.

The Java 9 module system doesn’t support module versioning. The versioning concern is left to the dependency-resolution systems like Maven. But these systems perform checks at compile time, not when the application is used.

Mixing Library Versions

This is not a trick we use often, but it’s a lifesaver when we have to. When our customers build their own plugins, they typically leverage .jar files built by other entities. We do, too, and in a typical Java application, there is only one class loader to load all these .jar files. If two versions of the same library are present, the resolution of class names is ambiguous and the application fails in strange ways. The Java 9 module system doesn’t provide a direct way to address this concern.

The NetBeans Platform uses its own class loaders. To simplify, each module has its own. Each class loader only needs to deal with a well-defined set of dependencies, and other class loaders are not affected by these dependencies.

For example, we have two optional plugins making use of the JAXB library, a popular building block to read XML files. One of them is the VTK plugin, a plugin to visualize 3D models. Another one is the Reservoir plugin, a plugin to visualize RESQML datasets. These two plugins can coexist in the same INTViewer deployment without problems, and they don’t even need to have the same version of JAXB.

In a classic Java application, a choice would have to be made: which version of JAXB is “the right one,” and the module using the “wrong version” would have to be updated. The NetBeans Platform makes it really easy to deal with these version conflicts. As a result, INTViewer customers are not faced with refactoring their code for each release just because another unrelated module needed a more recent version of a specific library.

INT has greatly benefited from the NetBeans Platform. Its module system is both powerful and easy to use. It has allowed us to provide, release after release, a painless way to maintain INTViewer plugins, for ourselves and for our customers.

For more information about INTViewer, visit the INTViewer product page, or contact us for a free trial.

Jan 26 2018

Simplifying the Learning Curve of the Seismic Unix Library

A graphical user interface to help jumpstart your SU Library adoption

The SU (Seismic Unix) Library is a well-known set of utilities used to research and process seismic data. Supported by the Center for Wave Phenomena (CWP) at the Colorado School of Mines (CSM), it is a powerful package that is widely used in the geoscience community.

Following the Linux philosophy, each utility within this package is a separate command. For example, the segyread command converts SEG-Y files to the SU format. With hundreds of commands at your disposal, and with each command having multiple parameters, it can be a daunting task to get started.

INTViewer provides a graphical user interface for the SU library, reducing the learning curve. The Seismic Workbench is a free plugin that has the documentation for the SU library built in, making it easy to find a particular command and all the parameters that this command requires. INTViewer builds the full command line for you based upon all individual commands selected. [See the Seismic Workbench plugin video walkthrough here.]

You can elect to run this command line from inside INTViewer or from your own terminal. Running inside INTViewer provides neat integration options: Not only you can leverage INTViewer’s built-in trace processors and generators, but you can also visualize in real time the datasets that each step creates. The workbench allows you to customize the display parameters of each output dataset, and save your set of steps as a complete job for later reuse.

An example of processing step configuration

While the SU Library was built with Linux in mind, Windows users are not without options. They typically use Cygwin to run native Linux applications, including the SU library utilities. [Stay tuned for our next blog describing the complete installation of Cygwin and the SU Library on Windows.] Users of the seismic workbench have reported that the graphical user interface and the integration with INTViewer made the SU Library much more accessible.

For more information about INTViewer, visit the INTViewer product page, or contact us for a free trial.

Aug 22 2017

How to Create Interactive Slideshows (VIDEO)

Presenting data to clients regularly poses many challenges, especially considering that today’s datasets are likely to exceed a petabyte or more. Presentations made with tools like PowerPoint may take hours to create, are instantly obsolete, and frequently don’t fully answer your clients’ questions.

With one simple plugin, INTViewer transforms the art of showing data to your clients by combining the simplicity of a slideshow with the power of live data.

Quick tip: Check out our INTViewer slideshow tutorial to get started!

Create, Share, and Standardize Presentations

The INTViewer slideshow plugin streamlines how your company presents data to potential customers.

Data managers can create slideshows in INTViewer and share them with their colleagues.

Large datasets can be transferred to laptops without any loss of definition using the lattice decimation plugin, making INTViewer slideshows portable.

This new presentation medium saves time and can help standardize how your sales team presents data, while leaving enough flexibility to answer customer questions.

Easy to Learn, Easy to Use

Presentations built using INTViewer work just like other presentation software—once you load the slideshow, press play to start, then press the Next button to go from one slide to another.

The slideshow window allows you to jump to a different slide without losing context.

2D-map-lines — This slide shows all of the lines at once.

verify-data-easily — The next slide shows the map and a cross-section of the highlighted 2D line.

Manipulating the data is incredibly easy. For example, to verify the definition of your data, you can zoom in just by holding the shift key and drawing a box around the section you want to view.

And to investigate a problematic area, you can view a spectrum analysis with just one click (S+draw a box).

Ready to make your presentations interactive?

For more information about INTViewer, check out our other blogs, visit the INTViewer product page, or contact us for a free trial.

Aug 01 2017

3 NetBeans Shortcuts to Help You Be More Productive

I have been using NetBeans daily for about 8 years, so I’d say I am pretty familiar … with the features I use all the time. Over the years, friends and colleagues have shown me that there are faster ways to get the job done. I have gathered in this post three shortcuts that I learned from others and that you can also use when you develop an INTViewer plugin.

#1 Finding a class file in the Project Tree

A software like INTViewer has thousands of source files, spread over dozens of plugins. As I am in the process of editing one file, I often find myself needing to find out which other files are related: I need contextual information about the file I am changing or I need to commit all changes to that module at once.

The project view before Shift+Ctrl+1 is pressed.

The shortcut to do this is to type Shift+Ctrl+1 on your keyboard.

The project view after Shift+Ctrl+1 is pressed.

This shortcut opens both the package where the file resides and the module that contains that file.

#2 Closing all other files

The process of writing software is not a continuous flow. I work on several aspects of the software at the time, with lots of interruptions. Sooner or later, I have several dozens of unrelated files open. When I need to work on a tricky part of the code, the first task is to clear the clutter.

The NetBeans makes it easy: the “close button” of each NetBeans window has a handy tooltip that informs you of available shortcuts.

The NetBeans tooltip for the window close button.

By pressing the Alt key as I am clicking this close button, I isolate the associated file, closing all other files that are open. I do this for each group of windows, and in 2 or 3 clicks, I reduced my clutter to the 2 or 3 files that matter.

Interestingly, because INTViewer is based on the NetBeans platform, INTViewer users also benefit from the same feature. If I have several INTViewer windows open, I can click on the one window I want to keep, automatically closing all others in the same tab group.

The INTViewer tooltip for the window close button.

#3 Loading already-configured projects

INTViewer itself is made of more than 80 plugins, but there are at least 50% more that are not part of the standard distribution. They are proprietary customer plugins, community plugins that we share with all our users, prototype plugins that we are working on. I sometimes need to run these plugins on top of the “bleeding edge” version of INTViewer’s code, sometimes on specific distributions that customers already use, sometimes on top of other plugins. The project configuration possibilities are endless, but I tend to use about 10 of these different configurations all the time.

NetBeans has a feature called Project Groups to facilitate switching between project configurations. To save your current project configuration, go to File→Project Groups. You will see a dialog with a button New Group that leads to the screen below:

This dialog proposes several options on how to create your project group. I typically use the Free Group option and press the Create Group button.

To load a project group already created, go to File→Project Groups, pick the project group that you need to work on, and choose Select Group

Your project tree will load exactly as you left it when you saved it as project group.