示例#1
0
def _process_single_tile(debug=None,
                         raw_conf_process_pyramid=None,
                         mapchete_config=None,
                         tile=None,
                         mode=None,
                         input_file=None,
                         verbose_dst=None,
                         vrt=None,
                         idx_out_dir=None,
                         no_pbar=None):
    with click_spinner.spinner(disable=debug) as spinner:
        with mapchete.Timer() as t:
            tile = raw_conf_process_pyramid(
                raw_conf(mapchete_config)).tile(*tile)
            with mapchete.open(mapchete_config,
                               mode=mode,
                               bounds=tile.bounds,
                               zoom=tile.zoom,
                               single_input_file=input_file) as mp:
                spinner.stop()
                tqdm.tqdm.write("processing 1 tile", file=verbose_dst)

                # run process on tile
                for result in mp.batch_processor(tile=tile):
                    write_verbose_msg(result, dst=verbose_dst)

            tqdm.tqdm.write(
                ("processing %s finished in %s" %
                 (mapchete_config, t) if isinstance(mapchete_config, str) else
                 "processing finished in %s" % t),
                file=verbose_dst)

            # write VRT index
            if vrt:
                with mapchete.Timer() as t_vrt:
                    tqdm.tqdm.write("creating VRT", file=verbose_dst)
                    for tile in tqdm.tqdm(zoom_index_gen(
                            mp=mp,
                            zoom=tile.zoom,
                            out_dir=idx_out_dir or mp.config.output.path,
                            vrt=vrt,
                    ),
                                          total=mp.count_tiles(
                                              tile.zoom, tile.zoom),
                                          unit="tile",
                                          disable=debug or no_pbar):
                        logger.debug("%s indexed", tile)

                    tqdm.tqdm.write(("VRT(s) for %s created in %s" %
                                     (mapchete_config, t_vrt) if isinstance(
                                         mapchete_config, str) else
                                     "VRT(s) created in %s" % t_vrt),
                                    file=verbose_dst)
示例#2
0
def _process_area(
    debug=None,
    mapchete_config=None,
    mode=None,
    zoom=None,
    wkt_geometry=None,
    point=None,
    bounds=None,
    input_file=None,
    multi=None,
    verbose_dst=None,
    max_chunksize=None,
    no_pbar=None,
    vrt=None,
    idx_out_dir=None,
):
    multi = multi or cpu_count()
    with click_spinner.spinner(disable=debug) as spinner:
        with mapchete.Timer() as t:
            with mapchete.open(
                mapchete_config,
                mode=mode,
                zoom=zoom,
                bounds=bounds_from_opts(
                    wkt_geometry=wkt_geometry,
                    point=point,
                    bounds=bounds,
                    raw_conf=raw_conf(mapchete_config)
                ),
                single_input_file=input_file
            ) as mp:
                spinner.stop()
                tiles_count = mp.count_tiles(
                    min(mp.config.init_zoom_levels),
                    max(mp.config.init_zoom_levels)
                )

                tqdm.tqdm.write(
                    "processing %s tile(s) on %s worker(s)" % (tiles_count, multi),
                    file=verbose_dst
                )

                # run process on tiles
                for process_info in tqdm.tqdm(
                    mp.batch_processor(
                        multi=multi,
                        zoom=zoom,
                        max_chunksize=max_chunksize
                    ),
                    total=tiles_count,
                    unit="tile",
                    disable=debug or no_pbar
                ):
                    write_verbose_msg(process_info, dst=verbose_dst)

            tqdm.tqdm.write(
                (
                    "processing %s finished in %s" % (mapchete_config, t)
                    if isinstance(mapchete_config, str)
                    else "processing finished in %s" % t
                ),
                file=verbose_dst
            )

            # write VRT index
            if vrt:
                with mapchete.Timer() as t_vrt:
                    tqdm.tqdm.write("creating VRT(s)", file=verbose_dst)
                    for tile in tqdm.tqdm(
                        zoom_index_gen(
                            mp=mp,
                            zoom=mp.config.init_zoom_levels,
                            out_dir=idx_out_dir or mp.config.output.path,
                            vrt=vrt
                        ),
                        total=mp.count_tiles(
                            min(mp.config.init_zoom_levels),
                            max(mp.config.init_zoom_levels)
                        ),
                        unit="tile",
                        disable=debug or no_pbar
                    ):
                        logger.debug("%s indexed", tile)

                    tqdm.tqdm.write(
                        (
                            "VRT(s) for %s created in %s" % (mapchete_config, t_vrt)
                            if isinstance(mapchete_config, str)
                            else "VRT(s) created in %s" % t_vrt
                        ),
                        file=verbose_dst
                    )