Struct PathType 

pub struct PathType { /* private fields */ }

Represents the homotopy type of a path in a punctured plane.

The PathType struct encapsulates the current path, puncture points, and the word representation of the homotopy type. It provides methods to update the path and retrieve the word representation.

Fields

• current_path: The current path represented as a PLPath (piecewise linear path).
• puncture_points: A shared reference to an array of PuncturePoint objects representing the puncture points in the plane.
• word: The word representation of the homotopy type, which is automatically updated whenever the path is modified.

Examples

use your_library::{PathType, PLPath, PuncturePoint};
use std::sync::Arc;

let puncture_points = vec![
    PuncturePoint { position: (0.0, 0.0), name: 'A' },
    PuncturePoint { position: (1.0, 1.0), name: 'B' },
];
let puncture_points = Arc::new(puncture_points);

let initial_path = PLPath::new();
let mut path_type = PathType {
    current_path: initial_path,
    puncture_points,
    word: String::new(),
};

// Update the path
let new_path = PLPath::from_points(&[(0.0, 0.0), (1.0, 0.0), (1.0, 1.0)]);
path_type.update_path(new_path);

// Get the updated word representation
println!("Word representation: {}", path_type.word());

Implementations

impl PathType

pub fn word_as_str(&self) -> &str

pub fn word(&self) -> String

Examples found in repository

examples/homotopy_word_debug.rs (line 112)

fn homotopy_text_update(
    mut text_query: Query<&mut Text, With<HomotopyWordText>>,
    path_query: Query<&PathType>,
) {
    if let Ok(path_type) = path_query.get_single() {
        if let Ok(mut text) = text_query.get_single_mut() {
            text.sections[0].value = path_type.word();
        }
    }
}

pub fn new(start: Vec2, puncture_points: Vec<PuncturePoint>) -> Self

Examples found in repository

examples/homotopy_word_debug.rs (line 60)

fn init(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ColorMaterial>>,
) {
    // spawn the camera
    commands.spawn(Camera2dBundle::default());

    // Define some puncture points
    let puncture_points = vec![
        PuncturePoint::new(Vec2::new(-225.0, 100.0), 'A'),
        PuncturePoint::new(Vec2::new(-75.0, 150.0), 'B'),
        PuncturePoint::new(Vec2::new(75.0, 150.0), 'C'),
        PuncturePoint::new(Vec2::new(225.0, 100.0), 'D'),
    ];

    // Render puncture points as red circles
    let radius = 5.0;
    let material = materials.add(ColorMaterial::from(Color::RED));
    for point in puncture_points.iter() {
        commands.spawn(MaterialMesh2dBundle {
            mesh: meshes.add(Circle::new(radius)).into(),
            material: material.clone(),
            transform: Transform::from_translation(point.position().extend(0.0)),
            ..Default::default()
        });
    }

    // spawn the player
    commands.spawn((
        Player,
        MaterialMesh2dBundle {
            mesh: meshes.add(Circle::new(10.0)).into(),
            material: materials.add(PLAYER_COLOR),
            transform: Transform::from_translation(PLAYER_START),
            ..Default::default()
        },
        PathType::new(PLAYER_START.truncate(), puncture_points),
    ));

    // spawn the text
    commands.spawn((
        TextBundle::from_section(
            "default",
            TextStyle {
                font_size: 60.0,
                ..Default::default()
            },
        )
        .with_text_justify(JustifyText::Center)
        .with_style(Style {
            position_type: PositionType::Absolute,
            bottom: Val::Px(5.0),
            right: Val::Px(5.0),
            ..Default::default()
        }),
        HomotopyWordText,
    ));
}

pub fn from_path(path: PLPath, puncture_points: Arc<[PuncturePoint]>) -> Self

pub fn concatenate(&self, other: &PLPath) -> Self

pub fn push(&mut self, point: &Vec2)

Appends a 2d position to the end of the current path.

pub fn update_word(&mut self) -> String

Updates the word representing the homotopy type of the path. Returns the updated word.

Trait Implementations

impl Clone for PathType

fn clone(&self) -> PathType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for PathType

where Self: Send + Sync + 'static,

type Storage = TableStorage

A marker type indicating the storage type used for this component. This must be either TableStorage or SparseStorage.

impl Debug for PathType

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

Formats the value using the given formatter.