Access to polygons of an object

[winksaville]

I notice in fn cube you create 6 polygons then union them into the cube. In this case I want to access the polygons so I can modify the face, write text on them. I tried using cube.to_polygon but that returned an empty vector.

Idea, provide a way to get the polygons you used to create an object.

[timschmidt]

Every CSG contains a Vec polygons which contains all the 3D Polygons. So, csg.polygons. 2D geometry is stored in csg.geometry as a geo GeometryCollection, and there's an extra metadata in every CSG as well. I suppose a better name for to_polygons() might be geometry_to_polygons().

[winksaville]

I now see there is a struct CSG.polygons field and indeed that is not empty, but to_polygons() returns an empty Vec. That appears to be because fn to_poloygons() is implemented as:

    pub fn to_polygons(&self) -> Vec<Polygon<S>> {
        let mut all_polygons = Vec::new();
    
        for geom in &self.geometry {
        ..
        }
        
        all_polygons
    }

But struct CSG.gometry is empty.

Here is my little test:

    // Create the cube
    let mut cube = CSG::cube(len_side, len_side, len_side, None);
    let geometry = &cube.geometry;
    println!("geometry: {:?}", geometry);
    let polygons = &cube.to_polygons();
    println!("to_polygons: {:?}", polygons);
    let polygons = &cube.polygons;
    println!("polygons: {:?}", polygons);

And here is the output:

geometry: GeometryCollection([])
to_polygons: []
polygons: [Polygon { vertices: [Vertex { pos: [0.0, 0.0, 0.0]  ... plane: Plane { normal: [[1.0, 0.0, 0.0]], w: 2.397 }, metadata: None }]`

[timschmidt]

I now see there is a struct CSG.polygons field and indeed that is not empty, but to_polygons() returns an empty Vec.

Yes, that is expected behavior, as to_polygons converts a 2D geometry to a 3D geometry. Since you've only supplied a 3D geometry, to_polygons correctly returns an empty set.

[winksaville]

Two suggestions:

• Add fn get_polygons, that function should use the appropriate source since there are two.
• Add a way to name polygons and the retrieve polygons by name.

[timschmidt]

I think an accessor function is an easy ask to resolve.

Two approaches to your second item: ideally the metadata system allows for this sort of thing. You can put your polygon name in the metadata field, then it will be there when you retrieve it to identify that polygon. There is not currently a function to query polygons based on metadata, though here are two options:

    // Group polygons by their metadata.
    //
    // Returns a map from the metadata (as `Option<S>`) to a
    // list of references to all polygons that have that metadata.
    //
    // # Example
    // ```
    // let mut csg = CSG::new();
    // // ... fill `csg.polygons` with some that share metadata, some that have None, etc.
    //
    // let grouped = csg.polygons_by_metadata();
    // for (meta, polys) in &grouped {
    //     println!("Metadata = {:?}, #polygons = {}", meta, polys.len());
    // }
    // ```
    // requires impl<S: Clone + Eq + Hash> CSG<S> { and use std::collections::HashMap; use std::hash::Hash;
     pub fn polygons_by_metadata(&self) -> HashMap<Option<S>, Vec<&Polygon<S>>> {
        let mut map: HashMap<Option<S>, Vec<&Polygon<S>>> = HashMap::new();
        
        for poly in &self.polygons {
            // Clone the `Option<S>` so we can use it as the key
            let key = poly.metadata.clone();
            map.entry(key).or_default().push(poly);
        }
        
        map
     }

    // Return polygons grouped by metadata
    // requires impl<S: Clone + std::cmp::PartialEq> CSG<S> {
     pub fn polygons_by_metadata_partialeq(&self) -> Vec<(Option<S>, Vec<&Polygon<S>>)> {
        let mut groups: Vec<(Option<S>, Vec<&Polygon<S>>)> = Vec::new();
        'outer: for poly in &self.polygons {
            let meta = poly.metadata.clone();
            // Try to find an existing group with the same metadata (requires a way to compare!)
            for (existing_meta, polys) in &mut groups {
               // For this to work, you need some form of comparison on `S`.
                // If S does not implement Eq, you might do partial compare or pointer compare, etc.
                if *existing_meta == meta {
                    polys.push(poly);
                    continue 'outer;
                }
            }
            // Otherwise, start a new group
            groups.push((meta, vec![poly]));
        }
        groups
     }

Each require some additional implementations for the metadata type, which has been the hold up. Comments and improvements welcome.

Second method: As I work to further integrate Rapier, for rigid body physics, there needs to be a concept of attachments. I am imagining nodes where attachments can happen as existing by default for every CSG on the corners and centers of edges and faces of the bounding box, and of each polygon. Each will have to be identifiable, and the bounding_box nodes will probably all have names. Polygon nodes might just be indexed. But there will have to be some reproducible system for identifying nodes, to facilitate attaching CSGs to each other as rigid bodies for physics simulation.

[winksaville]

Sorry I'm not sure how the above is suppose to know which polygon face is which and also what index it's associated with without reverse engineering the CSG. For my short term needs I can determine the relationship between the index and the faces "name", but ATM it's hard for me to imagine how to generalize that to create the metadata.

[timschmidt]

I'm not aware of any general solution to naming arbitrary polygon faces other than indexing. Open to suggestions.