Free histogram software for linux

Diffstat reads the output of the diff command and displays a histogram of the insertions, deletions, and modifications in each file.
It is commonly used to provide a summary of the changes in large, complex patch files.
Enhancements:
- A bugfix to avoid modifying data that is being used by tsearch() for ordering the binary tree.

Biome is a simulation library aimed at individual-based or agent-based simulations (like Swarm or EcoSim). Biomes features include a fast rng, an event-based scheduling system, Qt classes for graphs and histograms, an analysis framework, a basic persistence framework and many more.
Enhancements:
- An easy-to-use command line parser, a unified parameter class able to read from files or the command line, and a simple SDL canvas class were added.
- Many bugs and compatibility problems were removed.
- Many internal changes were made.

Xholon runtime framework executes applications that are event-driven or that have highly dynamic structure or behavior. Specify your models using XML and Java, or using third-party UML2 tools and MDA transformations.
To get started, read or actively work through the basic HelloWorld tutorial. Its a very simple application, but it demonstrates many of the main concepts.
For more detail on the concepts behind Xholon, you might want to read one of the papers thats been published. These describe how to model cells and other complex biological entities using tools designed for developing real-time and embedded systems.
This earlier work used Rational Rose RealTime and C++, rather than the current Java. Xholon is intended to be a runtime framework that can execute the same types of systems described in those papers, plus many more traditional non-biological event-driven systems.
The goal of the Cellontro sister project is to develop complex biological simulations using the Xholon framework. Most of the features described in the published papers have been re-implemented as Cellontro applications using Xholon.
Also have a look at the sample applications that are included with the Xholon software. These give an idea of the range of applications that can be supported by the Xholon runtime framework.
These have been employed as use cases to determine what functionality is most important in Xholon. The digital watch simulation is a good example of a Xholon application with a hierarchical state machine, developed using a UML modeling tool.
A Xholon is essentially a holon. A holon is an entity that lives within a hierarchical structure, and is both a whole and a part at the same time.
In mainstream computer science terms, a Xholon is a node in a tree. The node has a single parent, possibly one or more children, and possibly one or more siblings. A Xholon may also be an active agent able to interact in real-time with other Xholons in the tree.
In UML2 terminology, a Xholon is a structured classifier that may exist as a part within other structured classifiers, and that may in turn contain other structured classifiers as parts of itself. The result is a hierarchical containment structure, nested to an arbitrary number of levels.
As a part, a Xholon plays a specific role within another structured classifier. Xholons are UML classes that are subsequently refined using UML2 composite structure diagrams. Structured classifiers interact with each other through ports, by passing messages or by making function calls.
Using the more philosophical terminology used to describe holons, a Xholon is something that is simultaneously both a whole and a part. Since everything in the universe is a holon, then everything running within a computer application should be a Xholon. The term holon was invented by Arthur Koestler in 1967.
The Xholon Project is inspired by biological concepts. A major incentive behind the project is to build a run-time environment that is equally adapted to running simulations of biological systems, and to running more traditional real-time, embedded and other event-driven reactive systems.
Xholon applications may contain structures that are highly mutable. A Xholon is an active agent that can modify the tree structure in which it lives. It can navigate the tree to interact with any other node, it can add, delete or modify other nodes, it can exchange messages with other nodes, and it can move itself to another position within the tree.
The Xholon Project incorporates many concepts of the Real-time Object-Oriented Modeling (ROOM) methodology, much of which has been incorporated into UML2. At the same time, Xholon removes some of the limitations of ROOM to allow for greater flexibility, mutability and mobility of active objects.
The Xholon run-time can serve as a target for a Model Driven Architecture (MDA) transformation pipeline. MDA stresses the importance of models, and the ability to transform those models, through a series of steps, into an executing target system.
You can create your model using a UML tool such as Gentlewares Poseidon or NoMagics MagicDraw, save the model as an XMI file, transform it using XSLT (or by some other MDA means) into a Xholon model and application, and then execute the model.
Enhancements:
- UML state machine simulation capabilities have been extended, including animation, and fork, join, junction.
- Additional Agent-Based Modeling functionality is available.
- The NetLogo-like syntax has been enhanced.
- The architecture is more flexible and is ready to more fully support integration of multiple domains.
- Histograms and probability distributions are now available. Line charts update in real-time.
- Numerous other modeling, simulation, transformation, and execution features have been added.

graph-tool project is a program to help with statistical analysis of graphs.
Main features:
- support for directed and undirected graphs
- support for arbitrary vertex or edge properties
- generic filtering of edges and vertices
- several statistical measurements:
- degree (or scalar property) histogram
- vertex-vertex degree (or scalar property) correlation
- average nearest neighbours degree (or scalar property)
- vertex-edge-vertex correlation
- clustering coefficients
- assortativity coefficient
- average distance
- component statistics
- generation of random graphs with arbitrary degree distribution and degree correlation
- graph history measurement based on filtering
- support for graphml and dot file formats
The core algorithms are written in C++, making use of the Boost Graph Library, and template metaprogramming techniques, with performace in mind. The command line interface and other outlying code are written in python.

Suri Pluma is a satellite image processing tool and visualizer.
Suri Pluma project can open the most common image formats without importing to an internal format and minimizing the memory required for visualization.
It is designed to be modular and extensible. It has a meassurement tool (distance and areas with error estimation) and geographical and map coordinate information.
Designed with state of the art techniques and tools, it offers means to extract information in easy and intuitive ways, offering to the user quantitative and qualitative information immediatly, taking full profit of the different satellite sources.
It provides simplified access to the different data formats and exports to the most common and spreaded formats. It takes full advantage of the hardware resources, with very low minimal requirements.
The goal is to provide the user with a high quality software, bringing a simple tool for image processing and remote sensing.
Main features:
User Interface
- Windows based single-document user interface (SDI) for more flexibility.
- Intuitive graphic user interface, making the tasks simple for both beginner and advanced users.
Input file formats
- Automatic opening of Fast Format images (including SAC-C and Landsat), Tiff and GeoTiff distribuited by CONAE, as well as the different formats used by GLCF and other propietary formats as the ENVI format. Also supports standard graphic formats like Jpg, Png and Bmp.
- Image type auto detect. There is no need to import for visualization the data with known formats.
- Direct access to the different data types without conversion.
- Immediate opening images independently from their size.
- Opening many images at once without memory overflow.
- Supports generic RAW binary format with manual definition of parameters.
Image analysis:
- Area and distances measurement tools available.
- Planar coordinate and pixel value displaying in real-time.
Image visualization:
- RGB color composite viewing capabilites.
- Grayscale viewing capabilites.
- Zoom In/Out capabilites using the wheel on the mouse.
- Flexible navigation using Scroll/Zoom windows.
Image enhancement:
- Linear and nonlinear contrast enhancement.
- Histogram equalization.
Geographic location:
- Automatic recognition of georeferenced meta-data of the different formats, making possible the search of areas of interest by geographic coordinates.
Export images:
- Exports to different image formats, making Suri compatible with other analysis tools. Available on Suri Pluma V1.1.
Minimal requirements:
- Takes advantage of the hardware resources, making possible the visualization and analysis of big images in low-end hardware with great efficiency.
Available platforms:
- Suri is developed in C++ in Linux and Windows environments simultaneously and distribuited in both systems.

DigikamImagePlugins are a collection of plugins for digiKam 0.7.3 Image Editor and ShowFoto 0.2.0 (digiKam stand alone image editor implementation).
DigikamImagePlugins add new image treatment options like color management, filters or special effects.
Main features:
Image improvements:
- icon Adjust levels : a tool to adjust the photograph histogram levels manually.
- icon Adjust curves : a tool to adjust the photograph colors using curves.
- icon Noise Reduction : a photograph noise reduction filter.
- icon Unsharp : a photograph unsharp mask filter to unblur picture without increase noise.
- icon Lens Distortion : a tool for correct lens spherical aberration on photograph.
- icon Anti Vignetting : a tool for correct vignetting on photograph.
- icon Channel Mixer : a tool to mix the photograph color channels (CVS only).
- icon White Balance : a tool to adjust white color temperature balance of photograph (CVS only).
- icon Photograph Restoration : a tool to reduce photograph artefacts using CImg library (CVS only).
- icon Photograph Inpainting : a tool to remove unwanted photograph area using CImg library (CVS only).
Transformation tools:
- icon Free Rotation : a plugin to rotate a photograph with a free angle in degrees.
- icon Shear Tool : a plugin to shear a photograph horizontally and vertically.
- icon Perpective Tool : a plugin to adjust the photograph perpective.
- icon Blowup Photograph : a plugin to blowup a photograph without less image quality using CImg library (CVS only).
Image tools:
- icon Template Superimpose : a tool for superimpose a template on photograph.
- icon Add Border : a tool for add border around a photograph.
- icon Insert Text : a tool for insert text under a photograph (CVS only).
- icon Apply Texture : a tool to apply a decorative texture to a photograph (CVS only).
Special effects:
- icon Solarize : a plugin to solarize a photograph.
- icon Oil Paint : simulate oil painting on photograph (using Pieter Voloshyn algorithm).
- icon Emboss : an effect filter to emboss photograph (using Pieter Voloshyn algorithm).
- icon Rain Drops : adding the visual effect of raindrops on photograph (using Pieter Voloshyn algorithm).
- icon Charcoal : simulate charcoal drawing on photograph.
- icon FilmGrain : simulate film grain on photograph.
- icon Infrared : simulate infrared film effect on photograph (CVS only).
- icon Blur FX : apply bluring special effects on photograph (using Pieter Voloshyn algorithms - CVS only).
- icon Distortion FX : apply distortion special effects on photograph (using Pieter Voloshyn algorithms - CVS only).
Installation:
export WANT_AUTOCONF_2_5=1
export KDEDIR=KDE_installation_dir_on_your_system
make -f Makefile.cvs
./configure --enable-debug=full
make
su
make install

PAPI aims to provide the tool designer and application engineer with a consistent interface and methodology for use of the performance counter hardware found in most major microprocessors.
PAPI enables software engineers to see, in near real time, the relation between software performance and processor events.
The Performance API (PAPI) project specifies a standard application programming interface (API) for accessing hardware performance counters available on most modern microprocessors.
These counters exist as a small set of registers that count Events, occurrences of specific signals related to the processors function. Monitoring these events facilitates correlation between the structure of source/object code and the efficiency of the mapping of that code to the underlying architecture.
This correlation has a variety of uses in performance analysis including hand tuning, compiler optimization, debugging, benchmarking, monitoring and performance modeling. In addition, it is hoped that this information will prove useful in the development of new compilation technology as well as in steering architectural development towards alleviating commonly occurring bottlenecks in high performance computing.
PAPI provides two interfaces to the underlying counter hardware; a simple, high level interface for the acquisition of simple measurements and a fully programmable, low level interface directed towards users with more sophisticated needs.
The low level PAPI interface deals with hardware events in groups called EventSets. EventSets reflect how the counters are most frequently used, such as taking simultaneous measurements of different hardware events and relating them to one another.
For example, relating cycles to memory references or flops to level 1 cache misses can indicate poor locality and memory management. In addition, EventSets allow a highly efficient implementation which translates to more detailed and accurate measurements.
EventSets are fully programmable and have features such as guaranteed thread safety, writing of counter values, multiplexing and notification on threshold crossing, as well as processor specific features. The high level interface simply provides the ability to start, stop and read specific events, one at a time.
PAPI provides portability across different platforms. It uses the same routines with similar argument lists to control and access the counters for every architecture. As part of PAPI, we have predefined a set of events that we feel represents the lowest common denominator of every good counter implementation.
Our intent is that the same source code will count similar and possibly comparable events when run on different platforms. If the programmer chooses to use this set of standardized events, then the source code need not be changed and only a fresh compilation and link is necessary. However, should the developer wish to access machine specific events, the low level API provides access to all available events and counting modes.
If an event or feature does not exist on the current platform, PAPI returns an appropriate error code. This significantly reduces the porting effort of code using PAPI because the semantics of each call to PAPI remains the same, just the argument lists need updating. In addition to the standard set, each PAPI implementation supports all native events through the ability to directly accept platform specific counter numbers. Definitions for most, if not all of these, are included as conditional macros in the header file. In this way, PAPI avoids having inefficient code to translate all events for all platforms into a uniform representation and back again.
This translation is only done for the relatively few events defined in the standardized set. Some processors like those in the POWER series have counter groups. They enable access to specific groups of counters, instead of individual events. This presents a serious portability problem, thus PAPI abstracts hardware counters from their groups with a packed naming scheme. Each counter control value or event is made up of the counter group number and the number of the specific counter in that group.
PAPI can be divided into two layers of software. The upper layer consists of the API and machine independent support functions. The lower layer defines and exports a machine independent interface to machine dependent functions and data structures. These functions access the substrate, which may consist of the operating system, a kernel extension or assembly functions to directly access the processors registers.
PAPI tries to use the most efficient and flexible of the three, depending on what is available. Naturally, the functionality of the upper layers heavily depends on that provided by the substrate. In cases where the substrates do not provide highly desirable features, PAPI attempts to emulate them as described below.
PAPI makes sure the underlying operating system or library guards against overflow of counter values.
Each counter can potentially be incremented multiple times in a single clock cycle. This combined with increasing clock speeds and the small precision of some of the physical counters means that overflow is likely to occur.
One of the more advanced features of PAPI is to provide a portable implementation of asynchronous notification when counters exceed a user specified value.
This functionality provides the basis for PAPIs SVR4 compatible profiling calls, that generate an accurate histogram of performance interrupts based on hardware metrics, not on time. Such functionality provides the basis for all line level performance analysis software, from the antiquated days of AT&Ts prof to SGIs SpeedShop. Thus for any architecture with even the most rudimentary access to hardware performance counters, PAPI provides the foundation for a truly portable, source level, performance analysis tool based on real processor statistics.
Enhancements:
- The API was extended to decouple abstraction layers from hardware support and to provide initial support for different types of performance counters.

Kst is a real-time data viewing and plotting tool with basic data analysis functionality. Kst project contains many powerful built-in features and is expandable with plugins and extensions. Kst is a KDE application.
Main features:
- Real-time display and manipulation of streaming data
- Quick zooming and scrolling via mouse and keyboard
- Extensible via plugins
- Built-in high-speed equation interpreter
- Multiple tabs or windows
- Graphical plot layout manager
- Drag and drop
- Cut and paste
- Native power spectrum algorithm and histograms
- Support for the most popular data formats including:
- ASCII, dirfile, CDF, netCDF, piolib, FITS
- Plugin design allows additional formats
- Time input
- Built-in ELOG functionality
- Command-line and RPC control mechanisms
- Printing, including to images, postscript, and PDF
Enhancements:
- Numerous deadlock and crash fixes.