示例#1
0
    def __init__(self, center, bbox, zoom, basemap, opacity, size=None):

        self._configure_event_loop()
        point = center['geometry']['coordinates']
        if size is None:
            size = IMAGE_SIZE

        self.num_tiles = [
            math.ceil(size[x] / TILE_SIZE[x]) + 1 for x in (0, 1)
        ]
        center_tile = mercantile.tile(point[0], point[1], zoom)

        mercator = Proj(init='epsg:3857')
        wgs84 = Proj(init='epsg:4326')

        center_tile_bbox = BBox(mercantile.bounds(*center_tile),
                                projection=wgs84).project(mercator,
                                                          edge_points=0)
        center_to_image = world_to_image(center_tile_bbox, TILE_SIZE)
        center_to_world = image_to_world(center_tile_bbox, TILE_SIZE)
        center_point_px = center_to_image(*mercantile.xy(*point))

        self.ul_tile = mercantile.tile(*transform(
            mercator, wgs84,
            *center_to_world(center_point_px[0] -
                             math.ceil(IMAGE_SIZE[0] / 2), center_point_px[1] -
                             math.ceil(IMAGE_SIZE[1] / 2)), zoom))

        lr_tile = mercantile.Tile(x=min(2**zoom,
                                        self.ul_tile.x + self.num_tiles[0]),
                                  y=min(2**zoom,
                                        self.ul_tile.y + self.num_tiles[1]),
                                  z=zoom)

        ul = mercantile.xy(*mercantile.ul(*self.ul_tile))
        lr = mercantile.xy(*mercantile.ul(*lr_tile))

        self.image_bbox = BBox((ul[0], lr[1], lr[0], ul[1]))
        self.image_size = (TILE_SIZE[0] * self.num_tiles[0],
                           TILE_SIZE[1] * self.num_tiles[1])

        self.to_image = world_to_image(self.image_bbox, self.image_size)
        self.to_world = image_to_world(self.image_bbox, self.image_size)

        self.point_px = [
            round(x) for x in self.to_image(*mercantile.xy(*point))
        ]

        self.target_size = size
        self.point = point
        self.zoom = zoom
        self.basemap = basemap
        self._basemap_image = None
        self.opacity = opacity
示例#2
0
        def get_management_action_map(tsm):
            geojson_file = os.path.join(
                STSIM_MULTIPLIER_DIR,
                tsm.transition_multiplier_file_name).replace('.tif', '.json')

            with open(geojson_file, 'r') as f:
                polygons = json.load(f)

            transition_group = tsm.transition_group.name
            timestep = int(
                tsm.transition_multiplier_file_name.split('_')[-1].split('.')
                [0])
            label = '{} performed on {} {}'.format(transition_group,
                                                   timestep_units, timestep)
            image_data, bbox = map_maker.get_polygon_image(polygons)
            to_world = image_to_world(bbox, image_data.size)

            image_handle = BytesIO()
            image_data.save(image_handle, 'png')

            return {
                'label': label,
                'image_data': b64encode(image_handle.getvalue()),
                'scale': get_scale(to_world, image_data.size[1]),
                **basic_map_config
            }
示例#3
0
        def get_map_context(label,
                            name,
                            service,
                            is_output=False,
                            iteration=None,
                            timestep=None,
                            legend=None):

            service_url = service[name]
            if is_output:
                service_url = service_url.replace('{it}',
                                                  str(iteration)).replace(
                                                      '{t}', str(timestep))

            image_data, bbox = map_maker.get_image(service_url)
            to_world = image_to_world(bbox, image_data.size)
            bbox = bbox.project(WGS84, edge_points=0)

            image_handle = BytesIO()
            image_data.save(image_handle, 'png')

            scale = get_scale(to_world, image_data.size[1])
            legend_data = get_legend(service_url,
                                     is_output) if legend is None else legend

            return {
                'label': label,
                'image_data': b64encode(image_handle.getvalue()),
                'north': format_y_coord(bbox.ymax),
                'east': format_x_coord(bbox.xmax),
                'west': format_x_coord(bbox.xmin),
                'south': format_y_coord(bbox.ymin),
                'scale': scale,
                'legend': legend_data
            }
示例#4
0
    def execute(self, bounds, zoom, basemap, single_color, kept_colors, gained_colors, species, **kwargs):
        historic = kwargs['historic']
        futures = kwargs.get('futures', [])
        opacity = kwargs.get('opacity', 1.)

        map_image = self.get_basemap_image(basemap, bounds, IMAGE_SIZE, zoom)
        results_image = self.get_results_image(
            bounds, IMAGE_SIZE, single_color, kept_colors, gained_colors, species, historic, futures
        )
        map_image.paste(Image.blend(map_image, results_image, opacity), (0, 0), results_image)
        image_data = BytesIO()
        map_image.save(image_data, 'png')

        def format_x_coord(x):
            return '{}&deg; W'.format(round(abs(x), 2)) if x < 0 else '{}&deg; E'.format(round(x, 2))

        def format_y_coord(y):
            return '{}&deg; S'.format(round(abs(y), 2)) if y < 0 else '{}&deg; N'.format(round(y, 2))

        to_world = image_to_world(BBox(bounds, projection=WGS84).project(WEB_MERCATOR), IMAGE_SIZE)

        images_dir = self.get_images_dir()
        with open(os.path.join(images_dir, 'scale.png'), 'rb') as f:
            scale_data = b64encode(f.read())

        scale_bar_x = 38
        scale_bar_y = IMAGE_SIZE[1] - 15

        scale_bar_start = transform(WEB_MERCATOR, WGS84, *to_world(scale_bar_x, scale_bar_y))
        scale_bar_end = transform(WEB_MERCATOR, WGS84, *to_world(scale_bar_x + 96, scale_bar_y))
        scale = '{} mi'.format(round(vincenty(reversed(scale_bar_start), reversed(scale_bar_end)).miles, 1))

        context = {
            'today': now(),
            'image_data': b64encode(image_data.getvalue()),
            'east': format_x_coord(bounds[0]),
            'south': format_y_coord(bounds[1]),
            'west': format_x_coord(bounds[2]),
            'north': format_y_coord(bounds[3]),
            'scale_image_data': scale_data,
            'scale': scale,
            'single_color': single_color,
            'kept_colors': self.get_colors(kept_colors, len(futures)+1),
            'gained_colors': self.get_colors(gained_colors, len(futures)+1),
            'historic': historic.replace('_', '-'),
            'futures': [
                {'rcp': RCP_LABELS[rcp], 'year': YEAR_LABELS[year]}
                for rcp, year in [x.split('_', 1) for x in futures]
            ],
            'species': SPECIES_LABELS[species],
        }

        uuid = str(uuid4())
        report_dir = os.path.join(settings.MEDIA_ROOT, uuid)
        if not os.path.exists(report_dir):
            os.makedirs(report_dir)
        path = os.path.join(report_dir, 'SPHT Report.pdf')
        with open(path, 'wb') as f:
            HTML(BytesIO(render_to_string('spht/report.html', context).encode())).write_pdf(f)

        return '{}{}/SPHT Report.pdf'.format(settings.MEDIA_URL, uuid)
示例#5
0
    def __init__(self,
                 size,
                 point,
                 zoom,
                 center,
                 tile_layers,
                 region,
                 zone_id,
                 opacity,
                 constraint_geometry=None):
        self._configure_event_loop()

        self.num_tiles = [
            math.ceil(size[x] / TILE_SIZE[x]) + 1 for x in (0, 1)
        ]
        center_tile = mercantile.tile(center[1], center[0], zoom)

        mercator = Proj(init='epsg:3857')
        wgs84 = Proj(init='epsg:4326')

        center_tile_bbox = BBox(mercantile.bounds(*center_tile),
                                projection=wgs84).project(mercator,
                                                          edge_points=0)
        center_to_image = world_to_image(center_tile_bbox, TILE_SIZE)
        center_to_world = image_to_world(center_tile_bbox, TILE_SIZE)
        center_point_px = center_to_image(*mercantile.xy(center[1], center[0]))

        self.ul_tile = mercantile.tile(*transform(
            mercator, wgs84,
            *center_to_world(center_point_px[0] -
                             math.ceil(IMAGE_SIZE[0] / 2), center_point_px[1] -
                             math.ceil(IMAGE_SIZE[1] / 2)), zoom))

        lr_tile = mercantile.Tile(x=min(2**zoom,
                                        self.ul_tile.x + self.num_tiles[0]),
                                  y=min(2**zoom,
                                        self.ul_tile.y + self.num_tiles[1]),
                                  z=zoom)

        ul = mercantile.xy(*mercantile.ul(*self.ul_tile))
        lr = mercantile.xy(*mercantile.ul(*lr_tile))

        self.image_bbox = BBox((ul[0], lr[1], lr[0], ul[1]))
        self.image_size = (TILE_SIZE[0] * self.num_tiles[0],
                           TILE_SIZE[1] * self.num_tiles[1])

        self.to_image = world_to_image(self.image_bbox, self.image_size)
        self.to_world = image_to_world(self.image_bbox, self.image_size)

        self.point_px = [
            round(x) for x in self.to_image(*mercantile.xy(*point))
        ]
        self.center_point_px = self.to_image(
            *mercantile.xy(center[1], center[0]))

        self.target_size = size
        self.point = point
        self.zoom = zoom
        self.center = center
        self.tile_layers = tile_layers
        self.region = region
        self.zone_id = zone_id
        self.opacity = opacity
        self.constraint_geometry = constraint_geometry
示例#6
0
    def get_context(self, img_as_bytes=False):
        point = self.configuration['point']
        elevation = get_elevation_at_point(Point(point['x'],
                                                 point['y'])) / 0.3048
        method = self.configuration['method']
        objective = self.configuration['objective']
        climates = self.configuration['climate']

        if self.configuration['method'] == 'seedzone' and elevation is not None:
            zone_uid = self.configuration['zones']['selected']

            try:
                zone = SeedZone.objects.get(zone_uid=zone_uid)
                zone_id = zone.pk

                try:
                    limit = zone.transferlimit_set.filter(
                        low__lt=elevation, high__gte=elevation)[:1].get()
                    band = [0 if limit.low == -1 else limit.low, limit.high]
                except TransferLimit.DoesNotExist:
                    band = None
            except SeedZone.DoesNotExist:
                zone_id = None
                zone = None
                band = None
        else:
            zone_id = None
            zone = None
            band = None

        mercator = Proj(init='epsg:3857')
        wgs84 = Proj(init='epsg:4326')

        map_image, map_bbox = MapImage(
            IMAGE_SIZE, (point['x'], point['y']),
            self.zoom,
            self.center,
            self.tile_layers,
            self.configuration.get('region'),
            zone_id,
            self.opacity,
            constraint_geometry=self.get_constraint_geometry()).get_image()
        to_world = image_to_world(map_bbox, map_image.size)
        map_bbox = map_bbox.project(Proj(init='epsg:4326'), edge_points=0)

        image_data = BytesIO()
        map_image.save(image_data, 'png')
        if img_as_bytes:
            image_data.seek(0)  # seek to file start so we can read into ppt

        with open(os.path.join(get_images_dir(), 'north.png'), 'rb') as f:
            north_image_data = b64encode(f.read())

        with open(os.path.join(get_images_dir(), 'scale.png'), 'rb') as f:
            scale_image_data = b64encode(f.read())

        scale_bar_x = 38
        scale_bar_y = map_image.size[1] - 15
        scale_bar_start = transform(mercator, wgs84,
                                    *to_world(scale_bar_x, scale_bar_y))
        scale_bar_end = transform(mercator, wgs84,
                                  *to_world(scale_bar_x + 96, scale_bar_y))
        scale = '{} mi'.format(
            round(
                vincenty(reversed(scale_bar_start),
                         reversed(scale_bar_end)).miles, 1))

        legend = RESULTS_RENDERER.get_legend()[0]

        def format_x_coord(x):
            return '{}&deg; W'.format(round(
                abs(x), 2)) if x < 0 else '{}&deg; E'.format(round(x, 2))

        def format_y_coord(y):
            return '{}&deg; S'.format(round(
                abs(y), 2)) if y < 0 else '{}&deg; N'.format(round(y, 2))

        return {
            'today':
            datetime.today(),
            'image_data':
            b64encode(image_data.getvalue())
            if not img_as_bytes else image_data,
            'north':
            format_y_coord(map_bbox.ymax),
            'east':
            format_x_coord(map_bbox.xmax),
            'south':
            format_y_coord(map_bbox.ymin),
            'west':
            format_x_coord(map_bbox.xmin),
            'north_image_data':
            north_image_data,
            'scale_image_data':
            scale_image_data,
            'scale':
            scale,
            'legend_image_data':
            legend,
            'objective':
            'Find seedlots'
            if objective == 'seedlots' else 'Find planting sites',
            'location_label':
            'Planting site location'
            if objective == 'seedlots' else 'Seedlot location',
            'point': {
                'x': round(point['x'], 4),
                'y': round(point['y'], 4)
            },
            'elevation':
            round(elevation),
            'seedlot_year':
            self.get_year(climates['seedlot']),
            'site_year':
            self.get_year(climates['site']),
            'site_model':
            self.get_model(climates['site']),
            'method':
            method,
            'center':
            self.configuration['center'],
            'species':
            self.configuration.get('species')
            if method in ('seedzone', 'function') else None,
            'zone':
            getattr(zone, 'name', None),
            'band':
            band,
            'variables':
            self.get_context_variables(),
            'traits':
            self.get_context_traits(),
            'constraints':
            self.get_context_constraints(),
            'title':
            SEEDSOURCE_TITLE
        }