Free manipulate software for linux

CAD::Drawing::Manipulate is a Perl module to manipulate CAD::Drawing objects.

Move, Copy, Scale, Mirror, and Rotate methods for single entities and groups of entities.

Group Methods

These methods are called with required values, followed by a hash reference of option values. Note the difference between this and the individual entity manipulation syntax shown below. The absence of an %options hash reference implies everything in the drawing.

For details about each of the group manipulation methods, see the corresponding individual entity manipulation method.

Options

The $opts value shown for each of the group manipulation methods is fed directly to CAD::Drawing::select_addr(). See the documentation for this function for additional details.
One of the most common methods of selection (after the implicit all) may be the explicit list of addresses. This is done by simply passing an array reference rather than a hash reference.

GroupMove

Move selected entities by @dist.

$drw->GroupMove(@dist, $opts);

GroupCopy

Returns a list of addresses for newly created entities.

@new = $drw->GroupCopy(@dist, $opts);

GroupClone

Returns a list of addresses for newly created entities.

@new = $drw->GroupClone($dest, $opts);

place

Clones items from $source into $drw and moves them to @pt. Selects items according to %opts and optionally rotates them by $opts{ang} (given in radians.)

$drw->place($source, @pt, %opts);

GroupMirror

Mirrors the entities specified by %options (see select_addr()) across @axis.

@new = $drw->GroupMirror(@axis, %options);

GroupScale

Sorry, @pt is required here.

$drw->GroupScale($factor, @pt, %opts);

GroupRotate

Rotates specified entities by $angle. A center point may be specified via $opts{pt} = @pt.

$drw->GroupRotate($angle, %opts);

Individual Methods

Move

Moves entity at $addr by @dist (@dist may be three-dimensional.)

$drw->Move($addr, @dist);

Copy

$drw->Copy($addr, @dist);

Clone

Clones the entity at $addr into drawing $dest.

$drw->Clone($addr, $dest, %opts);

%opts may contain:

to_layer => $layer_name, # layer to clone into

Mirror

Mirrors entity specified by $addr across @axis.
Returns the address of the manipulated entity. If $opts{copy} is true, will clone the entity, otherwise modify in-place.

$drw->Mirror($addr, @axis, %opts);

Scale

$drw->Scale($addr, $factor, @pt);

Rotate

Rotates entity specified by $addr by $angle (+ccw radians) about @pt. Angle may be in degrees if $angle =~ s/d$// returns a true value (but I hope the "d" is the only thing on the end, because Im not looking for anything beyond that.) $angle = "45" . "d" will get converted, but $angle = "45" . "bad" will be called 0. Remember, this is Perl:)

$drw->Rotate($addr, $angle, @pt);

Internal Functions

pointrotate

Internal use only.

($x, $y) = pointrotate($x, $y, $ang, $xc, $yc);

pointmirror

@point = pointmirror($axis, $pt);

angle_of

angle_of(@segment);

Polygon Methods

These dont do anything yet and need to be moved to another module anyway.

CutPline

$drw->CutPline();

IntPline

$drw->IntPline();

intersect_pgon

intersect_pgon();

CAD::Drawing::Manipulate::Graphics - Gimp meets CAD.

Methods

All of these are CAD::Drawing methods (I force my own inheritance:)

image_init

Initialize the image at $addr based on the value at the fullpath key. This establishes the contained Image::Magick object and loads the image into memory in the image_handle key.

$drw->image_init($addr);

image_crop

Crops an image and its definition (actually, changes its insert point) according to the points given by @crop_points (which maybe had better be within the object (but I dont really sweat that.))

@crop_points should be in world coordinates as follows:

@crop_points = (
[$lower_left_x , $lower_left_y ],
[$upper_right_x, $upper_right_y],
);
# note that you can get these as
# ($drw->getExtentsRec($something))[0,2]

$drw->image_crop($addr, @crop_points);

image_scale

Scales both the image and the definition by $scale, starting at @base_point.

$drw->image_scale($addr, $scale, @base_point);

image_rotate

This leaves the definition orthoganal, expands the underlying image object, and resets the insert point and size properties accordingly.

$drw->image_rotate($addr, $angle, @point);

The current implementation does not handle the change to the image clipping boundary.

image_swap_context

This involves a scaling of the image (the contexts should be aligned over each other at this point or everything will go to hell.) Do your own move / rotate / crop before calling this, because all this does is to scale the underlying image object such that the vec property of the image definition at $dest_addr can be used correctly.

Note that this does not "swap" the image to $dest_addr, rather it uses the image definition of $dest_addr to change the image object and definition at $source_addr.
Also note that the image must fit completely inside (I think) of the destination in order for the composite to work correctly.

$drw->image_swap_context($source_addr, $dest_addr);

pu6e project is an Ultima 6 world editor.
pu6e is an editor for Ultima 6 and the Worlds of Ultima games (Martian Dreams, Savage Empire). It lets you manipulate many aspects of the game world and play the results with the original games.
Its written in Python and uses wxWindows and OpenGL. pu6e is tested on Linux and Windows 2000, and requires a 3D card.
Main features:
- Create, modify, and delete objects
- Manipulate containers, via a tree view
- Edit terrain and map chunks
- View all map and object tiles
- View tile and palette animation
- View and move NPCs
- View book contents
- Save map, object and NPC data
- Play your new worlds with the Ultima 6 family!

QTParted is a Partition Magic clone written in C++ using the Qt toolkit.
Some note about REISERFS/NTFS/JFS/EXT3 support in QTParted: Even if libparted does not support these filesystems QTParted can handle it. Of course it do it using external tools. This are the latest support status of this filesystems:
- Ntfs - Needed mkntfs and ntfsresize (linux-ntfs)
- ReiserFS - Needed (progsreiserfs) by libparted. Warning: progsreiserfs is not reisergsprogs!
- JFS - Needed mkfs.jfs (jfsutils)
- Ext2/Ext3 - Needed mkfs.ext3 (e2fsprogs)
- XFS - Needed mkfs.xfs (xfsprogs)

libfat is a library that allows you to access and manipulate FAT12 / FAT16 / FAT32 file systems. It includes a FUSE filesystem module to access FAT volumes which uses the library.

To generate the makefile use "autoreconf -i"

At the moment the documentation is the code itself.

For the fuse module, try launch the executable and follow the help.. For the library, try look at the (messy) comments.

Class::Date is a perl module, which provides a simple date type for perl.
You can create new Class::Date objects with a constructor from different scalar formats, array refs, and hash refs, and then you can easily manipulate it by the builtin "+" and "-" operators (e.g., $date=date([2001,03,15])+3Y 1s). Relative date types also available.
Enhancements:
- This release adds "ampm" and "meridiam" methods.

Sprite is a Perl module to manipulate text delimited databases using SQL.

SYNOPSIS

use Sprite;

$rdb = new Sprite;

$rdb->set_delimiter (-Read => ::) ## OR: (Read, ::);
$rdb->set_delimiter (-Write => ::) ## OR: (Write, ::);

$rdb->set_os (Win95);

## Valid arguments (case insensitive) include:
##
## Unix, Win95, Windows95, MSDOS, NT, WinNT, OS2, VMS,
## MacOS or Macintosh. Default determined by $^O.

$rdb->set_lock_file (c:win95tmpSprite.lck, 10);

$rdb->set_db_dir (Mac OS:Perl 5:Data) || die "Cant access dir!n";

$data = $rdb->sql (<<less