arcpy.server.CreateMapServerCache(input_service, service_cache_directory, tiling_scheme_type, scales_type, num_of_scales, dots_per_inch, tile_size, {predefined_tiling_scheme}, {tile_origin}, {scales}, {cache_tile_format}, {tile_compression_quality}, {storage_format}, {ready_to_serve_format})
|
Nom
|
Explication
|
Type de données
|
|
input_service
|
Couche de carte ou d’images à mettre en cache.
|
Image Service; Map Server
|
|
service_cache_directory
|
Répertoire parent du cache. Il doit s’agir d’un répertoire de cache ArcGIS Server inscrit.
|
String
|
|
tiling_scheme_type
|
Indique comment la structure de tuilage sera définie. Vous pouvez définir une nouvelle structure de tuilage ou accéder à un fichier de structure de tuilage prédéfini (.xml). Vous pouvez créer une structure prédéfinie en exécutant l’outil Generate Map Server Cache Tiling Scheme (Générer la structure de tuilage d’un cache de serveur de carte).
NEW—La structure de tuilage sera définie à l’aide des autres paramètres de cet outil concernant les niveaux d’échelle, le format d’image, le format de stockage, etc. Il s’agit de l’option par défaut.
PREDEFINED—La structure de tuilage sera définie à l’aide d’un fichier .xml. Vous pouvez créer un fichier de structure de tuilage à l’aide de l’outil Generate Map Server Cache Tiling Scheme (Générer la structure de tuilage d’un cache de serveur de carte).
|
String
|
|
scales_type
|
Spécifie la façon dont les tuiles sont mises à l’échelle.
STANDARD—Les échelles sont automatiquement générées en fonction du nombre de niveaux d’échelle. Elle utilisera les niveaux qui augmentent ou réduisent de moitié à partir de 1:1,000,000 et commencera avec le niveau le plus proche de l’étendue de la carte source. Si, par exemple, la carte source présente une étendue de 1:121 000 000 et que trois niveaux d’échelle sont définis, le service de carte crée un cache offrant les niveaux d’échelle de 1:128 000 000, 1:64 000 000 et 1:32 000 000. Il s’agit de l’option par défaut.
CUSTOM—Le concepteur du cache détermine les échelles.
|
String
|
|
num_of_scales
|
Le nombre de niveaux d’échelle à créer dans le cache. Ce paramètre est désactivé si vous créez une liste d’échelles personnalisée.
|
Long
|
|
dots_per_inch
|
Résolution en points par pouce (PPP) du périphérique en sortie prévu. Si la valeur PPP spécifiée ne correspond pas à la résolution du périphérique en sortie, l’échelle de la tuile de carte paraîtra incorrecte. La valeur par défaut est 96.
|
Long
|
|
tile_size
|
Spécifie la largeur et la hauteur des tuiles de cache en pixels. Pour un meilleur équilibre entre performance et fonctionnalité, évitez de vous écarter des largeurs standard de 256 sur 256 ou de 512 sur 512.
128 x 128—La largeur et la hauteur des tuiles de cache est de 128 x 128 pixels.
256 x 256—La largeur et la hauteur des tuiles de cache est de 256 x 256 pixels. Il s’agit de l’option par défaut.
512 x 512—La largeur et la hauteur des tuiles de cache est de 512 x 512 pixels.
1024 x 1024—La largeur et la hauteur des tuiles de cache est de 1 024 x 1 024 pixels.
|
String
|
|
predefined_tiling_scheme
(Facultatif)
|
Chemin d’accès à un fichier de structure de tuilage prédéfini (généralement nommé conf.xml).
|
File
|
|
tile_origin
(Facultatif)
|
Origine (angle supérieur gauche) de la structure de tuilage dans les coordonnées de la référence spatiale de la carte source. L’étendue de la carte source doit être comprise dans (sans devoir forcément coïncider avec) cette région.
|
Point
|
|
scales
[scales,...]
(Facultatif)
|
Niveaux d’échelle disponibles pour le cache. Ils ne sont pas représentés sous la forme de fractions. Utilisez plutôt 500 pour représenter une échelle de 1:500 par exemple, etc.
|
Value Table
|
|
cache_tile_format
(Facultatif)
|
Indique le format des tuiles du cache à utiliser.
PNG—Un format PNG avec différentes profondeurs de couleurs sera utilisé. Les profondeurs de couleurs sont optimisées en fonction de la variation des couleurs et des valeurs de transparence dans une tuile. Il s’agit de l’option par défaut.
PNG8—Un format d’image couleur 8 bits sans perte qui utilise une palette de couleurs indexées et une table de transparences alpha sera utilisé. Chaque pixel stocke une valeur (entre 0 et 255) utilisée pour rechercher la couleur dans la palette de couleurs et la transparence dans la table de transparences alpha. Les images PNG 8 bits sont semblables aux images GIF et génèrent des arrière-plans transparents pris en charge par la plupart des navigateurs web.
PNG24—Un format d’image à trois canaux sans perte qui offre de grandes variations de couleurs (16 millions de couleurs) et une prise en charge limitée de la transparence sera utilisé. Chaque pixel contient trois canaux de couleurs 8 bits et l'en-tête du fichier stocke la couleur unique qui représente l'arrière-plan transparent. Les versions de Microsoft Internet Explorer antérieures à la version 7 ne prennent pas en charge ce type de transparence. Les caches utilisant le format PNG24 sont sensiblement plus volumineux que ceux qui utilisent le format PNG8 ou JPEG ; ils occupent davantage d’espace disque et nécessitent une bande passante plus large pour le service des clients.
PNG32—Un format d’image à quatre canaux sans perte qui offre de grandes variations de couleurs (16 millions de couleurs) et une bonne prise en charge de la transparence sera utilisé. Chaque pixel contient trois canaux de couleurs 8 bits et un canal alpha 8 bits qui représente le niveau de transparence de chaque pixel. Si le format PNG32 gère les pixels partiellement transparents compris entre 0 et 255, l’outil de génération de caches d’ArcGIS Server ne retranscrit que les pixels complètement transparents (0) ou complètement opaques (255) dans le canal de transparence. Les caches utilisant le format PNG32 sont sensiblement plus volumineux que ceux qui utilisent les autres formats pris en charge ; ils occupent davantage d’espace disque et nécessitent une bande passante plus large pour le service des clients.
JPEG—Un format d’image à trois canaux avec perte qui offre de grandes variations de couleurs (16 millions de couleurs), mais ne prend pas en charge la transparence, sera utilisé. Chaque pixel contient trois canaux de couleur 8 bits. Les caches utilisant JPEG permettent de maîtriser la qualité en sortie et la taille.
MIXED—Le format PNG32 est créé partout où cette transparence est détectée (en d’autres termes, aux endroits où l’arrière-plan du bloc de données est visible). Le format JPEG est créé pour les tuiles restantes. Cela réduit la taille moyenne des fichiers tout en vous fournissant une superposition nette sur d’autres caches.
|
String
|
|
tile_compression_quality
(Facultatif)
|
Qualité de compression JPEG (1–100) à utiliser. La valeur par défaut est 75 pour le format de tuile JPEG et 0 pour les autres formats.
La compression est uniquement prise en charge pour le format JPEG. La sélection d'une valeur plus élevée entraîne une taille de fichier supérieure avec une image de meilleure qualité. La sélection d'une valeur inférieure entraîne une taille de fichier inférieure avec une image de qualité inférieure.
|
Long
|
|
storage_format
(Facultatif)
|
Indique le format de stockage qui sera utilisé pour les tuiles.
Héritage :
Ce paramètre est désormais obsolète. Le format de stockage Compact V2 sera toujours utilisé, quel que soit le format de stockage spécifié.
COMPACT—Le format de stockage Compact V2 sera utilisé pour regrouper les tuiles en fichiers volumineux appelés groupes. Ce format de stockage est efficace en termes de stockage et de mobilité. Il s’agit de l’option par défaut.
EXPLODED—Cette option est obsolète. Le format de stockage Compact V2 sera toujours utilisé.
|
String
|
|
ready_to_serve_format
(Facultatif)
|
Indique si le contenu du cache est généré conformément à la spécification de paquetage de tuiles ouverte et spécifie le format de fichier de la structure de cache.
READY_TO_SERVE_FORMAT—Le contenu du cache est généré conformément à la spécification de paquetage de tuiles ouverte (https://github.com/Esri/tile-package-spec). Un paquetage de tuiles peut être empaqueté dans une archive zip en tant que paquetage de tuiles pour les processus hors ligne. Le format du cache est Compact V2 et la structure du cache est stockée au format JSON.
NON_READY_TO_SERVE_FORMAT—Le contenu en cache est généré à l’aide d’une structure stockée au format XML. Utilisez cette option pour copier le cache dans des versions précédentes d’ArcGIS Enterprise. Il s’agit de l’option par défaut.
|
Boolean
|
Sortie dérivée
|
Nom
|
Explication
|
Type de données
|
|
out_service_url
|
L’URL de service de carte en sortie.
|
String
|
Exemple de code
Exemple 1 d’utilisation de la fonction CreateMapServerCache (script autonome)
L’exemple suivant crée la structure de tuilage et les dossiers de préparation pour un cache de service de carte avec le type d’échelle STANDARD. Après avoir exécuté ce script, utilisez l’outil Manage Map Server Cache Tiles (Gérer les tuiles d’un cache de serveur de carte) pour ajouter des tuiles au cache.
# Name: CreateMapServerCache.py
# Description: The following stand-alone script demonstrates how to create map
# using standard tiling schema for weblayers published to ArcGIS Enterprise and ArcGIS Online.
# and for map and image services on a stand alone ArcGIS Server
# Requirements: os, sys, time & traceback modules
# Any line that begins with a pound sign is a comment and will not be run
# Empty quotes take the default value.
# To accept arguments from the command line replace values of variables to
# "sys.argv[]"
# Import system modules
import arcpy
from arcpy import env
import sys
import time
import datetime
# Set environment settings
env.workspace = "C:/data"
# Sign in to portal
myPortal= "https://MyPortal.domain.com/portalwebadaptor"
arcpy.SignInToPortal(myPortal, "siteadminValue", "siteadminPassword")
myServer="https://Myserver.domain.com/serverwebadaptor"
serviceName= "SampleWorldCities"
serviceType= "MapServer"
myPortalServiceURL = (myServer + "/" + "rest/services" +"/" + serviceName + "/"
+ serviceType)
print (myPortalServiceURL)
# Stand alone ArcGIS Server
##target_server_connection = r"C:\share\python3\arcgis on MyServer"
##serviceName= "States"
##serviceType= "MapServer"
##myServerServiceURL= target_server_connection + "/" + serviceName + "." + serviceType
serviceCacheDirectory = "C:\\arcgisserver\\arcgiscache\\"
tilingSchemeType = "NEW"
scalesType = "STANDARD"
numOfScales = "4"
scales = ""
dotsPerInch = "96"
tileOrigin = ""
scales = ""
tileSize = "256 x 256"
cacheTileFormat = "PNG32"
tileCompressionQuality = ""
storageFormat = "COMPACT"
predefinedTilingScheme = ""
ready_to_serve_format="READY_TO_SERVE_FORMAT"
#variables for reporting
currentTime = datetime.datetime.now()
arg1 = currentTime.strftime("%H-%M")
arg2 = currentTime.strftime("%Y-%m-%d %H:%M")
file = 'E:/data/report_%s.txt' % arg1
# print results of the script to a report
report = open(file,'w')
try:
## starttime = time.clock()
result = arcpy.server.CreateMapServerCache(myPortalServiceURL,
serviceCacheDirectory,
tilingSchemeType, scalesType,
numOfScales, dotsPerInch,
tileSize, predefinedTilingScheme,
tileOrigin, scales,
cacheTileFormat,
tileCompressionQuality,
storageFormat,
ready_to_serve_format)
## finishtime = time.clock()
## elapsedtime = finishtime - starttime
# print messages to a file
while result.status < 4:
time.sleep(0.2)
resultValue = result.getMessages()
report.write ("completed " + str(resultValue))
## print("Created cache schema with 4 scales & default properties for" + \
## myServerServiceURL + " in " + str(elapsedtime) + " sec \n on " + arg2)
print("Created cache schema with 4 scales & default properties for" + \
myServerServiceURL + " in " + arg2)
except Exception as e:
# If an error occurred, print line number and error message
tb = sys.exc_info()[2]
report.write("Failed at step 1 \n" "Line %i" % tb.tb_lineno)
#report.write(e.message)
report.write(str(e))
print("Executed creation of Map server Cache schema ")
report.close()
Exemple 2 d’utilisation de la fonction CreateMapServerCache (script autonome)
L’exemple suivant crée la structure de tuilage et les dossiers de préparation pour un cache de service de carte avec le type d’échelle CUSTOM. Après avoir exécuté ce script, utilisez l’outil Manage Map Server Cache Tiles (Gérer les tuiles d’un cache de serveur de carte) pour ajouter des tuiles au cache.
# Name: CreateMapServerCache.py
# Description: The following stand-alone script demonstrates how to create map
# using Custom scales & jpg image format.
# Requirements: os, sys, time & traceback modules
# Any line that begins with a pound sign is a comment and will not be run
# Empty quotes take the default value.
# To accept arguments from the command line replace values of variables to
# "sys.argv[]"
# Import system modules
import arcpy
from arcpy import env
import sys
import time
import datetime
# Set environment settings
env.workspace = "C:/data"
# List of input variables for map service properties
# Sign in to portal
myPortal= "https://MyPortal.domain.com/portalwebadaptor"
arcpy.SignInToPortal(myPortal, "siteadminValue", "siteadminPassword")
myServer= "https://Myserver.domain.com/serverwebadaptor"
serviceName= "SampleWorldCities"
serviceType= "MapServer"
myPortalServiceURL = (myServer + "/" + "rest/services" +"/" + serviceName + "/"
+ serviceType)
print (myPortalServiceURL)
serviceCacheDirectory = "C:\\arcgisserver\\arcgiscache"
tilingSchemeType = "NEW"
scalesType = "CUSTOM"
numOfScales = "4"
dotsPerInch = "96"
tileSize = "256 x 256"
predefinedTilingScheme = ""
tileOrigin = ""
scales = "600265;350200;225400;44000"
cacheTileFormat = "JPEG"
tileCompressionQuality = "75"
storageFormat = "COMPACT"
currentTime = datetime.datetime.now()
arg1 = currentTime.strftime("%H-%M")
arg2 = currentTime.strftime("%Y-%m-%d %H:%M")
file = 'C:/data/report_%s.txt' % arg1
# print results of the script to a report
report = open(file,'w')
try:
result = arcpy.server.CreateMapServerCache(myPortalServiceURL,
serviceCacheDirectory,
tilingSchemeType, scalesType,
numOfScales, dotsPerInch,
tileSize, predefinedTilingScheme,
tileOrigin, scales,
cacheTileFormat,
tileCompressionQuality,
storageFormat)
#print messages to a file
while result.status < 4:
time.sleep(0.2)
resultValue = result.getMessages()
report.write ("completed " + str(resultValue))
print("Created cache schema with custom scales successfully for " + \
serviceName + " in " + str(elapsedtime) + " sec \n on " + arg2)
except Exception as e:
# If an error occurred, print line number and error message
tb = sys.exc_info()[2]
report.write("Failed at step 1 \n" "Line %i" % tb.tb_lineno)
report.write(str(e))
print("Executed creation of map server Cache schema using custom scales")
report.close()
Exemple 3 d’utilisation de la fonction CreateMapServerCache (script autonome)
L’exemple suivant crée la structure de tuilage et les dossiers de préparation pour un cache de service de carte avec la structure de tuilage PREDEFINED. Après avoir exécuté ce script, utilisez l’outil Manage Map Server Cache Tiles (Gérer les tuiles d’un cache de serveur de carte) pour ajouter des tuiles au cache.
# Name: CreateMapServerCache.py
# Description: The following stand-alone script demonstrates how to create map
# using existing predefined schema in a ready to serve format
# Requirements: os, sys, time & traceback modules
# Any line that begins with a pound sign is a comment and will not be run
# Empty quotes take the default value.
# To accept arguments from the command line replace values of variables to
# "sys.argv[]"
# Import system modules
import arcpy
from arcpy import env
import sys
import time
import datetime
# Set environment settings
env.workspace = "E:/data"
# Sign in to portal
myPortal= "https://MyPortal.domain.com/portalwebadaptor"
arcpy.SignInToPortal(myPortal, "siteadminValue", "siteadminPassword")
myServer= "https://Myserver.domain.com/serverwebadaptor"
serviceName= "SampleWorldCities"
serviceType= "MapServer"
myPortalServiceURL = (myServer + "/" + "rest/services" +"/" + serviceName + "/"
+ serviceType)
print (myPortalServiceURL)
# Stand alone ArcGIS Server
##target_server_connection = r"C:\share\python3\arcgis on MyServer"
##serviceName= "States"
##serviceType= "MapServer"
##myServerServiceURL= target_server_connection + "/" + serviceName + "." + serviceType
# List of input variables for map service properties
serviceCacheDirectory = "C:\\arcgisserver\\directories\\arcgiscache"
tilingSchemeType = "PREDEFINED"
scalesType = ""
tileOrigin = ""
scalesType = ""
numOfScales = ""
scales = ""
dotsPerInch = "96"
tileSize = "256 x 256"
cacheTileFormat = "MIXED"
tileCompressionQuality = "75"
storageFormat = "COMPACT"
predefinedTilingScheme = "C:/data/TilingSchemes/ArcGIS_Online_Bing_Maps_Google_Maps.xml"
ready_to_serve_format="READY_TO_SERVE_FORMAT"
#variables for reporting
currentTime = datetime.datetime.now()
arg1 = currentTime.strftime("%H-%M")
arg2 = currentTime.strftime("%Y-%m-%d %H:%M")
file = 'C:/data/report_%s.txt' % arg1
# print results of the script to a report
report = open(file,'w')
try:
result = arcpy.server.CreateMapServerCache(myPortalServiceURL,
serviceCacheDirectory,
tilingSchemeType, scalesType,
numOfScales, dotsPerInch,
tileSize, predefinedTilingScheme,
tileOrigin, scales,
cacheTileFormat,
tileCompressionQuality,
storageFormat,
ready_to_serve_format)
#print messages to a file
while result.status < 4:
time.sleep(0.2)
resultValue = result.getMessages()
report.write ("completed " + str(resultValue))
print("Created cache schema using predefined tiling schema for " + \
serviceName + " in " + arg2)
except Exception as e:
# If an error occurred, print line number and error message
tb = sys.exc_info()[2]
report.write("Failed at step 1 \n" "Line %i" % tb.tb_lineno)
report.write(str(e))
print("Executed creation of map server Cache schema using tiling scheme")
report.close()