Free seismic toolkit software for linux

SILC (Secure Internet Live Conferencing) is a protocol which provides secure conferencing services in the Internet. It can be used to send any kind of messages, in addition to normal text messages This includes multimedia messages like images, video, and audio stream.
All messages in the SILC network are encrypted and authenticated, and messages can also be digitally signed. SILC protocol supports AES, SHA-1, PKCS#1, PKCS#3, X.509, OpenPGP, and is being developed in the IETF. The software is delivered as SILC Client for end users, SILC Server for system administrators, and SILC Toolkit for application developers.
Enhancements:
- This version fixes several crash bugs, packet flag resetting, PFS rekey with CTR encryption mode, and some other bugs.

Mimas Toolkit is a C++ computer vision toolkit. It is easy to use and includes tools for edge detection, corner detection, various filters, optic flow, tracking, blob analysis, Web cam tools for real-time applications, and much more.
Mimas Toolkit project also includes many implementations of traditional algorithms such as Canny. It was developed for GNU/Linux but as the GUI is largely separate, porting to other platforms should be straightforward.
Mimas was originally conceived as a platform for real-time machine vision research. Its aim was and still is to reduce the turnaround time of new research into the application workspace. It is written in C++ and is released in source code form subject to the GNU Lesser General Public License (LGPL).
Mimas has been used to build a number of vision systems including for two European Union sponsored projects, namely MINIMAN (completed in 2002) and MiCRoN (expected to complete in the 3rd quarter of 2005). Mimas is also being used to build a number of customised vision solutions for academia and industry. As such, if you do require a vision-based solution then please contact the authors of this software.
Main features:
- generic image class (greylevel and colour)
- low level image processing
- frequency domain processing
- variety of recognition methods
- variety of tracking methods
- active contours
- comprehensive matrix library
- variety of statistical operations
- associative neural network
- multi-layer perceptrons ANN
- image capture
- various example interfaces
Mimas is designed to be platform independent from the ground-up. Hence a user interface is not built-in. Rather Mimas acts as the engine of a vision system. Since it is written in C++, we recommend that you use the GPL-ed version of the cross-platform Qt toolkit or the Mozilla XP toolkit for building user interfaces.

The CentralNic Toolkit is CentralNics system for instantaneous Registry-Registrar Communications. Registrars can use this system to register and modify domain names in real time, with no delays for human intervention or e-mail processing.
CentralNic Toolkit also provides advanced and efficient methods for searching for and querying domain names and whois records, and retrieving account information.
All the software developed for the Toolkit system is Open Source, and is developed in a participatory manner, relying on cooperation with our user base. Users of the software are encouraged to submit bugs, suggestions, feature requests and patches.
Enhancements:
- This release adds support for the new account management functions that allow automation of payment batches.

HPCToolkit is an open-source suite of multi-platform tools for profile-based performance analysis of applications. The figure provides an overview of the toolkit components and their relationships.
Main features:
- hpcrun: a tool for profiling executions of unmodified application binaries using statistical sampling of hardware performance counters.
- hpcprof & xprof: tools for interpeting sample-based execution profiles and relating them back to program source lines.
- bloop: a tool for analyzing application binaries to recover program structure; namely, to identify where loops are present and what program source lines they contain.
- hpcview: a tool for correlating program structure information, multiple sample-based performance profiles, and program source code to produce a performance database.
- hpcviewer: a java-based GUI for exploring databases consisting of performance information correlated with program source.
A program called hpcview is at the toolkits center. It takes performance profiles, program structure information, and, under the direction of a configuration file, correlates it with application source code to produce a browsable performance database.
hpcview also enables the user to define expressions to compute derived metrics as functions other metrics already defined (e.g. measured metrics read from data files or previously-computed derived metrics).
Performance databases are explored using our Java-based hpcviewer user interface that enables one to explore an applications performance data in a top-down fashion and enables one to easily navigate back and forth between performance data and source code.
The user interface presents performance data in a hierarchical display. At any time, you are looking at some program context (program, file, procedure, loop, or line). Also displayed is the data for both the parent and the children of the current context. Up and down arrows on the lines of the display are used to walk the hierarchy.
In order to speed up top-down analysis, the interface also provides `flatten and `un-flatten buttons. Their icons hint at their function. `Flatten modifies the hierarchy by eliding non-leaf children of the current node and replacing them with the grandchildren.
Unflatten reverses this. Since the tables are sorted, the flatten operation makes short work of diving into the program from the top to identify the most important files, procedures, loops and statements.
Performance data manipulated by hpcview can come from any source, as long as the profile data can be translated or saved directly to a standard, profile-like input format. To date, the principal sources of input data for hpcview have been hardware performance counter profiles.
Such profiles are generated by setting up a hardware counter to monitor events of interest (e.g., primary cache misses), to generate a trap when the counter overflows, and then to histogram the program counter values at which these traps occur. For Linux, we developed the hpcrun tool to collect profiles by sampling hardware performance counters.
This tool uses UTKs PAPI library for access to hardware performance counters. A second tool, hpcprof is used to map profiles collected using hpcrun back to program source lines. hpcprof is based on code from Curt Janssens cprof/vprof profiler. On operating systems other than Linux, we use vendor-supplied tools to collect profile data. On MIPS+Irix platforms, we use SGIs ssrun tool to collect profiles. On Alpha+Tru64, we use either with Compaqs uprofile or DCPI utilities for this purpose.
hpcview and hpcviewer can be used to view profile-like data of any type, not just data sampled from hardware performance counters. To analyze one program that contained many register spills, we built a perl script to examine assembly code generated by the SGI compilers for MIPS+Irix and create profiles that map register spills back to source code lines.
To facilitate automation, the programs in HPCToolkit are intended to be run using scripts and configuration files. Once these are set up, rerunning the program to collect new data, and all of the steps that go into generating a browsable dataset can be completely automated. The scripts automate the collection of data and conversion of profile data into a common, XML-based format.
Other performance tools (e.g. SGIs ssrun) report performance data at the line, procedure, and program level. However, since much of the time in scientific programs is spent in loops; having data at the loop level as well is critical to facilitate performance tuning.
For this reason, HPCToolkit includes a binary analyzer bloop that extracts loop nesting structure from application binaries and uses symbol table line map information to map this structure back to the source programs level. Because bloop works on binaries, this process is independent of the language used (though in practice it can be somewhat compiler dependent).
The loop nesting structure information produced by bloop enables hpcview to associate performance data with each loop in a program without incurring any additional overhead for data collection during program execution.
Supported platforms: Pentium+Linux, Opteron+Linux, Athlon+Linux, Itanium+Linux, Alpha+Tru64 and MIPS+Irix.
HPCToolkit is open-source software released with a BSD-like license.

Wiki::Toolkit is a toolkit for building Wikis.

Helps you develop Wikis quickly by taking care of the boring bits for you. You will still need to write some code - this isnt an instant Wiki.

SYNOPSIS

# Set up a wiki object with an SQLite storage backend, and an
# inverted index/DB_File search backend. This store/search
# combination can be used on systems with no access to an actual
# database server.

my $store = Wiki::Toolkit::Store::SQLite->new(
dbname => "/home/wiki/store.db" );
my $indexdb = Search::InvertedIndex::DB::DB_File_SplitHash->new(
-map_name => "/home/wiki/indexes.db",
-lock_mode => "EX" );
my $search = Wiki::Toolkit::Search::SII->new(
indexdb => $indexdb );

my $wiki = Wiki::Toolkit->new( store => $store,
search => $search );

# Do all the CGI stuff.
my $q = CGI->new;
my $action = $q->param("action");
my $node = $q->param("node");

if ($action eq display) {
my $raw = $wiki->retrieve_node($node);
my $cooked = $wiki->format($raw);
print_page(node => $node,
content => $cooked);
} elsif ($action eq preview) {
my $submitted_content = $q->param("content");
my $preview_html = $wiki->format($submitted_content);
print_editform(node => $node,
content => $submitted_content,
preview => $preview_html);
} elsif ($action eq commit) {
my $submitted_content = $q->param("content");
my $cksum = $q->param("checksum");
my $written = $wiki->write_node($node, $submitted_content, $cksum);
if ($written) {
print_success($node);
} else {
handle_conflict($node, $submitted_content);
}
}

The Visualization ToolKit (VTK) is an open source, freely available software system for 3D computer graphics, image processing, and visualization used by thousands of researchers and developers around the world. Visualization Toolkit consists of a C++ class library, and several interpreted interface layers including Tcl/Tk, Java, and Python.
Professional support and products for VTK are provided by Kitware, Inc. VTK supports a wide variety of visualization algorithms including scalar, vector, tensor, texture, and volumetric methods; and advanced modeling techniques such as implicit modelling, polygon reduction, mesh smoothing, cutting, contouring, and Delaunay triangulation. In addition, dozens of imaging algorithms have been directly integrated to allow the user to mix 2D imaging / 3D graphics algorithms and data.
The design and implementation of the library has been strongly influenced by object-oriented principles. VTK has been installed and tested on nearly every Unix-based platform, PCs (Windows 98/ME/NT/2000/XP), and Mac OSX Jaguar or later.
Many resources exist to help you utilize the full potential of VTK in your application area. These resources include:
Mailing List: Over 1900 users are subscribed to this list. A great place to post questions, and search for answers.
VTK Textbook: The Visualization Toolkit, An Object-Oriented Approach To 3D Graphics, 3rd edition, ISBN 1-930934-12-2, now published by Kitware. This is a great book to read if you want to learn the details of the visualization algorithms and data structures. The book is often used as a college text in visualization and graphics courses.
VTK Users Guide: The Visualization Toolkit Users Guide, ISBN 1-930934-13-0, published by Kitware. This is the book to get if you want to learn how to install and use VTK.
ParaView Guide: The ParaView Guide, ISBN 1-930934-14-9, published by Kitware. ParaView is a turn-key visualization system build on top of VTK, and makes VTK easier to use with an interactive, point and click interface. ParaView also supports supercomputing applications, including tiled display and distributed parallel processing.
CMake: Mastering CMake, ISBN 1-930934-11-4, published by Kitware. CMake is the premier, cross-platform build system used to compile and link VTK. A useful book if you want to use VTK in your projects.
Support: A variety of support options are available ranging from the single point-of-contact Professional Subscription to get you up and running, to custom Site Support to help you develop your next product with VTK.
Enhancements:
- Many bugs were fixed, including fixes for memory leaks, array bounds errors, and stack overflows.

WT Toolkit is a JavaScript toolkit that makes writing rich, robust, reliable AJAX applications as easy as writing desktop applications.
Instead of being yet another hack of making AJAX "barely work", WT Toolkit is designed to be highly object oriented, resistant to memory leaks, and comes with an intuitive event handling system modelled after the signal-slot system from Qt.
Main features:
- GUI Widgets
- Vector Graphics
- AJAX Forms and RPC
- Signal-Slot Event System
- Resistant to Memory Leaks