Function main

tools/grid.rs:573–682

()

}

fn main() -> eyre::Result<()> {
    color_eyre::install()?;
    let args = CmdlineOptions::parse();

    let filter = tracing_subscriber::EnvFilter::builder()
        .with_default_directive(args.log_level.into())
        .from_env_lossy();
    tracing_subscriber::fmt()
        .with_env_filter(filter)
        .with_ansi(true)
        .with_writer(std::io::stderr)
        .init();

    // Exit early with a nice error message here, so that I can use unreachable!() later
    if !cfg!(feature = "cxx-bindings")
        && args.grid_type == GridType::Radial
        && args.output_format == GridFormat::Graph
    {
        // No need to check if args.output_format == GridFormat::Cells, because that's hidden
        // behind the cxx-bindings feature already.
        eprintln!(
            "Using the {} output format with radial grids requires the 'cxx-bindings' feature",
            args.output_format
        );
        std::process::exit(1);
    }

    let (mut size_x, mut size_y) = if let Some(size) = args.size {
        (size, size)
    } else {
        (1.0, 1.0)
    };
    if let Some(size) = args.size_x {
        size_x = size;
    }
    if let Some(size) = args.size_y {
        size_y = size;
    }

    let writer = get_output_writer(&args.output)?;

    // Radial grids need to be created as geometry-first instead of grid-first, to enable
    // outputting the radial spokes as LINESTRINGs, and the concentric rings as POLYGONs, which
    // itself is desired, because it makes it possible to densify / smooth the rings separately
    // from the spokes.
    if args.grid_type == GridType::Radial {
        let strategy = if let Some(points) = args.ring_fill_points {
            FillStrategy::NumPoints(points)
        } else if let Some(ratio) = args.ring_fill_ratio {
            FillStrategy::RadiusRatio(ratio)
        } else {
            FillStrategy::None
        };
        let (spokes, rings) = radial_grid(args.width, args.height, size_y, strategy);
        let spokes = spokes.into_iter().map(Geometry::LineString);
        let rings = rings.into_iter().map(Geometry::Polygon);
        let geoms = rings.chain(spokes);