예제 #1
0
    def render_tile(self, tile_uri, x, y, z, buffer_size):

        tile = (x, y)
        c0, c1 = self.calcTileCoordinates(tile, z)
        tile_extent = (c0.x, c0.y, c1.x, c1.y)
        #dest_file = "WebGen_WPS_file.xml"
        #folder = "/home/klammer/Software/Quickly/TileGen/tilegen/data/media/"
        #test = makeWPSfile(tile_extent, folder+dest_file)
        #if test > 0:
        #    sendFile(dest_file, folder)

        # Bounding box for the tile
        if hasattr(mapnik,
                   'mapnik_version') and mapnik.mapnik_version() >= 800:
            bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
        else:
            bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
        render_size = 256
        self.m.resize(render_size, render_size)
        self.m.zoom_to_box(bbox)
        self.m.buffer_size = buffer_size

        # Render image with default Agg renderer
        im = mapnik.Image(render_size, render_size)
        mapnik.render(self.m, im)
        im.save(tile_uri, 'png256')
예제 #2
0
    def mouseReleaseEvent(self, event):
        if event.button() == Qt.LeftButton:
            self.drag = False
            self.endDragPos = event.pos()

            if self.toolMode == 3:
                QApplication.setOverrideCursor(QCursor(Qt.OpenHandCursor))
                cx = int(0.5 * self.map.width)
                cy = int(0.5 * self.map.height)
                dpos = self.endDragPos - self.startDragPos
                self.map.pan(cx - dpos.x(), cy - dpos.y())
                self.updateMap()
            if self.toolMode == 1:
                env = mapnik.Envelope(self.startDragPos.x(),
                                      self.endDragPos.y(), self.endDragPos.x(),
                                      self.startDragPos.y())
                self.map.zoom_to_box(self.map.view_transform().backward(env))
                self.updateMap()
            if self.toolMode == 2:
                self.scale = True
                w = self.startDragPos.x() - self.endDragPos.x()
                h = self.startDragPos.y() - self.endDragPos.y()
                self.zoomPos = QPoint(self.endDragPos.x() + w / 2,
                                      self.endDragPos.y() + h / 2)
                self.total_scale *= (((self.width() / w) +
                                      (self.height() / h)) / 2) * 0.8
                self.updateMap()
예제 #3
0
 def set_center_and_radius(self, lon, lat, radius=None, geographic=True):
     coords = mapnik.Coord(lon, lat)
     box = mapnik.Envelope(coords.x - radius, coords.y - radius,
                           coords.x + radius, coords.y + radius)
     if geographic and not self.proj_obj.geographic:
         box = box.forward(self.proj_obj)
     self.zoom_to_box(box)
def render_tile(mapfile, tile_uri, x, y, z):
	m = mapnik.Map(256, 256)

	# Load style XML
	mapnik.load_map(m, mapfile, True)

	# Obtain <Map> projection
	prj = mapnik.Projection(m.srs)

	# Projects between tile pixel co-ordinates and LatLong (EPSG:4326)
	tileproj = GoogleProjection(z+1)

	# Calculate pixel positions of bottom-left & top-right
	p0 = (x * 256, (y + 1) * 256)
	p1 = ((x + 1) * 256, y * 256)

	# Convert to LatLong (EPSG:4326)
	l0 = tileproj.fromPixelToLL(p0, z);
	l1 = tileproj.fromPixelToLL(p1, z);

	# Convert to map projection (e.g. mercator co-ords EPSG:900913)
	c0 = prj.forward(mapnik.Coord(l0[0],l0[1]))
	c1 = prj.forward(mapnik.Coord(l1[0],l1[1]))

	# Bounding box for the tile
	bbox = mapnik.Envelope(c0.x,c0.y, c1.x,c1.y)
	render_size = 256
	m.resize(render_size, render_size)
	m.zoom_to_box(bbox)
	m.buffer_size = 128

	# Render image with default Agg renderer
	im = mapnik.Image(render_size, render_size)
	mapnik.render(m, im)
	im.save(tile_uri, 'png256')
예제 #5
0
    def updateMap(self):
        self.timer.stop()
        if self.drag:
            cx = int(0.5 * self.map.width)
            cy = int(0.5 * self.map.height)
            dpos = self.endDragPos - self.startDragPos
            self.map.pan(cx - dpos.x(), cy - dpos.y())
            self.drag = False
        elif self.scale:
            ma = QMatrix()
            ma.translate(self.zoomPos.x(), self.zoomPos.y())
            ma.scale(self.total_scale, self.total_scale)
            ma.translate(-self.zoomPos.x(), -self.zoomPos.y())

            rect = ma.mapRect(QRectF(0, 0, self.map.width, self.map.height))
            env = mapnik.Envelope(rect.left(), rect.bottom(), rect.right(),
                                  rect.top())
            self.map.zoom_to_box(self.map.view_transform().backward(env))
            self.total_scale = 1.0
            self.scale = False

        im = mapnik.Image(self.map.width, self.map.height)
        mapnik.render(self.map, im)
        self.qim.loadFromData(QByteArray(im.tostring('png')))
        self.update()
예제 #6
0
    def __std_render(self, parameters, filename):
        merc = mapnik.Projection(
            '+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs +over'
        )
        longlat = mapnik.Projection(
            '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')

        imgwidth = math.trunc(parameters.pagewidth / inch * parameters.dpi)
        imgheight = math.trunc(parameters.pageheight / inch * parameters.dpi)

        m = mapnik.Map(imgwidth, imgheight)
        mapnik.load_map(m, parameters.mapstyle)
        m.srs = merc.params()

        if hasattr(mapnik, 'Box2d'):
            bbox = mapnik.Box2d(self.minlon, self.minlat, self.maxlon,
                                self.maxlat)
        else:
            bbox = mapnik.Envelope(self.minlon, self.minlat, self.maxlon,
                                   self.maxlat)

        transform = mapnik.ProjTransform(longlat, merc)
        merc_bbox = transform.forward(bbox)
        m.zoom_to_box(merc_bbox)

        #pdfprint = mapnik.printing.PDFPrinter(pagesize=[ (pagewidthcm+2) / 100, (pageheightcm+2) / 100], resolution=dpi)
        #pdfprint.render_map(m, filename)
        #context = pdfprint.get_context()
        #pdfprint.render_scale(m, ctx=context)
        #pdfprint.render_legend(m, ctx=context, attribution="(c) OpenStreetMap contributors")
        mapnik.render_to_file(m, filename, parameters.output_format)
예제 #7
0
def render(mapfile,
           dst_img,
           mm_width,
           mm_height,
           bounds,
           dpi=300,
           nztm_style='style-nztm.xml'):
    ''' Render an image with mapnik from an *.xml style file '''

    # create a version of the source style document in NZTM
    set_projection(mapfile, dst_path=nztm_style)

    # convert mm to pixels
    pixel_width = mm_to_pixels(mm_width, dpi)
    pixel_height = mm_to_pixels(mm_height, dpi)
    print('Rendering {} @ {} x {} pixels @ {} dpi'.format(
        dst_img, pixel_width, pixel_height, dpi))

    # create the output map
    m = mapnik.Map(pixel_width, pixel_height)
    # load style rules & set bounding box
    mapnik.load_map(m, nztm_style)
    bbox = mapnik.Envelope(mapnik.Coord(bounds[0], bounds[1]),
                           mapnik.Coord(bounds[2], bounds[3]))
    m.zoom_to_box(bbox)
    # render map & save
    mapnik.render_to_file(m, dst_img)
    print('Rendered {} @ {} x {} pixels'.format(dst_img, pixel_width,
                                                pixel_height))
    def render_tile(self, tile_uri, x, y, z):
        # Calculate pixel positions of bottom-left & top-right
        p0 = (x * 256, (y + 1) * 256)
        p1 = ((x + 1) * 256, y * 256)

        # Convert to LatLong (EPSG:4326)
        l0 = self.tileproj.fromPixelToLL(p0, z)
        l1 = self.tileproj.fromPixelToLL(p1, z)

        # Convert to map projection (e.g. mercator co-ords EPSG:900913)
        c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1]))
        c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1]))

        # Bounding box for the tile
        if hasattr(mapnik,
                   'mapnik_version') and mapnik.mapnik_version() >= 800:
            bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
        else:
            bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
        render_size = 256
        self.m.resize(render_size, render_size)
        self.m.zoom_to_box(bbox)
        self.m.buffer_size = 128

        # Render image with default Agg renderer
        im = mapnik.Image(render_size, render_size)
        mapnik.render(self.m, im)
        im.save(tile_uri, 'png256')
예제 #9
0
    def save(self, out, format):

        if format not in ('PNG'):
            raise KnownUnknown('We only saves .png tiles, not "%s"' % format)

        if not self.data['has_stuff']:
            im = Image.new('RGBA', (self.width, self.height))
            im.save(out, 'PNG')
            return

        fh, tmpfile = tempfile.mkstemp('.json')

        os.write(fh, json.dumps(self.data['geojson']))
        os.close(fh)

        map = mapnik.Map(0, 0)
        map.srs = '+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs'

        datasource = mapnik.Ogr(base=os.path.dirname(tmpfile),
                                file=os.path.basename(tmpfile),
                                layer='OGRGeoJSON')
        os.unlink(tmpfile)

        lyr = mapnik.Layer('xapi_raster')
        lyr.srs = '+proj=latlong +datum=WGS84'
        lyr.datasource = datasource

        style = mapnik.Style()
        rule = mapnik.Rule()

        if self.data['filltype'] == 'line':
            fill = mapnik.Color(str(self.data['fill']))
            # TO DO: make me a config flag
            # rule.symbols.append(mapnik.LineSymbolizer(fill, 1.0))
            rule.symbols.append(mapnik.LineSymbolizer(fill, 3.0))
            style.rules.append(rule)
        else:
            fill = mapnik.Color(str(self.data['fill']))
            rule.symbols.append(mapnik.PolygonSymbolizer(fill))
            style.rules.append(rule)

        map.append_style('xapi_raster', style)

        lyr.styles.append('xapi_raster')
        map.layers.append(lyr)

        xmin, ymin, xmax, ymax = self.data['bbox']
        env = mapnik.Envelope(xmin, ymin, xmax, ymax)

        map.width = self.width
        map.height = self.height
        map.zoom_to_box(env)

        img = mapnik.Image(self.width, self.height)
        mapnik.render(map, img)

        img = Image.fromstring('RGBA', (self.width, self.height),
                               img.tostring())
        img.save(out, 'PNG')
예제 #10
0
    def render(self):
        """ Renders the request, returning a binary in the specified format. """
        map_size = self.get_size()
        map, data_layers = self.factory.getMap(self.map_definition, map_size)

        geojson_file = tempfile.NamedTemporaryFile(suffix='.json')
        try:
            # write the JSON to a temporary file
            geojson_file.write(str(self))
            geojson_file.flush()

            # find the layer definition(s) in the map xml and update it
            # to point to our temporary file
            geojson_dir, geojson_filename = os.path.split(geojson_file.name)
            for layer in data_layers:
                layer.datasource = mapnik.Ogr(base=geojson_dir,
                                              file=geojson_filename,
                                              layer='OGRGeoJSON')

            # set the map extent
            if self.bbox_image:
                # specified extent
                map_bbox = mapnik.Envelope(
                    mapnik.Coord(self.bbox_image[0], self.bbox_image[1]),
                    mapnik.Coord(self.bbox_image[2], self.bbox_image[3]))
                map.zoom_to_box(map_bbox)
            else:
                # zoom to the extent of our data layers
                extent = data_layers[0].envelope()
                for l in data_layers[1:]:
                    extent += layer.envelope()
                map.zoom_to_box(extent)

            # if we have a buffer, apply it
            if self.bbox_image_buffer:
                extent = map.envelope()
                units = self.bbox_image_buffer[1].lower()
                if units == 'map':
                    # map-units
                    buffer = self.bbox_image_buffer[0]
                    extent.expand_to_include(extent.minx - buffer,
                                             extent.miny - buffer)
                    extent.expand_to_include(extent.maxx + buffer,
                                             extent.maxy + buffer)
                elif units == 'px':
                    # pixels
                    map.buffer_size = self.bbox_image_buffer[0]
                    extent = map.buffered_envelope()
                else:
                    self.L.warn("Unknown bbox_image_buffer units: %s", units)

                # reapply our new extent
                map.zoom_to_box(extent)

            # render it
            return self._render_surface(map, map_size)

        finally:
            geojson_file.close()
예제 #11
0
    def renderTile(self, tile):
        import mapnik, StringIO
        import PIL.Image

        if self.mapnik:
            m = self.mapnik
        else:
            if self.fonts:
                engine = mapnik.FontEngine.instance()
                for font in self.fonts:
                    engine.register_font(font)

            # Init it as 0,0
            m = mapnik.Map(0, 0)
            mapnik.load_map(m, self.mapfile)

            if self.projection:
                m.srs = self.projection

            # Restrict layer list, if requested
            if self.layers and self.layers != self.name:
                layers = self.layers.split(",")
                for layer_num in range(len(m.layers) - 1, -1, -1):
                    l = m.layers[layer_num]
                    if l.name not in layers:
                        del m.layers[layer_num]
                    if self.debug:
                        print >> sys.stderr, "Removed layer %s loaded from %s, not in list: %s" % (
                            l.name, self.mapfile, layers)

            # this will insure that it gets cached in mod_python
            self.mapnik = m

        # Set the mapnik size to match the size of the current tile
        m.width = tile.size()[0]
        m.height = tile.size()[1]

        bbox = tile.bounds()
        bbox = mapnik.Envelope(bbox[0], bbox[1], bbox[2], bbox[3])
        m.zoom_to_box(bbox)

        im = mapnik.Image(*tile.size())
        mapnik.render(m, im)
        if hasattr(im, 'tostring'):
            data = im.tostring()
        elif hasattr(mapnik, 'rawdata'):
            data = mapnik.rawdata(im)
        else:
            raise Exception(
                "Something is wrong: your version of Mapnik can't create a string from an image."
            )
        im = PIL.Image.fromstring('RGBA', tile.size(), data)
        buffer = StringIO.StringIO()
        im.save(buffer, self.extension)
        buffer.seek(0)
        tile.data = buffer.read()
        return tile.data
예제 #12
0
    def render_tile(self) -> bytes:
        """
        generate tile or load it from redis cache
        :return:  tile as png image in bytes format
        """
        tile_name: str = '/tmp/{}-{}-{}-{}.png'.format(
            self.request_date_to_string(), self.zoom, self.x_pixel,
            self.y_pixel)

        if env.bool("CACHE", default=False):
            # try if exists to get cache style_xml
            try:
                tile_content = cache.get(tile_name)
                if tile_content:
                    return tile_content
            except (redis.exceptions.ConnectionError,
                    redis.exceptions.DataError) as exc:
                print(exc)

        os.chdir(os.environ['STYLE_PATH'])
        map: mapnik.Map = mapnik.Map(self.width, self.height)
        mapnik.load_map_from_string(map, self.generate_date_style_xml())

        prj: mapnik.Projection = mapnik.Projection(
            "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs +over"
        )

        p0 = self.from_px_to_ll(
            (self.width * self.x_pixel, self.height * (self.y_pixel + 1)),
            self.zoom)
        p1 = self.from_px_to_ll(
            (self.width * (self.x_pixel + 1), self.height * self.y_pixel),
            self.zoom)
        c0 = prj.forward(mapnik.Coord(p0[0], p0[1]))
        c1 = prj.forward(mapnik.Coord(p1[0], p1[1]))

        bbox: mapnik.Envelope = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)

        map.zoom_to_box(bbox)
        image: mapnik.Image = mapnik.Image(self.width, self.height)
        mapnik.render(map, image)

        # todo generate tile without save it to hdd
        mapnik.render_to_file(map, tile_name)
        tile_content: bytes = open(tile_name, 'rb').read()
        os.remove(tile_name)

        if env.bool("CACHE", default=False):
            # upload style_xml file to redis cache
            cache.set(tile_name,
                      tile_content,
                      ex=env.int("CAHCE_EXPIRE_TIME", default=3600))

        return tile_content
예제 #13
0
 def set_center_and_zoom(self, lon, lat, level=0, geographic=True):
     coords = mapnik.Coord(lon, lat)
     if geographic and not self.proj_obj.geographic:
         coords = coords.forward(self.proj_obj)
     w, h = self.width, self.height
     res = self.get_scale_for_zoom_level(level)
     box = mapnik.Envelope(coords.x - 0.5 * w * res,
                           coords.y - 0.5 * h * res,
                           coords.x + 0.5 * w * res,
                           coords.y + 0.5 * h * res)
     self.zoom_to_box(box)
예제 #14
0
 def xyz_to_envelope(self,x,y,zoom, tms_style=False, count=1):
     """ Convert XYZ to mapnik.Envelope """
     # flip y to match TMS spec
     if tms_style:
         y = (2**zoom-1) - y
     ll = (x * self.size,(y + count) * self.size)
     ur = ((x + count) * self.size, y * self.size)
     minx,miny = self.px_to_ll(ll,zoom)
     maxx,maxy = self.px_to_ll(ur,zoom)
     lonlat_bbox = mapnik.Envelope(minx,miny,maxx,maxy)
     env = mercator.forward(lonlat_bbox)
     return env
def render(parameters):
    if not parameters.verbose:
        mapnik.logger.set_severity(getattr(mapnik.severity_type, 'None'))

    merc = mapnik.Projection(
        '+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs +over'
    )
    longlat = mapnik.Projection(
        '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')

    imgwidth = math.trunc(parameters.pagewidth / inch * parameters.dpi)
    imgheight = math.trunc(parameters.pageheight / inch * parameters.dpi)

    m = mapnik.Map(imgwidth, imgheight)
    mapnik.load_map(m, parameters.mapstyle)
    mapnik.load_map(m, parameters.hikingmapstyle)
    m.srs = merc.params()

    if hasattr(mapnik, 'Box2d'):
        bbox = mapnik.Box2d(parameters.minlon, parameters.minlat,
                            parameters.maxlon, parameters.maxlat)
    else:
        bbox = mapnik.Envelope(parameters.minlon, parameters.minlat,
                               parameters.maxlon, parameters.maxlat)

    transform = mapnik.ProjTransform(longlat, merc)
    merc_bbox = transform.forward(bbox)
    m.zoom_to_box(merc_bbox)

    for gpxfile in parameters.gpxfiles:
        gpxlayer = mapnik.Layer('GPXLayer')
        gpxlayer.datasource = mapnik.Ogr(file=gpxfile, layer='tracks')
        gpxlayer.styles.append('GPXStyle')
        m.layers.append(gpxlayer)

    if parameters.temptrackfile:
        overviewlayer = mapnik.Layer('OverviewLayer')
        overviewlayer.datasource = mapnik.Ogr(file=parameters.temptrackfile,
                                              layer='tracks')
        overviewlayer.styles.append('GPXStyle')
        m.layers.append(overviewlayer)

    if parameters.tempwaypointfile:
        waypointlayer = mapnik.Layer('WaypointLayer')
        waypointlayer.datasource = mapnik.Ogr(file=parameters.tempwaypointfile,
                                              layer='waypoints')
        waypointlayer.styles.append('WaypointStyle')
        m.layers.append(waypointlayer)

    mapnik.render_to_file(
        m, parameters.basefilename + "." + parameters.output_format,
        parameters.output_format, parameters.scale_factor)
예제 #16
0
    def __std_render(self, parameters, tempwaypointfile, filename):
        merc = mapnik.Projection(
            '+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs +over'
        )
        longlat = mapnik.Projection(
            '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')

        imgwidth = math.trunc(self.get_page_width() / inch * parameters.dpi)
        imgheight = math.trunc(self.get_page_height() / inch * parameters.dpi)

        m = mapnik.Map(imgwidth, imgheight)
        mapnik.load_map(m, parameters.mapstyle)
        mapnik.load_map(m, parameters.hikingmapstyle)
        m.srs = merc.params()

        if hasattr(mapnik, 'Box2d'):
            bbox = mapnik.Box2d(self.minlon, self.minlat, self.maxlon,
                                self.maxlat)
        else:
            bbox = mapnik.Envelope(self.minlon, self.minlat, self.maxlon,
                                   self.maxlat)

        transform = mapnik.ProjTransform(longlat, merc)
        merc_bbox = transform.forward(bbox)
        m.zoom_to_box(merc_bbox)

        for gpxfile in parameters.gpxfiles:
            gpxlayer = mapnik.Layer('GPXLayer')
            gpxlayer.datasource = mapnik.Ogr(file=gpxfile, layer='tracks')
            gpxlayer.styles.append('GPXStyle')
            m.layers.append(gpxlayer)

        if parameters.waypt_distance > 0:
            waypointlayer = mapnik.Layer('WaypointLayer')
            waypointlayer.datasource = mapnik.Ogr(file=tempwaypointfile,
                                                  layer='waypoints')
            waypointlayer.styles.append('WaypointStyle')
            m.layers.append(waypointlayer)

        #pdfprint = mapnik.printing.PDFPrinter(pagesize = [ 0.21, 0.297 ], \
        #                                      margin = 0.005, resolution = parameters.dpi)
        #context = pdfprint.get_cairo_context()
        #pdfprint.render_scale(m, ctx=context)
        #pdfprint.render_legend(m, ctx=context, attribution="(c) OpenStreetMap contributors")
        #pdfprint.render_map(m, filename)

        #im = mapnik.Image(m.width, m.height)
        #mapnik.render(m, im)
        #im.save(filename, parameters.output_format)

        mapnik.render_to_file(m, filename, parameters.output_format)
예제 #17
0
def pure_tile_rendering(args):

    tile_dir = args[0]
    mapfile = args[1]
    maxZoom = args[2]
    tile_uri = args[3]
    x = args[4]
    y = args[5]
    z = args[6]

    #not needed anymore, as the mapnik.map is sent directly to the function
    m = mapnik.Map(256, 256)
    # Load style XML
    mapnik.load_map_from_string(m, mapfile)
    # Obtain <Map> projection
    prj = mapnik.Projection(m.srs)
    # Projects between tile pixel co-ordinates and LatLong (EPSG:4326)
    tileproj = GoogleProjection(maxZoom + 1)

    tile = (x, y)
    #print 'Tile: ', tile
    # Calculate pixel positions of bottom-left & top-right
    p0 = (tile[0] * 256, (tile[1] + 1) * 256)
    p1 = ((tile[0] + 1) * 256, tile[1] * 256)
    # Convert to LatLong (EPSG:4326)
    l0 = tileproj.fromPixelToLL(p0, z)
    l1 = tileproj.fromPixelToLL(p1, z)
    # Convert to map projection (e.g. mercator co-ords EPSG:900913)
    c0 = prj.forward(mapnik.Coord(l0[0], l0[1]))
    c1 = prj.forward(mapnik.Coord(l1[0], l1[1]))

    #c0, c1 = calcTileCoordinates(tile, z)
    tile_extent = (c0.x, c0.y, c1.x, c1.y)

    # Bounding box for the tile
    bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
    m.zoom_to_box(bbox)

    # Render image with default Agg renderer
    im = mapnik.Image(m.height, m.width)
    mapnik.render(m, im)
    im.save(tile_uri, 'png256')
    return m.scale() / 0.00028
예제 #18
0
	def get_bbox(self):
		# Calculate pixel positions of bottom-left & top-right
		p0 = (self.mtx0 * TILE_SIZE, (self.mty0 + self.metatile) * TILE_SIZE)
		p1 = ((self.mtx0 + self.metatile) * TILE_SIZE, self.mty0 * TILE_SIZE)

		# Convert to LatLong (EPSG:4326)
		l0 = self.tileproj.fromPixelToLL(p0, self.zoom);
		l1 = self.tileproj.fromPixelToLL(p1, self.zoom);

		# Convert to map projection (e.g. mercator co-ords EPSG:900913)
		c0 = self.prj.forward(mapnik.Coord(l0[0],l0[1]))
		c1 = self.prj.forward(mapnik.Coord(l1[0],l1[1]))

		# Bounding box for the tile
		if hasattr(mapnik,'mapnik_version') and mapnik.mapnik_version() >= 800:
			bbox = mapnik.Box2d(c0.x,c0.y, c1.x,c1.y)
		else:
			bbox = mapnik.Envelope(c0.x,c0.y, c1.x,c1.y)
		return bbox
예제 #19
0
    def get_bbox(self, x, y, z):
        # Calculate pixel positions of bottom-left & top-right
        p0 = (x * self.render_size, (y + 1) * self.render_size)
        p1 = ((x + 1) * self.render_size, y * self.render_size)

        # Convert to LatLong (EPSG:4326)
        l0 = self.tileproj.fromPixelToLL(p0, z)
        l1 = self.tileproj.fromPixelToLL(p1, z)

        # Convert to map projection (e.g. mercator co-ords EPSG:900913)
        c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1]))
        c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1]))

        # Bounding box for the tile
        if hasattr(mapnik,
                   'mapnik_version') and mapnik.mapnik_version() >= 800:
            return mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
        else:
            return mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
예제 #20
0
파일: views.py 프로젝트: Gndsig/tilecalc
def mapnik_tiles(request):
    global MAP_CACHE
    w, h = int(request.GET['WIDTH']), int(request.GET['HEIGHT'])
    mime = request.GET['FORMAT']
    if not MAP_CACHE:
        MAP_CACHE = MapCache(request)
    env = map(float, request.GET['BBOX'].split(','))
    tile = MAP_CACHE.map
    tile.buffer_size = 128
    tile.resize(w, h)
    tile.zoom_to_box(mapnik.Envelope(*env))
    draw = mapnik.Image(tile.width, tile.height)
    mapnik.render(tile, draw)
    image = draw.tostring(str(mime.split('/')[1]))
    response = HttpResponse()
    response['Content-length'] = len(image)
    response['Content-Type'] = mime
    response.write(image)
    return response
def render_tile(m, z, x, y, scale, dir, type, lock=None, threadnum=None):
    n = 2**z
    n2 = n / 2
    x2n = x - n2
    y2n = (n - y - 1) - n2

    tilesize = float(scale) / float(n)

    bbox = [
        tilesize * x2n, tilesize * y2n, tilesize * (x2n + 1),
        tilesize * (y2n + 1)
    ]
    pdir = dir + "/" + str(z) + "/" + str(x)

    if lock:
        lock.acquire()
        print "Thread #%u: z=%u x=%u y=%u -> (%f,%f,%f,%f)" % (
            threadnum, z, x, y, bbox[0], bbox[1], bbox[2], bbox[3])
        if not os.path.exists(pdir):
            os.makedirs(pdir)
        lock.release()
    else:
        if not os.path.exists(pdir):
            os.makedirs(pdir)
        print "z=%u x=%u y=%u -> (%f,%f,%f,%f)" % (z, x, y, bbox[0], bbox[1],
                                                   bbox[2], bbox[3])

    if mapnik.Box2d:
        e = mapnik.Box2d(*bbox)
    else:
        e = mapnik.Envelope(*bbox)

    # zoom map to bounding box
    m.zoom_to_box(e)

    file = dir + "/" + str(z) + "/" + str(x) + "/" + str(y) + "." + type
    s = mapnik.Image(256, 256)

    mapnik.render(m, s)

    view = s.view(0, 0, 256, 256)
    view.save(file, type)
예제 #22
0
def simpleRendering(image, stylesheet, extent):
    mapfile = stylesheet
    map_uri = image

    imgx = 256
    imgy = 256

    m = mapnik.Map(imgx, imgy)
    mapnik.load_map(m, mapfile)
    #print 'simple Rendering'
    #print m.layers

    if hasattr(mapnik, 'mapnik_version') and mapnik.mapnik_version() >= 800:
        bbox = mapnik.Box2d(extent[0], extent[2], extent[1], extent[3])
    else:
        bbox = mapnik.Envelope(extent[0], extent[2], extent[1], extent[3])
    m.zoom_to_box(bbox)
    im = mapnik.Image(imgx, imgy)
    mapnik.render(m, im)
    view = im.view(0, 0, imgx, imgy)  # x,y,width,height
    view.save(map_uri, 'png')
    def render_tile(self, tile_dir, x, y, z):
        # Calculate pixel positions of bottom-left & top-right
        p0 = (x * 256 * aggregate, (y + 1) * 256 * aggregate)
        p1 = ((x + 1) * 256 * aggregate, y * 256 * aggregate)

        # Convert to LatLong (EPSG:4326)
        l0 = self.tileproj.fromPixelToLL(p0, z)
        l1 = self.tileproj.fromPixelToLL(p1, z)

        # Convert to map projection (e.g. mercator co-ords EPSG:900913)
        c0 = self.prj.forward(mapnik.Coord(l0[0], l0[1]))
        c1 = self.prj.forward(mapnik.Coord(l1[0], l1[1]))

        # Bounding box for the tile
        if hasattr(mapnik,
                   'mapnik_version') and mapnik.mapnik_version() >= 800:
            bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
        else:
            bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
        render_size = 256 * aggregate
        self.m.resize(render_size, render_size)
        self.m.zoom_to_box(bbox)
        self.m.buffer_size = 128

        # Render image with default Agg renderer
        im = mapnik.Image(render_size, render_size)
        mapnik.render(self.m, im)

        for i in range(0, aggregate):
            # check if we have directories in place
            str_x = "%s" % (x * aggregate + i)
            zoom = "%s" % z
            if not os.path.isdir(tile_dir + zoom + '/' + str_x):
                os.mkdir(tile_dir + zoom + '/' + str_x)
            for j in range(0, aggregate):
                view = im.view(i * 256, j * 256, 256, 256)
                #print(i*256,j*256,(i+1)*256,(j+1)*256)
                str_y = "%s" % (y * aggregate + j)
                tile_uri = tile_dir + zoom + '/' + str_x + '/' + str_y + '.png'
                view.save(tile_uri, 'png256')
예제 #24
0
파일: sources.py 프로젝트: osuchw/landez
    def render(self, bbox, width=None, height=None):
        """
        Render the specified tile with Mapnik
        """
        width = width or self.tilesize
        height = height or self.tilesize
        if not self._mapnik:
            self._mapnik = mapnik.Map(width, height)
            # Load style XML
            mapnik.load_map(self._mapnik, self.stylefile, True)
            # Obtain <Map> projection
            self._prj = mapnik.Projection(self._mapnik.srs)

        # Convert to map projection
        assert len(bbox) == 4, _(
            "Provide a bounding box tuple (minx, miny, maxx, maxy)")
        c0 = self._prj.forward(mapnik.Coord(bbox[0], bbox[1]))
        c1 = self._prj.forward(mapnik.Coord(bbox[2], bbox[3]))

        # Bounding box for the tile
        if hasattr(mapnik,
                   'mapnik_version') and mapnik.mapnik_version() >= 800:
            bbox = mapnik.Box2d(c0.x, c0.y, c1.x, c1.y)
        else:
            bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)

        self._mapnik.resize(width, height)
        self._mapnik.zoom_to_box(bbox)
        self._mapnik.buffer_size = 128

        # Render image with default Agg renderer
        tmpfile = NamedTemporaryFile(delete=False)
        im = mapnik.Image(width, height)
        mapnik.render(self._mapnik, im)
        im.save(tmpfile.name, 'png256')  # TODO: mapnik output only to file?
        tmpfile.close()
        content = open(tmpfile.name).read()
        os.unlink(tmpfile.name)
        return content
예제 #25
0
    def __call__(self, req):
        """
        """
        print
        print 'Using %s' % self.mapfile
        print
        bbox = req.get('BBOX')
        env = map(float, bbox.split(','))
        bbox = mapnik.Envelope(*env)

        if self.singletile:
            self.mapnik_map.width, self.mapnik_map.height = int(
                req.get('WIDTH')), int(req.get('HEIGHT'))

        self.mapnik_map.zoom_to_box(bbox)
        draw = mapnik.Image(self.mapnik_map.width, self.mapnik_map.height)
        mapnik.render(self.mapnik_map, draw)
        image = draw.tostring('png256')

        response = z.Response(image, status=200, mimetype=self.mime)
        response.content_length = len(image)
        return response
예제 #26
0
    def render_meta(self, m, style, x, y, z, sz):
        # Calculate pixel positions of bottom-left & top-right
        p0 = (x * 256, (y + sz) * 256)
        p1 = ((x + sz) * 256, y * 256)

        # Convert to LatLong (EPSG:4326)
        l0 = self.tileproj.fromPixelToLL(p0, z)
        l1 = self.tileproj.fromPixelToLL(p1, z)

        # Convert to map projection (e.g. mercator co-ords EPSG:900913)
        c0 = self.prj[style].forward(mapnik.Coord(l0[0], l0[1]))
        c1 = self.prj[style].forward(mapnik.Coord(l1[0], l1[1]))

        # Bounding box for the meta-tile
        bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
        render_size = 256 * sz
        m.resize(render_size, render_size)
        m.zoom_to_box(bbox)
        m.buffer_size = 128

        im = self.render_with_agg(m, render_size)
        #im = self.render_with_cairo(m, render_size)
        return self.split_meta_image(im, sz)
예제 #27
0
    def generate_image(self, xml, filename, ext, ftype, ll, dx, dy, res,
                       verbose, force):
        print "generate_image:", xml, filename
        mapfile = xml

        merc = "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs +over"
        latlon = "+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs"

        m = mapnik.Map(dx, dy)

        mapnik.load_map(m, mapfile)

        # Override projection defined in mapfile
        m.srs = latlon
        #m.srs 	= merc

        # Calculate projected boundaries
        prj = mapnik.Projection(m.srs)
        c0 = prj.forward(mapnik.Coord(ll[0], ll[1]))
        c1 = prj.forward(mapnik.Coord(ll[2], ll[3]))

        # Apply bounding box
        bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
        m.zoom_to_box(bbox)

        # Render image
        im = mapnik.Image(dx, dy)
        mapnik.render(m, im)

        view = im.view(0, 0, dx, dy)

        png_file = filename + ext  #".png"

        if force or not os.path.isfile(png_file):
            if verbose:
                print("saving " + png_file)
            view.save(png_file, ftype)
예제 #28
0
def render_tile(tile_uri, x, y, z):
    #print tile_uri,":",z,x,y
    # Calculate pixel positions of bottom-left & top-right
    p0 = (x * 256, (y + 1) * 256)
    p1 = ((x + 1) * 256, y * 256)

    # Convert to LatLong (EPSG:4326)
    l0 = tileproj.fromPixelToLL(p0, z)
    l1 = tileproj.fromPixelToLL(p1, z)

    # Convert to map projection (e.g. mercator co-ords EPSG:900913)
    c0 = prj.forward(mapnik.Coord(l0[0], l0[1]))
    c1 = prj.forward(mapnik.Coord(l1[0], l1[1]))

    bb = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
    render_size = 256
    m.resize(render_size, render_size)
    m.zoom_to_box(bb)
    m.buffer_size = 128

    # Render image with default Agg renderer
    im = mapnik.Image(render_size, render_size)
    mapnik.render(m, im)
    im.save(tile_uri, 'png256')
def draw_district_outline(statefp, state, district, shpfeature, map_size, contextmap) :
	# Create an image with district outlines and shading over the parts of the map
	# in other districts or other states. Also compute our desired bounding box.

	# Get bounding box of this map, which will be a little larger than the boudning box of the district.
	long_min, long_max, lat_min, lat_max = shpfeature.GetGeometryRef().GetEnvelope()
	margin = 0.06
	if contextmap :
		margin = 1.5
	d_long = long_max-long_min
	d_lat = lat_max-lat_min
	long_min -= d_long*margin
	long_max += d_long*margin
	lat_min -= d_lat*margin
	lat_max += d_lat*margin

	# Choose an aspect ratio for the final image that is a good match for
	# the shape of the district. We have two choices. We could use nice-looking
	# aspect ratios or we could use aspect ratios that match common sizes of
	# paper so that the map can be printed nicely.
	good_aspect_ratios = [
		(3.0,    3.0/1.0), # 8.5x17 tabloid landscape
		(1.5,   16.0/9.0), # HD widescreen
		(1.25,  11.0/8.5), # 8.5x11 letter landscape
		(1/1.25, 1.0/1.0), # square
		(1/1.5,  8.5/11.0), # 8.5x11 letter portrait
		(0,      8.5/17.0), # 8.5x17 tabloid portrait
		]

	for threshold, ratio in good_aspect_ratios:
		if d_long/d_lat > threshold:
			if ratio > 1.0:
				map_width = int(ratio * map_size)
				map_height = map_size
			else:
				map_width = map_size
				map_height = int(map_size / ratio)
			break
	
	# Create a map.
	m = mapnik.Map(map_width, map_height, output_projection)

	# Center to the projected coordinates.
	bounds = (mapnik.Projection(output_projection).forward( mapnik.Projection(census_shapefile_projection).inverse(mapnik.Coord(long_min, lat_min)) ),
			mapnik.Projection(output_projection).forward( mapnik.Projection(census_shapefile_projection).inverse(mapnik.Coord(long_max, lat_max)) ))
	m.zoom_to_box(mapnik.Envelope(bounds[0].x, bounds[0].y, bounds[1].x, bounds[1].y))

	if not contextmap :
		# Add a layer for counties and ZCTAs.
		# TODO: These should really be generated with the map tile layer
		# so that the labels don't hit each other.
		for layer, featurename, labelfontsize, labelcolor, border in (
				("county", "NAME", map_size/40, mapnik.Color('rgb(70%,20%,20%)'), True),
				("zcta510", "ZCTA5CE10", map_size/60, mapnik.Color('rgb(40%,40%,80%)'), False),
				):
			s = mapnik.Style()
			r = mapnik.Rule()
			if border:
				p = mapnik.LineSymbolizer(labelcolor, map_size/300)
				p.stroke.opacity = .3
				p.stroke.add_dash(.1, .1)
				r.symbols.append(p)
			r.symbols.append(mapnik.TextSymbolizer(mapnik.Expression('[%s]' % featurename), mapnik_label_font, labelfontsize, labelcolor))
			s.rules.append(r)
			m.append_style('%s Style' % layer, s)
			lyr = mapnik.Layer('world', census_shapefile_projection)
			lyr.datasource = mapnik.Shapefile(file=sys.argv[1] + "/tl_2013_us_%s.shp" % layer)
			lyr.styles.append('%s Style' % layer)
			m.layers.append(lyr)


	# Draw shading and numbering for the other districts.
	district_outline_color = mapnik.Color('rgb(100%,75%,25%)')
	s = mapnik.Style()
	r = mapnik.Rule()
	p = mapnik.PolygonSymbolizer(mapnik.Color('rgb(70%,70%,70%)'))
	p.fill_opacity = .55
	r.symbols.append(p)
	r.filter = mapnik.Filter("([CD113FP] <> '" + district + "' || [STATEFP] <> '" + statefp + "') && [CD113FP] != 'ZZ'")
	t = mapnik.TextSymbolizer(mapnik.Expression('[CD113FP]'), mapnik_label_font, map_size/15, district_outline_color)
	t.halo_radius = map_size/120
	r.symbols.append(t)
	s.rules.append(r)

	# Draw the outlines of districts. Use a hard thin outline to be exact plus
	# a faded wider outline for strength.
	r = mapnik.Rule()
	p = mapnik.LineSymbolizer(district_outline_color, 2)
	r.symbols.append(p)
	p = mapnik.LineSymbolizer(district_outline_color, map_size/140)
	p.stroke.opacity = .35
	r.symbols.append(p)
	s.rules.append(r)

	m.append_style('Other Districts Style',s)
	lyr = mapnik.Layer('world', census_shapefile_projection)
	lyr.datasource = mapnik.Shapefile(file=sys.argv[1] + "/tl_2013_us_cd113.shp")
	lyr.styles.append('Other Districts Style')
	m.layers.append(lyr)

	im = mapnik.Image(map_width, map_height)
	mapnik.render(m, im)

	env = m.envelope()
	env = ( mapnik.Projection(output_projection).inverse(mapnik.Coord(env[0], env[1])), mapnik.Projection(output_projection).inverse(mapnik.Coord(env[2], env[3])) )
	return im, env
        map_uri = options.name
        m = mapnik.Map(img[0], img[1])

        mapnik.load_map(m, mapfile)

        # Override projection defined in mapfile
        m.srs = latlon
        #m.srs 	= merc

        # Calculate projected boundaries
        prj = mapnik.Projection(m.srs)
        c0 = prj.forward(mapnik.Coord(bounds[0], bounds[1]))
        c1 = prj.forward(mapnik.Coord(bounds[2], bounds[3]))

        # Apply bounding box
        bbox = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
        m.zoom_to_box(bbox)

        # Render image
        im = mapnik.Image(img[0], img[1])
        mapnik.render(m, im)

        view = im.view(0, 0, img[0], img[1])

        if force or not os.path.isfile(map_uri):
            if verbose:
                print("saving " + map_uri)
            view.save(map_uri)

        if verbose:
            print 'output image to %s!\n' % map_uri