Free cad software for linux

LeoCAD is a CAD program that uses bricks similar to those found in many toys (but they dont represent any particular brand). Currently it has a library of more than 1000 different pieces, most of them were created by James Jessiman (the author of LDraw).

Intallation:

The first thing you should do is check that you have an OpenGL library installed in your computer by typing /sbin/ldconfig -p |grep libGL, you should see libGL.so listed in the output. If you cant find it, then you should download and compile Mesa 3D. Dont forget to add the Mesa installation path to /etc/ld.so.conf or LD_LIBRARY_PATH and run /sbin/ldconfig.

The next step is to download the executable and the pieces library. After the download is complete you have to extract the pieces library to any directory of your choice but if you choose a place other than "/usr/local/share/leocad/", youll have to set the variable LEOCAD_LIB to that directory.

Now you should extract the LeoCAD precompiled binaries, to any directory and run "leocad".

If you prefer to compile the program yourself, you can use the cvs server :pserver:guest@gerf.org:/usr/cvsroot (password is guest) to checkout the module leocad. I recommend using the tag for the last released version, for version 0.73 its leocad-0-73. You can do this by typing:

$ cvs -z3 -d :pserver:guest@gerf.org:/usr/cvsroot login

Enter "guest" without the quotes when asked for a password to login. Now to download the latest released version, type:

$ cvs -z3 -d :pserver:guest@gerf.org:/usr/cvsroot checkout -r leocad-0-73 leocad

Or if you want the latest development version:

$ cvs -z3 -d :pserver:guest@gerf.org:/usr/cvsroot checkout leocad

Keyframing

Each object in a LeoCAD project can have a different position and orientation for each step or frame that it appears. This feature is called keyframing, and works differently if the program is in Instruction or Animation mode.

This is very useful when creating instructions because it allows you to have a door open in one step and closed later, or have the camera display the model from a different angle on a certain step to show details from another section of the model.

If youre in animation mode, LeoCAD automatically interpolates the value of the previous key with the value of the next key to calculate the position of the object at each frame. This makes the creation of animations a very simple thing because you only need to set the start and end positions and LeoCAD will take care of the other frames.

When the Key Button () from the Animation Toolbar is depressed, a new key is added at the current step/frame each time you move or rotate an object, if a key doesnt already exist. When the icon is not pressed, the changes are made to the key immediately before the current step/frame.

Instructions and Animations

LeoCAD can be used to create building instructions and animations, making it a very powerful editor. When you start the program youre placed in Instruction mode by default, you can switch between Animation and Instruction mode using the Mode Button () from the Animation Toolbar.

Each program mode stores the position and orientation of all objects in separate places, so changing the position of an object on one mode does not change it on the other mode. To easily copy the position from the other mode, choose Copy Keys From ... from the Pieces Menu.

When youre in Instruction Mode, each time unit is called a Step and when youre in Animation Mode, each time unit is called a Frame. The most important difference between the 2 modes is how Keyframing works.

BRL-CAD project is a powerful Constructive Solid Geometry (CSG) solid modeling system. BRL-CAD includes an interactive geometry editor, ray tracing support for rendering and geometric analysis, network distributed framebuffer support, image-processing and signal-processing tools. The entire package is distributed in source code form.
Since the late 1950s, computers have been used to assist with the design and study of combat vehicle systems. The result has been a reduction in the amount of time and money required to take a system from the drawing board to full-scale production as well as increased efficiency in testing and evaluation.
In 1979, the U.S. Army Ballistic Research Laboratory (BRL) (now the U.S. Army Research Laboratory [ARL]) expressed a need for tools that could assist with the computer simulation and engineering analysis of combat vehicle systems and environments. When no existing computer-aided design (CAD) package was found to be adequate for this purpose, BRL software developers began assembling a suite of utilities capable of interactively displaying, editing, and interrogating geometric models. This suite became known as BRL-CAD.
Now comprising over one-half million lines of C code, BRL-CAD has become a powerful constructive solid geometry (CSG) modeling package that has been licensed at over 2,000 sites throughout the world. It contains a large collection of tools, utilities, and libraries including an interactive geometry editor, raytracing and generic framebuffer libraries, a network-distributed image-processing and signal-processing capability, and a customizable embedded scripting language. In addition, BRL-CAD simultaneously supports dual interaction methods, one using a command line and one using a graphical user interface (GUI).
A particular strength of the package lies in its ability to build and analyze realistic models of complex objects using a relatively small set of "primitive shapes." To do this, the shapes are manipulated by employing the basic Boolean operations of union, subtraction, and intersection. Another strength of the package is the speed of its raytracer, which is one of the fastest in existence. Finally, BRL-CAD users can accurately model objects on scales ranging from the subatomic through the galactic and get "all the details, all the time."
The application side of BRL-CAD also offers a number of tools and utilities. They primarily concern (1) geometric conversion, (2) geometric interrogation, (3) image format conversion, and (4) command-line-oriented image manipulation. The following is a list of the major BRL-CAD tools and utilities.
- MGED (Multiple-Device Geometry Editor) ? BRL-CADs graphics editor. (For detailed guidance on the use of MGED as well as a list of all the MGED commands currently available, see Butler et al. [2001].)
- Tools for raytracing and interrogating raytraced geometric objects.
- rt ? the main raytracer for rendering images in BRL-CAD.
- nirt ? a package for firing rays interactively and getting information about what the rays run into.
- remrt ? a network-distributed raytracing package.
- An assortment of geometric converters to convert to and/or from other geometry formats, including Euclid, ACAD, AutoCAD DXF, TANKILL, Wavefront OBJ, Pro/ENGINEER, JACK (the human factors model for doing workload/usability studies), Viewpoint Data Lab, NASTRAN, Digital Equipments Object File Format (OFF), Virtual Reality Mark-up Language (VRML), Stereo Lithography (STL), Cyberware Digitizer data, and FASTGEN4.
- bwish ? a Tcl/Tk interpreter in a windowing shell with enhancements compiled into it for accessing BRL-CAD libraries. It also includes various other extensions to the Tcl language.
- irprep ? produces input to the PRISM (Physically Realistic Infrared Simulation Model) code.
- JOVE (Jonathans Own Version of Emacs) ? a fast, light implementation of Emacs.
- Applications for displaying images of various types on the framebuffer application and retrieving data from that framebuffer into images of various types.
- Tools for generating geometry for common objects such as fences, walls, and geometric mathematical oddities (e.g., the sphereflake shown in Figure 2 in Section 4).
- Data manipulation programs to (1) convert integers to floats, floats to doubles, etc. (e.g., cv); (2) perform mathematical operations on file elements (e.g., imod, umod, and dmod); (3) compute statistics of file elements (e.g., istat, ustat, and dstat); etc.
- Utilities for building animation scripts ? keeping track of columnar data and interpolating it to allow one to produce input to the rt program to render multiple items for animation.
- Utah Raster Tool Kit ? image manipulation of all RLE-based images.
- Programs for manipulating images and converting between different image file types. The two primary BRL-CAD types are pix (24-bit red, green, and blue [RGB] color images) and bw (8-bit greyscale images). Converters exist for various image formats including alias, png, ppm, etc.
- Programs for filtering images, doing histograms on the image data, and extracting rectangles from the images.
- Tools for combining two images and blending them together. (These tools were created before good image editing tools for video production were available; today users would typically load the images directly into a video editing package.)
Enhancements:
- fixed -i argument bug in g-acad, g-dxf, g-nff, g-obj - Shawn Baker
- framebuffer toggle added to raytrace panel in mged - Sean Morrison
- fixed rtedge multithreaded output render bug - Erik Greenwald
- fixed jove/termcap issues on Mac OS X - Sean Morrison
- updated bundled libtermcap to NetBSD version 0.6 - Sean Morrison
- increased output precision on mged analyze command - Sean Morrison
- prevent mged shutdown on DSP objects with no data - Sean Morrison
- integration into the Arch Linux packaging system - Loui Chang
- upgrade of bundled tcl/tk from 8.4.6 to 8.5a5 - Sean Morrison
- improved EOL processing in 70+ tools - Sean Morrison, John Anderson
- rewrote pixcmp providing improved I/O format options - Sean Morrison
- added new manual page for pixcmp utility - Sean Morrison
- updated bundled zlib to version 1.2.3 - Sean Morrison
- updated bundled libpng to version 1.2.16 - Sean Morrison
- fixed Windows line-ending bug in dxf-g - John Anderson
- g_qa manual page documents the -t tolerance option - Lee Butler
- updated bundled blt to blt2.4z-patch-2 - Sean Morrison
- dxf-g turns 2D entities into sketches instead of nmg - John Anderson
- removed advertising clause from BSD code - Sean Morrison
- fix index bug, allow material ID of zero in rtweight - Karel Kulhavy
- fixed multiple frame render bug in raytracers - Karel Kulhavy
- mged help command now shows help for all args listed - Sean Morrison

CAD::Drawing is a Perl module with methods to create, load, and save vector graphics.

SYNOPSIS

The primary intention of this module is to provide high-level operations for creating, loading, saving and manipulating vector graphics without having to be overly concerned about smile floormats. As the code has seen more use, it has also drifted into a general purpose geometry API.

The syntax of this works something like the following:

A simple example of a (slightly misbehaved) file converter:

use CAD::Drawing;
$drw = CAD::Drawing->new;
$drw->load("file.dwg");
my %opts = (
layer => "smudge",
height => 5,
);
$drw->addtext([10, 2, 5], "Kilroy was here", %opts);
$drw->save("file.ps");

This is a very basic example, and will barely scratch the surface of this modules capabilities. See the details for each function below and in the documentation for the backend modules.

CAD::Drawing::IO are I/O methods for the CAD::Drawing module.

This module provides the load() and save() functions for CAD::Drawing and provides a point of flow-control to deal with the inheritance and other trickiness of having multiple formats handled through a single module.

Utility Functions

These are simply inherited by the CAD::Drawing module for your direct usage.
outloop

Crazy new experimental output method. Each entity supported by the format should have a key to a function in %functions, which is expected to accept the following input data:

$functions{$ent_type}->($obj, %data);

The %data hash is passed verbatim to each function.

$count = $drw->outloop(%functions, %data);

In addition to each of the $ent_type keys, functions for the keys before and after may also be defined. These (if they are defined) will be called before and after each entity, with the same arguments as the $ent_type functions.

is_persistent

Returns 1 if $filename points to a persistent (directory / db) drawing.

$drw->is_persistent($filename);

QCADesigner is the product of an ongoing research effort at the University of Calgary ATIPS Laboratory to create a design and simulation tool for Quantum Dot Cellular Automata (QCA). This tool is still under development and is provided free of cost to the research community "as is".
QCA is an emerging nanotechnology concept for the realization of a computer built with arrays of nano-scale QCA cells. These QCA cells are capable of performing all complex computational functions required for general-purpose computation.
QCA has been listed as one of the six emerging nanotechnologies with applications in future computers by the International Technology Roadmap For Semiconductors (ITRS). QCADesigner facilitates rapid design, layout and simulation of QCA circuits by providing powerful CAD features available in more complex circuit design tools.
Main features:
- Intuitive CAD-like user interface
- Easy drag-and-drop circuit design
- Encapsulated PostScript (EPS) printing
- Support for multiple layers (for signal crossover)
- Multilingual support (de hu ro fr - so far)
Enhancements:
- This is a minor bugfix release featuring an improved layer mapping dialog.
- However, the most important change is on the Windows front: The Windows version of QCADesigner now uses the Gaim version of the GTK+ Runtime Environment.
- The new version allows you to upgrade from the dropline.net version of GTK+.

CAD::Drawing::IO::Image is a Perl module with output methods for images.

Requisite Plug-in Functions

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

check_type

Returns true if $type is "img" or $filename matches one of the ImageMagick type extensions.

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

Methods

load

Requires vectorization...

load();

save

save();

image_color

image_color($color, $data);

CAD::Drawing::GUI::View are 2D graphics for CAD built on Tk::Zinc.

This module provides methods to turn a CAD::Drawing object into a Zinc canvas.

Overridden Methods

These make me behave like a Tk widget.

ClassInit

$view->ClassInit();

InitObject

$view->InitObject();

configure

$view->configure(%args);

args_filter

Filters configure arguments and adds non-tk args to our private data.

%args = $view->args_filter(%args);

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