Free drawing program software for linux

File::Drawing release, revise and retrieve contents to/from a drawing program module.

SYNOPSIS

##########
# Subroutine interface
#
use File::Drawing qw(
dod_date dod_drawing_number number2pm pm2number obsolete
broken backup);

$date = dod_date($sec, $min, $hour, $day, $month, $year);
$drawing_number = dod_drawing_number( );

$pm = number2pm($drawing_number, $repository);
$drawing_number = pm2number($drawing_number, $repository);

$old_value = config( $option );
$old_value = config( $option => $new_value);
(@all_options) = config( );

obsolete($drawing_number, $repository);
broken($drawing_number, $repository);
($file, $backup_file) = backup($drawing_number, $repository, $dir);

######
# Class Interface
#
use File::Drawing;

$default_options = defaults(@options);

$old_value = $default_options->config( $option );
$old_value = $default_options->config( $option => $new_value);
(@all_options) = $default_options->config( );

$drawing = new File::Drawing($contents, $white_tape, $pod, $file_contents, $drawing_number, $repository);

$drawing = File::Drawing->retrieve($drawing_number, @options);

$error = $drawing->release(@options);

$error = $drawing->revise(@options);

$date = $drawing->dod_date($sec, $min, $hour, $day, $month, $year);
$drawing_number = $$drawing->dod_drawing_number( );

$pm = $drawing->number2pm($drawing_number, $repository);
$drawing_number = $drawing->pm2number($drawing_number, $repository);

$drawing->obsolete($drawing_number, $repository);
$drawing->broken($drawing_number, $repository);
($file, $backup_file) = $drawing->backup($drawing_number, $repository, $dir);

Generally, if a subroutine will process a list of options, @options, that subroutine will also process an array reference, @options, [@options], or hash reference, %options, {@options}. If a subroutine will process an array reference, @options, [@options], that subroutine will also process a hash reference, %options, {@options}. See the description for a subroutine for details and exceptions.

The File::Drawing program module uses American National Standards for drawings as a model for storing data. Commercial, governement and casual orgainizations have stored information over the centuries as drawings. Drawings probably evolved from the census that the Romans rulers, started back when Rome was a little frontier town. In other words, the practices of the drafting displines have evolved over time and have stood the test of time.

Any deviation must be a crystal clear advantage. Many of the practices are in place to avoid common and costly human mistakes that obviously a computerize drafting system will not make. A good approach is to make the computerized data structure optimum for computers and have the computer render the computerized data into a form that meets the drafting standards.

The File::Drawing program module, uses the Perl program module name as a drawing repository, drawing number combination. The contents of the drawing is contained in the program module file. The < File::Drawing > program module established methods to retrieve contents from a program module drawing file, create an Perl drawing object with the contents, and methods to release and revise the contents in a program module drawing file from a Perl drawing object. Other popular methods for computerize date are the SQL and XML. Perl has a wide range of program modules using these approach.

In this time in history, the Drawings are highly standardize and even subject to Internationl standarization agreements. The Drawing Sheet Size and Format conform to ANSI Y14.1-1975 or its successor. The drawing has a box with zone numbers running right to left alon the top and bottom, and zone letters running bottom to top along the sides. There is a section inside the box, lower right corner with the blocks for such things as the title, drawing number, current revision, authoriztion, and sheet number. There is an expandable four column table in the top right corner to record the revision history.

CAD::Drawing::IO::PgDB is a Perl module with PostgreSQL save / load methods.

This module is considered pre-ALPHA and under-documented. Its use is strongly discouraged except under experimental conditions. Particularly susceptible to change will be the table structure of the database, which currently does not yet even have any auto-create method.

Requisite Plug-in Functions

See CAD::Drawing::IO for a description of the plug-in architecture.

check_type

Returns true if $type is "circ" or $filename is a directory containing a ".circ" file.

$fact = check_type($filename, $type);

Back-End Input and output methods

The functions load() and save() are responsible for determining the filetype (with forced types available via $opt->{type}.) These then call the appropriate load< thing > or save< thing > functions.

load

Loads a CAD::Drawing object from an SQL database. $spec should be of the form required by the database driver.
$opts->{auth} = ["username", "password"] may be required to create a connection.

$drw->load($spec, $opts);

save

$drw->save($spec, $opts);

cleardb

Deletes the drawing and all of its entities from the database.

$drw->cleardb();

Internals

parse_options

Allows options to come in through the $spec or %opts.

%options = parse_options($spec, %opts);

sort_addr

Sorts through @addr_list and returns a hash of array references for each entity type.

%these = sort_addr($layer, @addr_list);

xdraw is a small application that is used to draw onto an X display.

It is useful to specify certain regions of interest to people watching the screen.

The procedure currently works for single entire screens with their contents on hold.

The display is frozen as long as the drawing is taking place, and continues when the drawing is finished.

INSTALL

$ ./configure
$ make
$ su -c "make install"

- Altering the Prefix:
$ ./configure --prefix=/usr

- Other Options:
$ ./configure --help

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);

ZDraw is a fairly basic drawing applet used to demonstrate the concept of persistence in a drawing applet. What do I mean by persistence? Well, take most of the "demo" drawing applets available on the net. If you put the applet into the background, resize it, or partially/fully cover it with another window, then the "hidden" portion of the applet loses any drawings that were made.

A simple (and rudimentary) solution to this can be easily implemented using a Vector and creating a new object class LineObject within which we can store the start and end points of each line, together with its colour. Then, when we can override public void paint( Graphics g ) and insert some code that iterates through each element of the vector, repainting each line segment. This way, everytime the applet redraws itself, all of the lines will be repainted, and thus will not be lost!

CAD::Drawing::IO::Compressed is a Perl module to load and save compressed data.

Requisite Plug-in Functions

See CAD::Drawing::IO for a description of the plug-in architecture.

check_type

Returns true if $type is "compressed" or $filename has a ".gz" extension (probably the best way.)

$fact = check_type($filename, $type);

Compressed I/O functions

These use File::Temp and compression modules to create a compressed version of most supported I/O types (FIXME: need a tar scheme for directory-based formats (currently unsupported))

save

$drw->save($filename, %opts);

load

$drw->load($filename, %opts);

CAD::Drawing::IO::Split is a Perl module that allows fast distributed text file methods.

Requisite Plug-in Functions

See CAD::Drawing::IO for a description of the plug-in architecture.

check_type

Returns true if $type is "split" or $filename is a directory (need a tag?)

$fact = check_type($filename, $type);

Load/Save Methods

Concept here is to strip data down to the absolute bare minumum in an effort to find a generic and extensible incarnation of same.

save

Saves data into $toplevel_directory under a directory for each layer, each type, and a file for each id.

save($drw, $toplevel_directory, %options);

Requires that the directory already exists.

Selective saves not yet supported.

Unfortunately, the file-formats are rather primitive and the code needs refactoring. These are nowhere near stable, so dont expect version compatibility yet!

Needs a clear_all_like => $regex option.

load

load($drw, $toplevel_directory, %options);
%options may include selective-load arguments

Naming Functions

_dir_list
@list = _dir_list($dir);
_sp_filename

Creates nested directories which are required to save %obj and returns the filename which should be saved into.

_sp_filename(%obj, %data);

Inherited Methods

clear_dir

Removes layers (and items) from the split directory $dir.
Defaults to removing all.

$drw->clear_dir($dir, %options);

Available options:

like => qr/regex/, # if regex matches layer name
not_like => qr/regex/, # negative of above (compounded)

check_select() options:

%options is passed through CAD::Drawing::Defined::check_select(), so the selections returned by it will be utilized here.

select_layers => @layer_list,
select_types => @types_list,

Returns the number of items removed or undef() if $dir does not exist.