Why not adopt me?

This distribution is up for adoption! If you're interested then please contact the PAUSE module admins via email.

NAME

Imager::Bing::MapLayer - create a map layer for Bing Maps

SYNOPSIS

    my $layer = Imager::Bing::MapLayer->new(
      base_dir           => $dir,     # base directory (default '.')
      overwrite          => 1,        # overwrite existing (default)
      autosave           => 1,        # save on exit (default)
      in_memory          => 0,        # keep tiles in memory (default false)
      min_level          => 1,        # min zoom level (default)
      max_level          => 19,       # max zoom level (default)
      combine            => 'darken', # tile composition method (default)
    );

    # Plot polygons (e.g. geographic boundaries)

    $layer->polygon(
       points => $points,                  # listref to [ lat, lon ] points
       fill   => Imager::Fill->new( ... ), #
    );

    # Plot greyscale gradient circles for heatmaps

    $layer->radial_circle(
        r      => 100,              # radius in meters
        -min_r => 1,                # minimum pixel radius for any zoom level
        x      => $longitude,       # longitude (x = east-west)
        y      => $latitude,        # latitude  (y = north-south)
    );

    # Blur filter

    $layer->filter( type => 'gaussian', stddev => 1 );

    # Colourise greyscale heatmaps

    $layer->colourise();

DESCRIPTION

This module is a wrapper around the Imager::Draw module, which allows you to create Bing map layers using longitude and latitude coordinates.

The module will automatically map them to the appropriate points on tile files.

It adds the following options to drawing methods:

-min_level: The minimum zoom level to draw on.
-max_level: The maximum zoom level to draw on.

ATTRIBUTES

`in_memory`

The timeout for how many seconds a tile is kept in memory. The default is 0.

When a tile is timed out, it is saved to disk after each Imager drawing operation, and reloaded if it is later needed.

Setting this to a non-zero value keeps tiles in memory, but increases the memory requirements.

`centroid_latitude`

`centroid_longitude`

This is the centroid latitude and longitude for translating points to pixels. It defaults to a point in London.

You can probably get away with ignoring this, but if you are generating maps for different regions of the world, then you may consider changing this, or even maininging different map sets with different centroids.

`overwrite`

When true (default), existing tiles will be overwritten rather than edited.

Be wary of editing existing tiles, since antialiased lines and opaque fills will darken existing points rather than drawing over them.

`autosave`

When true (default), tiles will be automatically saved.

Alternatively, you can use the "save" method to manually save tiles.

Note that any times in memory when a script is interrupted may be lost. An alternative to add something to trap interruptions:

  local $SIG{INT} = sub {
      state $int = 0;
      unless ($int) {
          $int=1;
          $image->save();
      }
      exit 1;
  };

`combine`

The tile combination method. It defaults to darken.

`tile_class`

The base class used for tiles.

This can be used to subclass the tiles, for instance, to save tiles with a different filename to use with something other than Bing maps, e.g. Google Maps.

You might use something like:

  package MyTile;

  use Moose;
  extends 'Imager::Bing::MapLayer::Tile';

  use Path::Class;

  override 'build_filename' => sub {
    my ($self) = @_;
    my $file = file($self->base_dir, $self->level,
                    join(',', @{ $self->tile_coords }) . '.png');
    return $file->stringify;
  };

METHODS

`levels`

  my @levels = @{ $layer->levels };

This returns a reference to a list of Imager::Bing::MapLayer::Level objects.

`min_level`

The minimum zoom level to generate.

`max_level`

The maximum zoom level to generate.

`radial_circle`

    $layer->radial_circle(
        r      => $radius_in_meters,
        -min_r => $min_radius_in_pixels,
        x      => $longitude,
        y      => $latitude,
    );

This method plots "fuzzy" greyscale circles, which are intended to be used for heatmaps. The radius is scaled appropriately for each zoom level in the layer.

If -min_r is specified, then a circle will always be drawn with that minimum radius: this ensures that lower zoom levels will always have a point plotted.

`colourise`

`colorize`

    $layer->colourise();

The method colourises greyscale layers. It is intended to be used for heatmaps generated using the "radial_circle" method.

`filter`

    $layer->filter( type => 'gaussian', stddev => 1 );

This applies Imager::Filters to every tile on every zoom level of the layer.

Be aware that some filter effects may enhance the edges of tiles in each zoom level.