Crate geop_ops_assembly 

Assemblies: parts placed in a part (placed) — another program file’s part, loaded through the runner and placed by AddPart at a pose its program’s state holds — and mated to what is already there (mates). Where every placed part is, is the program’s state, which the editor settles after every edit (Settler, solving the mates: mechanism, solving); the step placing a part drags it as far as its mates let it (see editor), and so does the drag tool (DragTool) with no step edited — in hand by default, so a press and a move on a placed part drag it. The joints panel (JointsPanel) sets a joint’s coordinates, and says how free the placed parts are and which constraints conflict. PartPattern places copies of a placed part in a row or round an axis. Explode moves placed parts off where they are assembled, one move of an exploded view per step, and Drive drives joints by a time table, played and checked for collisions in the motion panel (MotionPanel) and written frame by frame (MotionExport). A part derived from another brings its bodies in (DerivedPart), mirrored or not (MirrorPart); a mirrored component is placed so (AddPartArgs::mirror).

Also what is exported of an assembly: an STL file of a part with the parts placed in it (Stl), and its mechanism as a robot description (urdf); and how the placed parts are drawn and listed (AssemblyDrawer). What a placed part is to what reads it is geop_ops_model::placed’s.

Re-exports

pub use mates::Anchor;

pub use mates::CouplingKind;

pub use mates::Joint;

pub use mates::JointKind;

pub use mates::Kind;

pub use mates::Limits;

pub use mates::MOTIONS;

pub use mates::Mate;

pub use mates::MateKind;

pub use mates::Motion;

pub use mates::On;

pub use mates::Resolved;

pub use mates::Transmission;

pub use mates::foot_parameter;

pub use mates::joint_parameter;

pub use mates::mate;

pub use mates::mate_name;

pub use mechanism::mates_resolved;

pub use placed::define_placed;

pub use urdf::Urdf;

Modules

editor

Editing a placed part: choosing its file, where it goes and whether it stays put, its mates — and dragging it, as far as its mates let it.

examples

The examples of assemblies (set): programs placing the parts other files build, written in Rust against the operation types — and the parts they place, the files of each example made of several (workspaces).

joints

Joints and couplings: mates that say how one part may move against another, rather than only what touches what.

mates

Mates: what holds the parts placed in a part together — two entities, each of a placed part or of the part itself, and what they must be to each other (see MateKind) — and solving them, by moving the placed parts (see crate::mechanism).

mechanism

The mechanism of a part: its mates as constraints on the program’s state — where its placed parts are, how its joints are turned — and what they declare for solving it: the parts a fixed mate holds, each joint’s coordinates as values a solve moves and a user sets. Solving, checking and measuring is generic (crate::solving).

placed

Placing a part in a part (define_placed): the part another program file builds, placed as a node of the part placing it (see geop_core_program::placed) and drawn as a part is drawn ([draw]) — and every placed part drawn where the state has it ([draw_instances]). What a placed part is to the steps and outputs that read it is geop_ops_model::placed’s.

residuals

What a constraint mate asks of the geometry of two placed parts, as residuals: a point, a line or a plane of each — where its part puts it (Geometry::placed) — and what they must be to each other (Kind), each residual a length that vanishes where it holds (residuals).

solving

Solving a part’s state as an editor does, the same for every program: settling it so every constraint holds (solve()), dragging a placed part (Pull::Point), setting a value a step offers to set (set), and asking which constraints hold (check), how free the placed parts are (freedom) and which constraints conflict (conflicting).

urdf

URDF export: an assembly as a robot description, for simulators — ROS, Gazebo, MuJoCo, PyBullet, Isaac — to load (export), written by the exporter Urdf as one ZIP archive of the robot and its meshes.

Structs

AddPart

Places the part the program in another file builds, named by the step’s id: its elements are then the part’s, behind that name (see MateEntity).

AddPartArgs

AssemblyDrawer

Draws the parts placed in a part, however deep, each as an instance of its component where the state has it (see [draw_instances]), and lists them all, however deep, by their paths.

Checked

What the last check of a study found.

Collision

Two parts found overlapping at a time of a motion.

DerivedPart

Brings the bodies the program in another file builds into the part — its parameters set as parameters says, else as its own — each entity named X there named derived(D,X) here, for the step D: a part derived from another, which follows it as it changes. Mirrored after (see MirrorPart), it is the other hand of that part, a part of its own.

DerivedPartArgs

DragTool

The drag tool, in hand: the placed part the pointer is over, and the one being dragged.

Drive

Drives joint coordinates by a time table: a motion study — see the module docs.

Explode

Moves placed parts of the part off where they are assembled — see the module docs.

ExplodeArgs

JointsPanel

The joints panel: see the module docs.

JointsState

What the joints panel shows.

MirrorPart

Mirrors every body of the part in place, in a plane of its own origin: the other hand of it, every entity keeping its name — so a step or a mate naming one still finds it. Its datums stay as they are: a frame mirrored is no frame. The part says it is mirrored where it is listed (the parameter mirrored, the plane’s name): a bill of materials tells it from the part as it was.

MirrorPartArgs

MotionArgs

A motion study, as its step holds it.

MotionExport

Writes a motion study frame by frame: at each, the values its drivers are set to and where every placed part is.

MotionOptions

Which motion study to write.

MotionPanel

The motion panel: see the module docs.

MotionState

What the motion panel shows: the studies of the part shown, the one played last and the time it was shown at, and what the last check found.

PartPattern

Places copies of the part placed by the step part — the same part, built once — wherever frames puts them (see Frames): in a row or a grid, round an axis, along a curve, at points — the part at the first — from a table of offsets, filling a face, or at the holes of a feature, of the part or of a part placed in it. Each copy is a placed part of its own, named part_pattern(P,i) for the step P and the copy labelled i — 1, 2, …, or i.j in a grid or a fill — its entities behind that name like any placed part’s: part_pattern(bolts,2)/extrude(head,end).

PartPatternArgs

Settler

Settles a program’s state by solving its mates (see solving).

Stl

Writes the solids of the part as an STL mesh.

StlOptions

How an STL file is written.

StudyState

A motion study as the panel lists it.

Enums

Direction

Which way a move goes: along one of the part’s axes, or along the z axis of the frame something picked gives — a face’s normal, an edge’s direction, a datum’s axis (see MateEntity::frame), where its part is assembled.

JointsCommand

What the joints panel is sent.

MotionCommand

What the motion panel is sent.

Constants

MIRRORED

The parameter a mirrored part says it is mirrored by.

Functions

register

Adds what assemblies offer an editor to r: placing parts and patterns of them, parts derived from others and mirrored, the STL of a part with its placed parts and the URDF of its mechanism, how placed parts are drawn, the joints panel, the drag tool, what settles the program’s state after every edit, and the examples of assemblies.