Struct Sweep 

pub struct Sweep;

Sweeps the areas of a sketch — the profile — along the curves of another sketch or of a 3-D sketch — the path — into a solid named sweep(W) for the operation W, kept as a new body or combined with another solid (see Combine). Or, as faces (Output::Faces), sweeps the profile’s curves into faces standing on their own — the area’s outline, or a chain of curves enclosing nothing.

The path is the path sketch’s one chain of curves, or its one loop, which sweeps a ring, or an edge of the part — a 3-D sketch’s chain runs through space, and the profile turns with it as little as it can. The profile travels along it from where it is drawn, square to the path as it was there (see geop_lib_sweep::sweep_along): draw it at the start of the path, its plane across it. An open path starts at its end nearer the profile, a closed one at its joint nearest the profile. The path is tangent-continuous, except where two lines meet at an angle, which the sweep mitres.

Named after the profile’s elements — X a piece of a curve and P a joint of the profile sketch K, as for crate::Extrude — and the path’s — C a piece of a curve and J a joint of the path sketch L:

• sweep(W,K,X,L,C): the face X sweeps along C;
• sweep(W,K,X,L,J): X where the path passes J;
• sweep(W,K,P,L,C) / sweep(W,K,P,L,J): the edge P sweeps along C, and its vertex at J;
• sweep(W,start) / sweep(W,end): the caps of an open path.

Along an open path the profile can change as it goes (see Control): twisted and scaled evenly along the path, or shaped by one or two guide rails — sketches whose one chain of curves starts on the profile’s plane, at a point of the profile, and runs along beside the path: that point of the profile follows the rail, the whole profile turned and scaled with it. And it can keep facing the way it is drawn rather than turn with the path (Orientation::FixedNormal).

Trait Implementations

impl Clone for Sweep

fn clone(&self) -> Sweep

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Sweep

impl Debug for Sweep

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Sweep

fn default() -> Sweep

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Sweep

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Editable for Sweep

const INFO: OperationInfo = <Sweep as ::geop_core_editor::part_operation::PartOperation>::INFO

type EditingState = FormState<<Sweep as PartOperation>::Session>

What the editor keeps about a step while it is edited, beyond its arguments, starting from the default whenever a step is opened.

fn new_args(context: &Context<'_>) -> Self::Args

The arguments of a new step: sensible defaults, taking the part it is inserted into into account.

fn presentation( context: &Context<'_>, args: &Self::Args, editing: &Self::EditingState, ) -> Form

What the editor shows while the step is edited. Never fails: an editor needs the form most exactly when the arguments do not build, so whatever is wrong is said in it.

fn process_user_event( context: &Context<'_>, args: &Self::Args, editing: &Self::EditingState, event: Event, ) -> (Self::Args, Self::EditingState)

The step’s arguments and editing state after event.

impl ModelOperation for Sweep

fn build( model: &mut NamedModel, reader: &Reader<'_>, step: &str, args: &SweepArgs, ) -> GeopResult<()>

Builds the step step — what everything it makes is named after — into model, reading whatever else it builds on through reader, so the step is rebuilt when that changes.

impl Operation for Sweep

const KIND: &'static str = <Sweep as ::geop_core_editor::part_operation::PartOperation>::KIND

The name programs store its steps under.

type Args = <Sweep as PartOperation>::Args

What a step of the operation is given. It is saved with the program, so it names targets and elements, never holds their internal ids.

fn run(ctx: &mut StepContext<'_>, args: &Self::Args) -> __GeopResult<()>

Declares what the step produces, through ctx (see StepContext::produce): cheap, since it runs in every run. What takes work is done in the makes, which run only when what they read changed.

impl PartOperation for Sweep

fn new_args(context: &Context<'_>) -> SweepArgs

The newest sketch along the sketch before it — joined to the newest solid if there is one.

fn form<'a>( context: &'a Context<'a>, args: &SweepArgs, _: &FormState<()>, ) -> EditForm<'a, SweepArgs>

The profile and the path, picked; the rails, if any; how the profile turns, twists and scales; whether a face; and how to combine.

const KIND: &'static str = "sweep"

The name programs store its steps under.

const INFO: OperationInfo

type Args = SweepArgs

What a step is given. It is saved with the program, so it names targets and elements, never holds their internal ids.

type Session = ()

What the editor keeps while a step is edited besides its arguments and the visuals selected: () for most.

fn run(ctx: &mut StepContext<'_>, args: &SweepArgs) -> GeopResult<()>

Declares what the step produces, through ctx (see StepContext::produce).

fn begin_event(session: &mut Self::Session)

What the session forgets at the start of every event, before the event is handled: nothing, by default.

fn canvas( context: &Context<'_>, edit: Edit<'_, Self::Args, Self::Session>, event: &CanvasEvent, )

What the pointer or a key did on the canvas: nothing, by default.

impl PartialEq for Sweep

fn eq(&self, other: &Sweep) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Sweep

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Sweep