Blog post added by Dustan Adkins
I would like to congratulate our Google Summer of Code (GSoC) students for 2012. We had a very stiff competition this year. I know this because I read (and in most cases re-read) proposals for two weeks trying to narrow down the field. Make no mistake - the proposals for Opticks this year were truly top-notch. I would have liked to accept more, but we were limited to just 3 slots. In the end, the following proposals were accepted:
I would like to thank all of the students who submitted proposals for Opticks and would like to extend an invitation to them to contribute to Opticks outside GSoC. I have been in touch with multiple students who were not selected, and all but one of them have agreed to contribute something to Opticks from their proposals. The one who did not agree to become a contributor was accepted by another GSoC organization, so congratulations to him, and we hope to see him again at the end of the summer.
I would also like to thank our mentors and co-mentors, without whom GSoC participation would not be possible: Trevor Clarke, Nathan Jennings, Tishampati Dhar, and Dr. Charles Wamsley.
And, of course, a special thanks to OSGeo and especially Anne Ghisla (aghisla) to letting Opticks participate under their organization and putting up with all of my questions.
I just finished the release of Opticks 4.9.0rc1 and IDL/Python/Spectral 1.6.0rc1. As I was finishing the release, I was informed that OPTICKS-1386 was found and would likely cause another release candidate (rc) to be created. Please take the time to download the rc's so we can find and fix any other issues in them to make this release as stable as possible.
Blog post added by Trevor Clarke
This past week I attended the FOSS4G North America conference in Washington DC. Overall it was a great conference. I got to meet some IRC regulars including hobu, nhv, and epifanio. We had some great discussions about open source LIDAR and how Opticks plans to fit into the newly developing LIDAR ecosystem. There were many interesting presentations on new and old projects. I'm particularly excited about the new versions of PostgreSQL and PostGIS as well as GeoTrellis, a new tool to automatically parallelize and distribute raster computations and attach a nice RESTful interface to the algorithms.
Daniel Risacher gave a great talk on the future of open source in the US DoD and intelligence community. I'm excited about his efforts to establish a group similar to the Apache Foundation tasked with assisting US government and IC projects with their open source dreams. This will be a HUGE step forward for the DoD and allowing for higher quality software for a much lower cost of ownership.
I've also decided that the GIS community really doesn't get remote sensing (especially hyperspectral) since most of the products out there (great as they are at what they do) treat processing and MASINT as an after thought. I see two major problems:
Let me be clear that I'm not trying to put down any projects, it just that GIS goals are often different so the tools don't always translate as well to remote sensing and it can often feel like we are the ugly ducklings of the imagery world. I'd love to use some of these great processing tools like PostGIS and GeoTrellis and I'm always watching to see if the will handle my workflows or can be easily adapted to handle 3-D cubes and alternate interleaves but I'm getting a bit frustrated. While Opticks is great at handling this as a rich desktop app and does have a batch mode, it's really not an ideal platform for webservices or distributed processing. Therefore, I may need to work on a new framework similar to GeoTrellis, etc. for MASINT processing.
I'd love to hear your thoughts, especially if you work on one of the FOSS4G projects that handles server-side processing, distributed processing, or in-database processing of raster data. (I mentioned 2 here but they are certainly not the only ones). I'd love to extend one of the existing projects if there's a fit but I don't have time to explore everything out there.
Blog post edited by Trevor Clarke
If you are experiencing problems downloading dependencies and require the use of an HTTP proxy the following should help you resolve the problem. The problem occurs when using the dependencies/retrieve-dependencies scripts. Try the following in the Dependencies directory:
This should show a bunch of settings. At the bottom you should see something like:
------------------------------------------- Proxy information ------------------------------------------- Java1.5+ proxy settings: Direct connection
Now, try setting your proxy settings:
You should see:
------------------------------------------- Proxy information ------------------------------------------- http.proxyHost = "proxyhostname" http.proxyPort = "3128" http.proxyUser = "username" http.proxyPassword = "password" Java1.5+ proxy settings: HTTP @ proxyhostname:3128 proxyhostname:3128 [unresolved]
Except you shouldn't see the "unresolved" (I used a fake proxy name for my test). If you don't need a username and password, just omit those settings.
Finally, you can grab the dependencies. Just remove the -dianostics option and replace it with all to simulate retrieve-dependencies or the appropriate dependencies option. For example, grab just win32 dependencies:
Blog post edited by Trevor Clarke
I've pushed a new importer out to COAN which loads a variety of RAW photo formats using libraw. I haven't got the build.py script working yet so I haven't created an AEB but it should build on at least win32 and win64 (Linux should work but I haven't tested it yet). There are quite a few limitations including:
Feel free to try it out and send me feedback, or better yet, branch it on github, make some changes/additions, and send a pull request. I'll be happy to take any changes provided they work well and don't decrease functionality.
You can access the source code here.
There is an AEB for Opticks 4.8.x (Windows and Linux) available.
Blog post added by Trevor Clarke
I've pushed a new importer out to COAN which loads a variety of RAW photo formats using libraw. I haven't got the build.py script working yet so I haven't created an AEB but it should build on at least win32 and win64 (Linux should work but I haven't tested it yet). There are quite a few limitations including:
Feel free to try it out and send me feedback, or better yet, branch it on github, make some changes/additions, and send a pull request. I'll be happy to take any changes provided they work well and don't decrease functionality.
You can access the source code here.
Blog post added by Trevor Clarke
Some users have had trouble downloading the dependencies if they are behind an HTTP proxy. User himsin has created a bash script which uses wget to download the required dependencies and mirrors then to a local directory for use with the dependency system. This script requires bash and wget. If you are on Windows you can install mingw32 or cygwin to obtain these tools.
Blog post added by Dustan Adkins
I have not added a new blog post in quite some time. I apologize for that and want to make sure everybody knows that I have not stopped. I have just been busy. I just now posted a draft of the Opticks Governance Policy, so you can see what I have been working on the last couple of weeks. Oh, and Google Summer of Code (GSoC) – Anne from OSGeo has been awesome to work with and has helped OSGeo (and, by proxy, Opticks) get into GSoC again this year. I am looking forward to mentoring a great summer of code. For interested parties, the official OSGeo GSoC page is here, and the Opticks project ideas page is here. We are also welcoming co-mentors – please message the Mailing Lists if you are interested. Finally, I have been acting on some suggestions from the community by updating the Opticks page on Wikipedia.
Blog post added by Dustan Adkins
I have a confession to make. Almost every time I make an AOI in Opticks, I make the same mistake. I click and drag to try to draw a rectangle and get a single pixel staring back at me mockingly. With a new option in Opticks 4.8.0 I now have an ally in my battle against this little dot. Opticks now allows me to change the default AOI pixel selection tool. So long, little dot! Hello nice, friendly rectangle! Here is where to find the option:
Blog post edited by Stuart Miller
A new imaging field that is really growing in popularity right now is LiDAR/LaDAR. These funky looking acronyms stand either for Light Detection And Ranging or Laser Detection And Ranging, depending on the technique used to collect the data. LiDAR/LaDAR work similarly to radar, just with light instead of radio waves. A typical collection involves shining a light on a surface and then checking the return time back to the sensor in order to determine the surface's distance. By collecting a large volume of points - frequently numbering in the millions - a point cloud can be generated that can be used to accurately visualize the surface in 3D.
LiDAR Visualization of the US Capitol Building (source)
The most obvious application for LiDAR collections is in surface reconstruction. LiDAR sensors can easily be placed on aerial vehicles to collect data over large swaths of land, and once the data has been collected the points can be displayed in their raw format or processed to reconstruct a standard 3D mesh, which can be exported and used in various 3D rendering engines. The raw point cloud can also be processed using a variety of algorithms to do interesting things, such as virtually removing trees and man-made objects in order to better analyze the bare earth. This allows for a great amount of insight into the topological composition of areas without having to physically destroy anything. One such algorithm is outlined here (PDF link), and shows the impressive results that an analyst can get by using very basic processing techniques on the data.
Interest in LiDAR is expanding beyond GIS applications, however. A major advancement in the accessibility of the technology came with the release of the Microsoft Kinect in 2010, which has a relatively low-resolution LiDAR sensor built in to detect the spatial position of users in front of the camera. Since the device operates over USB, developers were able to create a driver that allowed the Kinect to be used on a PC, giving rise to a large community dedicated to using the technology in new and interesting ways. One academic group in Germany was able to create a simple face scanner that uses the spatial positioning data from the LiDAR sensor to create all of the geometry, as well as getting texture data from the normal RGB camera. You can see their results in this video. Due to the explosive popularity of Kinect hacking, Microsoft is planning on releasing a version of the device specifically for PCs sometime in 2012.
Thom Yorke's big goofy head... in 3D
Point clouds have also gained popularity with artists due to the unique visualizations that can be produced. In late 2011, GeoDigital hosted a competition called LiDAR as Art where users could submit artistic LiDAR renderings, with the author of the best photo winning an iPad. You can see the submissions on their Flickr stream. Additionally, some major music videos have been released recently that relied entirely on LiDAR for their visualizations: Linkin Park's "Waiting For The End" and Radiohead's "House Of Cards." Radiohead also released all of the data used in composing the "House of Cards" video freely on a Google Code page, allowing those interested in the technology to explore the full data set and understand how the video was created.
We on the Opticks team are pretty excited about this technology, and have done some internal prototypes to see how we can integrate LiDAR support into our platform. Much of our work is very early, but we're hoping as time and funding become available we can expand further and eventually have a release with full support for common LiDAR formats, particularly LAS. If you are interested in following the development of our LiDAR support, you can check the open issue on our bug tracker where we will post updates as they occur. We also have some public builds of our prototypes available for download on Hudson.
Blog post added by Dustan Adkins
Before anyone flames me, I am well aware that the Python programming language is named after Monty Python and not the snake.
But this is becoming far too silly; I should get on with it!
First things first. You will need to have a distribution of Python installed on your machine. Oh, and make sure to get a version supported by Opticks. If you are not sure what to get, check for compatibility here. As of the time of this writing, only Python 2.5 and Python 2.6 are supported, and only Python 2.6 supports 64-bit.
Then download and install Opticks and the Python Scripting Extension.
If you have not already done so, install the Python extension. Depending on where Opticks is installed and what OS you are using, you will need to run Opticks as administrator (or root). Some users will be able to simply drag and drop the AEB file onto the Opticks application. If this does not work, then you will need to use the Extensions dialog. Detailed instructions for installing extensions are available here. Make sure to restart Opticks after installing the extension.
And now for something completely different. Once Python is installed, you should be able to see it in the Opticks Scripting Window. Open the Scripting Window by selecting "Scripting Window" from the "Tools" menu. Now you can enter commands. Here is an example using some Powerful Python One-Liners which amused me. Click on the image for a larger view:
On certain machines (I wish I could invest the time to narrow this down, but, alas, I cannot), Python will not show up correctly in Opticks. This can usually be attributed to Opticks not being able to find Python for some nebulous reason. Rather than starting some sort of Spanish Inquisition into the problem, I will show you two simple techniques for fixing it.
An environment variable is really no more than a hidden setting on your computer. Do not be afraid of them, although I should warn you that messing them up can have consequences (up to and including needing to reinstall the operating system). In this example, I am going to show you how to modify an environment variable called PATH. In simple terms, the PATH is essentially the master list of where your computer should go to find programs. For the Python Scripting Extension, we need to make sure that the Python shared library can be located. [Side note: Many people incorrectly refer to a shared library as a DLL. The truth is: a DLL is a shared library, and a shared library is not necessarily a DLL. For the purposes of this article, however, they are close enough to be considered equivalent. Although they a bit different. A bit...]
Now that we understand what the PATH does, how can you change it? This depends on your operating system. This question has been answered many times. One gotcha is that in Microsoft Vista and 7, users without administrator privileges may have trouble changing their PATH. This question has also been answered here. It took me awhile to find the "Change my environment variables" link referenced from that article, so here is a screenshot pointing out its location:
Change your PATH to reference the directory containing the Python shared library. On Windows, this is usually C:\Python25 or C:\Python26. Some distributions of Python even throw it into C:\Windows\System32 or another system folder. Once you have changed your PATH, you should be able to restart Opticks and try again. If you continue to have problems, please let us know via our Mailing Lists or real-time chat. There are more advanced steps which can be followed, however, they are outside the scope of this article.
Other than the title of this section, this article contains 5 obvious (or not-so-obvious) references to Monty Python. If you think you have found them all, let us know on Twitter or Facebook!
Blog post added by Trevor Clarke
This tutorial uses Opticks 4.8.0 with the Python extension 1.5.0 with Python 2.6. OpenCV 2.2 with the OpenCV Python AEB are also required. This tutorial may need to be adapted for configurations other than this.
It is assumed that the user has some knowledge of Python, the Opticks Python scripting engine, and basic OpenCV. Basic tasks such as accessing image data using Python will not be covered in detail nor will there be in depth explanation of the OpenCV functions used.
This tutorial uses the Bushehr Quickbird image from June 6, 2002 which can be obtained from the Sample Data page.
This tutorial will demonstrate:
The Python source code can be downloaded here: contours.py You can place this in a location where is can be imported into the Python scripting window or you can type the text directly into the scripting window.
The basic flow for the algorithm will first get the image data from Opticks, convert it into an 8-bit grayscale image, use the Canny algorithm to interactively find edges, use a contour tracing algorithm to vectorize the edges, and save contour information to an Opticks .ano file. Let's look at the code.
The next section of the main function calls the interactive_canny function. This function will return None if the user presses the q key. We'll go over this function now.
interactive_canny demonstrates how to use the OpenCV HighGUI functions to quickly create an interactive GUI to choose Canny thresholds. This iteratively calculates the Canny function and displays the results in a window. Since the imshow function displays an image at full resolution, the rsize function will scale the data if it is large. Two sliders are added to the window to allow the user to adjust the low and high thresholds and see the results. Pressing the q key will cancel the script and pressing the enter key will continue using the selected thresholds.
This next section in the main function using the OpenCV FindContours function to trace the edges. The default parameters create a flat (non-hierarchical) list of all the contours using simple chain codes which list only vertices and no intermediate points on the contours.
Once the contours are calculated we would like to create an annotation layer to display them. In Opticks 4.8.0, there are no functions available to create and manipulate annotation layers and AOIs can only be manipulated as bitmasks, not vectors. In order to work around this deficiency, we create a .ano file which is the Opticks native annotation file format. We will save this to the contours.ano file in the Opticks temp directory. The save_anno function is shown below.
An .ano file is an XML file and is not too difficult to create. The first section writes out some boilerplate XML indicating that this is an annotation element. The important parts of this header are the name attributes in the AnnotationElement and DataDescriptor XML tags. These should be the same value and indicate the name of the annotation layer. In this case, we are calling it Contours.
The while loop is used to iterate through all the contours in the list of contours. Near the end of the loop, the c = c.h_next() call will move to the next contour. Since we created a flat list, the c.v_next() call will always return None but is used to move down in a hierarchical contour list. We write out some information for the contour. The Graphic tag has a could of interesting attributes and children. The name attribute indicates the name of each contour; in this case we are just numbering them. The type attribute is the shape used to draw the contour; in this case, a closed polygon. (Polyline would have been another option if we didn't want a closed shape) The LineColor, {{FillStyle}, and other child elements determine how the contours will be drawn. We will use unfilled polygons with red borders.
The for loop iterates through all the vertices in the contour and writes out the pixel location of each vertex. The paths element is used to create complex hierarchical polygons. If we calculated hierarchical contours we could display them using multiple paths. For now, we just use a single path starting at the first pixel.
The end of the function writes the XML footer for the .ano file. There's also a check so we won't write out too many contours since more than a couple of thousand in a file can take a long time to load and display from a .ano file. We could write multiple files in this case but I'll leave that as an exercise to the reader.
This last piece of code creates an instance of the Import Data Set plug-in and points it to the .ano file we just created. This is used to import the result into the active window.
The easiest way to run the program is to save the .py file where it can be imported into Opticks. You can then load an image and type:
Here are some screenshots of the Bushehr data set. You can see the edge image with the adjusted thresholds and the resulting contours in Opticks.
Blog post added by Dustan Adkins
Nothing can be better than something. Especially in batch mode. Especially when calling OpticksBatch a lot. And especially when logging every line of output to a file. Opticks has provided a "brief" command-line argument to OpticksBatch for quite some time. But it was still too much. Users wanted less. So we gave it to them. In Opticks 4.8.0, you can now specify "verybrief". And it is very, very brief. You only get startup, shutdown, warning, and error messages. Here is a screenshot (click on it for a larger image):
If you are curious about the software used in that screenshot, I am using a free and open source program called Console. I use it primarily because it has tabs. I like tabs. And I like open source software. If it's free, it's for me!
Blog post added by Dustan Adkins
Opticks has, for a long time, had a feature known as Image Linking (or just Linking). Linking lets the user use either pixel or geographic coordinates to keep multiple windows in lock-step while zooming and panning, which can come in pretty handy. This feature is especially useful for looking at the same area over time, images covering the same area from different sensors, or comparing processed data to raw data.
In this example, I am going to compare the old (and somewhat tedious) method of linking with the new and much improved method available in 4.8.0. I will be using data from Landsat7 ETM+ which is available from our sample data downloads page here. Kudos and thanks go out to both the Landsat7 ETM+ team and USGS for providing us with this great imagery.
Download and install Opticks, and download the sample data and extract the archive. I used 7-zip for extraction, which is available here.
Open Opticks, and import all of the .re.ice.h5 files from the archive (there should be 3 altogether: spectral, thermal, and pan). You can do this either by using the "Import Data" command from the "File" menu or the toolbar button ( 
), or, if you prefer, you can drag and drop the files onto Opticks. As a side note, you can drag-and-drop multiple files at once, and you can use the "Import Options" dialog if you drag-and-drop using the secondary (e.g.: right) mouse button. For this example, I did not change any import options, so a regular drag-and-drop will do the trick for us. The files should load without any errors, although there will be a warning "Unable to load statistics" for each file. This is normal and is expected for these files (I believe that they use an older file format which did not support statistics, although I did not confirm this information).
Now that the files are loaded, tile the windows for a better look. This can be done by selecting "Tile Horizontally" from the "Window" menu ( 
). Now click within each window and press the 'e' key on the keyboard or click on the "Zoom to Fit" toolbar button ( 
). The Opticks window should now look like this:
Historically, there have been two ways to perform linking. There is a toolbar button ( 
), and there is a menu entry under "Tools" called "Link/Unlink...". Selecting either of those will invoke the Link/Unlink dialog.
Select any of the 3 images in the combo box (I chose "spectral"), and remember the name. Click "Next >".
The second page is the tricky part. Check the checkbox under "Views" (you may have to click twice. This is an annoying little bug that we would love to have fixed by someone in the community. Send us a patch!). Make sure that "Automatic" Link Type is selected and that the link is two-way by clicking the "Two-Way" checkbox. Just make it look like the image above and click "Next >" again.
We are almost halfway done. (Hey, I warned you that the old method was tedious. Fear not – the new method is much faster!) Now select an image which does not match the image you selected on page 1 (I chose "pan"). Click "Finish". And click "OK" on the message boxes telling you about zoom/pan limits. No, you are not actually finished. Go back and reopen the dialog, and select a different set of images (e.g.: "spectral" on page 1 and "thermal" on page 3). Oh, and don't forget the annoying little bug on page 2. And the message boxes - yikes!!
Now forget about the Link/Unlink dialog. Unless you want to do something fancy, you will probably never need it again. The Session Explorer now has Link/Unlink capability built into it. From the Session Explorer, select all 3 windows by shift-clicking or ctrl-clicking. Right-click (or left-click for us southpaws!) on your selection and click "Link" (note: if you have already linked the images as described above you will need to click "Unlink" first). Presto! This does the same thing as the Link/Unlink dialog! I should also mention that you can do this with one click. There is a new "Link All Windows" toolbar button ( 
) and a corresponding entry under the "Tools" menu.
For the power users out there I should also mention that there is an options page to control the Link Type. It is under "Tools" -> "Options". The Link Type option is under "Windows" -> "Workspace" -> "All". Here is a screenshot showing its hiding place:
So now that the images are linked, you can use the normal zoom and pan functions in Opticks. This should move all of the views within the windows around automatically and keep them in lock-step. Here is a sample screenshot:
By the way, you can also unlink images once you are done. Either use the Link/Unlink dialog and select "Unlink" as the Link Type, or (4.8.0 and later) select one or more windows using the Session Explorer and select "Unlink".
The final screenshot above is from Opticks 4.7.1. There is one toolbar button present in Opticks 4.8.0 which is missing from this screenshot. Another hint: it was mentioned somewhere in this tutorial. Can you find it? Tweet the answer to us or post it on our wall!
Blog post edited by Stuart Miller
A new imaging field that is really growing in popularity right now is LiDAR/LaDAR. These funky looking acronyms stand either for Light Detection And Ranging or Laser Detection And Ranging, depending on the technique used to collect the data. LiDAR/LaDAR work similarly to radar, just with light instead of sound waves. A typical collection involves shining a light on a surface and then checking the return time back to the sensor in order to determine the surface's distance. By collecting a large volume of points - frequently numbering in the millions - a point cloud can be generated that can be used to accurately visualize the surface in 3D.
LiDAR Visualization of the US Capitol Building (source)
The most obvious application for LiDAR collections is in surface reconstruction. LiDAR sensors can easily be placed on aerial vehicles to collect data over large swaths of land, and once the data has been collected the points can be displayed in their raw format or processed to reconstruct a standard 3D mesh, which can be exported and used in various 3D rendering engines. The raw point cloud can also be processed using a variety of algorithms to do interesting things, such as virtually removing trees and man-made objects in order to better analyze the bare earth. This allows for a great amount of insight into the topological composition of areas without having to physically destroy anything. One such algorithm is outlined here (PDF link), and shows the impressive results that an analyst can get by using very basic processing techniques on the data.
Interest in LiDAR is expanding beyond GIS applications, however. A major advancement in the accessibility of the technology came with the release of the Microsoft Kinect in 2010, which has a relatively low-resolution LiDAR sensor built in to detect the spatial position of users in front of the camera. Since the device operates over USB, developers were able to create a driver that allowed the Kinect to be used on a PC, giving rise to a large community dedicated to using the technology in new and interesting ways. One academic group in Germany was able to create a simple face scanner that uses the spatial positioning data from the LiDAR sensor to create all of the geometry, as well as getting texture data from the normal RGB camera. You can see their results in this video. Due to the explosive popularity of Kinect hacking, Microsoft is planning on releasing a version of the device specifically for PCs sometime in 2012.
Thom Yorke's big goofy head... in 3D
Point clouds have also gained popularity with artists due to the unique visualizations that can be produced. In late 2011, GeoDigital hosted a competition called LiDAR as Art where users could submit artistic LiDAR renderings, with the author of the best photo winning an iPad. You can see the submissions on their Flickr stream. Additionally, some major music videos have been released recently that relied entirely on LiDAR for their visualizations: Linkin Park's "Waiting For The End" and Radiohead's "House Of Cards." Radiohead also released all of the data used in composing the "House of Cards" video freely on a Google Code page, allowing those interested in the technology to explore the full data set and understand how the video was created.
We on the Opticks team are pretty excited about this technology, and have done some internal prototypes to see how we can integrate LiDAR support into our platform. Much of our work is very early, but we're hoping as time and funding become available we can expand further and eventually have a release with full support for common LiDAR formats, particularly LAS. If you are interested in following the development of our LiDAR support, you can check the open issue on our bug tracker where we will post updates as they occur. We also have some public builds of our prototypes available for download on Hudson.
Blog post edited by Trevor Clarke
The Opticks histogram can be a powerful analysis tool but sometimes you want to access the data outside of Opticks or in a Python script. While you can export an image of the histogram (right-click on the histogram and select Export) you'll need Python (or C++) to work directly with the histogram values. Here's how:
First, you need a RasterLayer. Python currently supports accessing statistics for a layer channel (red, green, blue, or gray) only. This example accesses statistics for the primary raster layer in the active view, so click on the view you want to use. See the API docs for full details.
The histogram_centers member is a list of bin centers and the histogram_counts member contains the number of pixels in each bin. There are also basic statistics in the s object. You can save these to a comma separated value (CSV) file.
If you want to work with (or save) statistics for an arbitrary subset of the data you'll need a different technique. (want to access arbitrary statistics using the previous method? Add an enhancement request)
First you need to access the data for the appropriate RasterElement. Next you need to use Python to calculate the statistics. The follow example will calculate exactly the same statistics as the previous example (assuming the first band was displayed in the gray channel and the data is in BSQ format).
You can calculate statistics for arbitrary subsets of the data as well.
Blog post added by Trevor Clarke
The Opticks histogram can be a powerful analysis tool but sometimes you want to access the data outside of Opticks or in a Python script. While you can export an image of the histogram (right-click on the histogram and select Export) you'll need Python (or C++) to work directly with the histogram values. Here's how:
First, you need a RasterLayer. Python currently supports accessing statistics for a layer channel (red, green, blue, or gray) only. This example accesses statistics for the primary raster layer in the active view, so click on the view you want to use. See the API docs for full details.
The histogram_centers member is a list of bin centers and the histogram_counts member contains the number of pixels in each bin. There are also basic statistics in the s object. You can save these to a comma separated value (CSV) file.
If you want to work with (or save) statistics for an arbitrary subset of the data you'll need a different technique. (want to access arbitrary statistics using the previous method? Add an enhancement request)
First you need to access the data for the appropriate RasterElement. Next you need to use Python to calculate the statistics. The follow example will calculate exactly the same statistics as the previous example (assuming the first band was displayed in the gray channel and the data is in BSQ format).
You can calculate statistics for arbitrary subsets of the data as well.
Blog post added by Trevor Clarke
Opticks does not currently have a video import for avi, mpg, etc. although there is some preliminary work in COAN. If you'd like to import a video for now, you can use ffmpeg to convert the video to raw frames and import those. Here is a brief example.
ffmpeg -i input_file.mpg -f rawvideo -pix_fmt gray output_file.raw
In the output from ffmpeg you'll see some information about the frame size. For example:
The Stream #0.0: Video: mjpeg, yuvj422p, 640x480, 30 tbr, 30 tbn, 30 tbc part is the interesting line and indicates a 640x480 pixel frame size.
You'll also need the total number of frames which is available when the conversion completes in the line which looks like:
frame= 1832 fps= 39 q=0.0 Lsize= 549600kB time=61.07 bitrate=73728.7kbits/s dup=430 drop=0
This example has 1832 frames.
When the conversion is done, load Opticks and go to File->Import Data.... Choose the Generic Importer and select output_file.raw then hit the Options button.
In the File tab put the frame size in the Columns and Rows sections and the total number of frames in the Bands section. Bits Per Element is 8 and Interleav Format is BSQ - single file. You may also want to set the On Disk (Read-Only) Processing Location in the Data tab. Import the file and you'll have a gray scale image. You can create a new animation using View->Create Animation or using the video extension from COAN.
You may want to use File->Export to save the file as a compressed ICE in order to save disk space. Choose Options->Ice Exporter in the export dialog and select GZIP compression.
If you want to convert all the color channels, you'll have to create separate files for each color channel. Instructions are below. When converting with ffmpeg, use a different -pix_fmt to select the appropriate color channel. You can also generate more bits per pixel if you need to extra dynamic range. If you change the bits per pixel, don't forget to adjust the Bits Per Element in the File tab when importing and also the Data Type in the Data tab. You can use -pix_fmt list to get a list of available formats.
| pix_fmt | channel | element size |
|---|---|---|
| gray | all colors converted to an unscaled gray channel | 8bpp |
| gray16le | same as gray but with 2 byte little endian pixels | 16bpp |
| rgb24 | red, green and blue channels which need to be split | 8bpp |
| yuv422 | YUV color space with 1 byte luminance and half byte color channels | 8/4bpp |
To split channels you need to use an external tool. An example python script follows. This is not a very efficient script but demonstrates the technique.
Import each of the three color channel files. Use one as the display layer but set the red, green, and blue color channels to the different raster elements. When animating, this will display as a color image.
Blog post added by Trevor Clarke
When performing terrain analysis and bathymetry, there are a few values which are useful for analysis. I won't go into the details on how to apply these indices, but I will show a couple of ways to calculate them in Opticks. All three of these indices involve a moving window calculation (convolution). These routines all require elevation information in a RasterElement, from a DTED file for example.
The roughness index is calculated by taking the height difference between the pixel at the center of the annulus and all other pixels in the annulus. The largest difference is the roughness index for the center pixel. Below is an example which uses the Python extension with the Scipy Python package. The generic_filter function passes the annulus as a one dimensional array and the extra_arguments parameter is used to pass the index of the center pixel in the annulus.
Similar to the roughness index, the TRI is calculated by taking the height difference between the pixel at the center of the annulus and all other pixels in the annulus. Instead of selecting the largest difference, the mean of the differences is calculated as the TRI. Below is a routine which calculates TRI using Python.
The TPI is similar to the TRI but instead of calculating the average of the height differences, we calculate the difference between the center pixel height and the average of the other pixels in the annulus. The Python code is very to the previous examples and is displayed below.
It's also possible to calculating these indices in real-time on a GPU by using the Cg filter functionality in Opticks. A number of files need to be created and placed in your Opticks install before starting Opticks. The Cg programs for the TRI and TPI are shown below. Instead of using a 9x9 moving window, a smaller 3x3 is used in these examples in order to reduce the number of lines of code. The size can be increased by adding new terms. A smaller window results in a more details, "higher resolution" index map. Roughness is left as an exercise for the reader.
Start Opticks and load a DTED. In the RasterLayer properties, enable GPU filters and select the index program. You will need to manually adjust the stretch since the histogram is calculated for the original data and not the index data. Try a raw stretch of -100 to 100 as a starting point.
Blog post edited by Trevor Clarke
If you would like to build Opticks for Linux (instead of using our pre-built packages) I've placed dependency builds here. You'll need to manually download these and place them in your trunk/Dependencies/packages directory then run dependencies.py.
Blog post added by Trevor Clarke
I've added a new sample Python script which uses OpenCV and Opticks animation callbacks to stabilize a video stream. You can go here to read it.
