Free segment software for linux

Geo::Google::Segment is an annotated segment of a path.

SYNOPSIS

use Geo::Google::Segment;
# you shouldnt need to construct these yourself,
# have a Geo::Google object do it for you.

Google Maps is able to serve up directions between two points. Directions consist of two types of components:

1. a series of points along a "polyline".
2. a series of annotations, each of which applies to a contiguous
range of points.

In the Geo::Google object model, directions are available by calling path() on a Geo::Google instance. The return value is a Geo::Google::Path object, which is a composite of Geo::Google::Segment objects, which are in turn composites of Geo::Google::Location objects.

SGet is a GTK+ application to download files over the Internet by segments, which makes the download process more efficient in most cases.

On this project, the final objective is to write a program to download files over the net by segments, wich offers a improved speed for downloads.

The ELF-Encrypter program suite is a collection of programs to encrypt ELF binaries using various algorithms, including the ones provided by GPG.
One can choose a lot of methods to obtain the encryption key, such as hashing a list of PCI peripheals, MAC addresses of ethernet cards, file inode numbers, passphrases and passwords.
Here is the complete list:
8-bit fixed mask (used only for testing)
32-bit user selectable mask (used only for testing)
Password
Cast5 (using GPG)
GPG - Encrypt (using GPG)
GPG - Sign (using GPG)
Ethernet MAC
Ethernet MAC and file inode
File inode
PCI binding
Executable files can be encrypted using the crypt-7lib program, then decrypted at runtime by a shared library (libdecrypt), directly linked to the binary or listed in LD_PRELOAD.
Users are strongly encouraged to use gpg-agent; however a special support for quintuple-agent is available at compilation time.
The suite also contains programs to manipulate and inject plain or encrypted code into ELF binaries.
This project is written in C and assembly for the x86 platform.
Enhancements:
- changed the data segment infection technique
- added the code to correct section table offsets

Filelight allows you to understand exactly where your diskspace is being used by graphically representating your filesystem as a set of concentric segmented-rings.

Filelight creates a complex, but data-rich graphical representation of the files and directories on your computer. An example of Filelights representation of KDEs disk usage is shown below. It is important to understand that the full circle represents 143MB, and there are 143MB of files contained recursively in the directory.

Segments are sized relative to the files they represent. Directories have child-segments that represent the files in that directory. Hovering over any segment gives you details about the file it represents, such as its size.

The net-result is something similar to KDirStat, however the data is more dense, and the representation more informative. Most people tend to use Filelight to find out where their diskspace is concentrated, and this is what it is mostly designed to do.

Filelight is released under the GNU General Public License.

Filelight creates an interactive map of concentric segmented-rings that helps visualize disk usage on your computer.

It is like a pie-chart, but the segments nest, allowing you to see not only which directories take up all your space, but which directories and files inside those directories are the real culprits.

Remote Filesystems

If you want to have a filelight-style map prerendered at set times during the week, and then controlled in a web browser, take a look at Philesight, an excellent utilty that is also open source.

You can also browser remote servers using the fish:// or ftp:// KIO slave inside FIlelight, but for a system administrator I think philesight is more useful, check it out.

Installing From Source

You should be able to just copy and paste the following into a terminal:

cd ~
wget http://methylblue.com/filelight/packages/filelight-1.0.tar.bz2
tar xjf filelight-1.0.tar.bz2
cd filelight-1.0
./configure --disable-debug && make
su -c make install

omega t+ is a computer assisted translation (CAT) tool suite.

omega t+ currently includes omegat, a translation editor tool with numerous features, extspell, an Apsell spell checker user interface, sentseg, for sentence segmenting of documents, and OmegaT packages, from which omegat is derived.

X12::Parser::Readme is a Perl module for understanding configuration (cf) files for X12::Parser.

X12 transactions
ASC X12 standards define commonly used EDI transactions. The standards define a structure/format for exchange of EDI data.

Each transaction type is called a "transaction set". The smallest data item in a transaction is called an "element". Groups of related elements form a data segment. A data element separator separates the elements within a segment. A segment starts with a element which is called the segment ID, and ends with a segment terminator.

Logical groups of segments are called loops. There are some segments, which are used only to identify the beginning of a loop, these are called as control segments. A logical set of loops together form a "transaction set".

Similar transaction sets can be lumped together by enclosing them in data segments that are known as functional group headers and trailers. Functional groups are grouped together using interchange control headers and trailers.

Parsing
Unlike XML/HTML parsers which relies on "" tags to determine start and end of data blocks, X12 transactions rely on pre-defined values (segment IDs) to indicate start and end of related data blocks (loops). Developing a parser that would work for all X12 transactions poses a challenge in this respect, as each transaction has its own hierarchy of loops and start/end indicators.

This lead to the development of the X12 configuration file (cf) specification. The cf specification is created to specify details regarding the blocks/loops and start/end information in a common format. Cf files can be created for the different transaction sets. (see section Building a cf file).
Now you can parse your EDI data file by invoking the X12::Parser specifying the cf file to use. This allows you to parse any X12 transaction data files just by building the cf file for that transaction type.

Cf file specification for X12::Parser
The cf file specifies any transaction in a hierarchical form. It identifies the loops and segments in a transaction. This information is used to parse the transaction file. The X12::Parser uses the X12::Parser::Cf module to read the cf file information before parsing a transaction file. Since the X12::Parser parses files based on the cf file it allows the user to parse different X12 transaction types just by using the appropriate cf file. The user can use the cf files that are bundled with this package or create new cf files. The cf provided with this package is for the HIPAA X12 Ver 4010 X12 transactions.

A cf file has two types of information: section and key=value pairs. A section contains information in key=value pairs.

Image::MetaData::JPEG is a Perl extension for showing/modifying JPEG (meta)data.

SYNOPSIS

use Image::MetaData::JPEG;

# Create a new JPEG file structure object
my $image = new Image::MetaData::JPEG(somepicture.jpg);
die Error: . Image::MetaData::JPEG::Error() unless $image;

# Get a list of references to comment segments
my @segments = $image->get_segments(COM, INDEXES);

# Get the JPEG picture dimensions
my ($dim_x, $dim_y) = $image->get_dimensions();

# Show all JPEG segments and their content
print $image->get_description();

# Retrieve a specific value from Exif meta-data
my $image_data = $image->get_Exif_data(IMAGE_DATA, TEXTUAL);
print $image_data->{DateTimeOriginal}->[0], "n";

# Modify the DateTime tag for the main image
$image->set_Exif_data({DateTime => 1994:07:23 12:14:51},
IMAGE_DATA, ADD);

# Delete all meta-data segments (please, dont)
$image->drop_segments(METADATA);

# Rewrite file to disk after your modifications
$image->save(new_file_name.jpg);

# ... and a lot more methods for viewing/modifying meta-data, which
# are accessed through the $file or $segments[$index] references.

The purpose of this module is to read/modify/rewrite meta-data segments in JPEG (Joint Photographic Experts Group format) files, which can contain comments, thumbnails, Exif information (photographic parameters), IPTC information (editorial parameters) and similar data.

Each JPEG file is made of consecutive segments (tagged data blocks), and the actual row picture data. Most of these segments specify parameters for decoding the picture data into a bitmap; some of them, namely the COMment and APPlication segments, contain instead meta-data, i.e., information about how the photo was shot (usually added by a digital camera) and additional notes from the photograph. These additional pieces of information are especially valuable for picture databases, since the meta-data can be saved together with the picture without resorting to additional database structures. See the appendix about the structure of JPEG files for technical details.

This module works by breaking a JPEG file into individual segments. Each file is associated to an Image::MetaData::JPEG structure object, which contains one Image::MetaData::JPEG::Segment object for each segment. Segments with a known format are then parsed, and their content can be accessed in a structured way for display. Some of them can even be modified and then rewritten to disk.

$JPEG::show_warnings

This package variable must be used to inhibit the printing of warnings: if it is false, warnings are silently ignored. Otherwise, warning messages come with a detailed back-trace and description of the warning location.

$Image::MetaData::JPEG::show_warnings = undef;