def create_mosaics():
print "Creating geodatabase for loss and fire mosaics in Amazonia..."
out_coor_system = arcpy.Describe(loss_tile).spatialReference
print " Creating gdb..."
arcpy.CreateFileGDB_management(dir, gdb)
print " Creating Hansen loss mosaic..."
arcpy.CreateMosaicDataset_management("{}.gdb".format(gdb_path),
Hansen_mosaic,
out_coor_system,
num_bands="1",
pixel_type="8_BIT_UNSIGNED")
print " Adding Hansen loss tiles to mosaic..."
arcpy.AddRastersToMosaicDataset_management(
"{0}.gdb/{1}".format(gdb_path, Hansen_mosaic),
raster_type="Raster Dataset",
input_path=Hansen_loss_tile_path)
# I haven't actually tested this code out. It's based on the Python snippet from manually clipping, so it might
# not work as I've modified it here. At least, the rectangle arguments need to change.
print " Clipping Hansen loss to Brazil boundary..."
arcpy.Clip_management(
in_raster="{0}.gdb/{1}".format(gdb_path, Hansen_mosaic),
rectangle=
"-73.9783164486978 -18.0406669808439 -43.9135843925793 5.27136996674568",
out_raster=legal_Amazon_loss_dir,
in_template_dataset="prodes_full_extent_reproj",
nodata_value="256",
clipping_geometry="ClippingGeometry",
maintain_clipping_extent="NO_MAINTAIN_EXTENT")
def extract_loss(scratch, lossyearmosaic, country_shapefile_int, iso, scratch_gdb):
arcpy.CheckOutExtension("Spatial")
arcpy.env.overwriteOutput = True
arcpy.env.workspace = scratch_gdb
arcpy.env.scratchWorkspace = scratch
mosaic_name = iso + "_extract"
sr = 4326
iso_loss_mosaic = arcpy.CreateMosaicDataset_management(scratch_gdb, mosaic_name, sr)
fields = ['ISO', 'SHAPE@']
shapecount = 0
with arcpy.da.SearchCursor(country_shapefile_int, fields) as cursor:
for row in cursor:
shapecount += 1
iso_row = row[0]
geometry = row[1]
if iso_row == iso:
country_loss_30tcd = arcpy.sa.ExtractByMask(lossyearmosaic, geometry)
extracted_folder = os.path.join(scratch, "extracted_tifs")
if not os.path.exists(extracted_folder):
os.mkdir(extracted_folder)
extracted_tif = os.path.join(extracted_folder, "{0}_{1}.tif".format(iso, shapecount))
country_loss_30tcd.save(extracted_tif)
extracted_tif_nd = extracted_tif.replace(".tif", "_nd.tif")
cmd = ["gdal_translate", "-a_nodata", "0", extracted_tif, extracted_tif_nd]
subprocess.check_call(cmd)
# arc having trouble deleting pre-nodata files, so just adding nd to mosaic
nd_tifs = glob.glob(os.path.join(extracted_folder, "{}*nd*".format(iso)))
for tif in nd_tifs:
arcpy.AddRastersToMosaicDataset_management(iso_loss_mosaic, "Raster Dataset", tif)
return iso_loss_mosaic
def main():
# Parse commandline arguments
parser = argparse.ArgumentParser(description='make mosaics')
parser.add_argument(
'--geodatabase',
'-g',
required=True,
help='path to geodatabase where mosaics will be created')
args = parser.parse_args()
for mosaic in ['tcd', 'area', 'loss', 'biomass']:
print "building mosaic for {}".format(mosaic)
path_dict = {
'tcd': r'S:\treecoverdensity_2000',
'area': r'S:\area_tiles',
'loss': r'S:\lossdata_2001_2014',
'biomass': r'S:\biomass'
}
out_cs = arcpy.SpatialReference(4326)
arcpy.CreateMosaicDataset_management(args.geodatabase, mosaic, out_cs)
# add rasters
mosaic_name = os.path.join(args.geodatabase, mosaic)
rastype = "Raster Dataset"
path_to_files = path_dict[mosaic]
arcpy.AddRastersToMosaicDataset_management(mosaic_name, rastype,
path_to_files)
def make_mosaic_from_tiles(dem_tiles_folder,
mosaic_name,
geodatabase,
coordinate_system,
make_gdb=True,
export_to_raster=False):
if not arcpy.Exists(geodatabase) and make_gdb is True:
folder, name = os.path.split(geodatabase)
arcpy.CreateFileGDB_management(folder, name)
print("Making Mosaic Dataset")
arcpy.CreateMosaicDataset_management(geodatabase,
mosaic_name,
coordinate_system,
num_bands=1)
mosaic_dataset = os.path.join(geodatabase, mosaic_name)
print("Adding Tiles to Dataset")
arcpy.AddRastersToMosaicDataset_management(
mosaic_dataset,
"Raster Dataset",
dem_tiles_folder,
update_overviews="UPDATE_OVERVIEWS")
if export_to_raster:
arcpy.MosaicToNewRaster_management(mosaic_dataset,
geodatabase,
"{}_export".format(mosaic_name),
pixel_type="32_BIT_FLOAT",
number_of_bands=1)
def createMosaicDataset(gdbPath, mdName, prjFile):
"""
1.创建镶嵌数据集
3.开启自动跟踪功能 会自动添加四个属性字段
"""
gdbname = gdbPath
mdname = mdName
prjfile = prjFile
noband = "1"
pixtype = "32_BIT_FLOAT"
# 1.创建镶嵌数据集
mdpath = gdbPath + "/" + mdName
if not arcpy.Exists(mdpath):
arcpy.CreateMosaicDataset_management(gdbname, mdname, prjfile, noband, pixtype)
# 2.并添加四个属性字段
# if arcpy.Exists(mdpath):
# arcpy.AddField_management(mdpath, 'createpreson', 'TEXT', 18, 11)
# arcpy.AddField_management(mdpath, 'createtime', 'DATE')
# arcpy.AddField_management(mdpath, 'updateepreson', 'TEXT', 18, 11)
# arcpy.AddField_management(mdpath, 'updatetime', 'DATE')
# 3.开启自动跟踪功能
desc = arcpy.Describe(mdpath)
if not desc.editorTrackingEnabled:
arcpy.EnableEditorTracking_management(mdpath, "createperson", "createtime", "updateperson", "updatetime",
"ADD_FIELDS", "UTC")
def mosaic_ndwi(self, gcs):
self.gcs = gcs
for ext in self.file_extension:
filters = ext
filters_new = "*" + filters
# Creates a file geodatabase
geodatabase_file_name = 'NDWI_GDB' + '_' + filters[:-4] + '.gdb'
print(geodatabase_file_name)
#Creates a raster dataset with .tif extension
mosaiced_raster_name = 'NDWI_Mosaiced' + '_' + filters[:-4] + '.tif'
print(mosaiced_raster_name)
# 1) Creates a file geodatabase in a folder
print('Creating Geodatabase file: {} of {} ... ^_^'.format(
ext, self.file_extension))
output_dir = os.path.join(self.main_dir, self.subfolder_1,
self.subfolder_3)
# output_dir_serach = os.path.split(output_dir)[0]
print('Output_directory {}:'.format(output_dir))
arcpy.CreateFileGDB_management(
output_dir, geodatabase_file_name) # Creates gdb file
print('Done!^_^')
# 2) Creates an empty mosaic dataset in a file geodatabase
in_workspace = os.path.join(
output_dir, geodatabase_file_name) # Path to the geodatabase
in_mosaicdataset_name = 'NDWI_RasterDataset' + '_' + filters[:-4]
NumberOfBand = "1"
PixelType = "32_BIT_FLOAT" # Pixel type can be changed
product_definition = "NONE"
Wavelength = ""
print('Creating an empty mosaic dataset: {} of {} ... ^_^'.format(
ext, self.file_extension))
arcpy.CreateMosaicDataset_management(in_workspace,
in_mosaicdataset_name,
self.gcs, NumberOfBand,
PixelType, product_definition,
Wavelength)
print('Done!^_^')
# 3) Add raster dataset to a mosaic dataset from many sources, including a file, folder, raster catalog, table, or web service.
in_mosaic_dataset = os.path.join(in_workspace,
in_mosaicdataset_name)
print(
'Adding rasters to an empty mosaic dataset: {} of {} ... ^_^'.
format(ext, self.file_extension))
arcpy.AddRastersToMosaicDataset_management(in_mosaic_dataset, "Raster Dataset", output_dir, \
"UPDATE_CELL_SIZES","UPDATE_BOUNDARY","NO_OVERVIEWS","2","#","#",'#', filters_new, "SUBFOLDERS",\
"EXCLUDE_DUPLICATES","NO_PYRAMIDS","NO_STATISTICS","NO_THUMBNAILS","#","NO_FORCE_SPATIAL_REFERENCE")
print('Done! ^_^')
# 4) Creates a folder to copy NDWI mosaiced dataset
in_raster = os.path.join(in_workspace, in_mosaicdataset_name)
ndwi = os.path.join(output_dir, 'NDWI_Mosaic' + '_' + filters[:-4])
if not os.path.exists(ndwi):
os.makedirs(ndwi)
print('Copying raster: {} of {} ... ^_^'.format(
ext, self.file_extension))
out_raster = os.path.join(ndwi, mosaiced_raster_name)
arcpy.CopyRaster_management(in_raster, out_raster, "#", "0", "0",
"NONE", "NONE", "32_BIT_FLOAT", "NONE",
"NONE")
print('Done! ^_^ ^_^ ^_^')
def create_mosaic(country_loss_30tcd, scratch_gdb):
out_cs = arcpy.SpatialReference(4326)
mosaic_name = "mosaic_country_loss_30tcd"
mosaic_path = os.path.join(scratch_gdb, mosaic_name)
arcpy.CreateMosaicDataset_management(scratch_gdb, mosaic_name, out_cs)
arcpy.AddRastersToMosaicDataset_management(mosaic_path, "Raster Dataset",
country_loss_30tcd)
return os.path.join(scratch_gdb, mosaic_name)
def __init__(self, output_basepath, dataset_name, coordinate_system,
options):
ArcTable.__init__(self, output_basepath, dataset_name, options)
if not arcpy.Exists(self.fullpath):
arcpy.CreateMosaicDataset_management(output_basepath, dataset_name,
coordinate_system,
options.get('num_bands'),
options.get('pixel_type'))
def mosaic_dem_cal_slp(self, gdb_name, folder2save_mosaic_ras, mosaiced_dem_ras_name,
projection, folder2save_slp_ras, slp_ras_name, z_factor):
self.gdb_name = gdb_name
self.folder2save_mosaic_ras = folder2save_mosaic_ras
self.mosaiced_dem_ras_name = mosaiced_dem_ras_name
self.projection = projection
self.folder2save_slp_ras = folder2save_slp_ras
self.slp_ras_name = slp_ras_name
self.z_factor = z_factor
file_path = os.path.join(self.main_dir, self.subfolder_1)
gdb_file_path = os.path.join(self.main_dir, self.subfolder_1, self.subfolder_3)
print('Creating geodatabase file... ^__^')
arcpy.CreateFileGDB_management(gdb_file_path, self.gdb_name)
print('Creating an empty raster dataset inside geodatabse... ^__^')
mosaic_dataset_name = 'My_RasterDataset'
mosaicgdb = os.path.join(gdb_file_path, self.gdb_name)
print("mosaicgdb", mosaicgdb)
NumberOfBand = "1"
PixelType = "16_BIT_SIGNED" # Pixel type can be changed
ProductDefinition = "NONE"
Wavelength = ""
arcpy.CreateMosaicDataset_management(mosaicgdb, mosaic_dataset_name, self.projection, NumberOfBand, PixelType, ProductDefinition, Wavelength)
print('Adding DEM rasters into an empty raster dataset... ^__^')
path_and_nameof_mosaic_dataset = os.path.join(mosaicgdb, mosaic_dataset_name)
arcpy.AddRastersToMosaicDataset_management(path_and_nameof_mosaic_dataset, "Raster Dataset",
file_path, "UPDATE_CELL_SIZES","UPDATE_BOUNDARY","NO_OVERVIEWS","2","#","#",
self.projection, '*'+self.file_extension, "SUBFOLDERS","EXCLUDE_DUPLICATES","NO_PYRAMIDS","NO_STATISTICS",
"NO_THUMBNAILS","#","FORCE_SPATIAL_REFERENCE")
in_raster = os.path.join(mosaicgdb, mosaic_dataset_name)
create_folder = os.path.join(self.main_dir, self.subfolder_1, self.subfolder_3, self.folder2save_mosaic_ras)
if not os.path.exists(create_folder):
os.makedirs(create_folder)
out_raster = os.path.join(create_folder, self.mosaiced_dem_ras_name)
arcpy.CopyRaster_management(in_raster, out_raster, "#","#","#","NONE","NONE","16_BIT_UNSIGNED","NONE","NONE")
def slope_cal():
print('Reading DEM! ^_^')
read_dem = arcpy.Raster(out_raster)
print('Caculating slope... ^__^')
arcpy.CheckOutExtension("spatial")
slope_raster = Slope(read_dem, "DEGREE", self.z_factor)
arcpy.CheckInExtension("spatial")
slope_cal_path = os.path.join(self.main_dir, self.subfolder_1, self.subfolder_3, self.folder2save_slp_ras)
if not os.path.exists(slope_cal_path):
os.makedirs(slope_cal_path)
slope_file = os.path.join(slope_cal_path, self.slp_ras_name)
print('Writing slope raster... ^__^')
slope_raster.save(slope_file)
print('Done! ^__^')
print('Resampling Slope raster...')
arcpy.CheckOutExtension("spatial")
in_ras_resample = arcpy.Raster(slope_file)
resampled_slope_file = os.path.join(slope_cal_path, 'Resam_' + self.slp_ras_name)
arcpy.Resample_management(in_ras_resample, resampled_slope_file, "8.9831528e-05", "BILINEAR")
arcpy.CheckInExtension("spatial")
print('Done! ^__^')
slope_cal()
def create_empty_mosaic_dataset(in_workspace, in_mosaicdataset_name, gcs):
"""Creates an empty mosaic dataset"""
NumberOfBand = "1"
PixelType = "32_BIT_FLOAT" # Pixel type can be changed
product_definition = "NONE"
Wavelength = ""
md = arcpy.CreateMosaicDataset_management(in_workspace,
in_mosaicdataset_name, gcs,
NumberOfBand, PixelType,
product_definition,
Wavelength)
return md
def empty_mosaic_dataset(self, in_workspace, in_mosaicdataset_name):
"""Creates an empty mosaic dataset (emd)"""
self.in_workspace = in_workspace
self.in_mosaicdataset_name = in_mosaicdataset_name
NumberOfBand = "1"
PixelType = "32_BIT_FLOAT" # Pixel type can be changed
product_definition = "NONE"
Wavelength = ""
md = arcpy.CreateMosaicDataset_management(
self.in_workspace, self.in_mosaicdataset_name, self.projection,
NumberOfBand, PixelType, product_definition, Wavelength)
return md
def CreateMosaicDataset(self):
arcpy.CreateMosaicDataset_management(workspace,
mosaic_name,
coordinate_sys,
num_bands="",
pixel_type="",
product_definition="NONE",
product_band_definitions="")
arcpy.AddRastersToMosaicDataset_management(
mosaic_dataset, "Raster Dataset", path_to_files,
"UPDATE_CELL_SIZES", "UPDATE_BOUNDARY", "NO_OVERVIEWS", "", "0",
"1500", imagery_spatial_ref, "#", "SUBFOLDERS", "ALLOW_DUPLICATES",
"NO_PYRAMIDS", "NO_STATISTICS", "NO_THUMBNAILS", "#",
"NO_FORCE_SPATIAL_REFERENCE")
def createMD(self):
self.log("Creating source mosaic datasets:", self.const_general_text)
try:
mdPath = os.path.join(self.m_base.m_geoPath, self.m_base.m_mdName)
if not arcpy.Exists(mdPath):
self.log("\t" + self.m_base.m_mdName, self.const_general_text)
arcpy.CreateMosaicDataset_management(
self.m_base.m_geoPath, self.m_base.m_mdName, self.srs,
self.num_bands, self.pixel_type, self.product_definition,
self.product_band_definitions)
except:
self.log("Failed!", self.const_critical_text)
self.log(arcpy.GetMessages(), self.const_critical_text)
return False
return True
def createMosaicDataset(gdb_path, md_name, spatial_reference):
a = datetime.now()
md_path = os.path.join(gdb_path, md_name)
deleteFileIfExists(md_path, useArcpy=True)
# Create a MD in same SR as file
arcpy.CreateMosaicDataset_management(in_workspace=gdb_path,
in_mosaicdataset_name=md_name,
coordinate_system=spatial_reference,
num_bands="1",
pixel_type="32_BIT_FLOAT",
product_definition="NONE",
product_band_definitions="#")
doTime(a, "\tCreated MD {}".format(md_path))
return md_path
def create_mosaic_dataset(self):
if not arcpy.Exists(self.output_gdb):
arcpy.CreateFileGDB_management(os.path.dirnam(output_gdb),
os.path.basename(output_gdb))
if not arcpy.Exists(join(self.output_gdb, self.output_mosaic)):
arcpy.CreateMosaicDataset_management(self.output_gdb,
self.output_mosaic,
self.mosaic_spatial_ref,
num_bands=self.numBands,
pixel_type="",
product_definition="NONE",
product_band_definitions="")
arcpy.AddRastersToMosaicDataset_management(
join(self.output_gdb, self.output_mosaic), "Raster Dataset",
self.composite_path, "UPDATE_CELL_SIZES", "UPDATE_BOUNDARY",
"UPDATE_OVERVIEWS", "", "0", "1500", self.imagery_spatial_ref, "#",
"SUBFOLDERS", "ALLOW_DUPLICATES", "NO_PYRAMIDS", "NO_STATISTICS",
"NO_THUMBNAILS", "#", "NO_FORCE_SPATIAL_REFERENCE")
def mosaicCreator(_mosaicPath, _simulationSteps):
try:
arcpy.CreateMosaicDataset_management(
_mosaicPath, "Mosaic",
"PROJCS['WGS_1984_Web_Mercator_Auxiliary_Sphere',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Mercator_Auxiliary_Sphere'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],PARAMETER['Standard_Parallel_1',0.0],PARAMETER['Auxiliary_Sphere_Type',0.0],UNIT['Meter',1.0]]",
None, None, "NONE", None)
except ExceptionI:
arcpy.AddMessage("Exception")
arcpy.AddMessage("Before Loop")
rasters = ''
for i in range(0, int(_simulationSteps), 50):
file1 = _mosaicPath
filePath = os.path.join(file1, "Frame" + str(i))
rasters = rasters + ';' + filePath
arcpy.AddMessage(filePath)
arcpy.AddMessage("rasters:" + rasters)
arcpy.management.AddRastersToMosaicDataset(
os.path.join(_mosaicPath, 'Mosaic'), "Raster Dataset", rasters,
"UPDATE_CELL_SIZES", "UPDATE_BOUNDARY", "NO_OVERVIEWS", None, 0, 1500,
None, None, "SUBFOLDERS", "ALLOW_DUPLICATES", "NO_PYRAMIDS",
"CALCULATE_STATISTICS", "NO_THUMBNAILS", None,
"NO_FORCE_SPATIAL_REFERENCE", "ESTIMATE_STATISTICS", None)
# Set local variables
inFeatures = os.path.join(_mosaicPath, 'Mosaic')
fieldName1 = "Time_Stamp"
fieldPrecision = 9
fieldAlias = "time"
# Execute AddField twice for two new fields
arcpy.AddField_management(inFeatures,
fieldName1,
"LONG",
fieldPrecision,
field_alias=fieldAlias,
field_is_nullable="NULLABLE")
arcpy.CalculateField_management(inFeatures, fieldName1, "!OBJECTID!")
arcpy.AddMessage("After Loop")
out_folder_path = path + r"\fileGDB"
out_name = "fGDB.gdb"
arcpy.CreateFileGDB_management(out_folder_path, out_name)
print "14"
print "Creating mosaic.."
# create empty mosaic dataset in fGDB.gdb
gdbname = path + r"\fileGDB\fGDB.gdb"
mdname = "mosaicds"
coordinate = "NAD 1983 StatePlane Florida East FIPS 0901 (US Feet)"
noband = "3"
pixtype = "8_BIT_UNSIGNED"
pdef = "NONE"
wavelength = ""
arcpy.CreateMosaicDataset_management(gdbname, mdname, coordinate, noband,
pixtype, pdef, wavelength)
print "15"
# Add rasters to mosaic dataset
arcpy.env.workspace = sid_loc
arcpy.env.parallelProcessingFactor = "200%" ######## DP increase
print "Adding rasters.."
mdname = gdbname + "/" + mdname
rastype = "Raster Dataset"
input_rasters = ";".join(name)
updatecs = "UPDATE_CELL_SIZES"
updatebnd = "UPDATE_BOUNDARY"
prj = arcpy.SpatialReference(102100)
#Add pdate Field to feature class so I can create space-time-ripple
arcpy.management.AddField(fc, "pdate", "DATE", None, None, None, "pdate",
"NULLABLE", "NON_REQUIRED", None)
arcpy.management.CalculateField(
fc, "pdate", "datetime.datetime.strptime(!GAME_DATE!, '%m/%d/%Y')",
"PYTHON", None)
#Get unique game dates
values = [row[0] for row in arcpy.da.SearchCursor(fc, "pdate")]
unique_game_dates = list(set(values))
print(unique_game_dates)
#create mosaic dataset for 2D space-time analysis
arcpy.CreateMosaicDataset_management(cum_md_gdb, cum_md_name, prj)
arcpy.AddField_management(out_md, "GAME_DATE", "DATE", None, None, None,
"pdate", "NULLABLE", "NON_REQUIRED", None)
#For every game, create feature classes that look at that game and all previous games
for date in unique_game_dates:
print("selecting")
out_fc_name = 'game_' + str(date.year) + '_' + str(date.month) + '_' + str(
date.day)
out_raster_name = out_fc_name + '_raster'
out_hexbin_name = out_fc_name + '_hexbin'
out_fc = os.path.join(cum_point_gdb, out_fc_name)
out_hex_fc = os.path.join(cum_hex_gdb, out_hexbin_name)
out_raster = os.path.join(cum_raster_gdb, out_raster_name)
if arcpy.Exists(out_fc) == False:
wc = "pdate <= date '%s'" % (date) #
move(z, ".\processed_data")
unzipped = glob("DTM*") + glob("DSM*") + glob("intensity*")
for tiles in unzipped:
move(tiles, ".\mosaic_data_source")
# create names for the new mosaic datasets
DTM = countyName + "_DTM"
DSM = countyName + "_DSM"
intensity = countyName + "_intensity"
# create a geodatabase to store the mosaic datasets
arcpy.CreateFileGDB_management(os.getcwd(), countyName)
# create a mosaic dataset for the DTM and the DSM
arcpy.CreateMosaicDataset_management(os.path.abspath(countyName + ".gdb"), DTM,
projfile)
arcpy.CreateMosaicDataset_management(os.path.abspath(countyName + ".gdb"), DSM,
projfile)
arcpy.CreateMosaicDataset_management(os.path.abspath(countyName + ".gdb"),
intensity, projfile)
DTMList = []
DSMList = []
intensityList = []
# make 3 lists containing the path of all DTM tif files, all DSM tif files, and all intensity raster files
os.chdir(mosaicDataSource)
for tif in glob("DTM_" + countyName + "*.tif"):
#print ("Found DTM: "+tif)
DTMList.append(os.path.abspath(tif))
for tif in glob("DSM_" + countyName + "*.tif"):
#arcpy.env.overwriteOutput = True
# create file GDB
if not os.path.exists(
os.path.join("C:\\", "Imagenes_Satelitales_ANM", "area_" + area,
"Mosaico", year, month, gdb_name + '.gdb')):
arcpy.CreateFileGDB_management(gdb_location, gdb_name, "CURRENT")
print "GDB" + " del area " + area + " y" + " fecha " + year + month + " ha sido creada"
else:
print("GDB ya existe, verifique")
print(" el script no puede continuar y se cerrara")
sys.exit()
# Process: Create Mosaic Dataset
arcpy.CreateMosaicDataset_management(m_location, mosaic_name, coords, "4",
"16_BIT_UNSIGNED", "NONE", "")
print "Dataset de Mosaico ha sido creado"
# Process: Create Statistics
rasters = arcpy.ListRasters(Input_Data_Filter)
for raster in rasters:
arcpy.BuildPyramidsandStatistics_management(
Input_Rasters_Data_Folder, "INCLUDE_SUBDIRECTORIES", "BUILD_PYRAMIDS",
"CALCULATE_STATISTICS", "NONE", "", "NONE", "1", "1", "", "-1", "NONE",
"NEAREST", "DEFAULT", "75", "OVERWRITE")
print "se han caculado estadisticas a la imagen" + (raster)
arcpy.Warp_management(temp_file_and_path, source_pnt, target_pnt,
output_file_and_path, "POLYORDER1", "BILINEAR")
#Deleting the unreference image
arcpy.Delete_management(temp_file_and_path)
print(output_file_and_path)
#Composite bands
arcpy.env.workspace = output_image_path
rasters = arcpy.ListRasters(galaxy + "*", "TIF")
arcpy.CompositeBands_management(rasters, composite_path_and_name)
#Create the mosaic and add images to it
coordinate_sys = "PROJCS['WGS_1984_Web_Mercator_Auxiliary_Sphere',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Mercator_Auxiliary_Sphere'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],PARAMETER['Standard_Parallel_1',0.0],PARAMETER['Auxiliary_Sphere_Type',0.0],UNIT['Meter',1.0]];-20037700 -30241100 10000;-100000 10000;-100000 10000;0.001;0.001;0.001;IsHighPrecision"
imagery_spatial_ref = "GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]];-400 -400 1000000000;-100000 10000;-100000 10000;8.98315284119522E-09;0.001;0.001;IsHighPrecision"
mosaic_gdb = r"C:\PROJECTS\R&D\ASTROARC\SINGS\Spitzer.gdb"
mosaic_name = "SINGS"
mosaic_dataset = os.path.join(mosaic_gdb, mosaic_name)
arcpy.CreateMosaicDataset_management(mosaic_gdb,
mosaic_name,
coordinate_sys,
num_bands="",
pixel_type="",
product_definition="NONE",
product_band_definitions="")
arcpy.AddRastersToMosaicDataset_management(
mosaic_dataset, "Raster Dataset", composite_image_path,
"UPDATE_CELL_SIZES", "UPDATE_BOUNDARY", "NO_OVERVIEWS", "", "0", "1500",
imagery_spatial_ref, "#", "SUBFOLDERS", "ALLOW_DUPLICATES", "NO_PYRAMIDS",
"NO_STATISTICS", "NO_THUMBNAILS", "#", "NO_FORCE_SPATIAL_REFERENCE")
print("Done.")
# variables
cities = ["Carpinteria", "SantaBarbara", "Goleta"]
heights = range(1,11) #sets the heights variable, from 1 meters to 10 meters
years_beg = [2010 + 10 * h for h in heights]
years_end = [2020 + 10 * h for h in heights] #sets the time periods that the rasters represent, this is a very arbitrary estimate: 1 meter per decade
# iterate over cities
for city in cities:
dem = "dem_" + city + ".tif" #sets dem variable to select the right city
# create slr_city mosaic to associate time with rasters
slr_city = "slr_" + city
gdb_slr_city = gdb + "/" + slr_city #sets variables to use in the raster mosaic
print("Creating slr_city mosaic: " + slr_city)
arcpy.CreateMosaicDataset_management(gdb, slr_city, sr, 1, "1_BIT") #adds a mosaic of rasters to the sb_slr_geodatabase
arcpy.AddField_management(gdb_slr_city, "YearBeg", "SHORT")
arcpy.AddField_management(gdb_slr_city, "YearEnd", "SHORT") #adds the time element to the new rasters in the mosaic
# iterate over slr heights
for height in heights:
slr_city_height = ws + "/slr_" + city + "_" + str(height) + "m.tif" #defines the workplace and name for each raster
# calculate slr_city_height raster
if not arcpy.Exists(slr_city_height): #checks to see if the raster exists
print(" Creating slr_city_height raster: " + os.path.basename(slr_city_height))
r = Con(Raster(dem) <= height, 1) #creates a new raster with the specified height
r.save(slr_city_height) #saves the raster
arcpy.AddRastersToMosaicDataset_management(gdb_slr_city, "Raster Dataset", slr_city_height) #adds the newly created raster to the mosaic
# update YearBeg & YearEnd in slr_city mosaic
) # clipping feature: "D:/LittleMissouri_River_Typing/01_Boundaries/01_Watershed/LittleMissouri_Watershed.shp"
dem_in = arcpy.GetParameterAsText(
5) # projected DEMs folder: "D:/PYDEM/Proj_DEM2/"
dem_out = arcpy.GetParameterAsText(
6) # Clipped DEM:"D:/PYDEM/GDB/DEM_Test.tif"
hill_out = arcpy.GetParameterAsText(
7) # Hillshade: "D:/PYDEM/GDB/Hill_Test.tif"
# Process: Create File GDB
arcpy.CreateFileGDB_management(gdb_path, gdb_name)
arcpy.AddMessage("File geodatabase created!")
# Process: Create Mosaic Dataset
arcpy.CreateMosaicDataset_management(gdb_path + "\\" + gdb_name,
mosaic_dataset, mosaic_cs, "1",
"32_BIT_FLOAT", "NONE", "")
arcpy.AddMessage("Mosaic dataset created!")
arcpy.AddMessage("Adding rasters to mosaic dataset")
# Process: Add Rasters To Mosaic Dataset
arcpy.env.workspace = dem_in
dem_list = arcpy.ListRasters()
for raster in dem_list:
arcpy.AddMessage("Adding " + raster + " to mosaic dataset")
arcpy.AddRastersToMosaicDataset_management(
gdb_path + "\\" + gdb_name + "\\" + mosaic_dataset, "Raster Dataset",
raster)
# Process: Clip DEM
def execute(request):
"""Mosaics input raster datasets into a new raster dataset or mosaic dataset.
:param request: json as a dict.
"""
status_writer = status.Writer()
parameters = request['params']
target_workspace = task_utils.get_parameter_value(parameters, 'target_workspace', 'value')
output_name = task_utils.get_parameter_value(parameters, 'output_dataset_name', 'value')
out_coordinate_system = task_utils.get_parameter_value(parameters, 'output_projection', 'code')
# Advanced options
output_raster_format = task_utils.get_parameter_value(parameters, 'raster_format', 'value')
compression_method = task_utils.get_parameter_value(parameters, 'compression_method', 'value')
compression_quality = task_utils.get_parameter_value(parameters, 'compression_quality', 'value')
arcpy.env.compression = '{0} {1}'.format(compression_method, compression_quality)
if output_raster_format in ('FileGDB', 'MosaicDataset'):
if not os.path.splitext(target_workspace)[1] in ('.gdb', '.mdb', '.sde'):
status_writer.send_state(status.STAT_FAILED, _('Target workspace must be a geodatabase'))
return
task_folder = request['folder']
if not os.path.exists(task_folder):
os.makedirs(task_folder)
clip_area = None
if not output_raster_format == 'MosaicDataset':
# Get the clip region as an extent object.
try:
clip_area_wkt = task_utils.get_parameter_value(parameters, 'processing_extent', 'wkt')
if not clip_area_wkt:
clip_area_wkt = 'POLYGON ((-180 -90, -180 90, 180 90, 180 -90, -180 -90))'
if not out_coordinate_system == '0':
clip_area = task_utils.get_clip_region(clip_area_wkt, out_coordinate_system)
else:
clip_area = task_utils.get_clip_region(clip_area_wkt)
except KeyError:
pass
status_writer.send_status(_('Setting the output workspace...'))
if not os.path.exists(target_workspace):
status_writer.send_state(status.STAT_FAILED, _('Target workspace does not exist'))
return
arcpy.env.workspace = target_workspace
status_writer.send_status(_('Starting to process...'))
num_results, response_index = task_utils.get_result_count(parameters)
raster_items = None
if num_results > task_utils.CHUNK_SIZE:
# Query the index for results in groups of 25.
query_index = task_utils.QueryIndex(parameters[response_index])
fl = query_index.fl
query = '{0}{1}{2}'.format(sys.argv[2].split('=')[1], '/select?&wt=json', fl)
fq = query_index.get_fq()
if fq:
groups = task_utils.grouper(range(0, num_results), task_utils.CHUNK_SIZE, '')
query += fq
elif 'ids' in parameters[response_index]:
groups = task_utils.grouper(list(parameters[response_index]['ids']), task_utils.CHUNK_SIZE, '')
else:
groups = task_utils.grouper(range(0, num_results), task_utils.CHUNK_SIZE, '')
headers = {'x-access-token': task_utils.get_security_token(request['owner'])}
for group in groups:
if fq:
results = requests.get(query + "&rows={0}&start={1}".format(task_utils.CHUNK_SIZE, group[0]), headers=headers)
elif 'ids' in parameters[response_index]:
results = requests.get(query + '{0}&ids={1}'.format(fl, ','.join(group)), headers=headers)
else:
results = requests.get(query + "&rows={0}&start={1}".format(task_utils.CHUNK_SIZE, group[0]), headers=headers)
input_items = task_utils.get_input_items(results.json()['response']['docs'])
if not input_items:
input_items = task_utils.get_input_items(parameters[response_index]['response']['docs'])
raster_items, pixels, bands, skipped = get_items(input_items)
else:
input_items = task_utils.get_input_items(parameters[response_index]['response']['docs'])
raster_items, pixels, bands, skipped = get_items(input_items)
if not raster_items:
if skipped == 0:
status_writer.send_state(status.STAT_FAILED, _('Invalid input types'))
skipped_reasons['All Items'] = _('Invalid input types')
task_utils.report(os.path.join(request['folder'], '__report.json'), len(raster_items), num_results, skipped_details=skipped_reasons)
return
else:
status_writer.send_state(status.STAT_WARNING, _('{0} results could not be processed').format(skipped))
task_utils.report(os.path.join(request['folder'], '__report.json'), len(raster_items), skipped, skipped_details=skipped_reasons)
return
# Get most common pixel type.
pixel_type = pixel_types[max(set(pixels), key=pixels.count)]
if output_raster_format in ('FileGDB', 'GRID', 'MosaicDataset'):
output_name = arcpy.ValidateTableName(output_name, target_workspace)
else:
output_name = '{0}.{1}'.format(arcpy.ValidateTableName(output_name, target_workspace), output_raster_format.lower())
if arcpy.Exists(os.path.join(target_workspace, output_name)):
status_writer.send_state(status.STAT_FAILED, _('Output dataset already exists.'))
return
if output_raster_format == 'MosaicDataset':
try:
status_writer.send_status(_('Generating {0}. Large input {1} will take longer to process.'.format('Mosaic', 'rasters')))
if out_coordinate_system == '0':
out_coordinate_system = raster_items[0]
else:
out_coordinate_system = None
mosaic_ds = arcpy.CreateMosaicDataset_management(target_workspace,
output_name,
out_coordinate_system,
max(bands),
pixel_type)
arcpy.AddRastersToMosaicDataset_management(mosaic_ds, 'Raster Dataset', raster_items)
arcpy.MakeMosaicLayer_management(mosaic_ds, 'mosaic_layer')
layer_object = arcpy.mapping.Layer('mosaic_layer')
task_utils.make_thumbnail(layer_object, os.path.join(request['folder'], '_thumb.png'))
except arcpy.ExecuteError:
skipped += 1
skipped_reasons['All Items'] = arcpy.GetMessages(2)
else:
try:
if len(bands) > 1:
status_writer.send_state(status.STAT_FAILED, _('Input rasters must have the same number of bands'))
return
if out_coordinate_system == '0':
out_coordinate_system = None
status_writer.send_status(_('Generating {0}. Large input {1} will take longer to process.'.format('Mosaic', 'rasters')))
if clip_area:
ext = '{0} {1} {2} {3}'.format(clip_area.XMin, clip_area.YMin, clip_area.XMax, clip_area.YMax)
tmp_mosaic = arcpy.MosaicToNewRaster_management(
raster_items,
target_workspace,
'tmpMosaic',
out_coordinate_system,
pixel_type,
number_of_bands=bands.keys()[0]
)
status_writer.send_status(_('Clipping...'))
out_mosaic = arcpy.Clip_management(tmp_mosaic, ext, output_name)
arcpy.Delete_management(tmp_mosaic)
else:
out_mosaic = arcpy.MosaicToNewRaster_management(raster_items,
target_workspace,
output_name,
out_coordinate_system,
pixel_type,
number_of_bands=bands.keys()[0],
mosaic_method='BLEND')
arcpy.MakeRasterLayer_management(out_mosaic, 'mosaic_layer')
layer_object = arcpy.mapping.Layer('mosaic_layer')
task_utils.make_thumbnail(layer_object, os.path.join(request['folder'], '_thumb.png'))
except arcpy.ExecuteError:
skipped += 1
skipped_reasons['All Items'] = arcpy.GetMessages(2)
# Update state if necessary.
if skipped > 0:
status_writer.send_state(status.STAT_WARNING, _('{0} results could not be processed').format(skipped))
task_utils.report(os.path.join(request['folder'], '__report.json'), len(raster_items), skipped, skipped_details=skipped_reasons)
def createQARasterMosaicDataset(md_name, gdb_path, spatial_reference, input_folder, mxd, footprint_path=None, lasd_boundary_path=None):
#Utility.printArguments(["md_name", "gdb_path", "spatial_reference", "input_folder", "mxd", "footprint_path", "lasd_boundary_path"],
# [md_name, gdb_path, spatial_reference, input_folder, mxd, footprint_path, lasd_boundary_path], "A04_C CreateQARasterMosaicDatasets")
md_path = os.path.join(gdb_path, md_name)
a = datetime.datetime.now()
if arcpy.Exists(md_path):
arcpy.AddMessage("\tMD Exists: {}".format(md_path))
else:
try:
raster_count = 0
#arcpy.AddMessage("\t\tLooking for rasters to add to {} in folder {}".format(md_path, input_folder))
for root, dirs, files in os.walk(input_folder): # @UnusedVariable
for f in files:
if f.upper().endswith(".TIF"):
raster_count = raster_count+1
if raster_count <=0:
arcpy.AddMessage("\t\tNo rasters to add to {} in folder {}".format(md_path, input_folder))
else:
arcpy.AddMessage("\t\tLooking for rasters to add to {} in folder {}".format(md_path, input_folder))
# Create a MD in same SR as LAS Dataset
arcpy.CreateMosaicDataset_management(in_workspace=gdb_path,
in_mosaicdataset_name=md_name,
coordinate_system=spatial_reference,
num_bands="",
pixel_type="",
product_definition="NONE",
product_band_definitions="")
arcpy.SetMosaicDatasetProperties_management(in_mosaic_dataset=md_path, rows_maximum_imagesize="4100", columns_maximum_imagesize="15000", allowed_compressions="None;JPEG;LZ77;LERC", default_compression_type="LERC", JPEG_quality="75", LERC_Tolerance="0.01", resampling_type="CUBIC", clip_to_footprints="NOT_CLIP", footprints_may_contain_nodata="FOOTPRINTS_DO_NOT_CONTAIN_NODATA", clip_to_boundary="CLIP", color_correction="NOT_APPLY", allowed_mensuration_capabilities="Basic", default_mensuration_capabilities="Basic", allowed_mosaic_methods="NorthWest;Center;LockRaster;ByAttribute;Nadir;Viewpoint;Seamline;None", default_mosaic_method="NorthWest", order_field="", order_base="", sorting_order="ASCENDING", mosaic_operator="FIRST", blend_width="10", view_point_x="600", view_point_y="300", max_num_per_mosaic="2000", cell_size_tolerance="0.8", cell_size="10 10", metadata_level="BASIC", transmission_fields="Name;MinPS;MaxPS;LowPS;HighPS;Tag;GroupName;ProductName;CenterX;CenterY;ZOrder;Shape_Length;Shape_Area;Thumbnail", use_time="DISABLED", start_time_field="", end_time_field="", time_format="", geographic_transform="", max_num_of_download_items="20", max_num_of_records_returned="1000", data_source_type="GENERIC", minimum_pixel_contribution="1", processing_templates="None", default_processing_template="None", time_interval="", time_interval_units="")
a = doTime(a, "\t\tCreated MD {}".format(md_name))
arcpy.AddRastersToMosaicDataset_management(in_mosaic_dataset=md_path,
raster_type="Raster Dataset",
input_path=input_folder,
update_cellsize_ranges="UPDATE_CELL_SIZES",
update_boundary="UPDATE_BOUNDARY",
update_overviews="NO_OVERVIEWS",
maximum_pyramid_levels="",
maximum_cell_size="0",
minimum_dimension="150",
spatial_reference="",
filter="#",
sub_folder="SUBFOLDERS",
duplicate_items_action="EXCLUDE_DUPLICATES",
build_pyramids="BUILD_PYRAMIDS",
calculate_statistics="CALCULATE_STATISTICS",
build_thumbnails="BUILD_THUMBNAILS",
operation_description="#",
force_spatial_reference="NO_FORCE_SPATIAL_REFERENCE",
estimate_statistics="ESTIMATE_STATISTICS",
aux_inputs="")
total_rows = int(arcpy.GetCount_management(md_path).getOutput(0))
if total_rows <= 0:
arcpy.AddWarning("No rasters found for '{}'".format(md_path))
deleteFileIfExists(md_path, True)
else:
try:
importMosaicDatasetGeometries(md_path, footprint_path, lasd_boundary_path)
except:
arcpy.AddWarning("Failed to update MD boundaries for '{}'".format(md_path))
a = doTime(a, "\tAdded Rasters to MD {}".format(md_name))
except:
arcpy.AddWarning("Failed to create MD for QA Raster Layer '{}'. Please remove any locks and delete related intermediate files".format(md_path))
return [md_path, md_name]
##==============================================================================
# For each variable create a filegeodatabase and a mosaic dataset
# Add rasters to mosaic dataset, calculate statistics
# Add time field and add index
ncTimeTableView = ncTimeDim + "TableView"
result = arcpy.MakeNetCDFTableView_md(inNetCDFFile, ncTimeDim,
ncTimeTableView, ncTimeDim)
for ncVar in ncVarsXYTimeDim:
ncVarFolderPath = scratchPath + os.sep + ncVar.lower()
result = arcpy.CreateFileGDB_management(outPath, ncVar)
fgdbPath = outPath + os.sep + ncVar + ".gdb"
result = arcpy.CreateMosaicDataset_management(fgdbPath, ncVar, spRef)
mosaicDatasetPath = fgdbPath + os.sep + ncVar
result = arcpy.SetMosaicDatasetProperties_management(
mosaicDatasetPath, "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", ncTimeDimSize)
result = arcpy.AddRastersToMosaicDataset_management(
mosaicDatasetPath, "Raster Dataset", ncVarFolderPath)
del ncVarFolderPath
result = arcpy.CalculateStatistics_management(mosaicDatasetPath)
mosaicTableView = ncVar + "TableView"
result = arcpy.MakeTableView_management(mosaicDatasetPath,
mosaicTableView)
result = arcpy.JoinField_management(mosaicTableView, "OBJECTID",
ncTimeTableView, "OID", ncTimeDim)
procLog = arcpy.GetParameterAsText(
6) #Log to store data on the mosaicking progress
# Open processing log.
Log = open(procLog, 'w+')
timeStamp = datetime.strftime(datetime.now(), '%Y-%m-%d %H:%M:%S')
Log.write('Solar radiation mosaic creation started %s.\n' % timeStamp)
# Local variables:
coordSys = arcpy.Describe(inFprints).spatialReference
# Process: Create Mosaic Dataset
# This creates the blank (empty) mosaic dataset
arcpy.AddMessage('Creating empty mosaic dataset...')
md = 'md_' + mosaicName
solarMosaic = arcpy.CreateMosaicDataset_management(scratchGDB, md, coordSys)
# Loop through the geodatabases and add rasters to the mosaic dataset
for gdb in inGDB.split(';'):
try:
# Process: Add Rasters To Mosaic Dataset
arcpy.AddMessage('Adding rasters from %s to mosaic dataset...' % gdb)
arcpy.AddRastersToMosaicDataset_management(
solarMosaic, "Raster Dataset", gdb, "UPDATE_CELL_SIZES",
"UPDATE_BOUNDARY", "NO_OVERVIEWS", "", "0", "1500", "", "",
"SUBFOLDERS", "OVERWRITE_DUPLICATES", "NO_PYRAMIDS",
"NO_STATISTICS", "NO_THUMBNAILS", "", "NO_FORCE_SPATIAL_REFERENCE")
Log.write('Successfully added rasters from %s to mosaic dataset. \n' %
gdb)
except:
arcpy.AddWarning('Failed to add rasters from %s.' % gdb)
agroRasters = list(r)[1:]
f.close()
Rasters = []
for i in range(0, len(agroRasters)):
Rasters.append(agroRasters[i][0])
arcpy.AddMessage("Creating mosaic dataset...")
# Create Mosaic Dataset
try:
if arcpy.Exists(agroMosaic):
print agroMosaic, "exists, will be deleted"
arcpy.DeleteMosaicDataset_management(agroMosaic)
arcpy.CreateMosaicDataset_management(env.workspace, agroMosaic, Proj, "1",
"32_BIT_SIGNED", "NONE", "")
print "New mosaic dataset", agroMosaic, "was created\nAdding", len(
agroRasters), "rasters to mosaic dataset..."
arcpy.AddRastersToMosaicDataset_management(
agroMosaic, "Raster Dataset", Rasters, "UPDATE_CELL_SIZES",
"UPDATE_BOUNDARY", "NO_OVERVIEWS", "", "0", "1500", Proj, "",
"SUBFOLDERS", "OVERWRITE_DUPLICATES", "NO_PYRAMIDS",
"CALCULATE_STATISTICS", "NO_THUMBNAILS", "",
"NO_FORCE_SPATIAL_REFERENCE")
arcpy.GetMessages()
except Exception as e:
print e.message
arcpy.AddMessage("Adding required fields...") # Add required fields
for field in fields[2:]: # exclude "Name" and "GroupName"
# Local variables: CTX_Mosaic_Rasters = OUTPUT_FOLDER CTX_Mosaic_NoDATA = CTX_Mosaic_Rasters CTX_Mosaic_Footprints1 = CTX_Mosaic_NoDATA CTX_Mosaic_Footprints2 = CTX_Mosaic_Footprints1 CTX_Final = CTX_Mosaic_Footprints2 CTXmosaic_GBD_gdb = OUTPUT_FOLDER CTX_Mosaic_Init = CTXmosaic_GBD_gdb CompleteDownload = "true" ExpressionTF = "CompleteDown = \"false\"" # Process: Create File GDB arcpy.CreateFileGDB_management(OUTPUT_FOLDER, MosaicName, "CURRENT") # Process: Create Mosaic Dataset arcpy.CreateMosaicDataset_management(CTXmosaic_GBD_gdb, MosaicName, "PROJCS['Mars_Equi180',GEOGCS['GCS_Mars_2000_Sphere',DATUM['D_Mars_2000_Sphere',SPHEROID['Mars_2000_Sphere_IAU_IAG',3396190.0,0.0]],PRIMEM['Reference_Meridian',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Equidistant_Cylindrical'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],PARAMETER['Standard_Parallel_1',180.0],UNIT['Meter',1.0]];-10669600 -16102700 10000;-100000 10000;-100000 10000;0.001;0.001;0.001;IsHighPrecision", "1", "8_BIT_UNSIGNED", "NONE", "") # Process: Add Rasters To Mosaic Dataset arcpy.AddRastersToMosaicDataset_management(CTX_Mosaic_Init, "Raster Dataset", "C:\\Users\\thare\\Documents\\GIT\\ArcGIS_Plugins\\CTX_CreateMosaic_fromASU", "UPDATE_CELL_SIZES", "UPDATE_BOUNDARY", "NO_OVERVIEWS", "", "0", "1500", "", "*.JP2", "NO_SUBFOLDERS", "EXCLUDE_DUPLICATES", "NO_PYRAMIDS", "CALCULATE_STATISTICS", "NO_THUMBNAILS", "", "NO_FORCE_SPATIAL_REFERENCE") # Process: Define Mosaic Dataset NoData arcpy.DefineMosaicDatasetNoData_management(CTX_Mosaic_Rasters, "1", "BAND_1 0", "", "", "NO_COMPOSITE_NODATA") # Process: BuildFootprints_1 arcpy.BuildFootprints_management(CTX_Mosaic_NoDATA, "", "RADIOMETRY", "1", "255", "10", "500", "NO_MAINTAIN_EDGES", "SKIP_DERIVED_IMAGES", "NO_BOUNDARY", "2000", "100", "NONE", "", "20", "0.05") # Process: BuildFootprints_2 arcpy.BuildFootprints_management(CTX_Mosaic_Footprints1, "", "NONE", "1", "254", "10", "5000", "NO_MAINTAIN_EDGES", "SKIP_DERIVED_IMAGES", "UPDATE_BOUNDARY", "2000", "100", "NONE", "", "20", "0.05") # Process: Set Mosaic Dataset Properties arcpy.SetMosaicDatasetProperties_management(CTX_Mosaic_Footprints2, "4100", "15000", "None;LZ77;JPEG;LERC", "None", "75", "0", "BILINEAR", "CLIP", "FOOTPRINTS_MAY_CONTAIN_NODATA", "CLIP", "NOT_APPLY", "", "NONE", "Center;NorthWest;LockRaster;ByAttribute;Nadir;Viewpoint;Seamline;None", "Seamline", "", "", "ASCENDING", "BLEND", "10", "600", "300", "1000", "0.8", "", "FULL", "", "DISABLED", "", "", "", "", "20", "1000", "GENERIC", "1")
def main(*argv):
"""
Main function for data discovery
"""
try:
# Read user input
#
servicelayer = argv[0]
outputws = argv[1]
outputgdb = argv[2]
mdname = argv[3]
polygonfeat = argv[4]
cellsize = float(argv[5])
clipping = argv[6]
nodataVal = float(argv[7])
userr = argv[8]
#... read more as optional parameters
# Check image service layer or URL
if not arcpy.Exists(servicelayer):
if servicelayer.startswith(
"http") and servicelayer.lower().find("imageserver") != -1:
arcpy.AddMessage("Input is a service URL")
serviceURL = servicelayer
else:
arcpy.AddError("Invalid Input.")
return
else:
islayer = arcpy.mapping.Layer(servicelayer)
# Check if the image service is from mosaic dataset
if not (islayer.isServiceLayer and islayer.isRasterLayer):
arcpy.AddError("Layer is not Image Service layer")
return
elif not islayer.supports("DEFINITIONQUERY"):
arcpy.AddError(
"Image Service is not publish from Mosaic Dataset")
return
# Get service URL from the image service layer
serviceURL = islayer.serviceProperties["URL"]
# Get general service information
inforeq = getISinfo(serviceURL)
isprj = inforeq[0]
pixtype = inforeq[1]
defaultrr = inforeq[2]
# Get spatial query request, item fields, values and spatial reference
queryres = getQueryFields(serviceURL, polygonfeat)
itemfields = queryres[0]
itemfeatures = queryres[1]
# Define output mosaic dataset path
mdpath = os.path.join(outputgdb, mdname)
# Check if there is items to download
if len(itemfeatures) > 0:
arcpy.AddMessage(
"Found items to download, creating mosaic dataset...")
mdprj = arcpy.CreateSpatialReference_management(isprj["wkid"])
# Create output mosaic dataset and recover fields
# Create File GDB for shipping md
if not arcpy.Exists(outputgdb):
arcpy.CreateFileGDB_management(os.path.dirname(outputgdb),
os.path.basename(outputgdb))
# Create output mosaic dataset
arcpy.env.overwriteOutput = 1
arcpy.CreateMosaicDataset_management(outputgdb, mdname, mdprj)
# Recover fields from the image service
missingfieldsName = recoverFields(itemfields, mdpath)
else:
arcpy.AddError("No raster can be downloaded")
# Download raster one by one, and add raster one by one
for itemfeature in itemfeatures:
itematt = itemfeature["attributes"]
itemgeo = itemfeature["geometry"]["rings"][0]
itemoid = itematt["OBJECTID"]
#Get clipping bounding box for each item
bbox = getbbox(polygonfeat, itemgeo, mdprj)
#Generate download image
file_name = downloaditem(serviceURL, itemoid, defaultrr, bbox,
cellsize, isprj, pixtype, userr, outputws)
#Clip output image to polygon geometry if clipping is true
if clipping:
clipimage(file_name, polygonfeat, itemoid, nodataVal)
# Add downloaded raster to output mosaic dataset
addrasters(mdpath, outputws, itematt)
arcpy.AddMessage("All done")
except:
arcpy.AddError("Clip and ship application failed")
