Function affine_transform

tools/transform.rs:181–224

(
    geometries: impl Iterator<Item = Geometry> + 'static,
    args: &CmdlineOptions,
)

}

fn affine_transform(
    geometries: impl Iterator<Item = Geometry> + 'static,
    args: &CmdlineOptions,
) -> Box<dyn Iterator<Item = Geometry> + '_> {
    match args.center {
        TransformCenter::Origin => {
            let center = coord! {x:0.0, y: 0.0};
            let transform = build_transform(args, center);
            Box::new(geometries.map(move |geom| geom.affine_transform(&transform)))
        }
        TransformCenter::EachGeometry => {
            let map = geometries.map(move |geom| {
                let center = geom
                    .bounding_rect()
                    .unwrap_or_else(|| {
                        panic!(
                            "Geometry '{}' didn't have a bounding rectangle",
                            geom.to_wkt()
                        )
                    })
                    .center();
                let transform = build_transform(args, center);
                geom.affine_transform(&transform)
            });
            Box::new(map)
        }
        // more expensive for large numbers of geometries (has to load all of them into RAM before
        // performing the transformations)
        TransformCenter::WholeCollection => {
            let geometries: Vec<_> = geometries.collect();
            let rect = bounding_box(&geometries);
            let center = rect.center();
            let transform = build_transform(args, center);

            // Instead of applying the transformation in-place all at once _and then_ writing the
            // results, we lazily perform the transformation so that we can pipeline the
            // transformation and the serialization.
            let map = geometries
                .into_iter()
                .map(move |geom| geom.affine_transform(&transform));
            Box::new(map)
        }
    }
}

fn from_polar(coord: Coord) -> Coord {
    let r = coord.x;