code stringlengths 66 870k | docstring stringlengths 19 26.7k | func_name stringlengths 1 138 | language stringclasses 1
value | repo stringlengths 7 68 | path stringlengths 5 324 | url stringlengths 46 389 | license stringclasses 7
values |
|---|---|---|---|---|---|---|---|
def Resolution(self, zoom):
'''Resolution (arc/pixel) for given zoom level (measured at Equator)'''
return self.resFact / 2 ** zoom
# return 180 / float( 1 << (8+zoom) ) | Resolution (arc/pixel) for given zoom level (measured at Equator) | Resolution | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def ZoomForPixelSize(self, pixelSize):
'''Maximal scaledown zoom of the pyramid closest to the pixelSize.'''
for i in range(MAXZOOMLEVEL):
if pixelSize > self.Resolution(i):
if i != 0:
return i - 1
else:
return 0 # We don't want to scale up | Maximal scaledown zoom of the pyramid closest to the pixelSize. | ZoomForPixelSize | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def TileBounds(
self,
tx,
ty,
zoom,
):
'''Returns bounds of the given tile'''
res = self.resFact / 2 ** zoom
return (tx * self.tileSize * res - 180, ty * self.tileSize
* res - 90, (tx + 1) * self.tileSize * res - 180, (ty
+ 1) * self.tileSize * res - 90) | Returns bounds of the given tile | TileBounds | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def TileLatLonBounds(
self,
tx,
ty,
zoom,
):
'''Returns bounds of the given tile in the SWNE form'''
b = self.TileBounds(tx, ty, zoom)
return (b[1], b[0], b[3], b[2]) | Returns bounds of the given tile in the SWNE form | TileLatLonBounds | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def __init__(
self,
width,
height,
tilesize=256,
tileformat='jpg',
):
"""Initialization of the Zoomify tile tree"""
self.tilesize = tilesize
self.tileformat = tileformat
imagesize = (width, height)
tiles = (math.ceil(width / tilesize), math.ceil(height
/ tilesize))
# Size (in tiles) for each tier of pyramid.
self.tierSizeInTiles = []
self.tierSizeInTiles.push(tiles)
# Image size in pixels for each pyramid tierself
self.tierImageSize = []
self.tierImageSize.append(imagesize)
while imagesize[0] > tilesize or imageSize[1] > tilesize:
imagesize = (math.floor(imagesize[0] / 2),
math.floor(imagesize[1] / 2))
tiles = (math.ceil(imagesize[0] / tilesize),
math.ceil(imagesize[1] / tilesize))
self.tierSizeInTiles.append(tiles)
self.tierImageSize.append(imagesize)
self.tierSizeInTiles.reverse()
self.tierImageSize.reverse()
# Depth of the Zoomify pyramid, number of tiers (zoom levels)
self.numberOfTiers = len(self.tierSizeInTiles)
# Number of tiles up to the given tier of pyramid.
self.tileCountUpToTier = []
self.tileCountUpToTier[0] = 0
for i in range(1, self.numberOfTiers + 1):
self.tileCountUpToTier.append(self.tierSizeInTiles[i
- 1][0] * self.tierSizeInTiles[i - 1][1]
+ self.tileCountUpToTier[i - 1]) | Initialization of the Zoomify tile tree | __init__ | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def tilefilename(
self,
x,
y,
z,
):
"""Returns filename for tile with given coordinates"""
tileIndex = x + y * self.tierSizeInTiles[z][0] \
+ self.tileCountUpToTier[z]
return os.path.join('TileGroup%.0f' % math.floor(tileIndex
/ 256), '%s-%s-%s.%s' % (z, x, y,
self.tileformat)) | Returns filename for tile with given coordinates | tilefilename | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def process(self):
"""The main processing function, runs all the main steps of processing"""
# Opening and preprocessing of the input file
self.open_input()
# Generation of main metadata files and HTML viewers
self.generate_metadata()
# Generation of the lowest tiles
self.generate_base_tiles()
# Generation of the overview tiles (higher in the pyramid)
self.generate_overview_tiles() | The main processing function, runs all the main steps of processing | process | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def error(self, msg, details=''):
"""Print an error message and stop the processing"""
if details:
self.parser.error(msg + '''
''' + details)
else:
self.parser.error(msg) | Print an error message and stop the processing | error | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def optparse_init(self):
"""Prepare the option parser for input (argv)"""
from optparse import OptionParser, OptionGroup
usage = 'Usage: %prog [options] input_file(s) [output]'
p = OptionParser(usage, version='%prog ' + __version__)
p.add_option(
'-p',
'--profile',
dest='profile',
type='choice',
choices=profile_list,
help="Tile cutting profile (%s) - default 'mercator' (Google Maps compatible)"
% ','.join(profile_list),
)
p.add_option(
'-r',
'--resampling',
dest='resampling',
type='choice',
choices=resampling_list,
help="Resampling method (%s) - default 'average'"
% ','.join(resampling_list),
)
p.add_option('-s', '--s_srs', dest='s_srs', metavar='SRS',
help='The spatial reference system used for the source input data'
)
p.add_option('-z', '--zoom', dest='zoom',
help="Zoom levels to render (format:'2-5' or '10')."
)
p.add_option('-e', '--resume', dest='resume',
action='store_true',
help='Resume mode. Generate only missing files.')
p.add_option('-a', '--srcnodata', dest='srcnodata',
metavar='NODATA',
help='NODATA transparency value to assign to the input data'
)
p.add_option('-d', '--tmscompatible', dest='tmscompatible',
action='store_true',
help='When using the geodetic profile, specifies the base resolution as 0.703125 or 2 tiles at zoom level 0.'
)
p.add_option('-l', '--leaflet', action='store_true',
dest='leaflet',
help="Set 0,0 point to north. For use with 'leaflet'. Requires -p raster. "
)
p.add_option('--processes', dest='processes', type='int',
default=multiprocessing.cpu_count(),
help='Number of concurrent processes (defaults to the number of cores in the system)'
)
p.add_option('-v', '--verbose', action='store_true',
dest='verbose',
help='Print status messages to stdout')
# KML options
g = OptionGroup(p, 'KML (Google Earth) options',
'Options for generated Google Earth SuperOverlay metadata'
)
g.add_option('-k', '--force-kml', dest='kml',
action='store_true',
help="Generate KML for Google Earth - default for 'geodetic' profile and 'raster' in EPSG:4326. For a dataset with different projection use with caution!"
)
g.add_option('-n', '--no-kml', dest='kml', action='store_false'
,
help='Avoid automatic generation of KML files for EPSG:4326'
)
g.add_option('-u', '--url', dest='url',
help='URL address where the generated tiles are going to be published'
)
p.add_option_group(g)
# HTML options
g = OptionGroup(p, 'Web viewer options',
'Options for generated HTML viewers a la Google Maps'
)
g.add_option(
'-w',
'--webviewer',
dest='webviewer',
type='choice',
choices=webviewer_list,
help="Web viewer to generate (%s) - default 'all'"
% ','.join(webviewer_list),
)
g.add_option('-t', '--title', dest='title',
help='Title of the map')
g.add_option('-c', '--copyright', dest='copyright',
help='Copyright for the map')
g.add_option('-g', '--googlekey', dest='googlekey',
help='Google Maps API key from http://code.google.com/apis/maps/signup.html'
)
(g.add_option('-b', '--bingkey', dest='bingkey',
help='Bing Maps API key from https://www.bingmapsportal.com/'
), )
p.add_option_group(g)
# TODO: MapFile + TileIndexes per zoom level for efficient MapServer WMS
# g = OptionGroup(p, "WMS MapServer metadata", "Options for generated mapfile and tileindexes for MapServer")
# g.add_option("-i", "--tileindex", dest='wms', action="store_true"
# help="Generate tileindex and mapfile for MapServer (WMS)")
# p.add_option_group(g)
p.set_defaults(
verbose=False,
profile='mercator',
kml=False,
url='',
webviewer='all',
copyright='',
resampling='average',
resume=False,
googlekey='INSERT_YOUR_KEY_HERE',
bingkey='INSERT_YOUR_KEY_HERE',
)
self.parser = p | Prepare the option parser for input (argv) | optparse_init | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def open_input(self):
"""Initialization of the input raster, reprojection if necessary"""
gdal.UseExceptions()
gdal.AllRegister()
if not self.options.verbose:
gdal.PushErrorHandler('CPLQuietErrorHandler')
# Initialize necessary GDAL drivers
self.out_drv = gdal.GetDriverByName(self.tiledriver)
self.mem_drv = gdal.GetDriverByName('MEM')
if not self.out_drv:
raise Exception("The '%s' driver was not found, is it available in this GDAL build?"
, self.tiledriver)
if not self.mem_drv:
raise Exception("The 'MEM' driver was not found, is it available in this GDAL build?"
)
# Open the input file
if self.input:
self.in_ds = gdal.Open(self.input, gdal.GA_ReadOnly)
else:
raise Exception('No input file was specified')
if self.options.verbose:
print ('Input file:', '( %sP x %sL - %s bands)'
% (self.in_ds.RasterXSize, self.in_ds.RasterYSize,
self.in_ds.RasterCount))
if not self.in_ds:
# Note: GDAL prints the ERROR message too
self.error("It is not possible to open the input file '%s'."
% self.input)
# Read metadata from the input file
if self.in_ds.RasterCount == 0:
self.error("Input file '%s' has no raster band"
% self.input)
if self.in_ds.GetRasterBand(1).GetRasterColorTable():
# TODO: Process directly paletted dataset by generating VRT in memory
self.error('Please convert this file to RGB/RGBA and run gdal2tiles on the result.'
,
"""From paletted file you can create RGBA file (temp.vrt) by:
gdal_translate -of vrt -expand rgba %s temp.vrt
then run:
gdal2tiles temp.vrt"""
% self.input)
# Get NODATA value
self.in_nodata = []
for i in range(1, self.in_ds.RasterCount + 1):
if self.in_ds.GetRasterBand(i).GetNoDataValue() != None:
self.in_nodata.append(self.in_ds.GetRasterBand(i).GetNoDataValue())
if self.options.srcnodata:
nds = list(map(float, self.options.srcnodata.split(',')))
if len(nds) < self.in_ds.RasterCount:
self.in_nodata = (nds
* self.in_ds.RasterCount)[:self.in_ds.RasterCount]
else:
self.in_nodata = nds
if self.options.verbose:
print('NODATA: %s' % self.in_nodata)
#
# Here we should have RGBA input dataset opened in self.in_ds
#
if self.options.verbose:
print ('Preprocessed file:', '( %sP x %sL - %s bands)'
% (self.in_ds.RasterXSize, self.in_ds.RasterYSize,
self.in_ds.RasterCount))
# Spatial Reference System of the input raster
self.in_srs = None
if self.options.s_srs:
self.in_srs = osr.SpatialReference()
self.in_srs.SetFromUserInput(self.options.s_srs)
self.in_srs_wkt = self.in_srs.ExportToWkt()
else:
self.in_srs_wkt = self.in_ds.GetProjection()
if not self.in_srs_wkt and self.in_ds.GetGCPCount() != 0:
self.in_srs_wkt = self.in_ds.GetGCPProjection()
if self.in_srs_wkt:
self.in_srs = osr.SpatialReference()
self.in_srs.ImportFromWkt(self.in_srs_wkt)
# elif self.options.profile != 'raster':
# self.error("There is no spatial reference system info included in the input file.","You should run gdal2tiles with --s_srs EPSG:XXXX or similar.")
# Spatial Reference System of tiles
self.out_srs = osr.SpatialReference()
if self.options.profile == 'mercator':
self.out_srs.ImportFromEPSG(900913)
elif self.options.profile == 'geodetic':
self.out_srs.ImportFromEPSG(4326)
else:
self.out_srs = self.in_srs
# Are the reference systems the same? Reproject if necessary.
self.out_ds = None
if self.options.profile in ('mercator', 'geodetic'):
if self.in_ds.GetGeoTransform() == (
0.0,
1.0,
0.0,
0.0,
0.0,
1.0,
) and self.in_ds.GetGCPCount() == 0:
self.error("There is no georeference - neither affine transformation (worldfile) nor GCPs. You can generate only 'raster' profile tiles."
,
"Either gdal2tiles with parameter -p 'raster' or use another GIS software for georeference e.g. gdal_transform -gcp / -a_ullr / -a_srs"
)
if self.in_srs:
if self.in_srs.ExportToProj4() \
!= self.out_srs.ExportToProj4() \
or self.in_ds.GetGCPCount() != 0:
# Generation of VRT dataset in tile projection, default 'nearest neighbour' warping
self.out_ds = gdal.AutoCreateWarpedVRT(self.in_ds,
self.in_srs_wkt, self.out_srs.ExportToWkt())
# TODO: HIGH PRIORITY: Correction of AutoCreateWarpedVRT according the max zoomlevel for correct direct warping!!!
if self.options.verbose:
print("Warping of the raster by AutoCreateWarpedVRT (result saved into 'tiles.vrt')")
self.out_ds.GetDriver().CreateCopy('tiles.vrt',
self.out_ds)
# Note: self.in_srs and self.in_srs_wkt contain still the non-warped reference system!!!
# Correction of AutoCreateWarpedVRT for NODATA values
if self.in_nodata != []:
(fd, tempfilename) = \
tempfile.mkstemp('-gdal2tiles.vrt')
self.out_ds.GetDriver().CreateCopy(tempfilename,
self.out_ds)
# open as a text file
s = open(tempfilename).read()
# Add the warping options
s = s.replace("""<GDALWarpOptions>""",
"""<GDALWarpOptions>
<Option name="INIT_DEST">NO_DATA</Option>
<Option name="UNIFIED_SRC_NODATA">YES</Option>""")
# replace BandMapping tag for NODATA bands....
for i in range(len(self.in_nodata)):
s = \
s.replace("""<BandMapping src="%i" dst="%i"/>"""
% (i + 1, i + 1),
"""<BandMapping src="%i" dst="%i">
<SrcNoDataReal>%i</SrcNoDataReal>
<SrcNoDataImag>0</SrcNoDataImag>
<DstNoDataReal>%i</DstNoDataReal>
<DstNoDataImag>0</DstNoDataImag>
</BandMapping>"""
% (i + 1, i + 1, self.in_nodata[i],
self.in_nodata[i])) # Or rewrite to white by: , 255 ))
# save the corrected VRT
open(tempfilename, 'w').write(s)
# open by GDAL as self.out_ds
self.out_ds = gdal.Open(tempfilename) # , gdal.GA_ReadOnly)
# delete the temporary file
os.unlink(tempfilename)
# set NODATA_VALUE metadata
self.out_ds.SetMetadataItem('NODATA_VALUES',
'%i %i %i' % (self.in_nodata[0],
self.in_nodata[1], self.in_nodata[2]))
if self.options.verbose:
print("Modified warping result saved into 'tiles1.vrt'")
open('tiles1.vrt', 'w').write(s)
# -----------------------------------
# Correction of AutoCreateWarpedVRT for Mono (1 band) and RGB (3 bands) files without NODATA:
# equivalent of gdalwarp -dstalpha
if self.in_nodata == [] and self.out_ds.RasterCount \
in [1, 3]:
(fd, tempfilename) = \
tempfile.mkstemp('-gdal2tiles.vrt')
self.out_ds.GetDriver().CreateCopy(tempfilename,
self.out_ds)
# open as a text file
s = open(tempfilename).read()
# Add the warping options
s = s.replace("""<BlockXSize>""",
"""<VRTRasterBand dataType="Byte" band="%i" subClass="VRTWarpedRasterBand">
<ColorInterp>Alpha</ColorInterp>
</VRTRasterBand>
<BlockXSize>"""
% (self.out_ds.RasterCount + 1))
s = s.replace("""</GDALWarpOptions>""",
"""<DstAlphaBand>%i</DstAlphaBand>
</GDALWarpOptions>"""
% (self.out_ds.RasterCount + 1))
s = s.replace("""</WorkingDataType>""",
"""</WorkingDataType>
<Option name="INIT_DEST">0</Option>"""
)
# save the corrected VRT
open(tempfilename, 'w').write(s)
# open by GDAL as self.out_ds
self.out_ds = gdal.Open(tempfilename) # , gdal.GA_ReadOnly)
# delete the temporary file
os.unlink(tempfilename)
if self.options.verbose:
print("Modified -dstalpha warping result saved into 'tiles1.vrt'")
open('tiles1.vrt', 'w').write(s)
s = '''
'''
else:
self.error('Input file has unknown SRS.',
'Use --s_srs ESPG:xyz (or similar) to provide source reference system.'
)
if self.out_ds and self.options.verbose:
print ('Projected file:', 'tiles.vrt',
'( %sP x %sL - %s bands)'
% (self.out_ds.RasterXSize,
self.out_ds.RasterYSize,
self.out_ds.RasterCount))
if not self.out_ds:
self.out_ds = self.in_ds
#
# Here we should have a raster (out_ds) in the correct Spatial Reference system
#
# Get alpha band (either directly or from NODATA value)
self.alphaband = self.out_ds.GetRasterBand(1).GetMaskBand()
if self.alphaband.GetMaskFlags() & gdal.GMF_ALPHA \
or self.out_ds.RasterCount == 4 or self.out_ds.RasterCount \
== 2:
# TODO: Better test for alpha band in the dataset
self.dataBandsCount = self.out_ds.RasterCount - 1
else:
self.dataBandsCount = self.out_ds.RasterCount
# KML test
self.isepsg4326 = False
srs4326 = osr.SpatialReference()
srs4326.ImportFromEPSG(4326)
if self.out_srs and srs4326.ExportToProj4() \
== self.out_srs.ExportToProj4():
self.kml = True
self.isepsg4326 = True
if self.options.verbose:
print('KML autotest OK!')
# Read the georeference
self.out_gt = self.out_ds.GetGeoTransform()
# originX, originY = self.out_gt[0], self.out_gt[3]
# pixelSize = self.out_gt[1] # = self.out_gt[5]
# Test the size of the pixel
# MAPTILER - COMMENTED
# if self.out_gt[1] != (-1 * self.out_gt[5]) and self.options.profile != 'raster':
# TODO: Process corectly coordinates with are have swichted Y axis (display in OpenLayers too)
# self.error("Size of the pixel in the output differ for X and Y axes.")
# Report error in case rotation/skew is in geotransform (possible only in 'raster' profile)
if (self.out_gt[2], self.out_gt[4]) != (0, 0):
self.error('Georeference of the raster contains rotation or skew. Such raster is not supported. Please use gdalwarp first.'
)
# TODO: Do the warping in this case automaticaly
#
# Here we expect: pixel is square, no rotation on the raster
#
# Output Bounds - coordinates in the output SRS
self.ominx = self.out_gt[0]
self.omaxx = self.out_gt[0] + self.out_ds.RasterXSize \
* self.out_gt[1]
self.omaxy = self.out_gt[3]
self.ominy = self.out_gt[3] - self.out_ds.RasterYSize \
* self.out_gt[1]
# Note: maybe round(x, 14) to avoid the gdal_translate behaviour, when 0 becomes -1e-15
if self.options.verbose:
print ('Bounds (output srs):', round(self.ominx, 13),
self.ominy, self.omaxx, self.omaxy)
#
# Calculating ranges for tiles in different zoom levels
#
if self.options.profile == 'mercator':
self.mercator = GlobalMercator() # from globalmaptiles.py
# Function which generates SWNE in LatLong for given tile
self.tileswne = self.mercator.TileLatLonBounds
# Generate table with min max tile coordinates for all zoomlevels
self.tminmax = list(range(0, 32))
for tz in range(0, 32):
(tminx, tminy) = self.mercator.MetersToTile(self.ominx,
self.ominy, tz)
(tmaxx, tmaxy) = self.mercator.MetersToTile(self.omaxx,
self.omaxy, tz)
# crop tiles extending world limits (+-180,+-90)
(tminx, tminy) = (max(0, tminx), max(0, tminy))
(tmaxx, tmaxy) = (min(2 ** tz - 1, tmaxx), min(2 ** tz
- 1, tmaxy))
self.tminmax[tz] = (tminx, tminy, tmaxx, tmaxy)
# TODO: Maps crossing 180E (Alaska?)
# Get the minimal zoom level (map covers area equivalent to one tile)
if self.tminz == None:
self.tminz = \
self.mercator.ZoomForPixelSize(self.out_gt[1]
* max(self.out_ds.RasterXSize,
self.out_ds.RasterYSize) / float(self.tilesize))
# Get the maximal zoom level (closest possible zoom level up on the resolution of raster)
if self.tmaxz == None:
self.tmaxz = \
self.mercator.ZoomForPixelSize(self.out_gt[1])
if self.options.verbose:
print ('Bounds (latlong):',
self.mercator.MetersToLatLon(self.ominx,
self.ominy),
self.mercator.MetersToLatLon(self.omaxx,
self.omaxy))
print ('MinZoomLevel:', self.tminz)
print ('MaxZoomLevel:', self.tmaxz, '(',
self.mercator.Resolution(self.tmaxz), ')')
if self.options.profile == 'geodetic':
self.geodetic = GlobalGeodetic(self.options.tmscompatible) # from globalmaptiles.py
# Function which generates SWNE in LatLong for given tile
self.tileswne = self.geodetic.TileLatLonBounds
# Generate table with min max tile coordinates for all zoomlevels
self.tminmax = list(range(0, 32))
for tz in range(0, 32):
(tminx, tminy) = self.geodetic.LonLatToTile(self.ominx,
self.ominy, tz)
(tmaxx, tmaxy) = self.geodetic.LonLatToTile(self.omaxx,
self.omaxy, tz)
# crop tiles extending world limits (+-180,+-90)
(tminx, tminy) = (max(0, tminx), max(0, tminy))
(tmaxx, tmaxy) = (min(2 ** (tz + 1) - 1, tmaxx), min(2
** tz - 1, tmaxy))
self.tminmax[tz] = (tminx, tminy, tmaxx, tmaxy)
# TODO: Maps crossing 180E (Alaska?)
# Get the maximal zoom level (closest possible zoom level up on the resolution of raster)
if self.tminz == None:
self.tminz = \
self.geodetic.ZoomForPixelSize(self.out_gt[1]
* max(self.out_ds.RasterXSize,
self.out_ds.RasterYSize) / float(self.tilesize))
# Get the maximal zoom level (closest possible zoom level up on the resolution of raster)
if self.tmaxz == None:
self.tmaxz = \
self.geodetic.ZoomForPixelSize(self.out_gt[1])
if self.options.verbose:
print ('Bounds (latlong):', self.ominx, self.ominy,
self.omaxx, self.omaxy)
if self.options.profile == 'raster':
log2 = lambda x: math.log10(x) / math.log10(2) # log2 (base 2 logarithm)
self.nativezoom = \
int(max(math.ceil(log2(self.out_ds.RasterXSize
/ float(self.tilesize))),
math.ceil(log2(self.out_ds.RasterYSize
/ float(self.tilesize)))))
if self.tmaxz < self.nativezoom:
self.tmaxz = self.nativezoom
if self.options.verbose:
print ('Native zoom of the raster:', self.nativezoom)
# Get the minimal zoom level (whole raster in one tile)
if self.tminz == None:
self.tminz = 0
# Get the maximal zoom level (native resolution of the raster)
if self.tmaxz == None:
self.tmaxz = self.nativezoom
# Generate table with min max tile coordinates for all zoomlevels
self.tminmax = list(range(0, self.tmaxz + 1))
self.tsize = list(range(0, self.tmaxz + 1))
for tz in range(0, self.tmaxz + 1):
tsize = 2.0 ** (self.nativezoom - tz) * self.tilesize
(tminx, tminy) = (0, 0)
tmaxx = int(math.ceil(self.out_ds.RasterXSize / tsize)) \
- 1
tmaxy = int(math.ceil(self.out_ds.RasterYSize / tsize)) \
- 1
self.tsize[tz] = math.ceil(tsize)
self.tminmax[tz] = (tminx, tminy, tmaxx, tmaxy)
# Function which generates SWNE in LatLong for given tile
if self.kml and self.in_srs_wkt:
self.ct = osr.CoordinateTransformation(self.in_srs,
srs4326)
def rastertileswne(x, y, z):
pixelsizex = 2 ** (self.tmaxz - z) * self.out_gt[1] # X-pixel size in level
pixelsizey = 2 ** (self.tmaxz - z) * self.out_gt[1] # Y-pixel size in level (usually -1*pixelsizex)
west = self.out_gt[0] + x * self.tilesize \
* pixelsizex
east = west + self.tilesize * pixelsizex
south = self.ominy + y * self.tilesize * pixelsizex
north = south + self.tilesize * pixelsizex
if not self.isepsg4326:
# Transformation to EPSG:4326 (WGS84 datum)
(west, south) = self.ct.TransformPoint(west,
south)[:2]
(east, north) = self.ct.TransformPoint(east,
north)[:2]
return (south, west, north, east)
self.tileswne = rastertileswne
else:
self.tileswne = lambda x, y, z: (0, 0, 0, 0) | Initialization of the input raster, reprojection if necessary | open_input | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def generate_metadata(self):
"""Generation of main metadata files and HTML viewers (metadata related to particular tiles are generated during the tile processing)."""
if not os.path.exists(self.output):
os.makedirs(self.output)
if self.options.profile == 'mercator':
(south, west) = self.mercator.MetersToLatLon(self.ominx,
self.ominy)
(north, east) = self.mercator.MetersToLatLon(self.omaxx,
self.omaxy)
(south, west) = (max(-85.05112878, south), max(-180.0,
west))
(north, east) = (min(85.05112878, north), min(180.0, east))
self.swne = (south, west, north, east)
# Generate googlemaps.html
if self.options.webviewer in ('all', 'google') \
and self.options.profile == 'mercator':
if not self.options.resume \
or not os.path.exists(os.path.join(self.output,
'googlemaps.html')):
f = open(os.path.join(self.output, 'googlemaps.html'
), 'w')
f.write(self.generate_googlemaps())
f.close()
# Generate openlayers.html
if self.options.webviewer in ('all', 'openlayers'):
if not self.options.resume \
or not os.path.exists(os.path.join(self.output,
'openlayers.html')):
f = open(os.path.join(self.output, 'openlayers.html'
), 'w')
f.write(self.generate_openlayers())
f.close()
elif self.options.profile == 'geodetic':
(west, south) = (self.ominx, self.ominy)
(east, north) = (self.omaxx, self.omaxy)
(south, west) = (max(-90.0, south), max(-180.0, west))
(north, east) = (min(90.0, north), min(180.0, east))
self.swne = (south, west, north, east)
# Generate openlayers.html
if self.options.webviewer in ('all', 'openlayers'):
if not self.options.resume \
or not os.path.exists(os.path.join(self.output,
'openlayers.html')):
f = open(os.path.join(self.output, 'openlayers.html'
), 'w')
f.write(self.generate_openlayers())
f.close()
elif self.options.profile == 'raster':
(west, south) = (self.ominx, self.ominy)
(east, north) = (self.omaxx, self.omaxy)
self.swne = (south, west, north, east)
# Generate openlayers.html
if self.options.webviewer in ('all', 'openlayers'):
if not self.options.resume \
or not os.path.exists(os.path.join(self.output,
'openlayers.html')):
f = open(os.path.join(self.output, 'openlayers.html'
), 'w')
f.write(self.generate_openlayers())
f.close()
# Generate tilemapresource.xml.
if not self.options.resume \
or not os.path.exists(os.path.join(self.output,
'tilemapresource.xml')):
f = open(os.path.join(self.output, 'tilemapresource.xml'),
'w')
f.write(self.generate_tilemapresource())
f.close()
if self.kml:
# TODO: Maybe problem for not automatically generated tminz
# The root KML should contain links to all tiles in the tminz level
children = []
(xmin, ymin, xmax, ymax) = self.tminmax[self.tminz]
for x in range(xmin, xmax + 1):
for y in range(ymin, ymax + 1):
children.append([x, y, self.tminz])
# Generate Root KML
if self.kml:
if not self.options.resume \
or not os.path.exists(os.path.join(self.output,
'doc.kml')):
f = open(os.path.join(self.output, 'doc.kml'), 'w')
f.write(self.generate_kml(None, None, None,
children))
f.close() | Generation of main metadata files and HTML viewers (metadata related to particular tiles are generated during the tile processing). | generate_metadata | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def generate_base_tiles(self, cpu):
"""Generation of the base tiles (the lowest in the pyramid) directly from the input raster"""
if self.options.verbose:
# mx, my = self.out_gt[0], self.out_gt[3] # OriginX, OriginY
# px, py = self.mercator.MetersToPixels( mx, my, self.tmaxz)
# print("Pixel coordinates:", px, py, (mx, my))
print('')
print('Tiles generated from the max zoom level:')
print('----------------------------------------')
print('')
# Set the bounds
(tminx, tminy, tmaxx, tmaxy) = self.tminmax[self.tmaxz]
# Just the center tile
# tminx = tminx+ (tmaxx - tminx)/2
# tminy = tminy+ (tmaxy - tminy)/2
# tmaxx = tminx
# tmaxy = tminy
ds = self.out_ds
tilebands = self.dataBandsCount + 1
querysize = self.querysize
if self.options.verbose:
print ('dataBandsCount: ', self.dataBandsCount)
print ('tilebands: ', tilebands)
# print(tminx, tminy, tmaxx, tmaxy)
tcount = (1 + abs(tmaxx - tminx)) * (1 + abs(tmaxy - tminy))
# print(tcount)
ti = 0
yrange = range(tmaxy, tminy - 1, -1)
if self.options.leaflet:
yrange = range(tminy, tmaxy + 1)
tz = self.tmaxz
for ty in yrange:
for tx in range(tminx, tmaxx + 1):
if self.stopped:
break
ti += 1
if (ti - 1) % self.options.processes != cpu:
continue
tilefilename = os.path.join(self.output, str(tz),
str(tx), '%s.%s' % (ty, self.tileext))
if self.options.verbose:
print (ti, '/', tcount, tilefilename) # , "( TileMapService: z / x / y )"
if self.options.resume and os.path.exists(tilefilename):
if self.options.verbose:
print('Tile generation skiped because of --resume')
else:
queue.put(tcount)
continue
# Create directories for the tile
if not os.path.exists(os.path.dirname(tilefilename)):
os.makedirs(os.path.dirname(tilefilename))
if self.options.profile == 'mercator':
# Tile bounds in EPSG:900913
b = self.mercator.TileBounds(tx, ty, tz)
elif self.options.profile == 'geodetic':
b = self.geodetic.TileBounds(tx, ty, tz)
# print "\tgdalwarp -ts 256 256 -te %s %s %s %s %s %s_%s_%s.tif" % ( b[0], b[1], b[2], b[3], "tiles.vrt", tz, tx, ty)
# Don't scale up by nearest neighbour, better change the querysize
# to the native resolution (and return smaller query tile) for scaling
if self.options.profile in ('mercator', 'geodetic'):
(rb, wb) = self.geo_query(ds, b[0], b[3], b[2],
b[1])
nativesize = wb[0] + wb[2] # Pixel size in the raster covering query geo extent
if self.options.verbose:
print ('\tNative Extent (querysize',
nativesize, '): ', rb, wb)
# Tile bounds in raster coordinates for ReadRaster query
(rb, wb) = self.geo_query(
ds,
b[0],
b[3],
b[2],
b[1],
querysize=querysize,
)
(rx, ry, rxsize, rysize) = rb
(wx, wy, wxsize, wysize) = wb
else:
# 'raster' profile:
tsize = int(self.tsize[tz]) # tilesize in raster coordinates for actual zoom
xsize = self.out_ds.RasterXSize # size of the raster in pixels
ysize = self.out_ds.RasterYSize
if tz >= self.nativezoom:
querysize = self.tilesize # int(2**(self.nativezoom-tz) * self.tilesize)
rx = tx * tsize
rxsize = 0
if tx == tmaxx:
rxsize = xsize % tsize
if rxsize == 0:
rxsize = tsize
rysize = 0
if ty == tmaxy:
rysize = ysize % tsize
if rysize == 0:
rysize = tsize
if self.options.leaflet:
ry = ty * tsize
else:
ry = ysize - ty * tsize - rysize
(wx, wy) = (0, 0)
(wxsize, wysize) = (int(rxsize / float(tsize)
* self.tilesize), int(rysize / float(tsize)
* self.tilesize))
if not self.options.leaflet:
if wysize != self.tilesize:
wy = self.tilesize - wysize
if self.options.verbose:
print ('\tReadRaster Extent: ', (rx, ry, rxsize,
rysize), (wx, wy, wxsize, wysize))
# Query is in 'nearest neighbour' but can be bigger in then the tilesize
# We scale down the query to the tilesize by supplied algorithm.
# Tile dataset in memory
dstile = self.mem_drv.Create('', self.tilesize,
self.tilesize, tilebands)
data = ds.ReadRaster(
rx,
ry,
rxsize,
rysize,
wxsize,
wysize,
band_list=list(range(1, self.dataBandsCount + 1)),
)
alpha = self.alphaband.ReadRaster(
rx,
ry,
rxsize,
rysize,
wxsize,
wysize,
)
if self.tilesize == querysize:
# Use the ReadRaster result directly in tiles ('nearest neighbour' query)
dstile.WriteRaster(
wx,
wy,
wxsize,
wysize,
data,
band_list=list(range(1, self.dataBandsCount
+ 1)),
)
dstile.WriteRaster(
wx,
wy,
wxsize,
wysize,
alpha,
band_list=[tilebands],
)
else:
# Note: For source drivers based on WaveLet compression (JPEG2000, ECW, MrSID)
# the ReadRaster function returns high-quality raster (not ugly nearest neighbour)
# TODO: Use directly 'near' for WaveLet files
# Big ReadRaster query in memory scaled to the tilesize - all but 'near' algo
dsquery = self.mem_drv.Create('', querysize,
querysize, tilebands)
# TODO: fill the null value in case a tile without alpha is produced (now only png tiles are supported)
# for i in range(1, tilebands+1):
# dsquery.GetRasterBand(1).Fill(tilenodata)
dsquery.WriteRaster(
wx,
wy,
wxsize,
wysize,
data,
band_list=list(range(1, self.dataBandsCount
+ 1)),
)
dsquery.WriteRaster(
wx,
wy,
wxsize,
wysize,
alpha,
band_list=[tilebands],
)
self.scale_query_to_tile(dsquery, dstile,
tilefilename)
del dsquery
del data
if self.options.resampling != 'antialias':
# Write a copy of tile to png/jpg
self.out_drv.CreateCopy(tilefilename, dstile,
strict=0)
del dstile
# Create a KML file for this tile.
if self.kml:
kmlfilename = os.path.join(self.output, str(tz),
str(tx), '%d.kml' % ty)
if not self.options.resume \
or not os.path.exists(kmlfilename):
f = open(kmlfilename, 'w')
f.write(self.generate_kml(tx, ty, tz))
f.close()
if not self.options.verbose:
queue.put(tcount) | Generation of the base tiles (the lowest in the pyramid) directly from the input raster | generate_base_tiles | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def generate_overview_tiles(self, cpu, tz):
"""Generation of the overview tiles (higher in the pyramid) based on existing tiles"""
tilebands = self.dataBandsCount + 1
# Usage of existing tiles: from 4 underlying tiles generate one as overview.
tcount = 0
for z in range(self.tmaxz - 1, self.tminz - 1, -1):
(tminx, tminy, tmaxx, tmaxy) = self.tminmax[z]
tcount += (1 + abs(tmaxx - tminx)) * (1 + abs(tmaxy
- tminy))
ti = 0
# querysize = tilesize * 2
(tminx, tminy, tmaxx, tmaxy) = self.tminmax[tz]
yrange = range(tmaxy, tminy - 1, -1)
if self.options.leaflet:
yrange = range(tminy, tmaxy + 1)
for ty in yrange:
for tx in range(tminx, tmaxx + 1):
if self.stopped:
break
ti += 1
if (ti - 1) % self.options.processes != cpu:
continue
tilefilename = os.path.join(self.output, str(tz),
str(tx), '%s.%s' % (ty, self.tileext))
if self.options.verbose:
print (ti, '/', tcount, tilefilename) # , "( TileMapService: z / x / y )"
if self.options.resume and os.path.exists(tilefilename):
if self.options.verbose:
print('Tile generation skiped because of --resume')
else:
queue.put(tcount)
continue
# Create directories for the tile
if not os.path.exists(os.path.dirname(tilefilename)):
os.makedirs(os.path.dirname(tilefilename))
dsquery = self.mem_drv.Create('', 2 * self.tilesize, 2
* self.tilesize, tilebands)
# TODO: fill the null value
# for i in range(1, tilebands+1):
# dsquery.GetRasterBand(1).Fill(tilenodata)
dstile = self.mem_drv.Create('', self.tilesize,
self.tilesize, tilebands)
# TODO: Implement more clever walking on the tiles with cache functionality
# probably walk should start with reading of four tiles from top left corner
# Hilbert curve
children = []
# Read the tiles and write them to query window
for y in range(2 * ty, 2 * ty + 2):
for x in range(2 * tx, 2 * tx + 2):
(minx, miny, maxx, maxy) = self.tminmax[tz + 1]
if x >= minx and x <= maxx and y >= miny and y \
<= maxy:
dsquerytile = \
gdal.Open(os.path.join(self.output,
str(tz + 1), str(x), '%s.%s' % (y,
self.tileext)), gdal.GA_ReadOnly)
if self.options.leaflet:
if ty:
tileposy = y % (2 * ty) \
* self.tilesize
elif ty == 0 and y == 1:
tileposy = self.tilesize
else:
tileposy = 0
else:
if ty == 0 and y == 1 or ty != 0 and y \
% (2 * ty) != 0:
tileposy = 0
else:
tileposy = self.tilesize
if tx:
tileposx = x % (2 * tx) * self.tilesize
elif tx == 0 and x == 1:
tileposx = self.tilesize
else:
tileposx = 0
dsquery.WriteRaster(
tileposx,
tileposy,
self.tilesize,
self.tilesize,
dsquerytile.ReadRaster(0, 0,
self.tilesize, self.tilesize),
band_list=list(range(1, tilebands
+ 1)),
)
children.append([x, y, tz + 1])
self.scale_query_to_tile(dsquery, dstile, tilefilename)
# Write a copy of tile to png/jpg
if self.options.resampling != 'antialias':
# Write a copy of tile to png/jpg
self.out_drv.CreateCopy(tilefilename, dstile,
strict=0)
if self.options.verbose:
print (
'\tbuild from zoom',
tz + 1,
' tiles:',
(2 * tx, 2 * ty),
(2 * tx + 1, 2 * ty),
(2 * tx, 2 * ty + 1),
(2 * tx + 1, 2 * ty + 1),
)
# Create a KML file for this tile.
if self.kml:
f = open(os.path.join(self.output, '%d/%d/%d.kml'
% (tz, tx, ty)), 'w')
f.write(self.generate_kml(tx, ty, tz, children))
f.close()
if not self.options.verbose:
queue.put(tcount) | Generation of the overview tiles (higher in the pyramid) based on existing tiles | generate_overview_tiles | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def geo_query(
self,
ds,
ulx,
uly,
lrx,
lry,
querysize=0,
):
"""For given dataset and query in cartographic coordinates
returns parameters for ReadRaster() in raster coordinates and
x/y shifts (for border tiles). If the querysize is not given, the
extent is returned in the native resolution of dataset ds."""
geotran = ds.GetGeoTransform()
rx = int((ulx - geotran[0]) / geotran[1] + 0.001)
ry = int((uly - geotran[3]) / geotran[5] + 0.001)
rxsize = int((lrx - ulx) / geotran[1] + 0.5)
rysize = int((lry - uly) / geotran[5] + 0.5)
if not querysize:
(wxsize, wysize) = (rxsize, rysize)
else:
(wxsize, wysize) = (querysize, querysize)
# Coordinates should not go out of the bounds of the raster
wx = 0
if rx < 0:
rxshift = abs(rx)
wx = int(wxsize * (float(rxshift) / rxsize))
wxsize = wxsize - wx
rxsize = rxsize - int(rxsize * (float(rxshift) / rxsize))
rx = 0
if rx + rxsize > ds.RasterXSize:
wxsize = int(wxsize * (float(ds.RasterXSize - rx) / rxsize))
rxsize = ds.RasterXSize - rx
wy = 0
if ry < 0:
ryshift = abs(ry)
wy = int(wysize * (float(ryshift) / rysize))
wysize = wysize - wy
rysize = rysize - int(rysize * (float(ryshift) / rysize))
ry = 0
if ry + rysize > ds.RasterYSize:
wysize = int(wysize * (float(ds.RasterYSize - ry) / rysize))
rysize = ds.RasterYSize - ry
return ((rx, ry, rxsize, rysize), (wx, wy, wxsize, wysize)) | For given dataset and query in cartographic coordinates
returns parameters for ReadRaster() in raster coordinates and
x/y shifts (for border tiles). If the querysize is not given, the
extent is returned in the native resolution of dataset ds. | geo_query | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def scale_query_to_tile(
self,
dsquery,
dstile,
tilefilename='',
):
"""Scales down query dataset to the tile dataset"""
querysize = dsquery.RasterXSize
tilesize = dstile.RasterXSize
tilebands = dstile.RasterCount
if self.options.resampling == 'average':
# Function: gdal.RegenerateOverview()
for i in range(1, tilebands + 1):
# Black border around NODATA
# if i != 4:
# dsquery.GetRasterBand(i).SetNoDataValue(0)
res = gdal.RegenerateOverview(dsquery.GetRasterBand(i),
dstile.GetRasterBand(i), 'average')
if res != 0:
self.error('RegenerateOverview() failed on %s, error %d'
% (tilefilename, res))
elif self.options.resampling == 'antialias':
# Scaling by PIL (Python Imaging Library) - improved Lanczos
array = numpy.zeros((querysize, querysize, tilebands),
numpy.uint8)
for i in range(tilebands):
array[:, :, i] = \
gdalarray.BandReadAsArray(dsquery.GetRasterBand(i
+ 1), 0, 0, querysize, querysize)
im = Image.fromarray(array, 'RGBA') # Always four bands
im1 = im.resize((tilesize, tilesize), Image.ANTIALIAS)
if os.path.exists(tilefilename):
im0 = Image.open(tilefilename)
im1 = Image.composite(im1, im0, im1)
im1.save(tilefilename, self.tiledriver)
else:
# Other algorithms are implemented by gdal.ReprojectImage().
dsquery.SetGeoTransform((
0.0,
tilesize / float(querysize),
0.0,
0.0,
0.0,
tilesize / float(querysize),
))
dstile.SetGeoTransform((
0.0,
1.0,
0.0,
0.0,
0.0,
1.0,
))
res = gdal.ReprojectImage(dsquery, dstile, None, None,
self.resampling)
if res != 0:
self.error('ReprojectImage() failed on %s, error %d'
% (tilefilename, res)) | Scales down query dataset to the tile dataset | scale_query_to_tile | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def generate_tilemapresource(self):
"""
Template for tilemapresource.xml. Returns filled string. Expected variables:
title, north, south, east, west, isepsg4326, projection, publishurl,
zoompixels, tilesize, tileformat, profile
"""
args = {}
args['title'] = self.options.title
(args['south'], args['west'], args['north'], args['east']) = \
self.swne
args['tilesize'] = self.tilesize
args['tileformat'] = self.tileext
args['publishurl'] = self.options.url
args['profile'] = self.options.profile
if self.options.profile == 'mercator':
args['srs'] = 'EPSG:900913'
elif self.options.profile == 'geodetic':
args['srs'] = 'EPSG:4326'
elif self.options.s_srs:
args['srs'] = self.options.s_srs
elif self.out_srs:
args['srs'] = self.out_srs.ExportToWkt()
else:
args['srs'] = ''
s = \
"""<?xml version="1.0" encoding="utf-8"?>
<TileMap version="1.0.0" tilemapservice="http://tms.osgeo.org/1.0.0">
<Title>%(title)s</Title>
<Abstract></Abstract>
<SRS>%(srs)s</SRS>
<BoundingBox minx="%(west).14f" miny="%(south).14f" maxx="%(east).14f" maxy="%(north).14f"/>
<Origin x="%(west).14f" y="%(south).14f"/>
<TileFormat width="%(tilesize)d" height="%(tilesize)d" mime-type="image/%(tileformat)s" extension="%(tileformat)s"/>
<TileSets profile="%(profile)s">
""" \
% args
for z in range(self.tminz, self.tmaxz + 1):
if self.options.profile == 'raster':
s += \
""" <TileSet href="%s%d" units-per-pixel="%.14f" order="%d"/>\n""" \
% (args['publishurl'], z, 2 ** (self.nativezoom
- z) * self.out_gt[1], z)
elif self.options.profile == 'mercator':
s += \
""" <TileSet href="%s%d" units-per-pixel="%.14f" order="%d"/>\n""" \
% (args['publishurl'], z, 156543.0339 / 2 ** z, z)
elif self.options.profile == 'geodetic':
s += \
""" <TileSet href="%s%d" units-per-pixel="%.14f" order="%d"/>\n""" \
% (args['publishurl'], z, 0.703125 / 2 ** z, z)
s += """ </TileSets>
</TileMap>
"""
return s |
Template for tilemapresource.xml. Returns filled string. Expected variables:
title, north, south, east, west, isepsg4326, projection, publishurl,
zoompixels, tilesize, tileformat, profile
| generate_tilemapresource | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def generate_kml(
self,
tx,
ty,
tz,
children=[],
**args
):
"""
Template for the KML. Returns filled string.
"""
(args['tx'], args['ty'], args['tz']) = (tx, ty, tz)
args['tileformat'] = self.tileext
if 'tilesize' not in args:
args['tilesize'] = self.tilesize
if 'minlodpixels' not in args:
args['minlodpixels'] = int(args['tilesize'] / 2) # / 2.56) # default 128
if 'maxlodpixels' not in args:
args['maxlodpixels'] = int(args['tilesize'] * 8) # 1.7) # default 2048 (used to be -1)
if children == []:
args['maxlodpixels'] = -1
if tx == None:
tilekml = False
args['title'] = self.options.title
else:
tilekml = True
args['title'] = '%d/%d/%d.kml' % (tz, tx, ty)
(args['south'], args['west'], args['north'], args['east'
]) = self.tileswne(tx, ty, tz)
if tx == 0:
args['drawOrder'] = 2 * tz + 1
elif tx != None:
args['drawOrder'] = 2 * tz
else:
args['drawOrder'] = 0
url = self.options.url
if not url:
if tilekml:
url = '../../'
else:
url = ''
s = \
"""<?xml version="1.0" encoding="utf-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2">
<Document>
<name>%(title)s</name>
<description></description>
<Style>
<ListStyle id="hideChildren">
<listItemType>checkHideChildren</listItemType>
</ListStyle>
</Style>""" \
% args
if tilekml:
s += \
"""
<Region>
<LatLonAltBox>
<north>%(north).14f</north>
<south>%(south).14f</south>
<east>%(east).14f</east>
<west>%(west).14f</west>
</LatLonAltBox>
<Lod>
<minLodPixels>%(minlodpixels)d</minLodPixels>
<maxLodPixels>%(maxlodpixels)d</maxLodPixels>
</Lod>
</Region>
<GroundOverlay>
<drawOrder>%(drawOrder)d</drawOrder>
<Icon>
<href>%(ty)d.%(tileformat)s</href>
</Icon>
<LatLonBox>
<north>%(north).14f</north>
<south>%(south).14f</south>
<east>%(east).14f</east>
<west>%(west).14f</west>
</LatLonBox>
</GroundOverlay>
""" \
% args
for (cx, cy, cz) in children:
(csouth, cwest, cnorth, ceast) = self.tileswne(cx, cy, cz)
s += \
"""
<NetworkLink>
<name>%d/%d/%d.%s</name>
<Region>
<LatLonAltBox>
<north>%.14f</north>
<south>%.14f</south>
<east>%.14f</east>
<west>%.14f</west>
</LatLonAltBox>
<Lod>
<minLodPixels>%d</minLodPixels>
<maxLodPixels>-1</maxLodPixels>
</Lod>
</Region>
<Link>
<href>%s%d/%d/%d.kml</href>
<viewRefreshMode>onRegion</viewRefreshMode>
<viewFormat/>
</Link>
</NetworkLink>
""" \
% (
cz,
cx,
cy,
args['tileformat'],
cnorth,
csouth,
ceast,
cwest,
args['minlodpixels'],
url,
cz,
cx,
cy,
)
s += """ </Document>
</kml>
"""
return s |
Template for the KML. Returns filled string.
| generate_kml | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def generate_googlemaps(self):
"""
Template for googlemaps.html implementing Overlay of tiles for 'mercator' profile.
It returns filled string. Expected variables:
title, googlemapskey, north, south, east, west, minzoom, maxzoom, tilesize, tileformat, publishurl
"""
args = {}
args['title'] = self.options.title
args['googlemapskey'] = self.options.googlekey
(args['south'], args['west'], args['north'], args['east']) = \
self.swne
args['minzoom'] = self.tminz
args['maxzoom'] = self.tmaxz
args['tilesize'] = self.tilesize
args['tileformat'] = self.tileext
args['publishurl'] = self.options.url
args['copyright'] = self.options.copyright
s = \
"""<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:v="urn:schemas-microsoft-com:vml">
<head>
<title>%(title)s</title>
<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
<meta http-equiv='imagetoolbar' content='no'/>
<style type="text/css"> v\:* {behavior:url(#default#VML);}
html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }
body { margin: 10px; background: #fff; }
h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }
#header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }
#subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}
#map { height: 95%%; border: 1px solid #888; }
</style>
<script src='http://maps.google.com/maps?file=api&v=2&key=%(googlemapskey)s'></script>
<script>
//<![CDATA[
/*
* Constants for given map
* TODO: read it from tilemapresource.xml
*/
var mapBounds = new GLatLngBounds(new GLatLng(%(south)s, %(west)s), new GLatLng(%(north)s, %(east)s));
var mapMinZoom = %(minzoom)s;
var mapMaxZoom = %(maxzoom)s;
var opacity = 0.75;
var map;
var hybridOverlay;
/*
* Create a Custom Opacity GControl
* http://www.maptiler.org/google-maps-overlay-opacity-control/
*/
var CTransparencyLENGTH = 58;
// maximum width that the knob can move (slide width minus knob width)
function CTransparencyControl( overlay ) {
this.overlay = overlay;
this.opacity = overlay.getTileLayer().getOpacity();
}
CTransparencyControl.prototype = new GControl();
// This function positions the slider to match the specified opacity
CTransparencyControl.prototype.setSlider = function(pos) {
var left = Math.round((CTransparencyLENGTH*pos));
this.slide.left = left;
this.knob.style.left = left+"px";
this.knob.style.top = "0px";
}
// This function reads the slider and sets the overlay opacity level
CTransparencyControl.prototype.setOpacity = function() {
// set the global variable
opacity = this.slide.left/CTransparencyLENGTH;
this.map.clearOverlays();
this.map.addOverlay(this.overlay, { zPriority: 0 });
if (this.map.getCurrentMapType() == G_HYBRID_MAP) {
this.map.addOverlay(hybridOverlay);
}
}
// This gets called by the API when addControl(new CTransparencyControl())
CTransparencyControl.prototype.initialize = function(map) {
var that=this;
this.map = map;
// Is this MSIE, if so we need to use AlphaImageLoader
var agent = navigator.userAgent.toLowerCase();
if ((agent.indexOf("msie") > -1) && (agent.indexOf("opera") < 1)){this.ie = true} else {this.ie = false}
// create the background graphic as a <div> containing an image
var container = document.createElement("div");
container.style.width="70px";
container.style.height="21px";
// Handle transparent PNG files in MSIE
if (this.ie) {
var loader = "filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='http://www.maptiler.org/img/opacity-slider.png', sizingMethod='crop');";
container.innerHTML = '<div style="height:21px; width:70px; ' +loader+ '" ></div>';
} else {
container.innerHTML = '<div style="height:21px; width:70px; background-image: url(http://www.maptiler.org/img/opacity-slider.png)" ></div>';
}
// create the knob as a GDraggableObject
// Handle transparent PNG files in MSIE
if (this.ie) {
var loader = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='http://www.maptiler.org/img/opacity-slider.png', sizingMethod='crop');";
this.knob = document.createElement("div");
this.knob.style.height="21px";
this.knob.style.width="13px";
this.knob.style.overflow="hidden";
this.knob_img = document.createElement("div");
this.knob_img.style.height="21px";
this.knob_img.style.width="83px";
this.knob_img.style.filter=loader;
this.knob_img.style.position="relative";
this.knob_img.style.left="-70px";
this.knob.appendChild(this.knob_img);
} else {
this.knob = document.createElement("div");
this.knob.style.height="21px";
this.knob.style.width="13px";
this.knob.style.backgroundImage="url(http://www.maptiler.org/img/opacity-slider.png)";
this.knob.style.backgroundPosition="-70px 0px";
}
container.appendChild(this.knob);
this.slide=new GDraggableObject(this.knob, {container:container});
this.slide.setDraggableCursor('pointer');
this.slide.setDraggingCursor('pointer');
this.container = container;
// attach the control to the map
map.getContainer().appendChild(container);
// init slider
this.setSlider(this.opacity);
// Listen for the slider being moved and set the opacity
GEvent.addListener(this.slide, "dragend", function() {that.setOpacity()});
//GEvent.addListener(this.container, "click", function( x, y ) { alert(x, y) });
return container;
}
// Set the default position for the control
CTransparencyControl.prototype.getDefaultPosition = function() {
return new GControlPosition(G_ANCHOR_TOP_RIGHT, new GSize(7, 47));
}
/*
* Full-screen Window Resize
*/
function getWindowHeight() {
if (self.innerHeight) return self.innerHeight;
if (document.documentElement && document.documentElement.clientHeight)
return document.documentElement.clientHeight;
if (document.body) return document.body.clientHeight;
return 0;
}
function getWindowWidth() {
if (self.innerWidth) return self.innerWidth;
if (document.documentElement && document.documentElement.clientWidth)
return document.documentElement.clientWidth;
if (document.body) return document.body.clientWidth;
return 0;
}
function resize() {
var map = document.getElementById("map");
var header = document.getElementById("header");
var subheader = document.getElementById("subheader");
map.style.height = (getWindowHeight()-80) + "px";
map.style.width = (getWindowWidth()-20) + "px";
header.style.width = (getWindowWidth()-20) + "px";
subheader.style.width = (getWindowWidth()-20) + "px";
// map.checkResize();
}
/*
* Main load function:
*/
function load() {
if (GBrowserIsCompatible()) {
// Bug in the Google Maps: Copyright for Overlay is not correctly displayed
var gcr = GMapType.prototype.getCopyrights;
GMapType.prototype.getCopyrights = function(bounds,zoom) {
return ["%(copyright)s"].concat(gcr.call(this,bounds,zoom));
}
map = new GMap2( document.getElementById("map"), { backgroundColor: '#fff' } );
map.addMapType(G_PHYSICAL_MAP);
map.setMapType(G_PHYSICAL_MAP);
map.setCenter( mapBounds.getCenter(), map.getBoundsZoomLevel( mapBounds ));
hybridOverlay = new GTileLayerOverlay( G_HYBRID_MAP.getTileLayers()[1] );
GEvent.addListener(map, "maptypechanged", function() {
if (map.getCurrentMapType() == G_HYBRID_MAP) {
map.addOverlay(hybridOverlay);
} else {
map.removeOverlay(hybridOverlay);
}
} );
var tilelayer = new GTileLayer(GCopyrightCollection(''), mapMinZoom, mapMaxZoom);
var mercator = new GMercatorProjection(mapMaxZoom+1);
tilelayer.getTileUrl = function(tile,zoom) {
if ((zoom < mapMinZoom) || (zoom > mapMaxZoom)) {
return "http://www.maptiler.org/img/none.png";
}
var ymax = 1 << zoom;
var y = ymax - tile.y -1;
var tileBounds = new GLatLngBounds(
mercator.fromPixelToLatLng( new GPoint( (tile.x)*256, (tile.y+1)*256 ) , zoom ),
mercator.fromPixelToLatLng( new GPoint( (tile.x+1)*256, (tile.y)*256 ) , zoom )
);
if (mapBounds.intersects(tileBounds)) {
return zoom+"/"+tile.x+"/"+y+".png";
} else {
return "http://www.maptiler.org/img/none.png";
}
}
// IE 7-: support for PNG alpha channel
// Unfortunately, the opacity for whole overlay is then not changeable, either or...
tilelayer.isPng = function() { return true;};
tilelayer.getOpacity = function() { return opacity; }
overlay = new GTileLayerOverlay( tilelayer );
map.addOverlay(overlay);
map.addControl(new GLargeMapControl());
map.addControl(new GHierarchicalMapTypeControl());
map.addControl(new CTransparencyControl( overlay ));
""" \
% args
if self.kml:
s += \
"""
map.addMapType(G_SATELLITE_3D_MAP);
map.getEarthInstance(getEarthInstanceCB);
"""
s += \
"""
map.enableContinuousZoom();
map.enableScrollWheelZoom();
map.setMapType(G_HYBRID_MAP);
}
resize();
}
"""
if self.kml:
s += \
"""
function getEarthInstanceCB(object) {
var ge = object;
if (ge) {
var url = document.location.toString();
url = url.substr(0,url.lastIndexOf('/'))+'/doc.kml';
var link = ge.createLink("");
if ("%(publishurl)s") { link.setHref("%(publishurl)s/doc.kml") }
else { link.setHref(url) };
var networkLink = ge.createNetworkLink("");
networkLink.setName("TMS Map Overlay");
networkLink.setFlyToView(true);
networkLink.setLink(link);
ge.getFeatures().appendChild(networkLink);
} else {
// alert("You should open a KML in Google Earth");
// add div with the link to generated KML... - maybe JavaScript redirect to the URL of KML?
}
}
""" \
% args
s += \
"""
onresize=function(){ resize(); };
//]]>
</script>
</head>
<body onload="load()">
<div id="header"><h1>%(title)s</h1></div>
<div id="subheader">Generated by <a href="http://www.maptiler.org/">MapTiler</a>/<a href="http://www.klokan.cz/projects/gdal2tiles/">GDAL2Tiles</a>, Copyright © 2008 <a href="http://www.klokan.cz/">Klokan Petr Pridal</a>, <a href="http://www.gdal.org/">GDAL</a> & <a href="http://www.osgeo.org/">OSGeo</a> <a href="http://code.google.com/soc/">GSoC</a>
<!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->
</div>
<div id="map"></div>
</body>
</html>
""" \
% args
return s |
Template for googlemaps.html implementing Overlay of tiles for 'mercator' profile.
It returns filled string. Expected variables:
title, googlemapskey, north, south, east, west, minzoom, maxzoom, tilesize, tileformat, publishurl
| generate_googlemaps | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def generate_openlayers(self):
"""
Template for openlayers.html implementing overlay of available Spherical Mercator layers.
It returns filled string. Expected variables:
title, bingkey, north, south, east, west, minzoom, maxzoom, tilesize, tileformat, publishurl
"""
args = {}
args['title'] = self.options.title
args['bingkey'] = self.options.bingkey
(args['south'], args['west'], args['north'], args['east']) = \
self.swne
args['minzoom'] = self.tminz
args['maxzoom'] = self.tmaxz
args['tilesize'] = self.tilesize
args['tileformat'] = self.tileext
args['publishurl'] = self.options.url
args['copyright'] = self.options.copyright
if self.options.tmscompatible:
args['tmsoffset'] = '-1'
else:
args['tmsoffset'] = ''
if self.options.profile == 'raster':
args['rasterzoomlevels'] = self.tmaxz + 1
args['rastermaxresolution'] = 2 ** self.nativezoom \
* self.out_gt[1]
s = \
"""<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
<head>
<title>%(title)s</title>
<meta http-equiv='imagetoolbar' content='no'/>
<style type="text/css"> v\:* {behavior:url(#default#VML);}
html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }
body { margin: 10px; background: #fff; }
h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }
#header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }
#subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}
#map { height: 95%%; border: 1px solid #888; }
.olImageLoadError { display: none; }
.olControlLayerSwitcher .layersDiv { border-radius: 10px 0 0 10px; }
</style>""" \
% args
if self.options.profile == 'mercator':
s += \
"""
<script src='http://maps.google.com/maps/api/js?sensor=false&v=3.7'></script>""" \
% args
s += \
"""
<script src="http://www.openlayers.org/api/2.12/OpenLayers.js"></script>
<script>
var map;
var mapBounds = new OpenLayers.Bounds( %(west)s, %(south)s, %(east)s, %(north)s);
var mapMinZoom = %(minzoom)s;
var mapMaxZoom = %(maxzoom)s;
var emptyTileURL = "http://www.maptiler.org/img/none.png";
OpenLayers.IMAGE_RELOAD_ATTEMPTS = 3;
function init(){""" \
% args
if self.options.profile == 'mercator':
s += \
"""
var options = {
div: "map",
controls: [],
projection: "EPSG:900913",
displayProjection: new OpenLayers.Projection("EPSG:4326"),
numZoomLevels: 20
};
map = new OpenLayers.Map(options);
// Create Google Mercator layers
var gmap = new OpenLayers.Layer.Google("Google Streets",
{
type: google.maps.MapTypeId.ROADMAP,
sphericalMercator: true
});
var gsat = new OpenLayers.Layer.Google("Google Satellite",
{
type: google.maps.MapTypeId.SATELLITE,
sphericalMercator: true
});
var ghyb = new OpenLayers.Layer.Google("Google Hybrid",
{
type: google.maps.MapTypeId.HYBRID,
sphericalMercator: true
});
var gter = new OpenLayers.Layer.Google("Google Terrain",
{
type: google.maps.MapTypeId.TERRAIN,
sphericalMercator: true
});
// Create Bing layers
var broad = new OpenLayers.Layer.Bing({
name: "Bing Roads",
key: "%(bingkey)s",
type: "Road",
sphericalMercator: true
});
var baer = new OpenLayers.Layer.Bing({
name: "Bing Aerial",
key: "%(bingkey)s",
type: "Aerial",
sphericalMercator: true
});
var bhyb = new OpenLayers.Layer.Bing({
name: "Bing Hybrid",
key: "%(bingkey)s",
type: "AerialWithLabels",
sphericalMercator: true
});
// Create OSM layer
var osm = new OpenLayers.Layer.OSM("OpenStreetMap");
// create TMS Overlay layer
var tmsoverlay = new OpenLayers.Layer.TMS( "TMS Overlay", "",
{
serviceVersion: '.',
layername: '.',
alpha: true,
type: '%(tileformat)s',
isBaseLayer: false,
getURL: getURL
});
if (OpenLayers.Util.alphaHack() == false) {
tmsoverlay.setOpacity(0.7);
}
map.addLayers([gmap, gsat, ghyb, gter,
broad, baer, bhyb,
osm, tmsoverlay]);
var switcherControl = new OpenLayers.Control.LayerSwitcher();
map.addControl(switcherControl);
switcherControl.maximizeControl();
map.zoomToExtent( mapBounds.transform(map.displayProjection, map.projection ) );
""" \
% args
elif self.options.profile == 'geodetic':
s += \
"""
var options = {
div: "map",
controls: [],
projection: "EPSG:4326"
};
map = new OpenLayers.Map(options);
var wms = new OpenLayers.Layer.WMS("VMap0",
"http://tilecache.osgeo.org/wms-c/Basic.py?",
{
layers: 'basic',
format: 'image/png'
}
);
var tmsoverlay = new OpenLayers.Layer.TMS( "TMS Overlay", "",
{
serviceVersion: '.',
layername: '.',
alpha: true,
type: '%(tileformat)s',
isBaseLayer: false,
getURL: getURL
});
if (OpenLayers.Util.alphaHack() == false) {
tmsoverlay.setOpacity(0.7);
}
map.addLayers([wms,tmsoverlay]);
var switcherControl = new OpenLayers.Control.LayerSwitcher();
map.addControl(switcherControl);
switcherControl.maximizeControl();
map.zoomToExtent( mapBounds );
""" \
% args
elif self.options.profile == 'raster':
s += \
"""
var options = {
div: "map",
controls: [],
maxExtent: new OpenLayers.Bounds( %(west)s, %(south)s, %(east)s, %(north)s ),
maxResolution: %(rastermaxresolution)f,
numZoomLevels: %(rasterzoomlevels)d
};
map = new OpenLayers.Map(options);
var layer = new OpenLayers.Layer.TMS( "TMS Layer","",
{
serviceVersion: '.',
layername: '.',
alpha: true,
type: '%(tileformat)s',
getURL: getURL
});
map.addLayer(layer);
map.zoomToExtent( mapBounds );
""" \
% args
s += \
"""
map.addControls([new OpenLayers.Control.PanZoomBar(),
new OpenLayers.Control.Navigation(),
new OpenLayers.Control.MousePosition(),
new OpenLayers.Control.ArgParser(),
new OpenLayers.Control.Attribution()]);
}
""" \
% args
if self.options.profile == 'mercator':
s += \
"""
function getURL(bounds) {
bounds = this.adjustBounds(bounds);
var res = this.getServerResolution();
var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));
var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));
var z = this.getServerZoom();
if (this.map.baseLayer.CLASS_NAME === 'OpenLayers.Layer.Bing') {
z+=1;
}
var path = this.serviceVersion + "/" + this.layername + "/" + z + "/" + x + "/" + y + "." + this.type;
var url = this.url;
if (OpenLayers.Util.isArray(url)) {
url = this.selectUrl(path, url);
}
if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {
return url + path;
} else {
return emptyTileURL;
}
}
""" \
% args
elif self.options.profile == 'geodetic':
s += \
"""
function getURL(bounds) {
bounds = this.adjustBounds(bounds);
var res = this.getServerResolution();
var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));
var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));
var z = this.getServerZoom()%(tmsoffset)s;
var path = this.serviceVersion + "/" + this.layername + "/" + z + "/" + x + "/" + y + "." + this.type;
var url = this.url;
if (OpenLayers.Util.isArray(url)) {
url = this.selectUrl(path, url);
}
if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {
return url + path;
} else {
return emptyTileURL;
}
}
""" \
% args
elif self.options.profile == 'raster':
s += \
"""
function getURL(bounds) {
bounds = this.adjustBounds(bounds);
var res = this.getServerResolution();
var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));
var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));
var z = this.getServerZoom();
var path = this.serviceVersion + "/" + this.layername + "/" + z + "/" + x + "/" + y + "." + this.type;
var url = this.url;
if (OpenLayers.Util.isArray(url)) {
url = this.selectUrl(path, url);
}
if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {
return url + path;
} else {
return emptyTileURL;
}
}
""" \
% args
s += \
"""
function getWindowHeight() {
if (self.innerHeight) return self.innerHeight;
if (document.documentElement && document.documentElement.clientHeight)
return document.documentElement.clientHeight;
if (document.body) return document.body.clientHeight;
return 0;
}
function getWindowWidth() {
if (self.innerWidth) return self.innerWidth;
if (document.documentElement && document.documentElement.clientWidth)
return document.documentElement.clientWidth;
if (document.body) return document.body.clientWidth;
return 0;
}
function resize() {
var map = document.getElementById("map");
var header = document.getElementById("header");
var subheader = document.getElementById("subheader");
map.style.height = (getWindowHeight()-80) + "px";
map.style.width = (getWindowWidth()-20) + "px";
header.style.width = (getWindowWidth()-20) + "px";
subheader.style.width = (getWindowWidth()-20) + "px";
if (map.updateSize) { map.updateSize(); };
}
onresize=function(){ resize(); };
</script>
</head>
<body onload="init()">
<div id="header"><h1>%(title)s</h1></div>
<div id="subheader">Generated by <a href="http://www.maptiler.org/">MapTiler</a>/<a href="http://www.klokan.cz/projects/gdal2tiles/">GDAL2Tiles</a>, Copyright © 2008 <a href="http://www.klokan.cz/">Klokan Petr Pridal</a>, <a href="http://www.gdal.org/">GDAL</a> & <a href="http://www.osgeo.org/">OSGeo</a> <a href="http://code.google.com/soc/">GSoC</a>
<!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->
</div>
<div id="map"></div>
<script type="text/javascript" >resize()</script>
</body>
</html>""" \
% args
return s |
Template for openlayers.html implementing overlay of available Spherical Mercator layers.
It returns filled string. Expected variables:
title, bingkey, north, south, east, west, minzoom, maxzoom, tilesize, tileformat, publishurl
| generate_openlayers | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def __init__(self, tileSize=256):
'''Initialize the TMS Global Mercator pyramid'''
self.tileSize = tileSize
self.initialResolution = 2 * math.pi * 6378137 / self.tileSize
# 156543.03392804062 for tileSize 256 pixels
self.originShift = 2 * math.pi * 6378137 / 2.0
# 20037508.342789244 | Initialize the TMS Global Mercator pyramid | __init__ | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def LatLonToMeters(self, lat, lon):
'''Converts given lat/lon in WGS84 Datum to XY in Spherical Mercator EPSG:900913'''
mx = lon * self.originShift / 180.0
my = math.log(math.tan((90 + lat) * math.pi / 360.0)) \
/ (math.pi / 180.0)
my = my * self.originShift / 180.0
return (mx, my) | Converts given lat/lon in WGS84 Datum to XY in Spherical Mercator EPSG:900913 | LatLonToMeters | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def MetersToLatLon(self, mx, my):
'''Converts XY point from Spherical Mercator EPSG:900913 to lat/lon in WGS84 Datum'''
lon = mx / self.originShift * 180.0
lat = my / self.originShift * 180.0
lat = 180 / math.pi * (2 * math.atan(math.exp(lat * math.pi
/ 180.0)) - math.pi / 2.0)
return (lat, lon) | Converts XY point from Spherical Mercator EPSG:900913 to lat/lon in WGS84 Datum | MetersToLatLon | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def PixelsToMeters(
self,
px,
py,
zoom,
):
'''Converts pixel coordinates in given zoom level of pyramid to EPSG:900913'''
res = self.Resolution(zoom)
mx = px * res - self.originShift
my = py * res - self.originShift
return (mx, my) | Converts pixel coordinates in given zoom level of pyramid to EPSG:900913 | PixelsToMeters | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def MetersToPixels(
self,
mx,
my,
zoom,
):
'''Converts EPSG:900913 to pyramid pixel coordinates in given zoom level'''
res = self.Resolution(zoom)
px = (mx + self.originShift) / res
py = (my + self.originShift) / res
return (px, py) | Converts EPSG:900913 to pyramid pixel coordinates in given zoom level | MetersToPixels | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def PixelsToTile(self, px, py):
'''Returns a tile covering region in given pixel coordinates'''
tx = int(math.ceil(px / float(self.tileSize)) - 1)
ty = int(math.ceil(py / float(self.tileSize)) - 1)
return (tx, ty) | Returns a tile covering region in given pixel coordinates | PixelsToTile | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def PixelsToRaster(
self,
px,
py,
zoom,
):
'''Move the origin of pixel coordinates to top-left corner'''
mapSize = self.tileSize << zoom
return (px, mapSize - py) | Move the origin of pixel coordinates to top-left corner | PixelsToRaster | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def MetersToTile(
self,
mx,
my,
zoom,
):
'''Returns tile for given mercator coordinates'''
(px, py) = self.MetersToPixels(mx, my, zoom)
return self.PixelsToTile(px, py) | Returns tile for given mercator coordinates | MetersToTile | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def TileBounds(
self,
tx,
ty,
zoom,
):
'''Returns bounds of the given tile in EPSG:900913 coordinates'''
(minx, miny) = self.PixelsToMeters(tx * self.tileSize, ty
* self.tileSize, zoom)
(maxx, maxy) = self.PixelsToMeters((tx + 1) * self.tileSize,
(ty + 1) * self.tileSize, zoom)
return (minx, miny, maxx, maxy) | Returns bounds of the given tile in EPSG:900913 coordinates | TileBounds | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def TileLatLonBounds(
self,
tx,
ty,
zoom,
):
'''Returns bounds of the given tile in latutude/longitude using WGS84 datum'''
bounds = self.TileBounds(tx, ty, zoom)
(minLat, minLon) = self.MetersToLatLon(bounds[0], bounds[1])
(maxLat, maxLon) = self.MetersToLatLon(bounds[2], bounds[3])
return (minLat, minLon, maxLat, maxLon) | Returns bounds of the given tile in latutude/longitude using WGS84 datum | TileLatLonBounds | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def Resolution(self, zoom):
'''Resolution (meters/pixel) for given zoom level (measured at Equator)'''
# return (2 * math.pi * 6378137) / (self.tileSize * 2**zoom)
return self.initialResolution / 2 ** zoom | Resolution (meters/pixel) for given zoom level (measured at Equator) | Resolution | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def ZoomForPixelSize(self, pixelSize):
'''Maximal scaledown zoom of the pyramid closest to the pixelSize.'''
for i in range(MAXZOOMLEVEL):
if pixelSize > self.Resolution(i):
if i != 0:
return i - 1
else:
return 0 # We don't want to scale up | Maximal scaledown zoom of the pyramid closest to the pixelSize. | ZoomForPixelSize | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def GoogleTile(
self,
tx,
ty,
zoom,
):
'''Converts TMS tile coordinates to Google Tile coordinates'''
# coordinate origin is moved from bottom-left to top-left corner of the extent
return (tx, 2 ** zoom - 1 - ty) | Converts TMS tile coordinates to Google Tile coordinates | GoogleTile | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def QuadTree(
self,
tx,
ty,
zoom,
):
'''Converts TMS tile coordinates to Microsoft QuadTree'''
quadKey = ''
ty = 2 ** zoom - 1 - ty
for i in range(zoom, 0, -1):
digit = 0
mask = 1 << i - 1
if tx & mask != 0:
digit += 1
if ty & mask != 0:
digit += 2
quadKey += str(digit)
return quadKey | Converts TMS tile coordinates to Microsoft QuadTree | QuadTree | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def LonLatToPixels(
self,
lon,
lat,
zoom,
):
'''Converts lon/lat to pixel coordinates in given zoom of the EPSG:4326 pyramid'''
res = self.resFact / 2 ** zoom
px = (180 + lon) / res
py = (90 + lat) / res
return (px, py) | Converts lon/lat to pixel coordinates in given zoom of the EPSG:4326 pyramid | LonLatToPixels | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def PixelsToTile(self, px, py):
'''Returns coordinates of the tile covering region in pixel coordinates'''
tx = int(math.ceil(px / float(self.tileSize)) - 1)
ty = int(math.ceil(py / float(self.tileSize)) - 1)
return (tx, ty) | Returns coordinates of the tile covering region in pixel coordinates | PixelsToTile | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def LonLatToTile(
self,
lon,
lat,
zoom,
):
'''Returns the tile for zoom which covers given lon/lat coordinates'''
(px, py) = self.LonLatToPixels(lon, lat, zoom)
return self.PixelsToTile(px, py) | Returns the tile for zoom which covers given lon/lat coordinates | LonLatToTile | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def Resolution(self, zoom):
'''Resolution (arc/pixel) for given zoom level (measured at Equator)'''
return self.resFact / 2 ** zoom
# return 180 / float( 1 << (8+zoom) ) | Resolution (arc/pixel) for given zoom level (measured at Equator) | Resolution | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def ZoomForPixelSize(self, pixelSize):
'''Maximal scaledown zoom of the pyramid closest to the pixelSize.'''
for i in range(MAXZOOMLEVEL):
if pixelSize > self.Resolution(i):
if i != 0:
return i - 1
else:
return 0 # We don't want to scale up | Maximal scaledown zoom of the pyramid closest to the pixelSize. | ZoomForPixelSize | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def TileBounds(
self,
tx,
ty,
zoom,
):
'''Returns bounds of the given tile'''
res = self.resFact / 2 ** zoom
return (tx * self.tileSize * res - 180, ty * self.tileSize
* res - 90, (tx + 1) * self.tileSize * res - 180, (ty
+ 1) * self.tileSize * res - 90) | Returns bounds of the given tile | TileBounds | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def TileLatLonBounds(
self,
tx,
ty,
zoom,
):
'''Returns bounds of the given tile in the SWNE form'''
b = self.TileBounds(tx, ty, zoom)
return (b[1], b[0], b[3], b[2]) | Returns bounds of the given tile in the SWNE form | TileLatLonBounds | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def __init__(
self,
width,
height,
tilesize=256,
tileformat='jpg',
):
"""Initialization of the Zoomify tile tree"""
self.tilesize = tilesize
self.tileformat = tileformat
imagesize = (width, height)
tiles = (math.ceil(width / tilesize), math.ceil(height
/ tilesize))
# Size (in tiles) for each tier of pyramid.
self.tierSizeInTiles = []
self.tierSizeInTiles.push(tiles)
# Image size in pixels for each pyramid tierself
self.tierImageSize = []
self.tierImageSize.append(imagesize)
while imagesize[0] > tilesize or imageSize[1] > tilesize:
imagesize = (math.floor(imagesize[0] / 2),
math.floor(imagesize[1] / 2))
tiles = (math.ceil(imagesize[0] / tilesize),
math.ceil(imagesize[1] / tilesize))
self.tierSizeInTiles.append(tiles)
self.tierImageSize.append(imagesize)
self.tierSizeInTiles.reverse()
self.tierImageSize.reverse()
# Depth of the Zoomify pyramid, number of tiers (zoom levels)
self.numberOfTiers = len(self.tierSizeInTiles)
# Number of tiles up to the given tier of pyramid.
self.tileCountUpToTier = []
self.tileCountUpToTier[0] = 0
for i in range(1, self.numberOfTiers + 1):
self.tileCountUpToTier.append(self.tierSizeInTiles[i
- 1][0] * self.tierSizeInTiles[i - 1][1]
+ self.tileCountUpToTier[i - 1]) | Initialization of the Zoomify tile tree | __init__ | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def tilefilename(
self,
x,
y,
z,
):
"""Returns filename for tile with given coordinates"""
tileIndex = x + y * self.tierSizeInTiles[z][0] \
+ self.tileCountUpToTier[z]
return os.path.join('TileGroup%.0f' % math.floor(tileIndex
/ 256), '%s-%s-%s.%s' % (z, x, y,
self.tileformat)) | Returns filename for tile with given coordinates | tilefilename | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def process(self):
"""The main processing function, runs all the main steps of processing"""
# Opening and preprocessing of the input file
self.open_input()
# Generation of main metadata files and HTML viewers
self.generate_metadata()
# Generation of the lowest tiles
self.generate_base_tiles()
# Generation of the overview tiles (higher in the pyramid)
self.generate_overview_tiles() | The main processing function, runs all the main steps of processing | process | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def error(self, msg, details=''):
"""Print an error message and stop the processing"""
if details:
self.parser.error(msg + '''
''' + details)
else:
self.parser.error(msg) | Print an error message and stop the processing | error | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def optparse_init(self):
"""Prepare the option parser for input (argv)"""
from optparse import OptionParser, OptionGroup
usage = 'Usage: %prog [options] input_file(s) [output]'
p = OptionParser(usage, version='%prog ' + __version__)
p.add_option(
'-p',
'--profile',
dest='profile',
type='choice',
choices=profile_list,
help="Tile cutting profile (%s) - default 'mercator' (Google Maps compatible)"
% ','.join(profile_list),
)
p.add_option(
'-r',
'--resampling',
dest='resampling',
type='choice',
choices=resampling_list,
help="Resampling method (%s) - default 'average'"
% ','.join(resampling_list),
)
p.add_option('-s', '--s_srs', dest='s_srs', metavar='SRS',
help='The spatial reference system used for the source input data'
)
p.add_option('-z', '--zoom', dest='zoom',
help="Zoom levels to render (format:'2-5' or '10')."
)
p.add_option('-e', '--resume', dest='resume',
action='store_true',
help='Resume mode. Generate only missing files.')
p.add_option('-a', '--srcnodata', dest='srcnodata',
metavar='NODATA',
help='NODATA transparency value to assign to the input data'
)
p.add_option('-d', '--tmscompatible', dest='tmscompatible',
action='store_true',
help='When using the geodetic profile, specifies the base resolution as 0.703125 or 2 tiles at zoom level 0.'
)
p.add_option('-l', '--leaflet', action='store_true',
dest='leaflet',
help="Set 0,0 point to north. For use with 'leaflet'. Requires -p raster. "
)
p.add_option('-v', '--verbose', action='store_true',
dest='verbose',
help='Print status messages to stdout')
# KML options
g = OptionGroup(p, 'KML (Google Earth) options',
'Options for generated Google Earth SuperOverlay metadata'
)
g.add_option('-k', '--force-kml', dest='kml',
action='store_true',
help="Generate KML for Google Earth - default for 'geodetic' profile and 'raster' in EPSG:4326. For a dataset with different projection use with caution!"
)
g.add_option('-n', '--no-kml', dest='kml', action='store_false'
,
help='Avoid automatic generation of KML files for EPSG:4326'
)
g.add_option('-u', '--url', dest='url',
help='URL address where the generated tiles are going to be published'
)
p.add_option_group(g)
# HTML options
g = OptionGroup(p, 'Web viewer options',
'Options for generated HTML viewers a la Google Maps'
)
g.add_option(
'-w',
'--webviewer',
dest='webviewer',
type='choice',
choices=webviewer_list,
help="Web viewer to generate (%s) - default 'all'"
% ','.join(webviewer_list),
)
g.add_option('-t', '--title', dest='title',
help='Title of the map')
g.add_option('-c', '--copyright', dest='copyright',
help='Copyright for the map')
g.add_option('-g', '--googlekey', dest='googlekey',
help='Google Maps API key from http://code.google.com/apis/maps/signup.html'
)
(g.add_option('-b', '--bingkey', dest='bingkey',
help='Bing Maps API key from https://www.bingmapsportal.com/'
), )
p.add_option_group(g)
# TODO: MapFile + TileIndexes per zoom level for efficient MapServer WMS
# g = OptionGroup(p, "WMS MapServer metadata", "Options for generated mapfile and tileindexes for MapServer")
# g.add_option("-i", "--tileindex", dest='wms', action="store_true"
# help="Generate tileindex and mapfile for MapServer (WMS)")
# p.add_option_group(g)
p.set_defaults(
verbose=False,
profile='mercator',
kml=False,
url='',
webviewer='all',
copyright='',
resampling='average',
resume=False,
googlekey='INSERT_YOUR_KEY_HERE',
bingkey='INSERT_YOUR_KEY_HERE',
)
self.parser = p | Prepare the option parser for input (argv) | optparse_init | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def open_input(self):
"""Initialization of the input raster, reprojection if necessary"""
gdal.AllRegister()
# Initialize necessary GDAL drivers
self.out_drv = gdal.GetDriverByName(self.tiledriver)
self.mem_drv = gdal.GetDriverByName('MEM')
if not self.out_drv:
raise Exception("The '%s' driver was not found, is it available in this GDAL build?"
, self.tiledriver)
if not self.mem_drv:
raise Exception("The 'MEM' driver was not found, is it available in this GDAL build?"
)
# Open the input file
if self.input:
self.in_ds = gdal.Open(self.input, gdal.GA_ReadOnly)
else:
raise Exception('No input file was specified')
if self.options.verbose:
print('Input file:', '( %sP x %sL - %s bands)'
% (self.in_ds.RasterXSize, self.in_ds.RasterYSize,
self.in_ds.RasterCount))
if not self.in_ds:
# Note: GDAL prints the ERROR message too
self.error("It is not possible to open the input file '%s'."
% self.input)
# Read metadata from the input file
if self.in_ds.RasterCount == 0:
self.error("Input file '%s' has no raster band"
% self.input)
if self.in_ds.GetRasterBand(1).GetRasterColorTable():
# TODO: Process directly paletted dataset by generating VRT in memory
self.error('Please convert this file to RGB/RGBA and run gdal2tiles on the result.'
,
"""From paletted file you can create RGBA file (temp.vrt) by:
gdal_translate -of vrt -expand rgba %s temp.vrt
then run:
gdal2tiles temp.vrt"""
% self.input)
# Get NODATA value
self.in_nodata = []
for i in range(1, self.in_ds.RasterCount + 1):
if self.in_ds.GetRasterBand(i).GetNoDataValue() != None:
self.in_nodata.append(self.in_ds.GetRasterBand(i).GetNoDataValue())
if self.options.srcnodata:
nds = list(map(float, self.options.srcnodata.split(',')))
if len(nds) < self.in_ds.RasterCount:
self.in_nodata = (nds
* self.in_ds.RasterCount)[:self.in_ds.RasterCount]
else:
self.in_nodata = nds
if self.options.verbose:
print('NODATA: %s' % self.in_nodata)
#
# Here we should have RGBA input dataset opened in self.in_ds
#
if self.options.verbose:
print ('Preprocessed file:', '( %sP x %sL - %s bands)'
% (self.in_ds.RasterXSize, self.in_ds.RasterYSize,
self.in_ds.RasterCount))
# Spatial Reference System of the input raster
self.in_srs = None
if self.options.s_srs:
self.in_srs = osr.SpatialReference()
self.in_srs.SetFromUserInput(self.options.s_srs)
self.in_srs_wkt = self.in_srs.ExportToWkt()
else:
self.in_srs_wkt = self.in_ds.GetProjection()
if not self.in_srs_wkt and self.in_ds.GetGCPCount() != 0:
self.in_srs_wkt = self.in_ds.GetGCPProjection()
if self.in_srs_wkt:
self.in_srs = osr.SpatialReference()
self.in_srs.ImportFromWkt(self.in_srs_wkt)
# elif self.options.profile != 'raster':
# self.error("There is no spatial reference system info included in the input file.","You should run gdal2tiles with --s_srs EPSG:XXXX or similar.")
# Spatial Reference System of tiles
self.out_srs = osr.SpatialReference()
if self.options.profile == 'mercator':
self.out_srs.ImportFromEPSG(900913)
elif self.options.profile == 'geodetic':
self.out_srs.ImportFromEPSG(4326)
else:
self.out_srs = self.in_srs
# Are the reference systems the same? Reproject if necessary.
self.out_ds = None
if self.options.profile in ('mercator', 'geodetic'):
if self.in_ds.GetGeoTransform() == (
0.0,
1.0,
0.0,
0.0,
0.0,
1.0,
) and self.in_ds.GetGCPCount() == 0:
self.error("There is no georeference - neither affine transformation (worldfile) nor GCPs. You can generate only 'raster' profile tiles."
,
"Either gdal2tiles with parameter -p 'raster' or use another GIS software for georeference e.g. gdal_transform -gcp / -a_ullr / -a_srs"
)
if self.in_srs:
if self.in_srs.ExportToProj4() \
!= self.out_srs.ExportToProj4() \
or self.in_ds.GetGCPCount() != 0:
# Generation of VRT dataset in tile projection, default 'nearest neighbour' warping
self.out_ds = gdal.AutoCreateWarpedVRT(self.in_ds,
self.in_srs_wkt, self.out_srs.ExportToWkt())
# TODO: HIGH PRIORITY: Correction of AutoCreateWarpedVRT according the max zoomlevel for correct direct warping!!!
if self.options.verbose:
print("Warping of the raster by AutoCreateWarpedVRT (result saved into 'tiles.vrt')")
self.out_ds.GetDriver().CreateCopy('tiles.vrt',
self.out_ds)
# Note: self.in_srs and self.in_srs_wkt contain still the non-warped reference system!!!
# Correction of AutoCreateWarpedVRT for NODATA values
if self.in_nodata != []:
import tempfile
tempfilename = tempfile.mktemp('-gdal2tiles.vrt'
)
self.out_ds.GetDriver().CreateCopy(tempfilename,
self.out_ds)
# open as a text file
s = open(tempfilename).read()
# Add the warping options
s = s.replace("""<GDALWarpOptions>""",
"""<GDALWarpOptions>
<Option name="INIT_DEST">NO_DATA</Option>
<Option name="UNIFIED_SRC_NODATA">YES</Option>""")
# replace BandMapping tag for NODATA bands....
for i in range(len(self.in_nodata)):
s = \
s.replace("""<BandMapping src="%i" dst="%i"/>"""
% (i + 1, i + 1),
"""<BandMapping src="%i" dst="%i">
<SrcNoDataReal>%i</SrcNoDataReal>
<SrcNoDataImag>0</SrcNoDataImag>
<DstNoDataReal>%i</DstNoDataReal>
<DstNoDataImag>0</DstNoDataImag>
</BandMapping>"""
% (i + 1, i + 1, self.in_nodata[i],
self.in_nodata[i])) # Or rewrite to white by: , 255 ))
# save the corrected VRT
open(tempfilename, 'w').write(s)
# open by GDAL as self.out_ds
self.out_ds = gdal.Open(tempfilename) # , gdal.GA_ReadOnly)
# delete the temporary file
os.unlink(tempfilename)
# set NODATA_VALUE metadata
self.out_ds.SetMetadataItem('NODATA_VALUES',
'%i %i %i' % (self.in_nodata[0],
self.in_nodata[1], self.in_nodata[2]))
if self.options.verbose:
print("Modified warping result saved into 'tiles1.vrt'")
open('tiles1.vrt', 'w').write(s)
# -----------------------------------
# Correction of AutoCreateWarpedVRT for Mono (1 band) and RGB (3 bands) files without NODATA:
# equivalent of gdalwarp -dstalpha
if self.in_nodata == [] and self.out_ds.RasterCount \
in [1, 3]:
import tempfile
tempfilename = tempfile.mktemp('-gdal2tiles.vrt'
)
self.out_ds.GetDriver().CreateCopy(tempfilename,
self.out_ds)
# open as a text file
s = open(tempfilename).read()
# Add the warping options
s = s.replace("""<BlockXSize>""",
"""<VRTRasterBand dataType="Byte" band="%i" subClass="VRTWarpedRasterBand">
<ColorInterp>Alpha</ColorInterp>
</VRTRasterBand>
<BlockXSize>"""
% (self.out_ds.RasterCount + 1))
s = s.replace("""</GDALWarpOptions>""",
"""<DstAlphaBand>%i</DstAlphaBand>
</GDALWarpOptions>"""
% (self.out_ds.RasterCount + 1))
s = s.replace("""</WorkingDataType>""",
"""</WorkingDataType>
<Option name="INIT_DEST">0</Option>"""
)
# save the corrected VRT
open(tempfilename, 'w').write(s)
# open by GDAL as self.out_ds
self.out_ds = gdal.Open(tempfilename) # , gdal.GA_ReadOnly)
# delete the temporary file
os.unlink(tempfilename)
if self.options.verbose:
print("Modified -dstalpha warping result saved into 'tiles1.vrt'")
open('tiles1.vrt', 'w').write(s)
s = '''
'''
else:
self.error('Input file has unknown SRS.',
'Use --s_srs ESPG:xyz (or similar) to provide source reference system.'
)
if self.out_ds and self.options.verbose:
print ('Projected file:', 'tiles.vrt',
'( %sP x %sL - %s bands)'
% (self.out_ds.RasterXSize,
self.out_ds.RasterYSize,
self.out_ds.RasterCount))
if not self.out_ds:
self.out_ds = self.in_ds
#
# Here we should have a raster (out_ds) in the correct Spatial Reference system
#
# Get alpha band (either directly or from NODATA value)
self.alphaband = self.out_ds.GetRasterBand(1).GetMaskBand()
if self.alphaband.GetMaskFlags() & gdal.GMF_ALPHA \
or self.out_ds.RasterCount == 4 or self.out_ds.RasterCount \
== 2:
# TODO: Better test for alpha band in the dataset
self.dataBandsCount = self.out_ds.RasterCount - 1
else:
self.dataBandsCount = self.out_ds.RasterCount
# KML test
self.isepsg4326 = False
srs4326 = osr.SpatialReference()
srs4326.ImportFromEPSG(4326)
if self.out_srs and srs4326.ExportToProj4() \
== self.out_srs.ExportToProj4():
self.kml = True
self.isepsg4326 = True
if self.options.verbose:
print('KML autotest OK!')
# Read the georeference
self.out_gt = self.out_ds.GetGeoTransform()
# originX, originY = self.out_gt[0], self.out_gt[3]
# pixelSize = self.out_gt[1] # = self.out_gt[5]
# Test the size of the pixel
# MAPTILER - COMMENTED
# if self.out_gt[1] != (-1 * self.out_gt[5]) and self.options.profile != 'raster':
# TODO: Process corectly coordinates with are have swichted Y axis (display in OpenLayers too)
# self.error("Size of the pixel in the output differ for X and Y axes.")
# Report error in case rotation/skew is in geotransform (possible only in 'raster' profile)
if (self.out_gt[2], self.out_gt[4]) != (0, 0):
self.error('Georeference of the raster contains rotation or skew. Such raster is not supported. Please use gdalwarp first.'
)
# TODO: Do the warping in this case automaticaly
#
# Here we expect: pixel is square, no rotation on the raster
#
# Output Bounds - coordinates in the output SRS
self.ominx = self.out_gt[0]
self.omaxx = self.out_gt[0] + self.out_ds.RasterXSize \
* self.out_gt[1]
self.omaxy = self.out_gt[3]
self.ominy = self.out_gt[3] - self.out_ds.RasterYSize \
* self.out_gt[1]
# Note: maybe round(x, 14) to avoid the gdal_translate behaviour, when 0 becomes -1e-15
if self.options.verbose:
print ('Bounds (output srs):', round(self.ominx, 13),
self.ominy, self.omaxx, self.omaxy)
#
# Calculating ranges for tiles in different zoom levels
#
if self.options.profile == 'mercator':
self.mercator = GlobalMercator() # from globalmaptiles.py
# Function which generates SWNE in LatLong for given tile
self.tileswne = self.mercator.TileLatLonBounds
# Generate table with min max tile coordinates for all zoomlevels
self.tminmax = list(range(0, 32))
for tz in range(0, 32):
(tminx, tminy) = self.mercator.MetersToTile(self.ominx,
self.ominy, tz)
(tmaxx, tmaxy) = self.mercator.MetersToTile(self.omaxx,
self.omaxy, tz)
# crop tiles extending world limits (+-180,+-90)
(tminx, tminy) = (max(0, tminx), max(0, tminy))
(tmaxx, tmaxy) = (min(2 ** tz - 1, tmaxx), min(2 ** tz
- 1, tmaxy))
self.tminmax[tz] = (tminx, tminy, tmaxx, tmaxy)
# TODO: Maps crossing 180E (Alaska?)
# Get the minimal zoom level (map covers area equivalent to one tile)
if self.tminz == None:
self.tminz = \
self.mercator.ZoomForPixelSize(self.out_gt[1]
* max(self.out_ds.RasterXSize,
self.out_ds.RasterYSize) / float(self.tilesize))
# Get the maximal zoom level (closest possible zoom level up on the resolution of raster)
if self.tmaxz == None:
self.tmaxz = \
self.mercator.ZoomForPixelSize(self.out_gt[1])
if self.options.verbose:
print ('Bounds (latlong):',
self.mercator.MetersToLatLon(self.ominx,
self.ominy),
self.mercator.MetersToLatLon(self.omaxx,
self.omaxy))
print ('MinZoomLevel:', self.tminz)
print ('MaxZoomLevel:', self.tmaxz, '(',
self.mercator.Resolution(self.tmaxz), ')')
if self.options.profile == 'geodetic':
self.geodetic = GlobalGeodetic(self.options.tmscompatible) # from globalmaptiles.py
# Function which generates SWNE in LatLong for given tile
self.tileswne = self.geodetic.TileLatLonBounds
# Generate table with min max tile coordinates for all zoomlevels
self.tminmax = list(range(0, 32))
for tz in range(0, 32):
(tminx, tminy) = self.geodetic.LonLatToTile(self.ominx,
self.ominy, tz)
(tmaxx, tmaxy) = self.geodetic.LonLatToTile(self.omaxx,
self.omaxy, tz)
# crop tiles extending world limits (+-180,+-90)
(tminx, tminy) = (max(0, tminx), max(0, tminy))
(tmaxx, tmaxy) = (min(2 ** (tz + 1) - 1, tmaxx), min(2
** tz - 1, tmaxy))
self.tminmax[tz] = (tminx, tminy, tmaxx, tmaxy)
# TODO: Maps crossing 180E (Alaska?)
# Get the maximal zoom level (closest possible zoom level up on the resolution of raster)
if self.tminz == None:
self.tminz = \
self.geodetic.ZoomForPixelSize(self.out_gt[1]
* max(self.out_ds.RasterXSize,
self.out_ds.RasterYSize) / float(self.tilesize))
# Get the maximal zoom level (closest possible zoom level up on the resolution of raster)
if self.tmaxz == None:
self.tmaxz = \
self.geodetic.ZoomForPixelSize(self.out_gt[1])
if self.options.verbose:
print ('Bounds (latlong):', self.ominx, self.ominy,
self.omaxx, self.omaxy)
if self.options.profile == 'raster':
log2 = lambda x: math.log10(x) / math.log10(2) # log2 (base 2 logarithm)
self.nativezoom = \
int(max(math.ceil(log2(self.out_ds.RasterXSize
/ float(self.tilesize))),
math.ceil(log2(self.out_ds.RasterYSize
/ float(self.tilesize)))))
if int(self.tmaxz or 0) < self.nativezoom:
self.tmaxz = self.nativezoom
if self.options.verbose:
print ('Native zoom of the raster:', self.nativezoom)
# Get the minimal zoom level (whole raster in one tile)
if self.tminz == None:
self.tminz = 0
# Get the maximal zoom level (native resolution of the raster)
if self.tmaxz == None:
self.tmaxz = self.nativezoom
# Generate table with min max tile coordinates for all zoomlevels
self.tminmax = list(range(0, self.tmaxz + 1))
self.tsize = list(range(0, self.tmaxz + 1))
for tz in range(0, self.tmaxz + 1):
tsize = 2.0 ** (self.nativezoom - tz) * self.tilesize
(tminx, tminy) = (0, 0)
tmaxx = int(math.ceil(self.out_ds.RasterXSize / tsize)) \
- 1
tmaxy = int(math.ceil(self.out_ds.RasterYSize / tsize)) \
- 1
self.tsize[tz] = math.ceil(tsize)
self.tminmax[tz] = (tminx, tminy, tmaxx, tmaxy)
# Function which generates SWNE in LatLong for given tile
if self.kml and self.in_srs_wkt:
self.ct = osr.CoordinateTransformation(self.in_srs,
srs4326)
def rastertileswne(x, y, z):
pixelsizex = 2 ** (self.tmaxz - z) * self.out_gt[1] # X-pixel size in level
pixelsizey = 2 ** (self.tmaxz - z) * self.out_gt[1] # Y-pixel size in level (usually -1*pixelsizex)
west = self.out_gt[0] + x * self.tilesize \
* pixelsizex
east = west + self.tilesize * pixelsizex
south = self.ominy + y * self.tilesize * pixelsizex
north = south + self.tilesize * pixelsizex
if not self.isepsg4326:
# Transformation to EPSG:4326 (WGS84 datum)
(west, south) = self.ct.TransformPoint(west,
south)[:2]
(east, north) = self.ct.TransformPoint(east,
north)[:2]
return (south, west, north, east)
self.tileswne = rastertileswne
else:
self.tileswne = lambda x, y, z: (0, 0, 0, 0) | Initialization of the input raster, reprojection if necessary | open_input | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def generate_metadata(self):
"""Generation of main metadata files and HTML viewers (metadata related to particular tiles are generated during the tile processing)."""
if not os.path.exists(self.output):
os.makedirs(self.output)
if self.options.profile == 'mercator':
(south, west) = self.mercator.MetersToLatLon(self.ominx,
self.ominy)
(north, east) = self.mercator.MetersToLatLon(self.omaxx,
self.omaxy)
(south, west) = (max(-85.05112878, south), max(-180.0,
west))
(north, east) = (min(85.05112878, north), min(180.0, east))
self.swne = (south, west, north, east)
# Generate googlemaps.html
if self.options.webviewer in ('all', 'google') \
and self.options.profile == 'mercator':
if not self.options.resume \
or not os.path.exists(os.path.join(self.output,
'googlemaps.html')):
f = open(os.path.join(self.output, 'googlemaps.html'
), 'w')
f.write(self.generate_googlemaps())
f.close()
# Generate openlayers.html
if self.options.webviewer in ('all', 'openlayers'):
if not self.options.resume \
or not os.path.exists(os.path.join(self.output,
'openlayers.html')):
f = open(os.path.join(self.output, 'openlayers.html'
), 'w')
f.write(self.generate_openlayers())
f.close()
elif self.options.profile == 'geodetic':
(west, south) = (self.ominx, self.ominy)
(east, north) = (self.omaxx, self.omaxy)
(south, west) = (max(-90.0, south), max(-180.0, west))
(north, east) = (min(90.0, north), min(180.0, east))
self.swne = (south, west, north, east)
# Generate openlayers.html
if self.options.webviewer in ('all', 'openlayers'):
if not self.options.resume \
or not os.path.exists(os.path.join(self.output,
'openlayers.html')):
f = open(os.path.join(self.output, 'openlayers.html'
), 'w')
f.write(self.generate_openlayers())
f.close()
elif self.options.profile == 'raster':
(west, south) = (self.ominx, self.ominy)
(east, north) = (self.omaxx, self.omaxy)
self.swne = (south, west, north, east)
# Generate openlayers.html
if self.options.webviewer in ('all', 'openlayers'):
if not self.options.resume \
or not os.path.exists(os.path.join(self.output,
'openlayers.html')):
f = open(os.path.join(self.output, 'openlayers.html'
), 'w')
f.write(self.generate_openlayers())
f.close()
# Generate tilemapresource.xml.
if not self.options.resume \
or not os.path.exists(os.path.join(self.output,
'tilemapresource.xml')):
f = open(os.path.join(self.output, 'tilemapresource.xml'),
'w')
f.write(self.generate_tilemapresource())
f.close()
if self.kml:
# TODO: Maybe problem for not automatically generated tminz
# The root KML should contain links to all tiles in the tminz level
children = []
(xmin, ymin, xmax, ymax) = self.tminmax[self.tminz]
for x in range(xmin, xmax + 1):
for y in range(ymin, ymax + 1):
children.append([x, y, self.tminz])
# Generate Root KML
if self.kml:
if not self.options.resume \
or not os.path.exists(os.path.join(self.output,
'doc.kml')):
f = open(os.path.join(self.output, 'doc.kml'), 'w')
f.write(self.generate_kml(None, None, None,
children))
f.close() | Generation of main metadata files and HTML viewers (metadata related to particular tiles are generated during the tile processing). | generate_metadata | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def generate_base_tiles(self):
"""Generation of the base tiles (the lowest in the pyramid) directly from the input raster"""
print('Generating Base Tiles:')
if self.options.verbose:
# mx, my = self.out_gt[0], self.out_gt[3] # OriginX, OriginY
# px, py = self.mercator.MetersToPixels( mx, my, self.tmaxz)
# print("Pixel coordinates:", px, py, (mx, my))
print('')
print('Tiles generated from the max zoom level:')
print('----------------------------------------')
print('')
# Set the bounds
(tminx, tminy, tmaxx, tmaxy) = self.tminmax[self.tmaxz]
# Just the center tile
# tminx = tminx+ (tmaxx - tminx)/2
# tminy = tminy+ (tmaxy - tminy)/2
# tmaxx = tminx
# tmaxy = tminy
ds = self.out_ds
tilebands = self.dataBandsCount + 1
querysize = self.querysize
if self.options.verbose:
print ('dataBandsCount: ', self.dataBandsCount)
print ('tilebands: ', tilebands)
# print(tminx, tminy, tmaxx, tmaxy)
tcount = (1 + abs(tmaxx - tminx)) * (1 + abs(tmaxy - tminy))
# print(tcount)
ti = 0
tz = self.tmaxz
yrange = range(tmaxy, tminy - 1, -1)
if self.options.leaflet:
yrange = range(tminy, tmaxy + 1)
for ty in yrange:
for tx in range(tminx, tmaxx + 1):
if self.stopped:
break
ti += 1
tilefilename = os.path.join(self.output, str(tz),
str(tx), '%s.%s' % (ty, self.tileext))
if self.options.verbose:
print (ti, '/', tcount, tilefilename) # , "( TileMapService: z / x / y )"
if self.options.resume and os.path.exists(tilefilename):
if self.options.verbose:
print('Tile generation skiped because of --resume')
else:
self.progressbar(ti / float(tcount))
continue
# Create directories for the tile
if not os.path.exists(os.path.dirname(tilefilename)):
os.makedirs(os.path.dirname(tilefilename))
if self.options.profile == 'mercator':
# Tile bounds in EPSG:900913
b = self.mercator.TileBounds(tx, ty, tz)
elif self.options.profile == 'geodetic':
b = self.geodetic.TileBounds(tx, ty, tz)
# print("\tgdalwarp -ts 256 256 -te %s %s %s %s %s %s_%s_%s.tif" % ( b[0], b[1], b[2], b[3], "tiles.vrt", tz, tx, ty))
# Don't scale up by nearest neighbour, better change the querysize
# to the native resolution (and return smaller query tile) for scaling
if self.options.profile in ('mercator', 'geodetic'):
(rb, wb) = self.geo_query(ds, b[0], b[3], b[2],
b[1])
nativesize = wb[0] + wb[2] # Pixel size in the raster covering query geo extent
if self.options.verbose:
print ('\tNative Extent (querysize',
nativesize, '): ', rb, wb)
# Tile bounds in raster coordinates for ReadRaster query
(rb, wb) = self.geo_query(
ds,
b[0],
b[3],
b[2],
b[1],
querysize=querysize,
)
(rx, ry, rxsize, rysize) = rb
(wx, wy, wxsize, wysize) = wb
else:
# 'raster' profile:
tsize = int(self.tsize[tz]) # tilesize in raster coordinates for actual zoom
xsize = self.out_ds.RasterXSize # size of the raster in pixels
ysize = self.out_ds.RasterYSize
if tz >= self.nativezoom:
querysize = self.tilesize # int(2**(self.nativezoom-tz) * self.tilesize)
rx = tx * tsize
rxsize = 0
if tx == tmaxx:
rxsize = xsize % tsize
if rxsize == 0:
rxsize = tsize
rysize = 0
if ty == tmaxy:
rysize = ysize % tsize
if rysize == 0:
rysize = tsize
if self.options.leaflet:
ry = ty * tsize
else:
ry = ysize - ty * tsize - rysize
(wx, wy) = (0, 0)
(wxsize, wysize) = (int(rxsize / float(tsize)
* self.tilesize), int(rysize / float(tsize)
* self.tilesize))
if not self.options.leaflet:
if wysize != self.tilesize:
wy = self.tilesize - wysize
if self.options.verbose:
print ('\tReadRaster Extent: ', (rx, ry, rxsize,
rysize), (wx, wy, wxsize, wysize))
# Query is in 'nearest neighbour' but can be bigger in then the tilesize
# We scale down the query to the tilesize by supplied algorithm.
# Tile dataset in memory
dstile = self.mem_drv.Create('', self.tilesize,
self.tilesize, tilebands)
data = ds.ReadRaster(
rx,
ry,
rxsize,
rysize,
wxsize,
wysize,
band_list=list(range(1, self.dataBandsCount + 1)),
)
alpha = self.alphaband.ReadRaster(
rx,
ry,
rxsize,
rysize,
wxsize,
wysize,
)
if self.tilesize == querysize:
# Use the ReadRaster result directly in tiles ('nearest neighbour' query)
dstile.WriteRaster(
wx,
wy,
wxsize,
wysize,
data,
band_list=list(range(1, self.dataBandsCount
+ 1)),
)
dstile.WriteRaster(
wx,
wy,
wxsize,
wysize,
alpha,
band_list=[tilebands],
)
else:
# Note: For source drivers based on WaveLet compression (JPEG2000, ECW, MrSID)
# the ReadRaster function returns high-quality raster (not ugly nearest neighbour)
# TODO: Use directly 'near' for WaveLet files
# Big ReadRaster query in memory scaled to the tilesize - all but 'near' algo
dsquery = self.mem_drv.Create('', querysize,
querysize, tilebands)
# TODO: fill the null value in case a tile without alpha is produced (now only png tiles are supported)
# for i in range(1, tilebands+1):
# dsquery.GetRasterBand(1).Fill(tilenodata)
dsquery.WriteRaster(
wx,
wy,
wxsize,
wysize,
data,
band_list=list(range(1, self.dataBandsCount
+ 1)),
)
dsquery.WriteRaster(
wx,
wy,
wxsize,
wysize,
alpha,
band_list=[tilebands],
)
self.scale_query_to_tile(dsquery, dstile,
tilefilename)
del dsquery
del data
if self.options.resampling != 'antialias':
# Write a copy of tile to png/jpg
self.out_drv.CreateCopy(tilefilename, dstile,
strict=0)
del dstile
# Create a KML file for this tile.
if self.kml:
kmlfilename = os.path.join(self.output, str(tz),
str(tx), '%d.kml' % ty)
if not self.options.resume \
or not os.path.exists(kmlfilename):
f = open(kmlfilename, 'w')
f.write(self.generate_kml(tx, ty, tz))
f.close()
if not self.options.verbose:
self.progressbar(ti / float(tcount)) | Generation of the base tiles (the lowest in the pyramid) directly from the input raster | generate_base_tiles | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def generate_overview_tiles(self):
"""Generation of the overview tiles (higher in the pyramid) based on existing tiles"""
print('Generating Overview Tiles:')
tilebands = self.dataBandsCount + 1
# Usage of existing tiles: from 4 underlying tiles generate one as overview.
tcount = 0
for tz in range(self.tmaxz - 1, self.tminz - 1, -1):
(tminx, tminy, tmaxx, tmaxy) = self.tminmax[tz]
tcount += (1 + abs(tmaxx - tminx)) * (1 + abs(tmaxy
- tminy))
ti = 0
# querysize = tilesize * 2
for tz in range(self.tmaxz - 1, self.tminz - 1, -1):
(tminx, tminy, tmaxx, tmaxy) = self.tminmax[tz]
yrange = range(tmaxy, tminy - 1, -1)
if self.options.leaflet:
yrange = range(tminy, tmaxy + 1)
for ty in yrange:
for tx in range(tminx, tmaxx + 1):
if self.stopped:
break
ti += 1
tilefilename = os.path.join(self.output, str(tz),
str(tx), '%s.%s' % (ty, self.tileext))
if self.options.verbose:
print (ti, '/', tcount, tilefilename) # , "( TileMapService: z / x / y )"
if self.options.resume \
and os.path.exists(tilefilename):
if self.options.verbose:
print('Tile generation skiped because of --resume')
else:
self.progressbar(ti / float(tcount))
continue
# Create directories for the tile
if not os.path.exists(os.path.dirname(tilefilename)):
os.makedirs(os.path.dirname(tilefilename))
dsquery = self.mem_drv.Create('', 2
* self.tilesize, 2 * self.tilesize,
tilebands)
# TODO: fill the null value
# for i in range(1, tilebands+1):
# dsquery.GetRasterBand(1).Fill(tilenodata)
dstile = self.mem_drv.Create('', self.tilesize,
self.tilesize, tilebands)
# TODO: Implement more clever walking on the tiles with cache functionality
# probably walk should start with reading of four tiles from top left corner
# Hilbert curve
children = []
# Read the tiles and write them to query window
for y in range(2 * ty, 2 * ty + 2):
for x in range(2 * tx, 2 * tx + 2):
(minx, miny, maxx, maxy) = self.tminmax[tz
+ 1]
if x >= minx and x <= maxx and y >= miny \
and y <= maxy:
dsquerytile = \
gdal.Open(os.path.join(self.output,
str(tz + 1), str(x), '%s.%s'
% (y, self.tileext)),
gdal.GA_ReadOnly)
if self.options.leaflet:
if ty:
tileposy = y % (2 * ty) \
* self.tilesize
elif ty == 0 and y == 1:
tileposy = self.tilesize
else:
tileposy = 0
else:
if ty == 0 and y == 1 or ty != 0 \
and y % (2 * ty) != 0:
tileposy = 0
else:
tileposy = self.tilesize
if tx:
tileposx = x % (2 * tx) \
* self.tilesize
elif tx == 0 and x == 1:
tileposx = self.tilesize
else:
tileposx = 0
dsquery.WriteRaster(
tileposx,
tileposy,
self.tilesize,
self.tilesize,
dsquerytile.ReadRaster(0, 0,
self.tilesize, self.tilesize),
band_list=list(range(1, tilebands
+ 1)),
)
children.append([x, y, tz + 1])
self.scale_query_to_tile(dsquery, dstile,
tilefilename)
# Write a copy of tile to png/jpg
if self.options.resampling != 'antialias':
# Write a copy of tile to png/jpg
self.out_drv.CreateCopy(tilefilename, dstile,
strict=0)
if self.options.verbose:
print (
'\tbuild from zoom',
tz + 1,
' tiles:',
(2 * tx, 2 * ty),
(2 * tx + 1, 2 * ty),
(2 * tx, 2 * ty + 1),
(2 * tx + 1, 2 * ty + 1),
)
# Create a KML file for this tile.
if self.kml:
f = open(os.path.join(self.output,
'%d/%d/%d.kml' % (tz, tx, ty)), 'w')
f.write(self.generate_kml(tx, ty, tz, children))
f.close()
if not self.options.verbose:
self.progressbar(ti / float(tcount)) | Generation of the overview tiles (higher in the pyramid) based on existing tiles | generate_overview_tiles | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def geo_query(
self,
ds,
ulx,
uly,
lrx,
lry,
querysize=0,
):
"""For given dataset and query in cartographic coordinates
returns parameters for ReadRaster() in raster coordinates and
x/y shifts (for border tiles). If the querysize is not given, the
extent is returned in the native resolution of dataset ds."""
geotran = ds.GetGeoTransform()
rx = int((ulx - geotran[0]) / geotran[1] + 0.001)
ry = int((uly - geotran[3]) / geotran[5] + 0.001)
rxsize = int((lrx - ulx) / geotran[1] + 0.5)
rysize = int((lry - uly) / geotran[5] + 0.5)
if not querysize:
(wxsize, wysize) = (rxsize, rysize)
else:
(wxsize, wysize) = (querysize, querysize)
# Coordinates should not go out of the bounds of the raster
wx = 0
if rx < 0:
rxshift = abs(rx)
wx = int(wxsize * (float(rxshift) / rxsize))
wxsize = wxsize - wx
rxsize = rxsize - int(rxsize * (float(rxshift) / rxsize))
rx = 0
if rx + rxsize > ds.RasterXSize:
wxsize = int(wxsize * (float(ds.RasterXSize - rx) / rxsize))
rxsize = ds.RasterXSize - rx
wy = 0
if ry < 0:
ryshift = abs(ry)
wy = int(wysize * (float(ryshift) / rysize))
wysize = wysize - wy
rysize = rysize - int(rysize * (float(ryshift) / rysize))
ry = 0
if ry + rysize > ds.RasterYSize:
wysize = int(wysize * (float(ds.RasterYSize - ry) / rysize))
rysize = ds.RasterYSize - ry
return ((rx, ry, rxsize, rysize), (wx, wy, wxsize, wysize)) | For given dataset and query in cartographic coordinates
returns parameters for ReadRaster() in raster coordinates and
x/y shifts (for border tiles). If the querysize is not given, the
extent is returned in the native resolution of dataset ds. | geo_query | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def scale_query_to_tile(
self,
dsquery,
dstile,
tilefilename='',
):
"""Scales down query dataset to the tile dataset"""
querysize = dsquery.RasterXSize
tilesize = dstile.RasterXSize
tilebands = dstile.RasterCount
if self.options.resampling == 'average':
# Function: gdal.RegenerateOverview()
for i in range(1, tilebands + 1):
# Black border around NODATA
# if i != 4:
# dsquery.GetRasterBand(i).SetNoDataValue(0)
res = gdal.RegenerateOverview(dsquery.GetRasterBand(i),
dstile.GetRasterBand(i), 'average')
if res != 0:
self.error('RegenerateOverview() failed on %s, error %d'
% (tilefilename, res))
elif self.options.resampling == 'antialias':
# Scaling by PIL (Python Imaging Library) - improved Lanczos
array = numpy.zeros((querysize, querysize, tilebands),
numpy.uint8)
for i in range(tilebands):
array[:, :, i] = \
gdalarray.BandReadAsArray(dsquery.GetRasterBand(i
+ 1), 0, 0, querysize, querysize)
im = Image.fromarray(array, 'RGBA') # Always four bands
im1 = im.resize((tilesize, tilesize), Image.ANTIALIAS)
if os.path.exists(tilefilename):
im0 = Image.open(tilefilename)
im1 = Image.composite(im1, im0, im1)
im1.save(tilefilename, self.tiledriver)
else:
# Other algorithms are implemented by gdal.ReprojectImage().
dsquery.SetGeoTransform((
0.0,
tilesize / float(querysize),
0.0,
0.0,
0.0,
tilesize / float(querysize),
))
dstile.SetGeoTransform((
0.0,
1.0,
0.0,
0.0,
0.0,
1.0,
))
res = gdal.ReprojectImage(dsquery, dstile, None, None,
self.resampling)
if res != 0:
self.error('ReprojectImage() failed on %s, error %d'
% (tilefilename, res)) | Scales down query dataset to the tile dataset | scale_query_to_tile | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def generate_tilemapresource(self):
"""
Template for tilemapresource.xml. Returns filled string. Expected variables:
title, north, south, east, west, isepsg4326, projection, publishurl,
zoompixels, tilesize, tileformat, profile
"""
args = {}
args['title'] = self.options.title
(args['south'], args['west'], args['north'], args['east']) = \
self.swne
args['tilesize'] = self.tilesize
args['tileformat'] = self.tileext
args['publishurl'] = self.options.url
args['profile'] = self.options.profile
if self.options.profile == 'mercator':
args['srs'] = 'EPSG:900913'
elif self.options.profile == 'geodetic':
args['srs'] = 'EPSG:4326'
elif self.options.s_srs:
args['srs'] = self.options.s_srs
elif self.out_srs:
args['srs'] = self.out_srs.ExportToWkt()
else:
args['srs'] = ''
s = \
"""<?xml version="1.0" encoding="utf-8"?>
<TileMap version="1.0.0" tilemapservice="http://tms.osgeo.org/1.0.0">
<Title>%(title)s</Title>
<Abstract></Abstract>
<SRS>%(srs)s</SRS>
<BoundingBox minx="%(west).14f" miny="%(south).14f" maxx="%(east).14f" maxy="%(north).14f"/>
<Origin x="%(west).14f" y="%(south).14f"/>
<TileFormat width="%(tilesize)d" height="%(tilesize)d" mime-type="image/%(tileformat)s" extension="%(tileformat)s"/>
<TileSets profile="%(profile)s">
""" \
% args
for z in range(self.tminz, self.tmaxz + 1):
if self.options.profile == 'raster':
s += \
""" <TileSet href="%s%d" units-per-pixel="%.14f" order="%d"/>\n""" \
% (args['publishurl'], z, 2 ** (self.nativezoom
- z) * self.out_gt[1], z)
elif self.options.profile == 'mercator':
s += \
""" <TileSet href="%s%d" units-per-pixel="%.14f" order="%d"/>\n""" \
% (args['publishurl'], z, 156543.0339 / 2 ** z, z)
elif self.options.profile == 'geodetic':
s += \
""" <TileSet href="%s%d" units-per-pixel="%.14f" order="%d"/>\n""" \
% (args['publishurl'], z, 0.703125 / 2 ** z, z)
s += """ </TileSets>
</TileMap>
"""
return s |
Template for tilemapresource.xml. Returns filled string. Expected variables:
title, north, south, east, west, isepsg4326, projection, publishurl,
zoompixels, tilesize, tileformat, profile
| generate_tilemapresource | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def generate_kml(
self,
tx,
ty,
tz,
children=[],
**args
):
"""
Template for the KML. Returns filled string.
"""
(args['tx'], args['ty'], args['tz']) = (tx, ty, tz)
args['tileformat'] = self.tileext
if 'tilesize' not in args:
args['tilesize'] = self.tilesize
if 'minlodpixels' not in args:
args['minlodpixels'] = int(args['tilesize'] / 2) # / 2.56) # default 128
if 'maxlodpixels' not in args:
args['maxlodpixels'] = int(args['tilesize'] * 8) # 1.7) # default 2048 (used to be -1)
if children == []:
args['maxlodpixels'] = -1
if tx == None:
tilekml = False
args['title'] = self.options.title
else:
tilekml = True
args['title'] = '%d/%d/%d.kml' % (tz, tx, ty)
(args['south'], args['west'], args['north'], args['east'
]) = self.tileswne(tx, ty, tz)
if tx == 0:
args['drawOrder'] = 2 * tz + 1
elif tx != None:
args['drawOrder'] = 2 * tz
else:
args['drawOrder'] = 0
url = self.options.url
if not url:
if tilekml:
url = '../../'
else:
url = ''
s = \
"""<?xml version="1.0" encoding="utf-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2">
<Document>
<name>%(title)s</name>
<description></description>
<Style>
<ListStyle id="hideChildren">
<listItemType>checkHideChildren</listItemType>
</ListStyle>
</Style>""" \
% args
if tilekml:
s += \
"""
<Region>
<LatLonAltBox>
<north>%(north).14f</north>
<south>%(south).14f</south>
<east>%(east).14f</east>
<west>%(west).14f</west>
</LatLonAltBox>
<Lod>
<minLodPixels>%(minlodpixels)d</minLodPixels>
<maxLodPixels>%(maxlodpixels)d</maxLodPixels>
</Lod>
</Region>
<GroundOverlay>
<drawOrder>%(drawOrder)d</drawOrder>
<Icon>
<href>%(ty)d.%(tileformat)s</href>
</Icon>
<LatLonBox>
<north>%(north).14f</north>
<south>%(south).14f</south>
<east>%(east).14f</east>
<west>%(west).14f</west>
</LatLonBox>
</GroundOverlay>
""" \
% args
for (cx, cy, cz) in children:
(csouth, cwest, cnorth, ceast) = self.tileswne(cx, cy, cz)
s += \
"""
<NetworkLink>
<name>%d/%d/%d.%s</name>
<Region>
<LatLonAltBox>
<north>%.14f</north>
<south>%.14f</south>
<east>%.14f</east>
<west>%.14f</west>
</LatLonAltBox>
<Lod>
<minLodPixels>%d</minLodPixels>
<maxLodPixels>-1</maxLodPixels>
</Lod>
</Region>
<Link>
<href>%s%d/%d/%d.kml</href>
<viewRefreshMode>onRegion</viewRefreshMode>
<viewFormat/>
</Link>
</NetworkLink>
""" \
% (
cz,
cx,
cy,
args['tileformat'],
cnorth,
csouth,
ceast,
cwest,
args['minlodpixels'],
url,
cz,
cx,
cy,
)
s += """ </Document>
</kml>
"""
return s |
Template for the KML. Returns filled string.
| generate_kml | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def generate_googlemaps(self):
"""
Template for googlemaps.html implementing Overlay of tiles for 'mercator' profile.
It returns filled string. Expected variables:
title, googlemapskey, north, south, east, west, minzoom, maxzoom, tilesize, tileformat, publishurl
"""
args = {}
args['title'] = self.options.title
args['googlemapskey'] = self.options.googlekey
(args['south'], args['west'], args['north'], args['east']) = \
self.swne
args['minzoom'] = self.tminz
args['maxzoom'] = self.tmaxz
args['tilesize'] = self.tilesize
args['tileformat'] = self.tileext
args['publishurl'] = self.options.url
args['copyright'] = self.options.copyright
s = \
"""<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:v="urn:schemas-microsoft-com:vml">
<head>
<title>%(title)s</title>
<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
<meta http-equiv='imagetoolbar' content='no'/>
<style type="text/css"> v\:* {behavior:url(#default#VML);}
html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }
body { margin: 10px; background: #fff; }
h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }
#header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }
#subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}
#map { height: 95%%; border: 1px solid #888; }
</style>
<script src='http://maps.google.com/maps?file=api&v=2&key=%(googlemapskey)s'></script>
<script>
//<![CDATA[
/*
* Constants for given map
* TODO: read it from tilemapresource.xml
*/
var mapBounds = new GLatLngBounds(new GLatLng(%(south)s, %(west)s), new GLatLng(%(north)s, %(east)s));
var mapMinZoom = %(minzoom)s;
var mapMaxZoom = %(maxzoom)s;
var opacity = 0.75;
var map;
var hybridOverlay;
/*
* Create a Custom Opacity GControl
* http://www.maptiler.org/google-maps-overlay-opacity-control/
*/
var CTransparencyLENGTH = 58;
// maximum width that the knob can move (slide width minus knob width)
function CTransparencyControl( overlay ) {
this.overlay = overlay;
this.opacity = overlay.getTileLayer().getOpacity();
}
CTransparencyControl.prototype = new GControl();
// This function positions the slider to match the specified opacity
CTransparencyControl.prototype.setSlider = function(pos) {
var left = Math.round((CTransparencyLENGTH*pos));
this.slide.left = left;
this.knob.style.left = left+"px";
this.knob.style.top = "0px";
}
// This function reads the slider and sets the overlay opacity level
CTransparencyControl.prototype.setOpacity = function() {
// set the global variable
opacity = this.slide.left/CTransparencyLENGTH;
this.map.clearOverlays();
this.map.addOverlay(this.overlay, { zPriority: 0 });
if (this.map.getCurrentMapType() == G_HYBRID_MAP) {
this.map.addOverlay(hybridOverlay);
}
}
// This gets called by the API when addControl(new CTransparencyControl())
CTransparencyControl.prototype.initialize = function(map) {
var that=this;
this.map = map;
// Is this MSIE, if so we need to use AlphaImageLoader
var agent = navigator.userAgent.toLowerCase();
if ((agent.indexOf("msie") > -1) && (agent.indexOf("opera") < 1)){this.ie = true} else {this.ie = false}
// create the background graphic as a <div> containing an image
var container = document.createElement("div");
container.style.width="70px";
container.style.height="21px";
// Handle transparent PNG files in MSIE
if (this.ie) {
var loader = "filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='http://www.maptiler.org/img/opacity-slider.png', sizingMethod='crop');";
container.innerHTML = '<div style="height:21px; width:70px; ' +loader+ '" ></div>';
} else {
container.innerHTML = '<div style="height:21px; width:70px; background-image: url(http://www.maptiler.org/img/opacity-slider.png)" ></div>';
}
// create the knob as a GDraggableObject
// Handle transparent PNG files in MSIE
if (this.ie) {
var loader = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='http://www.maptiler.org/img/opacity-slider.png', sizingMethod='crop');";
this.knob = document.createElement("div");
this.knob.style.height="21px";
this.knob.style.width="13px";
this.knob.style.overflow="hidden";
this.knob_img = document.createElement("div");
this.knob_img.style.height="21px";
this.knob_img.style.width="83px";
this.knob_img.style.filter=loader;
this.knob_img.style.position="relative";
this.knob_img.style.left="-70px";
this.knob.appendChild(this.knob_img);
} else {
this.knob = document.createElement("div");
this.knob.style.height="21px";
this.knob.style.width="13px";
this.knob.style.backgroundImage="url(http://www.maptiler.org/img/opacity-slider.png)";
this.knob.style.backgroundPosition="-70px 0px";
}
container.appendChild(this.knob);
this.slide=new GDraggableObject(this.knob, {container:container});
this.slide.setDraggableCursor('pointer');
this.slide.setDraggingCursor('pointer');
this.container = container;
// attach the control to the map
map.getContainer().appendChild(container);
// init slider
this.setSlider(this.opacity);
// Listen for the slider being moved and set the opacity
GEvent.addListener(this.slide, "dragend", function() {that.setOpacity()});
//GEvent.addListener(this.container, "click", function( x, y ) { alert(x, y) });
return container;
}
// Set the default position for the control
CTransparencyControl.prototype.getDefaultPosition = function() {
return new GControlPosition(G_ANCHOR_TOP_RIGHT, new GSize(7, 47));
}
/*
* Full-screen Window Resize
*/
function getWindowHeight() {
if (self.innerHeight) return self.innerHeight;
if (document.documentElement && document.documentElement.clientHeight)
return document.documentElement.clientHeight;
if (document.body) return document.body.clientHeight;
return 0;
}
function getWindowWidth() {
if (self.innerWidth) return self.innerWidth;
if (document.documentElement && document.documentElement.clientWidth)
return document.documentElement.clientWidth;
if (document.body) return document.body.clientWidth;
return 0;
}
function resize() {
var map = document.getElementById("map");
var header = document.getElementById("header");
var subheader = document.getElementById("subheader");
map.style.height = (getWindowHeight()-80) + "px";
map.style.width = (getWindowWidth()-20) + "px";
header.style.width = (getWindowWidth()-20) + "px";
subheader.style.width = (getWindowWidth()-20) + "px";
// map.checkResize();
}
/*
* Main load function:
*/
function load() {
if (GBrowserIsCompatible()) {
// Bug in the Google Maps: Copyright for Overlay is not correctly displayed
var gcr = GMapType.prototype.getCopyrights;
GMapType.prototype.getCopyrights = function(bounds,zoom) {
return ["%(copyright)s"].concat(gcr.call(this,bounds,zoom));
}
map = new GMap2( document.getElementById("map"), { backgroundColor: '#fff' } );
map.addMapType(G_PHYSICAL_MAP);
map.setMapType(G_PHYSICAL_MAP);
map.setCenter( mapBounds.getCenter(), map.getBoundsZoomLevel( mapBounds ));
hybridOverlay = new GTileLayerOverlay( G_HYBRID_MAP.getTileLayers()[1] );
GEvent.addListener(map, "maptypechanged", function() {
if (map.getCurrentMapType() == G_HYBRID_MAP) {
map.addOverlay(hybridOverlay);
} else {
map.removeOverlay(hybridOverlay);
}
} );
var tilelayer = new GTileLayer(GCopyrightCollection(''), mapMinZoom, mapMaxZoom);
var mercator = new GMercatorProjection(mapMaxZoom+1);
tilelayer.getTileUrl = function(tile,zoom) {
if ((zoom < mapMinZoom) || (zoom > mapMaxZoom)) {
return "http://www.maptiler.org/img/none.png";
}
var ymax = 1 << zoom;
var y = ymax - tile.y -1;
var tileBounds = new GLatLngBounds(
mercator.fromPixelToLatLng( new GPoint( (tile.x)*256, (tile.y+1)*256 ) , zoom ),
mercator.fromPixelToLatLng( new GPoint( (tile.x+1)*256, (tile.y)*256 ) , zoom )
);
if (mapBounds.intersects(tileBounds)) {
return zoom+"/"+tile.x+"/"+y+".png";
} else {
return "http://www.maptiler.org/img/none.png";
}
}
// IE 7-: support for PNG alpha channel
// Unfortunately, the opacity for whole overlay is then not changeable, either or...
tilelayer.isPng = function() { return true;};
tilelayer.getOpacity = function() { return opacity; }
overlay = new GTileLayerOverlay( tilelayer );
map.addOverlay(overlay);
map.addControl(new GLargeMapControl());
map.addControl(new GHierarchicalMapTypeControl());
map.addControl(new CTransparencyControl( overlay ));
""" \
% args
if self.kml:
s += \
"""
map.addMapType(G_SATELLITE_3D_MAP);
map.getEarthInstance(getEarthInstanceCB);
"""
s += \
"""
map.enableContinuousZoom();
map.enableScrollWheelZoom();
map.setMapType(G_HYBRID_MAP);
}
resize();
}
"""
if self.kml:
s += \
"""
function getEarthInstanceCB(object) {
var ge = object;
if (ge) {
var url = document.location.toString();
url = url.substr(0,url.lastIndexOf('/'))+'/doc.kml';
var link = ge.createLink("");
if ("%(publishurl)s") { link.setHref("%(publishurl)s/doc.kml") }
else { link.setHref(url) };
var networkLink = ge.createNetworkLink("");
networkLink.setName("TMS Map Overlay");
networkLink.setFlyToView(true);
networkLink.setLink(link);
ge.getFeatures().appendChild(networkLink);
} else {
// alert("You should open a KML in Google Earth");
// add div with the link to generated KML... - maybe JavaScript redirect to the URL of KML?
}
}
""" \
% args
s += \
"""
onresize=function(){ resize(); };
//]]>
</script>
</head>
<body onload="load()">
<div id="header"><h1>%(title)s</h1></div>
<div id="subheader">Generated by <a href="http://www.maptiler.org/">MapTiler</a>/<a href="http://www.klokan.cz/projects/gdal2tiles/">GDAL2Tiles</a>, Copyright © 2008 <a href="http://www.klokan.cz/">Klokan Petr Pridal</a>, <a href="http://www.gdal.org/">GDAL</a> & <a href="http://www.osgeo.org/">OSGeo</a> <a href="http://code.google.com/soc/">GSoC</a>
<!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->
</div>
<div id="map"></div>
</body>
</html>
""" \
% args
return s |
Template for googlemaps.html implementing Overlay of tiles for 'mercator' profile.
It returns filled string. Expected variables:
title, googlemapskey, north, south, east, west, minzoom, maxzoom, tilesize, tileformat, publishurl
| generate_googlemaps | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def generate_openlayers(self):
"""
Template for openlayers.html implementing overlay of available Spherical Mercator layers.
It returns filled string. Expected variables:
title, bingkey, north, south, east, west, minzoom, maxzoom, tilesize, tileformat, publishurl
"""
args = {}
args['title'] = self.options.title
args['bingkey'] = self.options.bingkey
(args['south'], args['west'], args['north'], args['east']) = \
self.swne
args['minzoom'] = self.tminz
args['maxzoom'] = self.tmaxz
args['tilesize'] = self.tilesize
args['tileformat'] = self.tileext
args['publishurl'] = self.options.url
args['copyright'] = self.options.copyright
if self.options.tmscompatible:
args['tmsoffset'] = '-1'
else:
args['tmsoffset'] = ''
if self.options.profile == 'raster':
args['rasterzoomlevels'] = self.tmaxz + 1
args['rastermaxresolution'] = 2 ** self.nativezoom \
* self.out_gt[1]
s = \
"""<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
<head>
<title>%(title)s</title>
<meta http-equiv='imagetoolbar' content='no'/>
<style type="text/css"> v\:* {behavior:url(#default#VML);}
html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }
body { margin: 10px; background: #fff; }
h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }
#header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }
#subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}
#map { height: 95%%; border: 1px solid #888; }
.olImageLoadError { display: none; }
.olControlLayerSwitcher .layersDiv { border-radius: 10px 0 0 10px; }
</style>""" \
% args
if self.options.profile == 'mercator':
s += \
"""
<script src='http://maps.google.com/maps/api/js?sensor=false&v=3.7'></script>""" \
% args
s += \
"""
<script src="http://www.openlayers.org/api/2.12/OpenLayers.js"></script>
<script>
var map;
var mapBounds = new OpenLayers.Bounds( %(west)s, %(south)s, %(east)s, %(north)s);
var mapMinZoom = %(minzoom)s;
var mapMaxZoom = %(maxzoom)s;
var emptyTileURL = "http://www.maptiler.org/img/none.png";
OpenLayers.IMAGE_RELOAD_ATTEMPTS = 3;
function init(){""" \
% args
if self.options.profile == 'mercator':
s += \
"""
var options = {
div: "map",
controls: [],
projection: "EPSG:900913",
displayProjection: new OpenLayers.Projection("EPSG:4326"),
numZoomLevels: 20
};
map = new OpenLayers.Map(options);
// Create Google Mercator layers
var gmap = new OpenLayers.Layer.Google("Google Streets",
{
type: google.maps.MapTypeId.ROADMAP,
sphericalMercator: true
});
var gsat = new OpenLayers.Layer.Google("Google Satellite",
{
type: google.maps.MapTypeId.SATELLITE,
sphericalMercator: true
});
var ghyb = new OpenLayers.Layer.Google("Google Hybrid",
{
type: google.maps.MapTypeId.HYBRID,
sphericalMercator: true
});
var gter = new OpenLayers.Layer.Google("Google Terrain",
{
type: google.maps.MapTypeId.TERRAIN,
sphericalMercator: true
});
// Create Bing layers
var broad = new OpenLayers.Layer.Bing({
name: "Bing Roads",
key: "%(bingkey)s",
type: "Road",
sphericalMercator: true
});
var baer = new OpenLayers.Layer.Bing({
name: "Bing Aerial",
key: "%(bingkey)s",
type: "Aerial",
sphericalMercator: true
});
var bhyb = new OpenLayers.Layer.Bing({
name: "Bing Hybrid",
key: "%(bingkey)s",
type: "AerialWithLabels",
sphericalMercator: true
});
// Create OSM layer
var osm = new OpenLayers.Layer.OSM("OpenStreetMap");
// create TMS Overlay layer
var tmsoverlay = new OpenLayers.Layer.TMS("TMS Overlay", "",
{
serviceVersion: '.',
layername: '.',
alpha: true,
type: '%(tileformat)s',
isBaseLayer: false,
getURL: getURL
});
if (OpenLayers.Util.alphaHack() == false) {
tmsoverlay.setOpacity(0.7);
}
map.addLayers([gmap, gsat, ghyb, gter,
broad, baer, bhyb,
osm, tmsoverlay]);
var switcherControl = new OpenLayers.Control.LayerSwitcher();
map.addControl(switcherControl);
switcherControl.maximizeControl();
map.zoomToExtent(mapBounds.transform(map.displayProjection, map.projection));
""" \
% args
elif self.options.profile == 'geodetic':
s += \
"""
var options = {
div: "map",
controls: [],
projection: "EPSG:4326"
};
map = new OpenLayers.Map(options);
var wms = new OpenLayers.Layer.WMS("VMap0",
"http://tilecache.osgeo.org/wms-c/Basic.py?",
{
layers: 'basic',
format: 'image/png'
}
);
var tmsoverlay = new OpenLayers.Layer.TMS("TMS Overlay", "",
{
serviceVersion: '.',
layername: '.',
alpha: true,
type: '%(tileformat)s',
isBaseLayer: false,
getURL: getURL
});
if (OpenLayers.Util.alphaHack() == false) {
tmsoverlay.setOpacity(0.7);
}
map.addLayers([wms,tmsoverlay]);
var switcherControl = new OpenLayers.Control.LayerSwitcher();
map.addControl(switcherControl);
switcherControl.maximizeControl();
map.zoomToExtent(mapBounds);
""" \
% args
elif self.options.profile == 'raster':
s += \
"""
var options = {
div: "map",
controls: [],
maxExtent: new OpenLayers.Bounds(%(west)s, %(south)s, %(east)s, %(north)s),
maxResolution: %(rastermaxresolution)f,
numZoomLevels: %(rasterzoomlevels)d
};
map = new OpenLayers.Map(options);
var layer = new OpenLayers.Layer.TMS("TMS Layer", "",
{
serviceVersion: '.',
layername: '.',
alpha: true,
type: '%(tileformat)s',
getURL: getURL
});
map.addLayer(layer);
map.zoomToExtent(mapBounds);
""" \
% args
s += \
"""
map.addControls([new OpenLayers.Control.PanZoomBar(),
new OpenLayers.Control.Navigation(),
new OpenLayers.Control.MousePosition(),
new OpenLayers.Control.ArgParser(),
new OpenLayers.Control.Attribution()]);
}
""" \
% args
if self.options.profile == 'mercator':
s += \
"""
function getURL(bounds) {
bounds = this.adjustBounds(bounds);
var res = this.getServerResolution();
var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));
var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));
var z = this.getServerZoom();
if (this.map.baseLayer.CLASS_NAME === 'OpenLayers.Layer.Bing') {
z+=1;
}
var path = this.serviceVersion + "/" + this.layername + "/" + z + "/" + x + "/" + y + "." + this.type;
var url = this.url;
if (OpenLayers.Util.isArray(url)) {
url = this.selectUrl(path, url);
}
if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {
return url + path;
} else {
return emptyTileURL;
}
}
""" \
% args
elif self.options.profile == 'geodetic':
s += \
"""
function getURL(bounds) {
bounds = this.adjustBounds(bounds);
var res = this.getServerResolution();
var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));
var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));
var z = this.getServerZoom()%(tmsoffset)s;
var path = this.serviceVersion + "/" + this.layername + "/" + z + "/" + x + "/" + y + "." + this.type;
var url = this.url;
if (OpenLayers.Util.isArray(url)) {
url = this.selectUrl(path, url);
}
if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {
return url + path;
} else {
return emptyTileURL;
}
}
""" \
% args
elif self.options.profile == 'raster':
s += \
"""
function getURL(bounds) {
bounds = this.adjustBounds(bounds);
var res = this.getServerResolution();
var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));
var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));
var z = this.getServerZoom();
var path = this.serviceVersion + "/" + this.layername + "/" + z + "/" + x + "/" + y + "." + this.type;
var url = this.url;
if (OpenLayers.Util.isArray(url)) {
url = this.selectUrl(path, url);
}
if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {
return url + path;
} else {
return emptyTileURL;
}
}
""" \
% args
s += \
"""
function getWindowHeight() {
if (self.innerHeight) return self.innerHeight;
if (document.documentElement && document.documentElement.clientHeight)
return document.documentElement.clientHeight;
if (document.body) return document.body.clientHeight;
return 0;
}
function getWindowWidth() {
if (self.innerWidth) return self.innerWidth;
if (document.documentElement && document.documentElement.clientWidth)
return document.documentElement.clientWidth;
if (document.body) return document.body.clientWidth;
return 0;
}
function resize() {
var map = document.getElementById("map");
var header = document.getElementById("header");
var subheader = document.getElementById("subheader");
map.style.height = (getWindowHeight()-80) + "px";
map.style.width = (getWindowWidth()-20) + "px";
header.style.width = (getWindowWidth()-20) + "px";
subheader.style.width = (getWindowWidth()-20) + "px";
if (map.updateSize) { map.updateSize(); };
}
onresize=function(){ resize(); };
</script>
</head>
<body onload="init()">
<div id="header"><h1>%(title)s</h1></div>
<div id="subheader">Generated by <a href="http://www.maptiler.org/">MapTiler</a>/<a href="http://www.klokan.cz/projects/gdal2tiles/">GDAL2Tiles</a>, Copyright © 2008 <a href="http://www.klokan.cz/">Klokan Petr Pridal</a>, <a href="http://www.gdal.org/">GDAL</a> & <a href="http://www.osgeo.org/">OSGeo</a> <a href="http://code.google.com/soc/">GSoC</a>
<!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->
</div>
<div id="map"></div>
<script type="text/javascript" >resize()</script>
</body>
</html>""" \
% args
return s |
Template for openlayers.html implementing overlay of available Spherical Mercator layers.
It returns filled string. Expected variables:
title, bingkey, north, south, east, west, minzoom, maxzoom, tilesize, tileformat, publishurl
| generate_openlayers | python | commenthol/gdal2tiles-leaflet | gdal2tiles.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles.py | MIT |
def build_dataset(tokenizer, config):
'''
We assume that we have preprocessed the dataset appropriately such that the sample is organized as follows:
{"positive": prompt + answer_positive, "negative": prompt + answer_negative}, where the positive response is preferred.
'''
def tokenize(sample):
tokenized_pos = tokenizer(sample['positive'], truncation=True)
tokenized_neg = tokenizer(sample['negative'], truncation=True)
sample["chosen_input_ids"] = tokenized_pos["input_ids"]
sample["chosen_attention_mask"] = tokenized_pos["attention_mask"]
sample["rejected_input_ids"] = tokenized_neg["input_ids"]
sample["rejected_attention_mask"] = tokenized_neg["attention_mask"]
return sample
ds = load_dataset("json", data_files=config.dataset_path, split="train", field="instances")
ds = ds.map(tokenize, batched=False)
ds = ds.filter(lambda x: len(x["chosen_input_ids"]) <= 512 and len(x["rejected_input_ids"]) <= 512)
eval_dataset = None
if config.validation_split_percentage > 0:
idx_gap = int((1-config.validation_split_percentage/100) * len(ds))
train_dataset = ds.select(range(idx_gap))
eval_dataset = ds.select(range(idx_gap, len(ds)))
else:
train_dataset = ds
return train_dataset, eval_dataset |
We assume that we have preprocessed the dataset appropriately such that the sample is organized as follows:
{"positive": prompt + answer_positive, "negative": prompt + answer_negative}, where the positive response is preferred.
| build_dataset | python | OptimalScale/LMFlow | contrib/rlhflow/reward_modeling.py | https://github.com/OptimalScale/LMFlow/blob/master/contrib/rlhflow/reward_modeling.py | Apache-2.0 |
def tokenize(
self,
dataset,
add_special_tokens=True,
*args,
**kwargs
) -> Dataset:
"""
Tokenize the full dataset.
Parameters
------------
dataset : lmflow.datasets.Dataset.
args : Optional.
Positional arguments.
kwargs : Optional.
Keyword arguments.
Returns
------------
tokenized_datasets :
The tokenized dataset, without any leading or trailing special
tokens (normally they are Begin-Of-Sentence or End-Of-Sentence
tokens).
"""
# Preprocessing the datasets.
# First we tokenize all the texts.
if dataset.get_backend() != "huggingface":
raise NotImplementedError(
"tokenization of datasets with non-huggingface backend are"
"not supported yet"
)
dataset_type = dataset.get_type()
model_args = self.model_args
raw_datasets = dataset
hf_raw_datasets = dataset.get_backend_dataset()
column_names = list(hf_raw_datasets.features)
data_args = raw_datasets.get_data_args()
# Requires three types of information for tokenizing different datasets
# 1) Which fields require tokenization, e.g.
# "text2float": "text", but not "float"
# "text2text": both "input" and "output"
# 2) How will there tokenized sequence concatenated together, e.g.
# "text_only": "text" -> "text"
# "text2text": "input", "output" -> "input" + "output"
# 3) Which fields require loss in final computation, e.g.
# "text_only": "text"
# "text2text": "output" only
tokenized_column_order = None # Handles 1) and 2)
label_columns = None # Handles 3)
if dataset_type == "text_only":
tokenized_column_order = ["text"]
label_columns = ["text"]
elif dataset_type == "text2text":
tokenized_column_order = ["input", "output"]
label_columns = ["output"]
add_special_tokens = False
elif dataset_type == "conversation":
if data_args.conversation_template:
if data_args.conversation_template in PRESET_TEMPLATES.keys():
conversation_template = PRESET_TEMPLATES[data_args.conversation_template]
else:
raise NotImplementedError(
f"Conversation template {data_args.conversation_template} is not supported yet."
)
else:
logger.warning("No conversation template provided. Using default template.")
conversation_template = PRESET_TEMPLATES['empty']
logger.warning(f"Conversation template: {conversation_template}")
else:
raise NotImplementedError(
f"dataset type \"{dataset_type}\" is not supported, currently"
" only support following data types:\n"
f" 1) {TEXT_ONLY_DATASET_DESCRIPTION}\n"
f" 2) {TEXT2TEXT_DATASET_DESCRIPTION}\n"
f" 3) {CONVERSATION_DATASET_DESCRIPTION}\n"
)
# Whether to truncate long sequences to fit into max_length
use_truncation = False
if model_args.use_lora or data_args.disable_group_texts:
use_truncation = True
tokenize_fn = conversation_tokenize_function
tokenize_fn_kwargs = {
"data_args": data_args,
"tokenizer": self.tokenizer,
"column_names": column_names,
}
if "conversation" in dataset_type:
tokenize_fn_kwargs["conversation_template"] = conversation_template
else:
tokenize_fn_kwargs["label_columns"] = label_columns
tokenize_fn_kwargs["tokenized_column_order"] = tokenized_column_order
tokenize_fn_kwargs["add_special_tokens"] = add_special_tokens
tokenize_fn_kwargs["use_truncation"] = use_truncation
tokenize_kwargs = {}
if not data_args.streaming:
fingerprint = hashlib.md5(
(
raw_datasets.get_fingerprint()
+ str(self.tokenizer)
+ f'###padding_side={self.tokenizer.padding_side}'
+ ('###conversation_template=' + str(conversation_template) if "conversation" in dataset_type else "")
+ f'###disable_group_texts={data_args.disable_group_texts}'
+ f'###block_size={data_args.block_size}'
).encode("utf-8")
).hexdigest()
tokenize_kwargs = {
"num_proc": data_args.preprocessing_num_workers,
"load_from_cache_file": not data_args.overwrite_cache,
"desc": "Running tokenizer on dataset",
"new_fingerprint": fingerprint,
}
tokenized_datasets = raw_datasets.map(
tokenize_fn,
batched=True,
remove_columns=column_names,
fn_kwargs=tokenize_fn_kwargs,
**tokenize_kwargs
)
return tokenized_datasets |
Tokenize the full dataset.
Parameters
------------
dataset : lmflow.datasets.Dataset.
args : Optional.
Positional arguments.
kwargs : Optional.
Keyword arguments.
Returns
------------
tokenized_datasets :
The tokenized dataset, without any leading or trailing special
tokens (normally they are Begin-Of-Sentence or End-Of-Sentence
tokens).
| tokenize | python | OptimalScale/LMFlow | contrib/tool-finetune/function_call_finetune.py | https://github.com/OptimalScale/LMFlow/blob/master/contrib/tool-finetune/function_call_finetune.py | Apache-2.0 |
def update_ema(target_params, source_params, rate=0.99):
"""
Update target parameters to be closer to those of source parameters using
an exponential moving average.
:param target_params: the target parameter sequence.
:param source_params: the source parameter sequence.
:param rate: the EMA rate (closer to 1 means slower).
"""
for targ, src in zip(target_params, source_params):
# if src.requires_grad == True:
targ.detach().mul_(rate).add_(src, alpha=1 - rate) |
Update target parameters to be closer to those of source parameters using
an exponential moving average.
:param target_params: the target parameter sequence.
:param source_params: the source parameter sequence.
:param rate: the EMA rate (closer to 1 means slower).
| update_ema | python | OptimalScale/LMFlow | experimental/LISA-diffusion/diffusion_dpo/train_diffusion_dpo_lisa.py | https://github.com/OptimalScale/LMFlow/blob/master/experimental/LISA-diffusion/diffusion_dpo/train_diffusion_dpo_lisa.py | Apache-2.0 |
def group_by_keys_nothrow(data, keys=base_plus_ext, lcase=True, suffixes=None, handler=None):
"""Return function over iterator that groups key, value pairs into samples.
:param keys: function that splits the key into key and extension (base_plus_ext) :param lcase: convert suffixes to
lower case (Default value = True)
"""
current_sample = None
for filesample in data:
assert isinstance(filesample, dict)
fname, value = filesample["fname"], filesample["data"]
prefix, suffix = keys(fname)
if prefix is None:
continue
if lcase:
suffix = suffix.lower()
# FIXME webdataset version throws if suffix in current_sample, but we have a potential for
# this happening in the current LAION400m dataset if a tar ends with same prefix as the next
# begins, rare, but can happen since prefix aren't unique across tar files in that dataset
if current_sample is None or prefix != current_sample["__key__"] or suffix in current_sample:
if valid_sample(current_sample):
yield current_sample
current_sample = {"__key__": prefix, "__url__": filesample["__url__"]}
if suffixes is None or suffix in suffixes:
current_sample[suffix] = value
if valid_sample(current_sample):
yield current_sample | Return function over iterator that groups key, value pairs into samples.
:param keys: function that splits the key into key and extension (base_plus_ext) :param lcase: convert suffixes to
lower case (Default value = True)
| group_by_keys_nothrow | python | OptimalScale/LMFlow | experimental/LISA-diffusion/latent_consistency_model/train_lcm_distill_sd_wds_lisa.py | https://github.com/OptimalScale/LMFlow/blob/master/experimental/LISA-diffusion/latent_consistency_model/train_lcm_distill_sd_wds_lisa.py | Apache-2.0 |
def guidance_scale_embedding(w, embedding_dim=512, dtype=torch.float32):
"""
See https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298
Args:
timesteps (`torch.Tensor`):
generate embedding vectors at these timesteps
embedding_dim (`int`, *optional*, defaults to 512):
dimension of the embeddings to generate
dtype:
data type of the generated embeddings
Returns:
`torch.FloatTensor`: Embedding vectors with shape `(len(timesteps), embedding_dim)`
"""
assert len(w.shape) == 1
w = w * 1000.0
half_dim = embedding_dim // 2
emb = torch.log(torch.tensor(10000.0)) / (half_dim - 1)
emb = torch.exp(torch.arange(half_dim, dtype=dtype) * -emb)
emb = w.to(dtype)[:, None] * emb[None, :]
emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1)
if embedding_dim % 2 == 1: # zero pad
emb = torch.nn.functional.pad(emb, (0, 1))
assert emb.shape == (w.shape[0], embedding_dim)
return emb |
See https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298
Args:
timesteps (`torch.Tensor`):
generate embedding vectors at these timesteps
embedding_dim (`int`, *optional*, defaults to 512):
dimension of the embeddings to generate
dtype:
data type of the generated embeddings
Returns:
`torch.FloatTensor`: Embedding vectors with shape `(len(timesteps), embedding_dim)`
| guidance_scale_embedding | python | OptimalScale/LMFlow | experimental/LISA-diffusion/latent_consistency_model/train_lcm_distill_sd_wds_lisa.py | https://github.com/OptimalScale/LMFlow/blob/master/experimental/LISA-diffusion/latent_consistency_model/train_lcm_distill_sd_wds_lisa.py | Apache-2.0 |
def append_dims(x, target_dims):
"""Appends dimensions to the end of a tensor until it has target_dims dimensions."""
dims_to_append = target_dims - x.ndim
if dims_to_append < 0:
raise ValueError(f"input has {x.ndim} dims but target_dims is {target_dims}, which is less")
return x[(...,) + (None,) * dims_to_append] | Appends dimensions to the end of a tensor until it has target_dims dimensions. | append_dims | python | OptimalScale/LMFlow | experimental/LISA-diffusion/latent_consistency_model/train_lcm_distill_sd_wds_lisa.py | https://github.com/OptimalScale/LMFlow/blob/master/experimental/LISA-diffusion/latent_consistency_model/train_lcm_distill_sd_wds_lisa.py | Apache-2.0 |
def update_ema(target_params, source_params, rate=0.99):
"""
Update target parameters to be closer to those of source parameters using
an exponential moving average.
:param target_params: the target parameter sequence.
:param source_params: the source parameter sequence.
:param rate: the EMA rate (closer to 1 means slower).
"""
for targ, src in zip(target_params, source_params):
# if src.requires_grad == True:
targ.detach().mul_(rate).add_(src, alpha=1 - rate) |
Update target parameters to be closer to those of source parameters using
an exponential moving average.
:param target_params: the target parameter sequence.
:param source_params: the source parameter sequence.
:param rate: the EMA rate (closer to 1 means slower).
| update_ema | python | OptimalScale/LMFlow | experimental/LISA-diffusion/latent_consistency_model/train_lcm_distill_sd_wds_lisa.py | https://github.com/OptimalScale/LMFlow/blob/master/experimental/LISA-diffusion/latent_consistency_model/train_lcm_distill_sd_wds_lisa.py | Apache-2.0 |
def group_by_keys_nothrow(data, keys=base_plus_ext, lcase=True, suffixes=None, handler=None):
"""Return function over iterator that groups key, value pairs into samples.
:param keys: function that splits the key into key and extension (base_plus_ext) :param lcase: convert suffixes to
lower case (Default value = True)
"""
current_sample = None
for filesample in data:
assert isinstance(filesample, dict)
fname, value = filesample["fname"], filesample["data"]
prefix, suffix = keys(fname)
if prefix is None:
continue
if lcase:
suffix = suffix.lower()
# FIXME webdataset version throws if suffix in current_sample, but we have a potential for
# this happening in the current LAION400m dataset if a tar ends with same prefix as the next
# begins, rare, but can happen since prefix aren't unique across tar files in that dataset
if current_sample is None or prefix != current_sample["__key__"] or suffix in current_sample:
if valid_sample(current_sample):
yield current_sample
current_sample = {"__key__": prefix, "__url__": filesample["__url__"]}
if suffixes is None or suffix in suffixes:
current_sample[suffix] = value
if valid_sample(current_sample):
yield current_sample | Return function over iterator that groups key, value pairs into samples.
:param keys: function that splits the key into key and extension (base_plus_ext) :param lcase: convert suffixes to
lower case (Default value = True)
| group_by_keys_nothrow | python | OptimalScale/LMFlow | experimental/LISA-diffusion/latent_consistency_model/train_lcm_distill_sd_wds_lora.py | https://github.com/OptimalScale/LMFlow/blob/master/experimental/LISA-diffusion/latent_consistency_model/train_lcm_distill_sd_wds_lora.py | Apache-2.0 |
def guidance_scale_embedding(w, embedding_dim=512, dtype=torch.float32):
"""
See https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298
Args:
timesteps (`torch.Tensor`):
generate embedding vectors at these timesteps
embedding_dim (`int`, *optional*, defaults to 512):
dimension of the embeddings to generate
dtype:
data type of the generated embeddings
Returns:
`torch.FloatTensor`: Embedding vectors with shape `(len(timesteps), embedding_dim)`
"""
assert len(w.shape) == 1
w = w * 1000.0
half_dim = embedding_dim // 2
emb = torch.log(torch.tensor(10000.0)) / (half_dim - 1)
emb = torch.exp(torch.arange(half_dim, dtype=dtype) * -emb)
emb = w.to(dtype)[:, None] * emb[None, :]
emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1)
if embedding_dim % 2 == 1: # zero pad
emb = torch.nn.functional.pad(emb, (0, 1))
assert emb.shape == (w.shape[0], embedding_dim)
return emb |
See https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298
Args:
timesteps (`torch.Tensor`):
generate embedding vectors at these timesteps
embedding_dim (`int`, *optional*, defaults to 512):
dimension of the embeddings to generate
dtype:
data type of the generated embeddings
Returns:
`torch.FloatTensor`: Embedding vectors with shape `(len(timesteps), embedding_dim)`
| guidance_scale_embedding | python | OptimalScale/LMFlow | experimental/LISA-diffusion/latent_consistency_model/train_lcm_distill_sd_wds_lora.py | https://github.com/OptimalScale/LMFlow/blob/master/experimental/LISA-diffusion/latent_consistency_model/train_lcm_distill_sd_wds_lora.py | Apache-2.0 |
def append_dims(x, target_dims):
"""Appends dimensions to the end of a tensor until it has target_dims dimensions."""
dims_to_append = target_dims - x.ndim
if dims_to_append < 0:
raise ValueError(f"input has {x.ndim} dims but target_dims is {target_dims}, which is less")
return x[(...,) + (None,) * dims_to_append] | Appends dimensions to the end of a tensor until it has target_dims dimensions. | append_dims | python | OptimalScale/LMFlow | experimental/LISA-diffusion/latent_consistency_model/train_lcm_distill_sd_wds_lora.py | https://github.com/OptimalScale/LMFlow/blob/master/experimental/LISA-diffusion/latent_consistency_model/train_lcm_distill_sd_wds_lora.py | Apache-2.0 |
def update_ema(target_params, source_params, rate=0.99):
"""
Update target parameters to be closer to those of source parameters using
an exponential moving average.
:param target_params: the target parameter sequence.
:param source_params: the source parameter sequence.
:param rate: the EMA rate (closer to 1 means slower).
"""
for targ, src in zip(target_params, source_params):
targ.detach().mul_(rate).add_(src, alpha=1 - rate) |
Update target parameters to be closer to those of source parameters using
an exponential moving average.
:param target_params: the target parameter sequence.
:param source_params: the source parameter sequence.
:param rate: the EMA rate (closer to 1 means slower).
| update_ema | python | OptimalScale/LMFlow | experimental/LISA-diffusion/latent_consistency_model/train_lcm_distill_sd_wds_lora.py | https://github.com/OptimalScale/LMFlow/blob/master/experimental/LISA-diffusion/latent_consistency_model/train_lcm_distill_sd_wds_lora.py | Apache-2.0 |
def parse_argument(sys_argv):
"""Parses arguments from command line.
Args:
sys_argv: the list of arguments (strings) from command line.
Returns:
A struct whose member corresponds to the required (optional) variable.
For example,
```
args = parse_argument(['main.py' '--input', 'a.txt', '--num', '10'])
args.input # 'a.txt'
args.num # 10
```
"""
parser = argparse.ArgumentParser(
formatter_class=argparse.RawTextHelpFormatter)
# Training parameters
parser.add_argument(
"--dataset_path", type=str,
default=None,
help=textwrap.dedent("input dataset path, reads from stdin by default")
)
parser.add_argument(
"--output_path", type=str,
default=None,
help=textwrap.dedent("output dataset path, writes to stdout by default")
)
parser.add_argument(
"--end_mark", type=str,
default="###",
help=textwrap.dedent("end mark that append to the end of output")
)
# Parses from commandline
args = parser.parse_args(sys_argv[1:])
return args | Parses arguments from command line.
Args:
sys_argv: the list of arguments (strings) from command line.
Returns:
A struct whose member corresponds to the required (optional) variable.
For example,
```
args = parse_argument(['main.py' '--input', 'a.txt', '--num', '10'])
args.input # 'a.txt'
args.num # 10
```
| parse_argument | python | OptimalScale/LMFlow | scripts/data_preprocess/add_end_mark.py | https://github.com/OptimalScale/LMFlow/blob/master/scripts/data_preprocess/add_end_mark.py | Apache-2.0 |
def parse_argument(sys_argv):
"""Parses arguments from command line.
Args:
sys_argv: the list of arguments (strings) from command line.
Returns:
A struct whose member corresponds to the required (optional) variable.
For example,
```
args = parse_argument(['main.py' '--input', 'a.txt', '--num', '10'])
args.input # 'a.txt'
args.num # 10
```
"""
parser = argparse.ArgumentParser(
formatter_class=argparse.RawTextHelpFormatter)
# Training parameters
parser.add_argument(
"--dataset_path", type=str,
default=None,
help=textwrap.dedent("input dataset path, reads from stdin by default")
)
parser.add_argument(
"--output_path", type=str,
default=None,
help=textwrap.dedent("output dataset path, writes to stdout by default")
)
parser.add_argument(
"--prompt_structure", type=str,
default="{input}",
help=textwrap.dedent("prompt structure to augment input")
)
# Parses from commandline
args = parser.parse_args(sys_argv[1:])
return args | Parses arguments from command line.
Args:
sys_argv: the list of arguments (strings) from command line.
Returns:
A struct whose member corresponds to the required (optional) variable.
For example,
```
args = parse_argument(['main.py' '--input', 'a.txt', '--num', '10'])
args.input # 'a.txt'
args.num # 10
```
| parse_argument | python | OptimalScale/LMFlow | scripts/data_preprocess/add_prompt.py | https://github.com/OptimalScale/LMFlow/blob/master/scripts/data_preprocess/add_prompt.py | Apache-2.0 |
def parse_argument(sys_argv):
"""Parses arguments from command line.
Args:
sys_argv: the list of arguments (strings) from command line.
Returns:
A struct whose member corresponds to the required (optional) variable.
For example,
```
args = parse_argument(['main.py' '--input', 'a.txt', '--num', '10'])
args.input # 'a.txt'
args.num # 10
```
"""
parser = argparse.ArgumentParser(
formatter_class=argparse.RawTextHelpFormatter)
# Training parameters
parser.add_argument(
"--output_path", type=str,
default=None,
help=textwrap.dedent("output dataset path, writes to stdout by default")
)
parser.add_argument(
"--merge_from_path", type=str,
nargs="+",
help=textwrap.dedent(
"dataset path of the extra dataset that will be merged"
" into input dataset"
)
)
# Parses from commandline
args = parser.parse_args(sys_argv[1:])
return args | Parses arguments from command line.
Args:
sys_argv: the list of arguments (strings) from command line.
Returns:
A struct whose member corresponds to the required (optional) variable.
For example,
```
args = parse_argument(['main.py' '--input', 'a.txt', '--num', '10'])
args.input # 'a.txt'
args.num # 10
```
| parse_argument | python | OptimalScale/LMFlow | scripts/data_preprocess/concat.py | https://github.com/OptimalScale/LMFlow/blob/master/scripts/data_preprocess/concat.py | Apache-2.0 |
def parse_argument(sys_argv):
"""Parses arguments from command line.
Args:
sys_argv: the list of arguments (strings) from command line.
Returns:
A struct whose member corresponds to the required (optional) variable.
For example,
```
args = parse_argument(['main.py' '--input', 'a.txt', '--num', '10'])
args.input # 'a.txt'
args.num # 10
```
"""
parser = argparse.ArgumentParser(
formatter_class=argparse.RawTextHelpFormatter)
# Training parameters
parser.add_argument(
"--output_path", type=str,
default=None,
help=textwrap.dedent("output dataset path, writes to stdout by default")
)
parser.add_argument(
"--merge_from_path", type=str,
nargs="+",
help=textwrap.dedent(
"dataset path of the extra dataset that will be merged"
" into input dataset"
)
)
parser.add_argument(
"--seed", type=int, default=42,
help=textwrap.dedent("pseudorandom seed")
)
parser.add_argument(
"--eval_size", type=int, default=200,
help=textwrap.dedent("size of eval dataset")
)
parser.add_argument(
"--test_size", type=int, default=1000,
help=textwrap.dedent("size of test dataset")
)
parser.add_argument(
"--k", type=int, default=10,
help=textwrap.dedent("the train dataset will be divide into k folds")
)
# Parses from commandline
args = parser.parse_args(sys_argv[1:])
return args | Parses arguments from command line.
Args:
sys_argv: the list of arguments (strings) from command line.
Returns:
A struct whose member corresponds to the required (optional) variable.
For example,
```
args = parse_argument(['main.py' '--input', 'a.txt', '--num', '10'])
args.input # 'a.txt'
args.num # 10
```
| parse_argument | python | OptimalScale/LMFlow | scripts/data_preprocess/concat_shuffle_split.py | https://github.com/OptimalScale/LMFlow/blob/master/scripts/data_preprocess/concat_shuffle_split.py | Apache-2.0 |
def parse_argument(sys_argv):
"""Parses arguments from command line.
Args:
sys_argv: the list of arguments (strings) from command line.
Returns:
A struct whose member corresponds to the required (optional) variable.
For example,
```
args = parse_argument(['main.py' '--input', 'a.txt', '--num', '10'])
args.input # 'a.txt'
args.num # 10
```
"""
parser = argparse.ArgumentParser(
formatter_class=argparse.RawTextHelpFormatter)
# Training parameters
parser.add_argument(
"--dataset_path", type=str,
default=None,
help="input dataset path, reads from stdin by default"
)
# Parses from commandline
args = parser.parse_args(sys_argv[1:])
return args | Parses arguments from command line.
Args:
sys_argv: the list of arguments (strings) from command line.
Returns:
A struct whose member corresponds to the required (optional) variable.
For example,
```
args = parse_argument(['main.py' '--input', 'a.txt', '--num', '10'])
args.input # 'a.txt'
args.num # 10
```
| parse_argument | python | OptimalScale/LMFlow | scripts/data_preprocess/count.py | https://github.com/OptimalScale/LMFlow/blob/master/scripts/data_preprocess/count.py | Apache-2.0 |
def parse_argument(sys_argv):
"""Parses arguments from command line.
Args:
sys_argv: the list of arguments (strings) from command line.
Returns:
A struct whose member corresponds to the required (optional) variable.
For example,
```
args = parse_argument(['main.py' '--input', 'a.txt', '--num', '10'])
args.input # 'a.txt'
args.num # 10
```
"""
parser = argparse.ArgumentParser(
formatter_class=argparse.RawTextHelpFormatter)
parser.add_argument(
"--dataset_path", type=str,
default=None,
help=textwrap.dedent("input dataset path, reads from stdin by default")
)
# Training parameters
parser.add_argument(
"--output_path", type=str,
default=None,
help=textwrap.dedent("output dataset path, writes to stdout by default")
)
parser.add_argument(
"--merge_from_path", type=str,
nargs="+",
help=textwrap.dedent(
"dataset path of the extra dataset that will be merged"
" into input dataset"
)
)
# Parses from commandline
args = parser.parse_args(sys_argv[1:])
return args | Parses arguments from command line.
Args:
sys_argv: the list of arguments (strings) from command line.
Returns:
A struct whose member corresponds to the required (optional) variable.
For example,
```
args = parse_argument(['main.py' '--input', 'a.txt', '--num', '10'])
args.input # 'a.txt'
args.num # 10
```
| parse_argument | python | OptimalScale/LMFlow | scripts/data_preprocess/merge.py | https://github.com/OptimalScale/LMFlow/blob/master/scripts/data_preprocess/merge.py | Apache-2.0 |
def parse_argument(sys_argv):
"""Parses arguments from command line.
Args:
sys_argv: the list of arguments (strings) from command line.
Returns:
A struct whose member corresponds to the required (optional) variable.
For example,
```
args = parse_argument(['main.py' '--input', 'a.txt', '--num', '10'])
args.input # 'a.txt'
args.num # 10
```
"""
parser = argparse.ArgumentParser(
formatter_class=argparse.RawTextHelpFormatter)
# Training parameters
parser.add_argument(
"--dataset_path", type=str,
default=None,
help=textwrap.dedent("input dataset path, reads from stdin by default")
)
parser.add_argument(
"--output_path", type=str,
default=None,
help=textwrap.dedent("output dataset path, writes to stdout by default")
)
# Parses from commandline
args = parser.parse_args(sys_argv[1:])
return args | Parses arguments from command line.
Args:
sys_argv: the list of arguments (strings) from command line.
Returns:
A struct whose member corresponds to the required (optional) variable.
For example,
```
args = parse_argument(['main.py' '--input', 'a.txt', '--num', '10'])
args.input # 'a.txt'
args.num # 10
```
| parse_argument | python | OptimalScale/LMFlow | scripts/data_preprocess/raw2textonly.py | https://github.com/OptimalScale/LMFlow/blob/master/scripts/data_preprocess/raw2textonly.py | Apache-2.0 |
def raw2textonly(fin):
"""
Converts raw text to text-only format.
Args:
fin: the input file description of the raw text file.
Returns:
a dict with "text-only" format.
"""
data_dict = {
"type": "text_only",
"instances": [ { "text": line.strip() } for line in fin ],
}
return data_dict |
Converts raw text to text-only format.
Args:
fin: the input file description of the raw text file.
Returns:
a dict with "text-only" format.
| raw2textonly | python | OptimalScale/LMFlow | scripts/data_preprocess/raw2textonly.py | https://github.com/OptimalScale/LMFlow/blob/master/scripts/data_preprocess/raw2textonly.py | Apache-2.0 |
def parse_argument(sys_argv):
"""Parses arguments from command line.
Args:
sys_argv: the list of arguments (strings) from command line.
Returns:
A struct whose member corresponds to the required (optional) variable.
For example,
```
args = parse_argument(['main.py' '--input', 'a.txt', '--num', '10'])
args.input # 'a.txt'
args.num # 10
```
"""
parser = argparse.ArgumentParser(
formatter_class=argparse.RawTextHelpFormatter)
# Training parameters
parser.add_argument(
"--dataset_path", type=str,
default=None,
help="input dataset path, reads from stdin by default"
)
parser.add_argument(
"--output_path", type=str,
default=None,
help="output dataset path, writes to stdout by default"
)
parser.add_argument(
"--ratio", type=float, required=True,
help="sample ratio, will be floored if number of samples is not a int"
)
parser.add_argument(
"--seed", type=int, default=42,
help="pseudorandom seed"
)
# Parses from commandline
args = parser.parse_args(sys_argv[1:])
return args | Parses arguments from command line.
Args:
sys_argv: the list of arguments (strings) from command line.
Returns:
A struct whose member corresponds to the required (optional) variable.
For example,
```
args = parse_argument(['main.py' '--input', 'a.txt', '--num', '10'])
args.input # 'a.txt'
args.num # 10
```
| parse_argument | python | OptimalScale/LMFlow | scripts/data_preprocess/sample.py | https://github.com/OptimalScale/LMFlow/blob/master/scripts/data_preprocess/sample.py | Apache-2.0 |
def parse_argument(sys_argv):
"""Parses arguments from command line.
Args:
sys_argv: the list of arguments (strings) from command line.
Returns:
A struct whose member corresponds to the required (optional) variable.
For example,
```
args = parse_argument(['main.py' '--input', 'a.txt', '--num', '10'])
args.input # 'a.txt'
args.num # 10
```
"""
parser = argparse.ArgumentParser(
formatter_class=argparse.RawTextHelpFormatter)
# Training parameters
parser.add_argument(
"--dataset_path", type=str,
default=None,
help="input dataset path, reads from stdin by default"
)
parser.add_argument(
"--output_path", type=str,
default=None,
help="output dataset path, writes to stdout by default"
)
parser.add_argument(
"--seed", type=int, default=42,
help="pseudorandom seed"
)
# Parses from commandline
args = parser.parse_args(sys_argv[1:])
return args | Parses arguments from command line.
Args:
sys_argv: the list of arguments (strings) from command line.
Returns:
A struct whose member corresponds to the required (optional) variable.
For example,
```
args = parse_argument(['main.py' '--input', 'a.txt', '--num', '10'])
args.input # 'a.txt'
args.num # 10
```
| parse_argument | python | OptimalScale/LMFlow | scripts/data_preprocess/shuffle.py | https://github.com/OptimalScale/LMFlow/blob/master/scripts/data_preprocess/shuffle.py | Apache-2.0 |
def _check_instance_format(self):
"""
Checks if data (instances) have required fields.
Raises messages with hints if not matched.
"""
fields = self.backend_dataset.features
correct_fields = INSTANCE_FIELDS_MAP[self.type]
if not set(correct_fields).issubset(set(fields)):
raise ValueError(
f'data instance fields incorrect'
f' {list(correct_fields)} are required.'
) |
Checks if data (instances) have required fields.
Raises messages with hints if not matched.
| _check_instance_format | python | OptimalScale/LMFlow | src/lmflow/datasets/dataset.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/datasets/dataset.py | Apache-2.0 |
def from_dict(self, dict_obj: dict, *args, **kwargs):
r"""
Create a Dataset object from a dictionary.
Return a Dataset given a dict with format:
{
"type": TYPE,
"instances": [
{
"key_1": VALUE_1.1,
"key_2": VALUE_1.2,
...
},
{
"key_1": VALUE_2.1,
"key_2": VALUE_2.2,
...
},
...
]
}
Parameters
-----------
dict_obj : dict.
A dictionary containing the dataset information.
args : Optional.
Positional arguments.
kwargs : Optional.
Keyword arguments.
Returns
---------
self : Dataset object.
"""
if self.backend == "huggingface":
if KEY_TYPE not in dict_obj:
raise ValueError(
f'"{KEY_TYPE}" must be provided to initialize a dataset,'
f' e.g.\n'
f' {TEXT_ONLY_DATASET_DESCRIPTION}'
)
if KEY_INSTANCES not in dict_obj:
raise ValueError(
f'"{KEY_INSTANCES}" must be provided to initialize a'
f' dataset, e.g.\n'
f' {TEXT_ONLY_DATASET_DESCRIPTION}'
)
self.type = dict_obj[KEY_TYPE]
if not self.type in INSTANCE_FIELDS_MAP:
raise ValueError(f'type "{self.type}" is not supported')
correct_fields = INSTANCE_FIELDS_MAP[self.type]
for i, instance in enumerate(dict_obj[KEY_INSTANCES]):
fields = instance.keys()
if not set(correct_fields).issubset(set(fields)):
raise ValueError(
f'data instance fields incorrect'
f' {list(correct_fields)} are required.'
)
try:
hf_dict = {}
if len(dict_obj[KEY_INSTANCES]) > 0:
for key in dict_obj[KEY_INSTANCES][0].keys():
hf_dict[key] = [
instance[key] for instance in dict_obj[KEY_INSTANCES]
]
self.backend_dataset = HFDataset.from_dict(hf_dict, *args, **kwargs)
except AttributeError as ex:
raise ValueError(
f"Error occurs: {ex}. Failed to convert dict to"
f" \"{self.type}\" dataset," f" the standard format is as"
f" follows:\n"
f" {DATASET_DESCRIPTION_MAP[self.type]}"
)
self._check_instance_format()
return self
elif self.backend == "dict":
self.backend_dataset = dict_obj
self.type = dict_obj[KEY_TYPE]
return self
else:
raise NotImplementedError(
f'Currently .from_dict is not supported for backend "{self.backend}"'
) |
Create a Dataset object from a dictionary.
Return a Dataset given a dict with format:
{
"type": TYPE,
"instances": [
{
"key_1": VALUE_1.1,
"key_2": VALUE_1.2,
...
},
{
"key_1": VALUE_2.1,
"key_2": VALUE_2.2,
...
},
...
]
}
Parameters
-----------
dict_obj : dict.
A dictionary containing the dataset information.
args : Optional.
Positional arguments.
kwargs : Optional.
Keyword arguments.
Returns
---------
self : Dataset object.
| from_dict | python | OptimalScale/LMFlow | src/lmflow/datasets/dataset.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/datasets/dataset.py | Apache-2.0 |
def create_from_dict(cls, dict_obj, *args, **kwargs):
r"""
Returns
--------
Returns a Dataset object given a dict.
"""
empty_data_args = DatasetArguments(dataset_path=None)
dataset = Dataset(empty_data_args)
return dataset.from_dict(dict_obj) |
Returns
--------
Returns a Dataset object given a dict.
| create_from_dict | python | OptimalScale/LMFlow | src/lmflow/datasets/dataset.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/datasets/dataset.py | Apache-2.0 |
def to_dict(self):
r"""
Returns
---------
Return a dict represents the dataset:
{
"type": TYPE,
"instances": [
{
"key_1": VALUE_1.1,
"key_2": VALUE_1.2,
...
},
{
"key_1": VALUE_2.1,
"key_2": VALUE_2.2,
...
},
...
]
}
A python dict object represents the content of this dataset.
"""
if self.backend == "huggingface":
dict_obj = {}
dict_obj[KEY_TYPE] = self.get_type()
hf_dict = self.backend_dataset.to_dict()
dict_obj[KEY_INSTANCES] = []
first_key = None
for key in hf_dict.keys():
first_key = key
break
if first_key is not None:
num_instances = len(hf_dict[first_key])
dict_obj[KEY_INSTANCES] = [
{
key: hf_dict[key][i] for key in hf_dict.keys()
}
for i in range(num_instances)
]
return dict_obj
elif self.backend == "dict":
dict_obj = self.backend_dataset
return dict_obj
else:
raise NotImplementedError(
f'Current .to_dict is not supported for backend "{self.backend}"'
) |
Returns
---------
Return a dict represents the dataset:
{
"type": TYPE,
"instances": [
{
"key_1": VALUE_1.1,
"key_2": VALUE_1.2,
...
},
{
"key_1": VALUE_2.1,
"key_2": VALUE_2.2,
...
},
...
]
}
A python dict object represents the content of this dataset.
| to_dict | python | OptimalScale/LMFlow | src/lmflow/datasets/dataset.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/datasets/dataset.py | Apache-2.0 |
def map(self, *args, **kwargs):
r"""
Parameters
------------
args : Optional.
Positional arguments.
kwargs : Optional.
Keyword arguments.
Returns
---------
self : Dataset object.
"""
# If the dataset uses Hugging Face as the backend,
# call the `map()` function of the Hugging Face backend dataset
if self.backend == "huggingface":
# Set the mapped dataset as the backend dataset of the current dataset
mapped_backend_dataset = self.backend_dataset.map(*args, **kwargs)
self.backend_dataset = mapped_backend_dataset
return self
else:
# If the backend is not Hugging Face, raise a NotImplementedError
raise NotImplementedError(
f'Currently .map is not supported for backend "{self.backend}"'
) |
Parameters
------------
args : Optional.
Positional arguments.
kwargs : Optional.
Keyword arguments.
Returns
---------
self : Dataset object.
| map | python | OptimalScale/LMFlow | src/lmflow/datasets/dataset.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/datasets/dataset.py | Apache-2.0 |
def save(
self,
file_path: str,
format: str="json"
):
r"""
Save the dataset to a json file.
Parameters
------------
file_path : str.
The path to the file where the dataset will be saved.
"""
if format == "json":
assert Path(file_path).suffix == ".json", "The file path must have a .json extension."
with open(file_path, "w", encoding='utf-8') as fout:
json.dump(self.to_dict(), fout, indent=4, ensure_ascii=False)
else:
logger.error(f"Unsupported format when saving the dataset: {format}.") |
Save the dataset to a json file.
Parameters
------------
file_path : str.
The path to the file where the dataset will be saved.
| save | python | OptimalScale/LMFlow | src/lmflow/datasets/dataset.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/datasets/dataset.py | Apache-2.0 |
def sample(self, n: int, seed: int=42):
r"""
Sample n instances from the dataset.
Parameters
------------
n : int.
The number of instances to sample from the dataset.
Returns
---------
sample_dataset : Dataset object.
A new dataset object containing the sampled instances.
"""
if self.backend == "huggingface":
sampled_dataset = self.backend_dataset.shuffle(seed=seed).select(range(n))
output_dataset = self.create_from_dict(
{
"type": self.get_type(),
"instances": [
{
col_name: sampled_dataset[col_name][i] for col_name in sampled_dataset.column_names
} for i in range(n)
]
}
)
return output_dataset
else:
raise NotImplementedError(
f'Currently .sample is not supported for backend "{self.backend}"'
) |
Sample n instances from the dataset.
Parameters
------------
n : int.
The number of instances to sample from the dataset.
Returns
---------
sample_dataset : Dataset object.
A new dataset object containing the sampled instances.
| sample | python | OptimalScale/LMFlow | src/lmflow/datasets/dataset.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/datasets/dataset.py | Apache-2.0 |
def train_test_split(self, test_size: float=0.2, shuffle: bool=True, seed: int=42):
r"""
Split the dataset into training and testing sets.
Parameters
------------
test_size : float, default=0.2.
The proportion of the dataset that will be used for testing.
Returns
---------
train_dataset : Dataset object.
A new dataset object containing the training instances.
test_dataset : Dataset object.
A new dataset object containing the testing instances.
"""
if self.backend == "huggingface":
splited = self.backend_dataset.train_test_split(
test_size=test_size, shuffle=shuffle, seed=seed
)
train_dataset = self.create_from_dict(
{
"type": self.get_type(),
"instances": [
{
col_name: splited["train"][col_name][i] for col_name in splited["train"].column_names
} for i in range(len(splited["train"]))
]
}
)
test_dataset = self.create_from_dict(
{
"type": self.get_type(),
"instances": [
{
col_name: splited["test"][col_name][i] for col_name in splited["test"].column_names
} for i in range(len(splited["test"]))
]
}
)
return train_dataset, test_dataset
else:
raise NotImplementedError(
f'Currently .train_test_split is not supported for backend "{self.backend}"'
) |
Split the dataset into training and testing sets.
Parameters
------------
test_size : float, default=0.2.
The proportion of the dataset that will be used for testing.
Returns
---------
train_dataset : Dataset object.
A new dataset object containing the training instances.
test_dataset : Dataset object.
A new dataset object containing the testing instances.
| train_test_split | python | OptimalScale/LMFlow | src/lmflow/datasets/dataset.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/datasets/dataset.py | Apache-2.0 |
def drop_instances(self, indices: list):
r"""
Drop instances from the dataset.
Parameters
------------
indices : list.
A list of indices of the instances to drop from the dataset.
"""
if self.backend == "huggingface":
self.backend_dataset = self.backend_dataset.remove_indices(indices)
else:
raise NotImplementedError(
f'Currently .drop_instances is not supported for backend "{self.backend}"'
) |
Drop instances from the dataset.
Parameters
------------
indices : list.
A list of indices of the instances to drop from the dataset.
| drop_instances | python | OptimalScale/LMFlow | src/lmflow/datasets/dataset.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/datasets/dataset.py | Apache-2.0 |
def sanity_check(
self,
drop_invalid: bool=True,
):
r"""
Perform a sanity check on the dataset.
"""
if self.backend == "huggingface":
self.hf_dataset_sanity_check(drop_invalid)
else:
raise NotImplementedError(
f'Currently .sanity_check is not supported for backend "{self.backend}"'
) |
Perform a sanity check on the dataset.
| sanity_check | python | OptimalScale/LMFlow | src/lmflow/datasets/dataset.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/datasets/dataset.py | Apache-2.0 |
def hf_dataset_sanity_check(
self,
drop_invalid: bool=True,
):
r"""
Perform a sanity check on the HuggingFace dataset.
"""
if self.backend_dataset is None or len(self.backend_dataset) == 0:
raise ValueError("Dataset is empty.")
if self.type == 'text_to_textlist':
num_output_per_instance = len(self.backend_dataset['output'][0])
dataset_cache = self.backend_dataset.filter(lambda x: len(x['input'])!=0)
dataset_cache = self.backend_dataset.filter(lambda x: len(x['output']) == num_output_per_instance)
dataset_cache = self.backend_dataset.filter(lambda x: not all([len(output) == 0 for output in x['output']]))
if len(dataset_cache) != len(self.backend_dataset):
warning_info = (
f"Found {len(self.backend_dataset) - len(dataset_cache)} invalid instances "
"during hf_dataset_sanity_check, please check:\n"
" 1. length of input strings should not be empty\n"
" 2. length of output strings should not be all empty\n"
" 3. number of output strings should be consistent\n" # since we will use tensor reshape later
)
if drop_invalid:
self.backend_dataset = dataset_cache
logger.warning(warning_info+"Invalid instances are dropped.")
else:
raise ValueError(warning_info)
else:
logger.warning(f"No sanity check for {self.type} dataset.") |
Perform a sanity check on the HuggingFace dataset.
| hf_dataset_sanity_check | python | OptimalScale/LMFlow | src/lmflow/datasets/dataset.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/datasets/dataset.py | Apache-2.0 |
def preprocess_llama_from_llava_plain(
sources,
tokenizer: transformers.PreTrainedTokenizer,
has_image: bool = False):
"""
This function just add the image in the front of text.
And don't add any prompt.
Args:
sources: The input data with text and image.
tokenizer: The tokenizer to process text.
has_image: Whether the input data has image.
Returns:
The input_ids and labels for the model.
"""
conversations = []
for source in sources:
assert len(source) == 2
assert DEFAULT_IMAGE_TOKEN in source[0]['value']
source[0]['value'] = DEFAULT_IMAGE_TOKEN
conversation = source[0]['value'] + source[1]['value'] + conversation_lib.default_conversation.sep
conversations.append(conversation)
# tokenize conversations
input_ids = [tokenizer_image_token(prompt, tokenizer, return_tensors='pt') for prompt in conversations]
targets = copy.deepcopy(input_ids)
for target, source in zip(targets, sources):
tokenized_len = len(tokenizer_image_token(source[0]['value'], tokenizer))
target[:tokenized_len] = IGNORE_INDEX
return dict(input_ids=input_ids, labels=targets) |
This function just add the image in the front of text.
And don't add any prompt.
Args:
sources: The input data with text and image.
tokenizer: The tokenizer to process text.
has_image: Whether the input data has image.
Returns:
The input_ids and labels for the model.
| preprocess_llama_from_llava_plain | python | OptimalScale/LMFlow | src/lmflow/datasets/multi_modal_dataset.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/datasets/multi_modal_dataset.py | Apache-2.0 |
def preprocess_llama_from_llava_v1(
sources,
tokenizer: transformers.PreTrainedTokenizer,
has_image: bool = False):
"""
This function add the prompt and then put the image after the prompt.
So it needs additional code to generate the target label.
Args:
sources: The input data with text and image.
tokenizer: The tokenizer to process text.
has_image: Whether the input data has image.
Returns:
The input_ids and labels for the model.
"""
conv = conversation_lib.default_conversation.copy()
roles = {"human": conv.roles[0], "gpt": conv.roles[1]}
# Apply prompt templates
conversations = []
for i, source in enumerate(sources):
if roles[source[0]["from"]] != conv.roles[0]:
# Skip the first one if it is not from human
source = source[1:]
conv.messages = []
for j, sentence in enumerate(source):
role = roles[sentence["from"]]
assert role == conv.roles[j % 2], f"{i}"
conv.append_message(role, sentence["value"])
conversations.append(conv.get_prompt())
# Tokenize conversations
if has_image:
input_ids = torch.stack([tokenizer_image_token(prompt, tokenizer, return_tensors='pt') for prompt in conversations], dim=0)
else:
input_ids = tokenizer(
conversations,
return_tensors="pt",
padding="longest",
max_length=tokenizer.model_max_length,
truncation=True,
).input_ids
targets = input_ids.clone()
assert conv.sep_style == conversation_lib.SeparatorStyle.TWO
# Mask targets
sep = conv.sep + conv.roles[1] + ": "
for conversation, target in zip(conversations, targets):
total_len = int(target.ne(tokenizer.pad_token_id).sum())
rounds = conversation.split(conv.sep2)
cur_len = 1
target[:cur_len] = IGNORE_INDEX
for i, rou in enumerate(rounds):
if rou == "":
break
parts = rou.split(sep)
if len(parts) != 2:
break
parts[0] += sep
if has_image:
round_len = len(tokenizer_image_token(rou, tokenizer))
instruction_len = len(tokenizer_image_token(parts[0], tokenizer)) - 2
else:
round_len = len(tokenizer(rou).input_ids)
instruction_len = len(tokenizer(parts[0]).input_ids) - 2
target[cur_len : cur_len + instruction_len] = IGNORE_INDEX
cur_len += round_len
target[cur_len:] = IGNORE_INDEX
if cur_len < tokenizer.model_max_length:
if cur_len != total_len:
target[:] = IGNORE_INDEX
print(
f"WARNING: tokenization mismatch: {cur_len} vs. {total_len}."
f" (ignored)"
)
return dict(
input_ids=input_ids,
labels=targets,
) |
This function add the prompt and then put the image after the prompt.
So it needs additional code to generate the target label.
Args:
sources: The input data with text and image.
tokenizer: The tokenizer to process text.
has_image: Whether the input data has image.
Returns:
The input_ids and labels for the model.
| preprocess_llama_from_llava_v1 | python | OptimalScale/LMFlow | src/lmflow/datasets/multi_modal_dataset.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/datasets/multi_modal_dataset.py | Apache-2.0 |
def __init__(
self,
model_args,
tune_strategy='normal',
ds_config=None,
device="gpu",
use_accelerator=False,
*args,
**kwargs
):
"""
Initializes a HFDecoderModel instance.
:param model_args: dictionary with model arguments such as model name, path, revision, etc.
:param tune_strategy: tuning strategy: normal, none, lora or adapter
:param ds_config: deepspeed configuration for distributed training
"""
HFModelMixin.__init__(
self,
model_args=model_args,
do_train=True if tune_strategy == "normal" else False,
ds_config=ds_config,
device=device,
use_accelerator=use_accelerator,
*args,
**kwargs
) |
Initializes a HFDecoderModel instance.
:param model_args: dictionary with model arguments such as model name, path, revision, etc.
:param tune_strategy: tuning strategy: normal, none, lora or adapter
:param ds_config: deepspeed configuration for distributed training
| __init__ | python | OptimalScale/LMFlow | src/lmflow/models/hf_decoder_model.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/models/hf_decoder_model.py | Apache-2.0 |
def tokenize(
self,
dataset: Dataset,
add_special_tokens=True,
*args,
**kwargs
) -> Dataset:
"""
Tokenize the full dataset.
Parameters
------------
dataset : lmflow.datasets.Dataset.
args : Optional.
Positional arguments.
kwargs : Optional.
Keyword arguments.
Returns
------------
tokenized_datasets :
The tokenized dataset, without any leading or trailing special
tokens (normally they are Begin-Of-Sentence or End-Of-Sentence
tokens).
"""
# Preprocessing the datasets.
# First we tokenize all the texts.
if dataset.get_backend() != "huggingface":
raise NotImplementedError(
"tokenization of datasets with non-huggingface backend are"
"not supported yet"
)
dataset_type = dataset.get_type()
model_args = self.model_args
raw_datasets = dataset
hf_raw_datasets = dataset.get_backend_dataset()
column_names = list(hf_raw_datasets.features)
data_args = raw_datasets.get_data_args()
# Requires three types of information for tokenizing different datasets
# 1) Which fields require tokenization, e.g.
# "text2float": "text", but not "float"
# "text2text": both "input" and "output"
# 2) How will there tokenized sequence concatenated together, e.g.
# "text_only": "text" -> "text"
# "text2text": "input", "output" -> "input" + "output"
# 3) Which fields require loss in final computation, e.g.
# "text_only": "text"
# "text2text": "output" only
tokenized_column_order = None # Handles 1) and 2)
label_columns = None # Handles 3)
if dataset_type == "text_only":
tokenized_column_order = ["text"]
label_columns = ["text"]
elif dataset_type == "text2text":
tokenized_column_order = ["input", "output"]
label_columns = ["output"]
add_special_tokens = False
elif dataset_type == "conversation":
if data_args.conversation_template:
if data_args.conversation_template in PRESET_TEMPLATES.keys():
conversation_template = PRESET_TEMPLATES[data_args.conversation_template]
else:
raise NotImplementedError(
f"Conversation template {data_args.conversation_template} is not supported yet."
)
else:
logger.warning("No conversation template provided. Using default template.")
conversation_template = PRESET_TEMPLATES['empty']
logger.warning(f"Conversation template: {conversation_template}")
else:
raise NotImplementedError(
f"dataset type \"{dataset_type}\" is not supported, currently"
" only support following data types:\n"
f" 1) {TEXT_ONLY_DATASET_DESCRIPTION}\n"
f" 2) {TEXT2TEXT_DATASET_DESCRIPTION}\n"
f" 3) {CONVERSATION_DATASET_DESCRIPTION}\n"
)
# Whether to truncate long sequences to fit into max_length
use_truncation = False
if model_args.use_lora or data_args.disable_group_texts:
use_truncation = True
tokenize_fn = conversation_tokenize_function if "conversation" in dataset_type else tokenize_function
tokenize_fn_kwargs = {
"data_args": data_args,
"tokenizer": self.tokenizer,
"column_names": column_names,
}
if "conversation" in dataset_type:
tokenize_fn_kwargs["conversation_template"] = conversation_template
else:
tokenize_fn_kwargs["label_columns"] = label_columns
tokenize_fn_kwargs["tokenized_column_order"] = tokenized_column_order
tokenize_fn_kwargs["add_special_tokens"] = add_special_tokens
tokenize_fn_kwargs["use_truncation"] = use_truncation
tokenize_kwargs = {}
if not data_args.streaming:
fingerprint = hashlib.md5(
(
raw_datasets.get_fingerprint()
+ str(self.tokenizer)
+ f'###padding_side={self.tokenizer.padding_side}'
+ ('###conversation_template=' + str(conversation_template) if "conversation" in dataset_type else "")
+ f'###disable_group_texts={data_args.disable_group_texts}'
+ f'###block_size={data_args.block_size}'
).encode("utf-8")
).hexdigest()
tokenize_kwargs = {
"num_proc": data_args.preprocessing_num_workers,
"load_from_cache_file": not data_args.overwrite_cache,
"desc": "Running tokenizer on dataset",
"new_fingerprint": fingerprint,
}
if data_args.block_size < self.tokenizer.model_max_length:
logger.warning(
f"block_size {data_args.block_size} < model_max_length {self.tokenizer.model_max_length}, "
"use block_size for maximum tokenized sequence length."
)
tokenized_datasets = raw_datasets.map(
tokenize_fn,
batched=True,
remove_columns=column_names,
fn_kwargs=tokenize_fn_kwargs,
**tokenize_kwargs
)
return tokenized_datasets |
Tokenize the full dataset.
Parameters
------------
dataset : lmflow.datasets.Dataset.
args : Optional.
Positional arguments.
kwargs : Optional.
Keyword arguments.
Returns
------------
tokenized_datasets :
The tokenized dataset, without any leading or trailing special
tokens (normally they are Begin-Of-Sentence or End-Of-Sentence
tokens).
| tokenize | python | OptimalScale/LMFlow | src/lmflow/models/hf_decoder_model.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/models/hf_decoder_model.py | Apache-2.0 |
def encode(self, input: Union[str, List[str]], *args, **kwargs ) -> Union[List[int], List[List[int]]]:
"""
Perform encoding process of the tokenizer.
Parameters
------------
inputs : str or list.
The text sequence.
args : Optional.
Positional arguments.
kwargs : Optional.
Keyword arguments.
Returns
------------
outputs :
if string input,return the tokenized inputs.
"Hello,world!"-> [101, 7592, 1010, 2088, 102]
if batch input,return {input_ids,attention_mask,token_type_ids}
["Hello,world!","Hello!"]-> {'input_ids': tensor([[ 101, 7592, 1010, 2088, 102],...),'attention_mask': tensor([[1, 1, 1, 1, 1],[0,0,1,1,1]])}
"""
if isinstance(input, list):
return self.tokenizer(text=input, *args, **kwargs)#batch encode,will automatically do left padding
elif isinstance(input, str):
return self.tokenizer.encode(text=input, *args, **kwargs)
else:
raise NotImplementedError(f'type "{type(input)}" cannot be encoded') |
Perform encoding process of the tokenizer.
Parameters
------------
inputs : str or list.
The text sequence.
args : Optional.
Positional arguments.
kwargs : Optional.
Keyword arguments.
Returns
------------
outputs :
if string input,return the tokenized inputs.
"Hello,world!"-> [101, 7592, 1010, 2088, 102]
if batch input,return {input_ids,attention_mask,token_type_ids}
["Hello,world!","Hello!"]-> {'input_ids': tensor([[ 101, 7592, 1010, 2088, 102],...),'attention_mask': tensor([[1, 1, 1, 1, 1],[0,0,1,1,1]])}
| encode | python | OptimalScale/LMFlow | src/lmflow/models/hf_decoder_model.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/models/hf_decoder_model.py | Apache-2.0 |
def decode(self, input, *args, **kwargs ) -> Union[str, List[str]]:
"""
Perform decoding process of the tokenizer.
Parameters
------------
inputs : list or tensor.
The token sequence.
args : Optional.
Positional arguments.
kwargs : Optional.
Keyword arguments.
Returns
------------
outputs :
The text decoded from the token inputs.
if batch input,return the list of text
[[101, 7592, 1010, 2088, 102],[101, 7592, 1010, 2088, 102]]-> ["Hello,world!","Hello,world!"
if single input,return the text
[101, 7592, 1010, 2088, 102]-> "Hello,world!"
"""
if isinstance(input, List):
input=torch.tensor(input)
if input.dim()==2:
return self.tokenizer.batch_decode(input, *args, **kwargs)#batch_decode
else:
# Can be list of ints or a Tensor
return self.tokenizer.decode(input, *args, **kwargs) |
Perform decoding process of the tokenizer.
Parameters
------------
inputs : list or tensor.
The token sequence.
args : Optional.
Positional arguments.
kwargs : Optional.
Keyword arguments.
Returns
------------
outputs :
The text decoded from the token inputs.
if batch input,return the list of text
[[101, 7592, 1010, 2088, 102],[101, 7592, 1010, 2088, 102]]-> ["Hello,world!","Hello,world!"
if single input,return the text
[101, 7592, 1010, 2088, 102]-> "Hello,world!"
| decode | python | OptimalScale/LMFlow | src/lmflow/models/hf_decoder_model.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/models/hf_decoder_model.py | Apache-2.0 |
def inference(
self,
inputs,
release_gpu: bool = False,
use_vllm: bool = False,
**kwargs
):
"""
Perform generation process of the model.
Parameters
------------
inputs :
The sequence used as a prompt for the generation or as model inputs to the model.
When using vllm inference, this should be a string or a list of strings.
When using normal inference, this should be a tensor.
release_gpu : bool, optional
Whether to release the GPU resource after inference, by default False.
use_vllm : bool, optional
Whether to use VLLM for inference, by default False.
kwargs : Optional.
Keyword arguments.
Returns
------------
outputs :
The generated sequence output
"""
if not self._activated:
self.activate_model_for_inference(
use_vllm=use_vllm,
**kwargs,
)
if use_vllm:
if not is_vllm_available():
raise ImportError("vllm is not installed. Please install vllm to use VLLM inference.")
res = self.__vllm_inference(inputs, **kwargs)
else:
res = self.__inference(inputs, **kwargs)
if release_gpu:
self.deactivate_model_for_inference(use_vllm=use_vllm)
return res |
Perform generation process of the model.
Parameters
------------
inputs :
The sequence used as a prompt for the generation or as model inputs to the model.
When using vllm inference, this should be a string or a list of strings.
When using normal inference, this should be a tensor.
release_gpu : bool, optional
Whether to release the GPU resource after inference, by default False.
use_vllm : bool, optional
Whether to use VLLM for inference, by default False.
kwargs : Optional.
Keyword arguments.
Returns
------------
outputs :
The generated sequence output
| inference | python | OptimalScale/LMFlow | src/lmflow/models/hf_decoder_model.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/models/hf_decoder_model.py | Apache-2.0 |
def __inference(self, inputs, *args, **kwargs):
"""
Perform generation process of the model.
Parameters
------------
inputs :
The **tokenized** sequence used as a prompt for the generation or as model inputs to the model.
args : Optional.
Positional arguments.
kwargs : Optional.
Keyword arguments.
Returns
------------
outputs :
The generated sequence output
"""
with torch.no_grad():
if self.use_accelerator:
outputs = self.backend_model.generate(
input_ids=inputs,
pad_token_id=self.tokenizer.pad_token_id,
*args,
**kwargs
)
else:
if self.device == "gpu":
outputs = self.ds_engine.module.generate(
input_ids=inputs,
synced_gpus=True,
pad_token_id=self.tokenizer.pad_token_id,
*args,
**kwargs
)
elif self.device == "cpu":
outputs = self.backend_model.generate(
input_ids=inputs,
synced_gpus=True,
pad_token_id=self.tokenizer.pad_token_id,
*args,
**kwargs
)
else:
raise NotImplementedError(
f"device \"{self.device}\" is not supported"
)
return outputs |
Perform generation process of the model.
Parameters
------------
inputs :
The **tokenized** sequence used as a prompt for the generation or as model inputs to the model.
args : Optional.
Positional arguments.
kwargs : Optional.
Keyword arguments.
Returns
------------
outputs :
The generated sequence output
| __inference | python | OptimalScale/LMFlow | src/lmflow/models/hf_decoder_model.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/models/hf_decoder_model.py | Apache-2.0 |
def __vllm_inference(
self,
inputs: Union[str, List[str]],
sampling_params: Optional['SamplingParams'] = None,
**kwargs,
) -> List[VLLMInferenceResultWithInput]:
"""Perform VLLM inference process of the model.
Parameters
----------
inputs : Union[str, List[str]]
Prompt(s), string or a list of strings.
sampling_params : Optional[SamplingParams], optional
vllm SamplingParams object, by default None.
Returns
-------
List[VLLMInferenceResultWithInput]
Return a list of VLLMInferenceResultWithInput, where each
element contains the input prompt and the corresponding output.
When `sampling_params.detokenize = True`, the output would be a list of strings,
contains sampling_params.n samples for the corresponding prompt.
When `sampling_params.detokenize = False`, return a list of list of ints
(token ids, no decoding after generation).
"""
vllm_outputs = self.backend_model_for_inference.generate(
inputs,
sampling_params=sampling_params,
use_tqdm=True,
)
final_output = []
for output in vllm_outputs:
if sampling_params.detokenize:
output_list = [sentence.text for sentence in output.outputs]
else:
output_list = [sentence.token_ids for sentence in output.outputs]
final_output.append({"input": output.prompt, "output": output_list})
return final_output | Perform VLLM inference process of the model.
Parameters
----------
inputs : Union[str, List[str]]
Prompt(s), string or a list of strings.
sampling_params : Optional[SamplingParams], optional
vllm SamplingParams object, by default None.
Returns
-------
List[VLLMInferenceResultWithInput]
Return a list of VLLMInferenceResultWithInput, where each
element contains the input prompt and the corresponding output.
When `sampling_params.detokenize = True`, the output would be a list of strings,
contains sampling_params.n samples for the corresponding prompt.
When `sampling_params.detokenize = False`, return a list of list of ints
(token ids, no decoding after generation).
| __vllm_inference | python | OptimalScale/LMFlow | src/lmflow/models/hf_decoder_model.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/models/hf_decoder_model.py | Apache-2.0 |
def prepare_inputs_for_inference(
self,
dataset: Dataset,
apply_chat_template: bool = True,
enable_distributed_inference: bool = False,
use_vllm: bool = False,
**kwargs,
) -> Union[List[str], "ray.data.Dataset", Dict[str, torch.Tensor]]:
"""
Prepare inputs for inference.
Parameters
------------
dataset : lmflow.datasets.Dataset.
The dataset used for inference.
args : Optional.
Positional arguments.
kwargs : Optional.
Keyword arguments.
Returns
------------
outputs :
The prepared inputs for inference.
"""
if use_vllm:
if not is_ray_available() and enable_distributed_inference:
raise ImportError("ray is not installed. Please install ray to use distributed vllm inference.")
inference_inputs = self.__prepare_inputs_for_vllm_inference(
dataset=dataset,
apply_chat_template=apply_chat_template,
enable_distributed_inference=enable_distributed_inference,
)
else:
inference_inputs = self.__prepare_inputs_for_inference(
dataset,
apply_chat_template=apply_chat_template,
enable_distributed_inference=enable_distributed_inference,
)
return inference_inputs |
Prepare inputs for inference.
Parameters
------------
dataset : lmflow.datasets.Dataset.
The dataset used for inference.
args : Optional.
Positional arguments.
kwargs : Optional.
Keyword arguments.
Returns
------------
outputs :
The prepared inputs for inference.
| prepare_inputs_for_inference | python | OptimalScale/LMFlow | src/lmflow/models/hf_decoder_model.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/models/hf_decoder_model.py | Apache-2.0 |
def save(self, dir, save_full_model=False, *args, **kwargs):
"""
Perform generation process of the model.
Parameters
------------
dir :
The directory to save model and tokenizer
save_full_model : Optional.
Whether to save full model.
kwargs : Optional.
Keyword arguments.
Returns
------------
outputs :
The generated sequence output
"""
self.get_tokenizer().save_pretrained(dir)
if save_full_model and self.model_args.use_lora:
save_dtype = (
torch.float16
if self.model_args.torch_dtype in ["auto", None]
else getattr(torch, self.model_args.torch_dtype)
)
self.backend_model_full.to(dtype=save_dtype).save_pretrained(dir)
logger.warning(f"Save full model with dtype: {save_dtype}")
else:
self.get_backend_model().save_pretrained(dir) |
Perform generation process of the model.
Parameters
------------
dir :
The directory to save model and tokenizer
save_full_model : Optional.
Whether to save full model.
kwargs : Optional.
Keyword arguments.
Returns
------------
outputs :
The generated sequence output
| save | python | OptimalScale/LMFlow | src/lmflow/models/hf_decoder_model.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/models/hf_decoder_model.py | Apache-2.0 |
def __init__(
self,
model_args,
tune_strategy='normal',
ds_config=None,
device="gpu",
use_accelerator=False,
custom_model=False,
with_deepspeed=True,
pipeline_args=None,
*args,
**kwargs
):
"""
Initializes a HFDecoderModel instance.
:param model_args: dictionary with model arguments such as model name, path, revision, etc.
:param tune_strategy: tuning strategy: normal, none, lora or adapter
:param ds_config: deepspeed configuration for distributed training
"""
# See more about loading any type of standard or custom dataset (from
# files, python dict, pandas DataFrame, etc) at
# https://huggingface.co/docs/datasets/loading_datasets.html.
# Load pretrained model and tokenizer
#
# Distributed training: The .from_pretrained methods guarantee that
# only one local process can concurrently download model & vocab.
self.device = device
if tune_strategy == 'normal':
raise NotImplementedError(
f"tune_strategy \"{tune_strategy}\" is not supported"
)
elif tune_strategy == 'none':
if use_accelerator:
raise NotImplementedError(
f"Currently encoder2decoder model is not supported with accelerator"
)
# dschf = HfDeepSpeedConfig(ds_config)
dschf = HfTrainerDeepSpeedConfig(ds_config)
if pipeline_args is not None:
dschf.trainer_config_process(pipeline_args)
peft_model_id = model_args.lora_model_path
# NOTE: Currently offload is not supported by llama
if "llama" in model_args.model_name_or_path and model_args.use_ram_optimized_load:
logger.warning(
"llama does not support RAM optimized load. Automatically"
" use original load instead."
)
model_args.use_ram_optimized_load = False
# get model register
self.arch_type = model_args.arch_type
if self.arch_type == "encoder_decoder":
if model_args.model_name_or_path == 'THUDM/chatglm-6b':
model_register = AutoModel
else:
model_register = AutoModelForSeq2SeqLM
elif self.arch_type == "vision_encoder_decoder":
if not custom_model:
model_register = AutoModelForVision2Seq
else:
model_register = CustomAutoVision2SeqModel
else:
raise NotImplementedError
if not custom_model:
if model_args.model_name_or_path == 'THUDM/chatglm-6b':
self.backend_model = model_register.from_pretrained(model_args.model_name_or_path, trust_remote_code=True)
elif model_args.use_ram_optimized_load and peft_model_id is None:
try:
# RAM-optimized load
self.backend_model = model_register.from_pretrained(
model_args.model_name_or_path,
device_map="auto",
offload_folder="offload",
offload_state_dict=True,
)
except:
logger.warning(
"Failed to use RAM optimized load. Automatically"
" use original load instead."
)
# Normal load
self.backend_model = model_register.from_pretrained(
model_args.model_name_or_path,
)
else:
if peft_model_id is not None:
logger.warning(
"LoRA does not support RAM optimized load currently."
" Automatically use original load instead."
)
self.backend_model = model_register.from_pretrained(
model_args.model_name_or_path,
)
# else:
# self.backend_model = model_register.from_pretrained(
# model_args.model_name_or_path)
else:
if model_args.llava_loading is False:
# FIXME remove the following from_pretrained code by
# creating a unified pretrained model.
model = CustomAutoVision2SeqModel.from_pretrained(model_args.model_name_or_path)
if model_args.llm_model_name_or_path is not None:
text_config = LlamaConfig.from_pretrained(model_args.llm_model_name_or_path)
model.config.text_config = text_config
model.language_model_from_pretrained(model_args.llm_model_name_or_path,
low_resource=model_args.low_resource)
state_dict = torch.load(
model_args.pretrained_language_projection_path,
map_location="cpu")
model.load_state_dict(state_dict, strict=False)
else:
config = AutoConfig.from_pretrained(
model_args.model_name_or_path)
if model_args.low_resource:
kwargs = dict(
torch_dtype=torch.float16,
load_in_8bit=True,
device_map="auto",
)
else:
# kwargs = dict(torch_dtype=torch.float16)
kwargs = dict(device_map="auto")
if (model_args.image_encoder_name_or_path is None and
model_args.qformer_name_or_path is None and
model_args.llm_model_name_or_path is None):
config = AutoConfig.from_pretrained(
model_args.model_name_or_path)
model = CustomAutoVision2SeqModel.from_pretrained(
model_args.model_name_or_path, **kwargs)
else:
config = update_custom_config(config, model_args)
model = CustomAutoVision2SeqModel(
config,
image_encoder_name_or_path=model_args.image_encoder_name_or_path,
qformer_name_or_path=model_args.qformer_name_or_path,
language_model_name_or_path=model_args.llm_model_name_or_path,
low_resource=model_args.low_resource)
if model_args.pretrained_language_projection_path is not None:
state_dict = torch.load(
model_args.pretrained_language_projection_path, map_location="cpu")
new_state_dict = {}
new_state_dict['model.language_projection.weight'] = \
state_dict['model.mm_projector.weight']
new_state_dict['model.language_projection.bias'] = \
state_dict['model.mm_projector.bias']
if model_args.llava_pretrain_model_path is not None:
# used for inference that directly load the preatrain model
model = load_llava_pretrain_model(
model, model_args.llava_pretrain_model_path)
if model_args.save_pretrain_model_path is not None:
model.save_pretrained(
model_args.save_pretrain_model_path)
self.backend_model = model
# init tokenizer
if self.arch_type == "encoder_decoder":
self.tokenizer = AutoTokenizer.from_pretrained(
model_args.model_name_or_path, trust_remote_code=True)
elif self.arch_type == "vision_encoder_decoder":
if model_args.llava_loading is False:
# blip2 image and token processor
self.tokenizer = AutoProcessor.from_pretrained(
model_args.model_name_or_path, trust_remote_code=True)
if model_args.llm_model_name_or_path is not None:
# update the tokenizer from the custom llm.
self.tokenizer.tokenizer = (
AutoTokenizer.from_pretrained(
model_args.llm_model_name_or_path)
)
self.image_processor = self.tokenizer.image_processor
else:
# image processor is stored in the vision encoder
if model_args.llm_model_name_or_path is not None:
self.tokenizer = AutoTokenizer.from_pretrained(
model_args.llm_model_name_or_path)
else:
self.tokenizer = AutoTokenizer.from_pretrained(
config.text_config._name_or_path)
self.image_processor = self.backend_model.image_processor
else:
raise NotImplementedError
self.backend_model_full = self.backend_model
if peft_model_id is not None:
self.backend_model = PeftModel.from_pretrained(
self.backend_model, peft_model_id
)
if tune_strategy == "none" and with_deepspeed is True:
# when load the model with 4bit / 8bit.
# fail to use deepspeed.
if device == "gpu":
deepspeed.init_distributed()
self.ds_engine = deepspeed.initialize(model=self.backend_model, config_params=ds_config)[0]
self.ds_engine.module.eval()
self.tokenizer.padding_side = "left" # necessary for auto-gressive inference
elif tune_strategy == 'adapter':
raise NotImplementedError('adapter tune strategy not implemented')
if self.arch_type == "encoder_decoder":
if self.tokenizer.eos_token_id is None:
self.tokenizer.eos_token_id = self.backend_model.config.eos_token_id
if self.tokenizer.pad_token is None:
self.tokenizer.pad_token_id = self.tokenizer.eos_token_id |
Initializes a HFDecoderModel instance.
:param model_args: dictionary with model arguments such as model name, path, revision, etc.
:param tune_strategy: tuning strategy: normal, none, lora or adapter
:param ds_config: deepspeed configuration for distributed training
| __init__ | python | OptimalScale/LMFlow | src/lmflow/models/hf_encoder_decoder_model.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/models/hf_encoder_decoder_model.py | Apache-2.0 |
def encode(self, input: Union[str, List[str]], *args, **kwargs ) -> Union[List[int], List[List[int]]]:
"""
Perform encoding process of the tokenizer.
Parameters
------------
inputs : str or list.
The text sequence.
args : Optional.
Positional arguments.
kwargs : Optional.
Keyword arguments.
Returns
------------
outputs :
The tokenized inputs.
"""
# check how to handle the image processor
if isinstance(input, dict):
# TODO refactor the input type to make it elegant.
kwargs.update(input)
if "images" not in input:
tokens = self.tokenizer(*args, **kwargs)
else:
if getattr(self.tokenizer, "image_processor", None) is not None:
tokens = self.tokenizer(*args, **kwargs)
elif getattr(self, "image_processor", None) is not None:
images = kwargs.pop("images")
tokens = self.tokenizer(*args, **kwargs)
images = self.image_processor.preprocess(
images, return_tensors='pt')['pixel_values'][0]
tokens['pixel_values'] = images
else:
print("Can not find the image processor")
raise NotImplementedError
return tokens
elif isinstance(input, list):
return self.tokenizer(text=input, *args, **kwargs)#batch encode,will automatically do left padding
elif isinstance(input, str):
return self.tokenizer.encode(text=input, *args, **kwargs)
else:
raise NotImplementedError(f'type "{type(input)}" cannot be encoded') |
Perform encoding process of the tokenizer.
Parameters
------------
inputs : str or list.
The text sequence.
args : Optional.
Positional arguments.
kwargs : Optional.
Keyword arguments.
Returns
------------
outputs :
The tokenized inputs.
| encode | python | OptimalScale/LMFlow | src/lmflow/models/hf_encoder_decoder_model.py | https://github.com/OptimalScale/LMFlow/blob/master/src/lmflow/models/hf_encoder_decoder_model.py | Apache-2.0 |
Subsets and Splits
Django Code with Docstrings
Filters Python code examples from Django repository that contain Django-related code, helping identify relevant code snippets for understanding Django framework usage patterns.
SQL Console for Shuu12121/python-treesitter-filtered-datasetsV2
Retrieves specific code examples from the Flask repository but doesn't provide meaningful analysis or patterns beyond basic data retrieval.
HTTPX Repo Code and Docstrings
Retrieves specific code examples from the httpx repository, which is useful for understanding how particular libraries are used but doesn't provide broader analytical insights about the dataset.
Requests Repo Docstrings & Code
Retrieves code examples with their docstrings and file paths from the requests repository, providing basic filtering but limited analytical value beyond finding specific code samples.
Quart Repo Docstrings & Code
Retrieves code examples with their docstrings from the Quart repository, providing basic code samples but offering limited analytical value for understanding broader patterns or relationships in the dataset.