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 clipDerivedRaster(out_raster_path, vector_bound_path):
# a = datetime.datetime.now()
raster_name = os.path.split(out_raster_path)[1]
if os.path.exists(out_raster_path) and not str(raster_name).startswith("C_"):
raster_path, raster_name = os.path.split(out_raster_path)
clip_raster_path = os.path.join(raster_path, "C_{}".format(raster_name))
# arcpy.AddMessage("Clipping raster {} to {}".format(out_raster_path, clip_raster_path))
if os.path.exists(clip_raster_path):
deleteFileIfExists(clip_raster_path, True)
arcpy.Rename_management(out_raster_path, clip_raster_path)
try:
arcpy.Clip_management(in_raster=clip_raster_path, out_raster=out_raster_path, in_template_dataset=vector_bound_path, nodata_value=RasterConfig.NODATA_DEFAULT, clipping_geometry="ClippingGeometry", maintain_clipping_extent="NO_MAINTAIN_EXTENT")
except:
try:
# NO Data value may not be applicable to this raster type
arcpy.Clip_management(in_raster=clip_raster_path, out_raster=out_raster_path, in_template_dataset=vector_bound_path, nodata_value="", clipping_geometry="ClippingGeometry", maintain_clipping_extent="NO_MAINTAIN_EXTENT")
except:
pass
deleteFileIfExists(out_raster_path, True)
# doTime(a, "\tClip raster {}".format(clip_raster_path))
return clip_raster_path
def createRasterDatasetStats(f_path, stat_file_path=None):
a = datetime.now()
try:
# this no data value doesn't apply to all rasters, but easier to just try and move on
arcpy.SetRasterProperties_management(f_path,
data_type="#",
statistics="#",
stats_file="#",
nodata="1 {}".format(
RasterConfig.NODATA_DEFAULT))
except:
pass
try:
arcpy.CalculateStatistics_management(in_raster_dataset=f_path,
x_skip_factor="1",
y_skip_factor="1",
ignore_values="",
skip_existing="OVERWRITE",
area_of_interest="Feature Set")
except Exception as e:
arcpy.AddMessage('Could Not Calculate Statistics')
arcpy.AddMessage(e)
raster_properties = {}
rasterObject = arcpy.Raster(f_path)
raster_properties[
BAND_COUNT] = rasterObject.bandCount # Integer - The number of bands in the referenced raster dataset.
# raster_properties['catalogPath'] = rasterObject.catalogPath # String - The full path and the name of the referenced raster dataset.
raster_properties[
COMP_TYPE] = rasterObject.compressionType # String - The compression type. The following are the available types:LZ77,JPEG,JPEG 2000,PACKBITS,LZW,RLE,CCITT GROUP 3,CCITT GROUP 4,CCITT (1D),None.
# raster_properties[EXTENT] = rasterObject.extent # Extent - The extent of the referenced raster dataset.
raster_properties[
FORMAT] = rasterObject.format # String - The raster format
raster_properties[
HAS_RAT] = rasterObject.hasRAT # Boolean - Identifies if there is an associated attribute table: True if an attribute table exists or False if no attribute table exists.
raster_properties[
HEIGHT] = rasterObject.height # Integer - The number of rows.
raster_properties[
IS_INT] = rasterObject.isInteger # Boolean - The integer state: True if the raster dataset has integer type.
raster_properties[
IS_TEMP] = rasterObject.isTemporary # Boolean - The state of the referenced raster dataset: True if the raster dataset is temporary or False if permanent.
raster_properties[
MAX] = rasterObject.maximum # Double - The maximum value in the referenced raster dataset.
raster_properties[
MEAN] = rasterObject.mean # Double - The mean value in the referenced raster dataset.
raster_properties[
MEAN_CELL_HEIGHT] = rasterObject.meanCellHeight # Double - The cell size in the y direction.
raster_properties[
MEAN_CELL_WIDTH] = rasterObject.meanCellWidth # Double - The cell size in the x direction.
raster_properties[
MIN] = rasterObject.minimum # Double - The minimum value in the referenced raster dataset.
#Added to bypass zmin = 'None' error 15 April 2019 BJN
if raster_properties[MIN] is None or raster_properties[MIN] < -285:
raster_properties[
MIN] = 0 # Double - The minimum value in the referenced raster dataset.
raster_properties[
NAME] = rasterObject.name # String - The name of the referenced raster dataset.
raster_properties[
NODATA_VALUE] = rasterObject.noDataValue # Double - The NoData value of the referenced raster dataset.
raster_properties[
PATH] = rasterObject.path # String - The full path and name of the referenced raster dataset.
raster_properties[
PIXEL_TYPE] = rasterObject.pixelType # String - The pixel type of the referenced raster dataset.
raster_properties[
SPAT_REF] = rasterObject.spatialReference # SpatialReference - The spatial reference of the referenced raster dataset.
raster_properties[
STAND_DEV] = rasterObject.standardDeviation # Double - The standard deviation of the values in the referenced raster dataset.
raster_properties[
UNCOMP_SIZE] = rasterObject.uncompressedSize # Double - The size of the referenced raster dataset on disk.
raster_properties[
WIDTH] = rasterObject.width # Integer - The number of columns.
raster_properties[V_NAME] = None
raster_properties[V_UNIT] = None
raster_properties[H_NAME] = None
raster_properties[H_UNIT] = None
raster_properties[H_WKID] = None
if rasterObject.spatialReference is not None:
raster_properties[V_NAME], raster_properties[
V_UNIT] = Utility.getVertCSInfo(rasterObject.spatialReference)
raster_properties[H_NAME] = rasterObject.spatialReference.name
raster_properties[
H_UNIT] = rasterObject.spatialReference.linearUnitName
raster_properties[H_WKID] = rasterObject.spatialReference.factoryCode
raster_properties[XMIN] = rasterObject.extent.XMin
raster_properties[YMIN] = rasterObject.extent.YMin
raster_properties[XMAX] = rasterObject.extent.XMax
raster_properties[YMAX] = rasterObject.extent.YMax
valList = []
for key in KEY_LIST:
valList.append(raster_properties[key])
keyList = ','.join(KEY_LIST)
for i, value in enumerate(valList):
valList[i] = str(value)
valList = ','.join(valList)
# arcpy.AddMessage("\t{}".format(keyList))
# arcpy.AddMessage("\t{}".format(valList))
if stat_file_path is not None:
# Output file
deleteFileIfExists(stat_file_path)
OutFile = open(stat_file_path, 'w')
OutFile.write('{}\n{}\n'.format(keyList, valList))
OutFile.close()
doTime(a, "\tCreated STATS {}".format(stat_file_path))
doTime(a, "\tCreated STATS {}".format(raster_properties))
return raster_properties
def createQARasterMosaics(isClassified, gdb_path, spatial_reference, target_folder, mxd, footprint_path=None, lasd_boundary_path=None):
mosaics = []
simple_footprint_path = None
simple_lasd_boundary_path = None
stats_methods = STATS_METHODS
for method in stats_methods:
arcpy.AddMessage("Creating {} MDS".format(method))
for dataset_name in DATASET_NAMES:
name = dataset_name
if not isClassified:
# Using a generic name for non-classified data
name = ""
md_name = method
if len(name) > 0:
md_name = "{}{}".format(method, name)
input_folder = os.path.join(target_folder, method, name[1:])
arcpy.AddMessage("Creating {} MD from {}".format(md_name, input_folder))
try:
if simple_footprint_path is None:
simple_footprint_path = "{}_Simple".format(footprint_path)
arcpy.SimplifyPolygon_cartography(in_features=footprint_path, out_feature_class=simple_footprint_path,
algorithm="POINT_REMOVE", tolerance=Raster.boundary_interval, minimum_area="0 SquareMeters",
error_option="RESOLVE_ERRORS", collapsed_point_option="NO_KEEP")
Utility.addToolMessages()
deleteFields(simple_footprint_path)
#try:
# arcpy.DeleteField_management(in_table=simple_footprint_path, drop_field="Id;ORIG_FID;InPoly_FID;SimPgnFlag;MaxSimpTol;MinSimpTol")
#except:
# pass
if simple_lasd_boundary_path is None:
simple_lasd_boundary_path = "{}_Simple".format(lasd_boundary_path)
arcpy.SimplifyPolygon_cartography(in_features=lasd_boundary_path, out_feature_class=simple_lasd_boundary_path,
algorithm="POINT_REMOVE", tolerance=Raster.boundary_interval, minimum_area="0 SquareMeters",
error_option="RESOLVE_ERRORS", collapsed_point_option="NO_KEEP")
Utility.addToolMessages()
deleteFields(simple_lasd_boundary_path)
#try:
# arcpy.DeleteField_management(in_table=simple_lasd_boundary_path, drop_field="Id;ORIG_FID;InPoly_FID;SimPgnFlag;MaxSimpTol;MinSimpTol")
#except:
# pass
except:
arcpy.AddWarning("Failed to create simplified footprints and boundaries in '{}'".format(gdb_path))
qa_md = createQARasterMosaicDataset(md_name, gdb_path, spatial_reference, input_folder, mxd, simple_footprint_path, simple_lasd_boundary_path)
if qa_md is not None:
mosaics.append(qa_md)
md_name = CANOPY_DENSITY
dhm_md_path = os.path.join(gdb_path, md_name)
mosaics.append([dhm_md_path, md_name])
if arcpy.Exists(dhm_md_path):
arcpy.AddMessage("{} already exists.".format(md_name))
else:
try:
vert_cs_name, vert_unit_name = Utility.getVertCSInfo(spatial_reference) # @UnusedVariable
# No need to update boundary and footprints since it will inherit from the original
pc_all_md_path = os.path.join(gdb_path, "POINT_COUNT_ALL")
createReferenceddMosaicDataset(pc_all_md_path, dhm_md_path, spatial_reference, vert_unit_name)
except:
arcpy.AddMessage("Failed to create {}".format(dhm_md_path))
deleteFileIfExists(simple_footprint_path, True)
deleteFileIfExists(simple_lasd_boundary_path, True)
return mosaics
def createRasterBoundaryAndFootprints(fgdb_path, target_path, project_ID, project_path, project_UID):
a = datetime.datetime.now()
stat_out_folder = os.path.join(target_path, STAT_LAS_FOLDER)
b_file_list = []
c_file_list = []
for f_name in [f for f in os.listdir(stat_out_folder) if (f.startswith('B_') and f.endswith('.shp'))]:
b_path = os.path.join(stat_out_folder, f_name)
c_path = os.path.join(stat_out_folder, "C{}".format(f_name[1:]))
try:
if not os.path.exists(b_path):
arcpy.AddWarning("Failed to find B boundary file {}".format(b_path))
else:
b_file_list.append(b_path)
except:
pass
try:
if not os.path.exists(c_path):
arcpy.AddWarning("Failed to find C boundary file {}".format(c_path))
else:
c_file_list.append(c_path)
deleteFields(c_path)
except:
pass
a = doTime(a, "Found {} footprints".format(len(b_file_list)))
try:
for file_type in [r'C_*.shp', r'B_*.shp']:
bad_shape_type_list = list(filter(lambda x: arcpy.Describe(x).shapeType != 'Polygon',glob.glob(os.path.join(stat_out_folder, file_type))))
if len(bad_shape_type_list) > 0:
for bad_type in bad_shape_type_list:
arcpy.AddMessage("ERROR: Bad shape type in file '{}'".format(bad_type))
except:
pass
las_footprint = getLasFootprintPath(fgdb_path)
lasd_boundary = getLasdBoundaryPath(fgdb_path)
if arcpy.Exists(las_footprint):
arcpy.AddMessage("Footprints exist: {}".format(las_footprint))
else:
# Delete the boundary if the footprints don't exist (have to recreate anyway)
deleteFileIfExists(lasd_boundary, True)
lasd_boundary_B = "{}B".format(lasd_boundary)
deleteFileIfExists(lasd_boundary_B, True)
las_footprint_1 = os.path.join(fgdb_path, "{}B1".format(las_footprint))
las_footprint_2 = os.path.join(fgdb_path, "{}B2".format(las_footprint))
las_footprint_CP = os.path.join(fgdb_path, "{}B_CP".format(las_footprint))
a = doTime(a, "\tMerging B footprints to {}".format(las_footprint_2))
deleteFileIfExists(las_footprint_1, True)
deleteFileIfExists(las_footprint_2, True)
deleteFileIfExists(las_footprint_CP, True)
##Old Code arcpy.Merge_management(inputs=b_file_list, output=las_footprint_2)
##New Code
#BJN: Reduce memory usage by appending blocks of tiles instead of merging
# all of the tiles at once.
out_path, out_name = os.path.split(las_footprint_2)
cfs_template = b_file_list[0]
arcpy.CreateFeatureclass_management(out_path, out_name, "POLYGON", template = cfs_template, spatial_reference = cfs_template)
append_group_size = 1024 #appending x tiles at a time
append_group_start = 0 #list offset for the current file group
while append_group_start < len(b_file_list):
#set the new file group endpoint
append_group_end = append_group_start + append_group_size
#Use the next append_group_size tiles, or up to the end of the list,
#whichever is smaller.
append_msg = '{}Adding {} tiles'.format(' '*8, append_group_size)
if append_group_end < len(b_file_list):
arcpy.Append_management(b_file_list[append_group_start:append_group_end], las_footprint_2)
else:
append_msg = '{}Adding {} tiles'.format(' '*8, len(b_file_list[append_group_start:]))
arcpy.Append_management(b_file_list[append_group_start:], las_footprint_2)
arcpy.AddMessage(append_msg)
#Set the new start point
append_group_start = append_group_end
arcpy.Compact_management(out_path)
##End New Code
#Utility.addToolMessages()
deleteFields(las_footprint_2)
arcpy.RepairGeometry_management(in_features=las_footprint_2, delete_null="DELETE_NULL")
#Utility.addToolMessages()
a = doTime(a, "\tMerged B and repaired footprints to {}".format(las_footprint_2))
#arcpy.CreateCartographicPartitions_cartography(in_features=las_footprint_2, out_features=las_footprint_CP, feature_count=PARTITION_COUNT)
#a = doTime(a, "\tCreated B carto parts")
#arcpy.env.cartographicPartitions = las_footprint_CP
#a = doTime(a, "\tSet B cartographic partitions to {}".format(las_footprint_CP))
#arcpy.SimplifyPolygon_cartography(in_features=las_footprint_2, out_feature_class=las_footprint_1, algorithm="POINT_REMOVE", tolerance="0.5 Meters", minimum_area="0 Unknown", error_option="RESOLVE_ERRORS", collapsed_point_option="NO_KEEP", in_barriers="")
#Utility.addToolMessages()
#arcpy.env.cartographicPartitions = None
#a = doTime(a, "\tSimplified B las footprints to {}".format(las_footprint_1))
#deleteFileIfExists(las_footprint_2, True)
#arcpy.RepairGeometry_management(in_features=las_footprint_1, delete_null="DELETE_NULL")
#Utility.addToolMessages()
#a = doTime(a, "Merged B las footprints {}".format(las_footprint_1))
createBoundaryFeatureClass(las_footprint_2, lasd_boundary_B)
deleteFileIfExists(las_footprint_2, True)
a = datetime.datetime.now()
# Merge the other footprints before clipping
las_footprint_1 = os.path.join(fgdb_path, "{}C1".format(las_footprint))
las_footprint_2 = os.path.join(fgdb_path, "{}C2".format(las_footprint))
las_footprint_CP = os.path.join(fgdb_path, "{}C_CP".format(las_footprint))
deleteFileIfExists(las_footprint_1, True)
deleteFileIfExists(las_footprint_2, True)
deleteFileIfExists(las_footprint_CP, True)
a = doTime(a, "\tMerging C las footprints to {}".format(las_footprint_2))
arcpy.Merge_management(inputs=c_file_list, output=las_footprint_2)
#Utility.addToolMessages()
deleteFields(las_footprint_2)
arcpy.RepairGeometry_management(in_features=las_footprint_2, delete_null="DELETE_NULL")
#Utility.addToolMessages()
a = doTime(a, "\tMerged C las footprints to {}".format(las_footprint_2))
#arcpy.CreateCartographicPartitions_cartography(in_features=las_footprint_2, out_features=las_footprint_CP, feature_count=PARTITION_COUNT)
#a = doTime(a, "\tCreated C carto parts")
#arcpy.env.cartographicPartitions = las_footprint_CP
#a = doTime(a, "\tSet C cartographic partitions to {}".format(las_footprint_CP))
#arcpy.SimplifyPolygon_cartography(in_features=las_footprint_2, out_feature_class=las_footprint_1, algorithm="POINT_REMOVE", tolerance="0.5 Meters", minimum_area="0 Unknown", error_option="RESOLVE_ERRORS", collapsed_point_option="NO_KEEP", in_barriers="")
#Utility.addToolMessages()
#arcpy.env.cartographicPartitions = None
#a = doTime(a, "\tSimplified C las footprints to {}".format(las_footprint_1))
#deleteFileIfExists(las_footprint_2, True)
#arcpy.RepairGeometry_management(in_features=las_footprint_1, delete_null="DELETE_NULL")
#Utility.addToolMessages()
#a = doTime(a, "Merged C las footprints {}".format(las_footprint_1))
lasd_boundary_C = "{}C".format(lasd_boundary)
deleteFileIfExists(lasd_boundary_C, True)
createBoundaryFeatureClass(las_footprint_2, lasd_boundary_C)
lasd_boundary_SD = "{}_SD".format(lasd_boundary)
lasd_boundary_SD1 = "{}_SD1".format(lasd_boundary)
lasd_boundary_SD2 = "{}_SD2".format(lasd_boundary)
lasd_boundary_SD3 = "{}_SD3".format(lasd_boundary)
deleteFileIfExists(lasd_boundary_SD, True)
deleteFileIfExists(lasd_boundary_SD1, True)
deleteFileIfExists(lasd_boundary_SD2, True)
deleteFileIfExists(lasd_boundary_SD3, True)
# Replace a layer/table view name with a path to a dataset (which can be a layer file) or create the layer/table view within the script
arcpy.SymDiff_analysis(in_features=lasd_boundary_B, update_features=lasd_boundary_C, out_feature_class=lasd_boundary_SD1, join_attributes="ONLY_FID", cluster_tolerance="3 Meters")
arcpy.Buffer_analysis(in_features=lasd_boundary_SD1, out_feature_class=lasd_boundary_SD2, buffer_distance_or_field="-3 Meters", line_side="FULL", line_end_type="ROUND", dissolve_option="NONE", dissolve_field="", method="PLANAR")
arcpy.MultipartToSinglepart_management(in_features=lasd_boundary_SD2, out_feature_class=lasd_boundary_SD3)
arcpy.Buffer_analysis(in_features=lasd_boundary_SD3, out_feature_class=lasd_boundary_SD, buffer_distance_or_field="3 Meters", line_side="FULL", line_end_type="ROUND", dissolve_option="NONE", dissolve_field="", method="PLANAR")
arcpy.DeleteField_management(in_table=lasd_boundary_SD, drop_field="FID_BoundaryLASDatasetB;FID_BoundaryLASDatasetC;BUFF_DIST;ORIG_FID")
deleteFileIfExists(lasd_boundary_C, True)
deleteFileIfExists(lasd_boundary_SD1, True)
deleteFileIfExists(lasd_boundary_SD2, True)
deleteFileIfExists(lasd_boundary_SD3, True)
a = doTime(a, "Created symetrical difference in boundaries {}".format(lasd_boundary_SD))
checkNullFields(las_footprint_2)
a = datetime.datetime.now()
deleteFileIfExists(las_footprint, True)
arcpy.Clip_analysis(in_features=las_footprint_2, clip_features=lasd_boundary_B, out_feature_class=las_footprint, cluster_tolerance="")
#deleteFileIfExists(las_footprint_1, True)
deleteFileIfExists(lasd_boundary_B, True)
#deleteFileIfExists(lasd_boundary, True)
#deleteFileIfExists(las_footprint_CP, True)
#arcpy.env.cartographicPartitions = None
deleteFileIfExists(las_footprint_2, True)
a = doTime(a, "Clipped las footprints to dataset boundary {} ".format(las_footprint))
deleteFields(las_footprint)
try:
arcpy.RepairGeometry_management(in_features=las_footprint, delete_null="KEEP_NULL")
except:
pass
if arcpy.Exists(lasd_boundary):
arcpy.AddMessage("Boundary exists: {}".format(lasd_boundary))
else:
deleteFileIfExists(lasd_boundary, True)
summary_string, field_alter = getStatsFields(las_footprint)
createBoundaryFeatureClass(las_footprint, lasd_boundary, summary_string, field_alter)
addProjectInfo(las_footprint, lasd_boundary, project_ID, project_path, project_UID)
deleteFields(lasd_boundary)
try:
arcpy.RepairGeometry_management(in_features=lasd_boundary, delete_null="KEEP_NULL")
except:
pass
return lasd_boundary, las_footprint
def createBoundaryFeatureClass(raster_footprint, target_raster_boundary, statistics_fields="", alter_field_infos=None):
a = datetime.datetime.now()
aa = a
deleteFields(raster_footprint)
lasd_boundary_0 = "{}0".format(target_raster_boundary)
lasd_boundary_1 = "{}1".format(target_raster_boundary)
deleteFileIfExists(lasd_boundary_0, True)
deleteFileIfExists(lasd_boundary_1, True)
arcpy.AddMessage("\tMultipart to Singlepart")
arcpy.MultipartToSinglepart_management(in_features=raster_footprint, out_feature_class=lasd_boundary_0)
Utility.addToolMessages()
arcpy.RepairGeometry_management(in_features=lasd_boundary_0, delete_null="DELETE_NULL")
deleteFields(lasd_boundary_0)
arcpy.AddMessage("\tBuffering")
arcpy.Buffer_analysis(in_features=lasd_boundary_0, out_feature_class=lasd_boundary_1, buffer_distance_or_field="10 Meters", line_side="FULL", line_end_type="ROUND", dissolve_option="NONE", method="PLANAR")
Utility.addToolMessages()
arcpy.RepairGeometry_management(in_features=lasd_boundary_1, delete_null="DELETE_NULL")
deleteFields(lasd_boundary_1)
deleteFileIfExists(lasd_boundary_0, True)
lasd_boundary_2 = "{}2".format(target_raster_boundary)
deleteFileIfExists(lasd_boundary_2, True)
arcpy.AddMessage("\tDissolving with statistics: {}".format(statistics_fields))
arcpy.Dissolve_management(
in_features=lasd_boundary_1,
out_feature_class=lasd_boundary_2,
statistics_fields=statistics_fields
)
Utility.addToolMessages()
arcpy.RepairGeometry_management(in_features=lasd_boundary_2, delete_null="DELETE_NULL")
deleteFields(lasd_boundary_2)
a = doTime(a, "\tDissolved to {}".format(lasd_boundary_2))
if alter_field_infos is not None:
for alter_field_info in alter_field_infos:
try:
alterField(lasd_boundary_2, alter_field_info[0], alter_field_info[1], alter_field_info[2])
except:
pass
a = doTime(a, "\tRenamed summary fields")
lasd_boundary_3 = "{}3".format(target_raster_boundary)
deleteFileIfExists(lasd_boundary_3, True)
arcpy.EliminatePolygonPart_management(in_features=lasd_boundary_2, out_feature_class=lasd_boundary_3, condition="AREA", part_area="10000 SquareMiles", part_area_percent="0", part_option="CONTAINED_ONLY")
arcpy.RepairGeometry_management(in_features=lasd_boundary_3, delete_null="DELETE_NULL")
deleteFileIfExists(lasd_boundary_1, True)
deleteFields(lasd_boundary_3)
lasd_boundary_4 = "{}4".format(target_raster_boundary)
deleteFileIfExists(lasd_boundary_4, True)
arcpy.SimplifyPolygon_cartography(in_features=lasd_boundary_3, out_feature_class=lasd_boundary_4, algorithm="BEND_SIMPLIFY", tolerance="20 Meters", minimum_area="0 Unknown", error_option="RESOLVE_ERRORS", collapsed_point_option="NO_KEEP", in_barriers="")
arcpy.RepairGeometry_management(in_features=lasd_boundary_4, delete_null="DELETE_NULL")
deleteFields(lasd_boundary_4)
#try:
# arcpy.DeleteField_management(in_table=lasd_boundary_4, drop_field="Id;ORIG_FID;InPoly_FID;SimPgnFlag;MaxSimpTol;MinSimpTol")
#except:
# pass
deleteFileIfExists(lasd_boundary_3, True)
deleteFileIfExists(target_raster_boundary, True)
arcpy.Buffer_analysis(in_features=lasd_boundary_4, out_feature_class=target_raster_boundary, buffer_distance_or_field="-10 Meters", line_side="FULL", line_end_type="ROUND", dissolve_option="ALL", method="PLANAR")
arcpy.RepairGeometry_management(in_features=target_raster_boundary, delete_null="DELETE_NULL")
deleteFields(target_raster_boundary)
deleteFileIfExists(lasd_boundary_4, True)
if alter_field_infos is not None and len(alter_field_infos) > 0:
fields = ";".join([field[1] for field in alter_field_infos])
arcpy.JoinField_management(in_data=target_raster_boundary, in_field="OBJECTID", join_table=lasd_boundary_2, join_field="OBJECTID", fields=fields)
Utility.addToolMessages()
deleteFileIfExists(lasd_boundary_2, True)
a = doTime(aa, "Dissolved las footprints to dataset boundary {} ".format(target_raster_boundary))
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]
def createBoundaryFeatureClass(raster_footprint,
target_raster_boundary,
statistics_fields="",
alter_field_infos=None):
a = datetime.datetime.now()
aa = a
raster_boundary_1 = "{}1".format(target_raster_boundary)
deleteFileIfExists(raster_boundary_1, True)
arcpy.Buffer_analysis(in_features=raster_footprint,
out_feature_class=raster_boundary_1,
buffer_distance_or_field="10 Meters",
line_side="FULL",
line_end_type="ROUND",
dissolve_option="NONE",
method="PLANAR")
arcpy.RepairGeometry_management(in_features=raster_boundary_1,
delete_null="DELETE_NULL")
deleteFields(raster_boundary_1)
a = doTime(a, "\tBuffer out into {}".format(raster_boundary_1))
raster_boundary_2 = "{}2".format(target_raster_boundary)
deleteFileIfExists(raster_boundary_2, True)
arcpy.AddMessage(
"\tDissolving with statistics: {}".format(statistics_fields))
arcpy.Dissolve_management(in_features=raster_boundary_1,
out_feature_class=raster_boundary_2,
dissolve_field=FIELD_INFO[ELEV_TYPE][0],
statistics_fields=statistics_fields)
arcpy.RepairGeometry_management(in_features=raster_boundary_2,
delete_null="DELETE_NULL")
deleteFields(raster_boundary_2)
a = doTime(a, "\tDissolved to {}".format(raster_boundary_2))
deleteFileIfExists(raster_boundary_1, True)
alterFields(alter_field_infos, raster_boundary_2)
a = doTime(a, "\tAltered Fields on {}".format(raster_boundary_2))
raster_boundary_3 = "{}3".format(target_raster_boundary)
deleteFileIfExists(raster_boundary_3, True)
arcpy.EliminatePolygonPart_management(in_features=raster_boundary_2,
out_feature_class=raster_boundary_3,
condition="AREA",
part_area="10000 SquareMiles",
part_area_percent="0",
part_option="CONTAINED_ONLY")
arcpy.RepairGeometry_management(in_features=raster_boundary_3,
delete_null="DELETE_NULL")
deleteFields(raster_boundary_3)
a = doTime(a,
"\tEliminated internal parts on {}".format(raster_boundary_3))
# Don't delete raster boundary 2 because we need it later
# JWS 4/26 - Bend Simplify -> Point Remove & 20 Meters -> 0.1 Meters
raster_boundary_4 = "{}4".format(target_raster_boundary)
deleteFileIfExists(raster_boundary_4, True)
arcpy.SimplifyPolygon_cartography(in_features=raster_boundary_3,
out_feature_class=raster_boundary_4,
algorithm="POINT_REMOVE",
tolerance="0.1 Meters",
minimum_area="0 Unknown",
error_option="RESOLVE_ERRORS",
collapsed_point_option="NO_KEEP",
in_barriers="")
arcpy.RepairGeometry_management(in_features=raster_boundary_4,
delete_null="DELETE_NULL")
deleteFields(raster_boundary_4)
a = doTime(a, "\tSimplified to {}".format(raster_boundary_4))
deleteFileIfExists(raster_boundary_3, True)
deleteFileIfExists(target_raster_boundary, True)
arcpy.Buffer_analysis(in_features=raster_boundary_4,
out_feature_class=target_raster_boundary,
buffer_distance_or_field="-10 Meters",
line_side="FULL",
line_end_type="ROUND",
dissolve_option="NONE",
method="PLANAR")
arcpy.RepairGeometry_management(in_features=target_raster_boundary,
delete_null="DELETE_NULL")
deleteFields(target_raster_boundary)
a = doTime(a, "\tBuffer back into {}".format(target_raster_boundary))
deleteFileIfExists(raster_boundary_4, True)
if alter_field_infos is not None and len(alter_field_infos) > 0:
fields = ";".join([field[1] for field in alter_field_infos])
arcpy.JoinField_management(in_data=target_raster_boundary,
in_field="OBJECTID",
join_table=raster_boundary_2,
join_field="OBJECTID",
fields=fields)
# Utility.addToolMessages()
a = doTime(
a, "\tJoined {} with {}".format(target_raster_boundary,
raster_boundary_2))
deleteFileIfExists(raster_boundary_2, True)
a = doTime(
aa, "Dissolved raster footprints to dataset boundary {} ".format(
target_raster_boundary))
def createRasterBoundaryAndFootprints(fgdb_path, target_path, project_ID,
project_path, project_UID, elev_type):
a = datetime.datetime.now()
raster_footprint = None
raster_boundary = None
stat_out_folder = os.path.join(target_path, STAT_RASTER_FOLDER, elev_type)
if not os.path.exists(stat_out_folder):
arcpy.AddMessage(
"Raster statistics for elevation type don't exist: {}".format(
stat_out_folder))
else:
b_file_list = []
for f_name in [
f for f in os.listdir(stat_out_folder)
if (f.startswith('B_') and f.endswith('.shp'))
]:
b_path = os.path.join(stat_out_folder, f_name)
try:
if not os.path.exists(b_path):
arcpy.AddWarning(
"Failed to find B boundary file {}".format(b_path))
else:
b_file_list.append(b_path)
except:
pass
a = doTime(a, "Found boundaries {}".format(len(b_file_list)))
raster_footprint = getRasterFootprintPath(fgdb_path, elev_type)
raster_boundary = getRasterBoundaryPath(fgdb_path, elev_type)
if arcpy.Exists(raster_footprint):
arcpy.AddMessage(
"Raster Footprints exist: {}".format(raster_footprint))
else:
deleteFileIfExists(raster_footprint, True)
arcpy.Merge_management(inputs=b_file_list, output=raster_footprint)
arcpy.RepairGeometry_management(in_features=raster_footprint,
delete_null="DELETE_NULL")
deleteFields(raster_footprint)
field_alter = []
for base_field in FIELD_INFO:
field_name = base_field[0]
new_field_name = base_field[0]
new_field_alias = base_field[1]
new_field = [field_name, new_field_name, new_field_alias]
field_alter.append(new_field)
alterFields(field_alter, raster_footprint)
a = doTime(a,
"Merged raster footprints {}".format(raster_footprint))
arcpy.RepairGeometry_management(in_features=raster_footprint,
delete_null="DELETE_NULL")
deleteFields(raster_footprint)
if arcpy.Exists(raster_boundary):
arcpy.AddMessage(
"Raster Boundary exist: {}".format(raster_boundary))
else:
summary_string, field_alter = getStatsFields(raster_footprint)
createBoundaryFeatureClass(raster_footprint, raster_boundary,
summary_string, field_alter)
addProjectInfo(raster_footprint, raster_boundary, project_ID,
project_path, project_UID)
# Buffer Footprint @ 1 Meter & Clip to Avoid Gaps in Output Mosaic
one_meter_buffer = arcpy.Buffer_analysis(
raster_footprint,
os.path.join(fgdb_path,
'{}_2m'.format(os.path.split(raster_footprint)[1])),
'2 METER')
arcpy.RepairGeometry_management(in_features=one_meter_buffer,
delete_null="DELETE_NULL")
deleteFields(one_meter_buffer)
arcpy.Clip_analysis(one_meter_buffer, raster_boundary,
raster_footprint)
arcpy.RepairGeometry_management(in_features=raster_footprint,
delete_null="DELETE_NULL")
deleteFields(raster_footprint)
arcpy.Delete_management(one_meter_buffer)
## ?? DUPLICATE Code Block??
# Buffer Footprint @ 1 Meter & Clip to Avoid Gaps in Output Mosaic
#one_meter_buffer = arcpy.Buffer_analysis(
# raster_footprint,
# os.path.join(fgdb_path, '{}_1m'.format(os.path.split(raster_footprint)[1])),
# '1 METER'
# )
#arcpy.Clip_analysis(one_meter_buffer, raster_boundary, raster_footprint)
#arcpy.Delete_management(one_meter_buffer)
#deleteFields(raster_footprint)
return raster_footprint, raster_boundary
def RevalueRaster(f_path, elev_type, raster_props, target_path, publish_path, minZ, maxZ, bound_path, spatial_ref=None):
arcpy.AddMessage("RevalueRaster {} {}: ZRange({},{})".format(elev_type, f_path,minZ,maxZ))
Utility.setArcpyEnv(is_overwrite_output=True)
a = datetime.now()
nodata = RasterConfig.NODATA_DEFAULT
isInt = (elev_type == INT)
if isInt:
minZ, maxZ = 0, 255
arcpy.AddMessage("RevalueRaster type {} is intensity {}: ZRange({},{})".format(elev_type, f_path,minZ,maxZ))
f_name, target_f_path, publish_f_path, stat_out_folder, stat_file_path, bound_out_folder, vector_bound_path = getFilePaths(f_path, elev_type, target_path, publish_path) # @UnusedVariable
# target_f_left, target_f_right = os.path.splitext(target_f_path)
# target1_f_path = "{}1{}".format(target_f_left, target_f_right)
publish_f_left, publish_f_right = os.path.splitext(publish_f_path)
publish1_f_path = "{}1{}".format(publish_f_left, publish_f_right)
# Don't maintain fGDB raster format, update to TIFF
# if raster_props[FORMAT] == "FGDBR":
# target_f_path = "{}.TIF".format(target_f_path)
if raster_props[BAND_COUNT] <> 1:
arcpy.AddMessage("Skipping Raster {}, not 1 band image.".format(f_path))
else:
# Intensity may be another type
if not isInt and not (raster_props[PIXEL_TYPE] == PIXEL_TYPE_F32 or raster_props[PIXEL_TYPE] == PIXEL_TYPE_D64):
arcpy.AddMessage("Skipping Raster '{}', '{}' not Float32 type image.".format(f_path, raster_props[PIXEL_TYPE]))
else:
if not (raster_props[FORMAT] == "TIFF" or raster_props[FORMAT] == "GRID" or raster_props[FORMAT] == "IMAGINE Image" or raster_props[FORMAT] == "FGDBR"):
arcpy.AddMessage("Skipping Raster '{}', '{}' not supported image format.".format(f_path, raster_props[FORMAT]))
else:
if arcpy.Exists(target_f_path):
arcpy.AddMessage("\tDerived Raster exists: {}".format(target_f_path))
else:
deleteFileIfExists(target_f_path, True)
arcpy.AddMessage("\tSaving derived raster to {}".format(target_f_path))
# Compression isn't being applied properly so results are uncompressed
rasterObject = arcpy.Raster(f_path)
if isInt:
mean = rasterObject.mean
stdDev = rasterObject.standardDeviation
maximumPixel = mean + (stdDev * 2)
linearTransform = arcpy.sa.TfLinear(maximum=maximumPixel, upperThreshold=maximumPixel)
outRescale = arcpy.sa.RescaleByFunction(rasterObject, linearTransform, minZ, maxZ)
outRescale.save(target_f_path)
del outRescale, rasterObject
else:
outSetNull = arcpy.sa.Con(((rasterObject >= (float(minZ))) & (rasterObject <= (float(maxZ)))), f_path) # @UndefinedVariable
outSetNull.save(target_f_path)
del outSetNull, rasterObject
if spatial_ref is not None:
arcpy.AddMessage("Applying projection to raster '{}' {}".format(target_f_path, spatial_ref))
if str(spatial_ref).lower().endswith(".prj"):
arcpy.AddMessage("loading spatial reference from prj file '{}'".format(spatial_ref))
spatial_ref = arcpy.SpatialReference(spatial_ref)
arcpy.AddMessage("loaded spatial reference from prj file '{}'".format(spatial_ref))
# 3/22/18 - Handle UTF-8 Encoding - 'u\u2013' From MI Delta
try:
arcpy.AddMessage("Applying projection '{}'".format( spatial_ref))
arcpy.AddMessage("Applying string projection '{}'".format( spatial_ref.exportToString()))
arcpy.AddMessage("Applying encoded projection '{}'".format( spatial_ref.exportToString().encode('utf-8')))
except Exception as e:
arcpy.AddMessage('Error: {}'.format(e))
arcpy.DefineProjection_management(in_dataset=target_f_path, coor_system=spatial_ref)
# Set the no data default value on the input raster
arcpy.SetRasterProperties_management(in_raster=target_f_path, data_type="ELEVATION", nodata="1 {}".format(nodata))
arcpy.CalculateStatistics_management(in_raster_dataset=target_f_path, x_skip_factor="1", y_skip_factor="1", ignore_values="", skip_existing="OVERWRITE", area_of_interest="Feature Set")
# arcpy.BuildPyramidsandStatistics_management(in_workspace=target_f_path,
# build_pyramids="BUILD_PYRAMIDS",
# calculate_statistics="CALCULATE_STATISTICS",
# BUILD_ON_SOURCE="BUILD_ON_SOURCE",
# pyramid_level="-1",
# SKIP_FIRST="NONE",
# resample_technique="BILINEAR",
# compression_type="LZ77",
# compression_quality="75",
# skip_existing="SKIP_EXISTING")
# make sure we make a new published copy of this
if arcpy.Exists(publish_f_path):
arcpy.Delete_management(publish_f_path)
a = doTime(a, "\tCopied '{}' to '{}' with valid values between {} and {}".format(f_path, target_f_path, minZ, maxZ))
if arcpy.Exists(publish_f_path):
arcpy.AddMessage("\tPublish Raster exists: {}".format(publish_f_path))
else:
arcpy.AddMessage("\tCopy and clip published raster from {} to {}".format(target_f_path, publish1_f_path))
a = datetime.now()
deleteFileIfExists(publish1_f_path, True)
deleteFileIfExists(publish_f_path, True)
# arcpy.RasterToOtherFormat_conversion(target_f_path, publish_f_path, Raster_Format="TIFF")
arcpy.CopyRaster_management(in_raster=target_f_path, out_rasterdataset=publish1_f_path, config_keyword="", background_value="", nodata_value=nodata, onebit_to_eightbit="NONE", colormap_to_RGB="NONE", pixel_type="32_BIT_FLOAT", scale_pixel_value="NONE", RGB_to_Colormap="NONE", format="TIFF", transform="NONE")
arcpy.AddMessage("\tCliping temp raster {} to {}".format(publish1_f_path, publish_f_path))
arcpy.Clip_management(in_raster=publish1_f_path, out_raster=publish_f_path, in_template_dataset=bound_path, nodata_value=nodata, clipping_geometry="ClippingGeometry", maintain_clipping_extent="NO_MAINTAIN_EXTENT")
deleteFileIfExists(publish1_f_path, True)
arcpy.SetRasterProperties_management(in_raster=publish_f_path, data_type="ELEVATION", nodata="1 {}".format(nodata))
arcpy.CalculateStatistics_management(in_raster_dataset=publish_f_path, x_skip_factor="1", y_skip_factor="1", ignore_values="", skip_existing="OVERWRITE", area_of_interest="Feature Set")
# arcpy.BuildPyramidsandStatistics_management(in_workspace=publish_f_path,
# build_pyramids="BUILD_PYRAMIDS",
# calculate_statistics="CALCULATE_STATISTICS",
# BUILD_ON_SOURCE="BUILD_ON_SOURCE",
# pyramid_level="-1",
# SKIP_FIRST="NONE",
# resample_technique="BILINEAR",
# compression_type="LZ77",
# compression_quality="75",
# skip_existing="SKIP_EXISTING")
a = doTime(a, "\tCopied '{}' to '{}'".format(target_f_path, publish_f_path))
def createVectorBoundaryC(f_path, f_name, raster_props, stat_out_folder, vector_bound_path, minZ, maxZ, bound_path, elev_type):
a = datetime.now()
arcpy.AddMessage("\tCreating {} bound for '{}' using min z '{}' and max z'{}'".format(elev_type, f_path, minZ, maxZ))
vector_1_bound_path = os.path.join(stat_out_folder, "B1_{}.shp".format(f_name))
vector_2_bound_path = os.path.join(stat_out_folder, "B2_{}.shp".format(f_name))
vector_3_bound_path = os.path.join(stat_out_folder, "B3_{}.shp".format(f_name))
vector_4_bound_path = os.path.join(stat_out_folder, "B4_{}.shp".format(f_name))
vector_5_bound_path = os.path.join(stat_out_folder, "B5_{}.shp".format(f_name))
deleteFileIfExists(vector_bound_path, useArcpy=True)
deleteFileIfExists(vector_1_bound_path, useArcpy=True)
deleteFileIfExists(vector_2_bound_path, useArcpy=True)
deleteFileIfExists(vector_3_bound_path, useArcpy=True)
deleteFileIfExists(vector_4_bound_path, useArcpy=True)
deleteFileIfExists(vector_5_bound_path, useArcpy=True)
arcpy.RasterDomain_3d(in_raster=f_path, out_feature_class=vector_5_bound_path, out_geometry_type="POLYGON")
Utility.addToolMessages()
arcpy.MultipartToSinglepart_management(in_features=vector_5_bound_path, out_feature_class=vector_4_bound_path)
Utility.addToolMessages()
checkRecordCount(vector_4_bound_path)
arcpy.EliminatePolygonPart_management(in_features=vector_4_bound_path, out_feature_class=vector_3_bound_path, condition="AREA", part_area="10000 SquareMiles", part_area_percent="0", part_option="CONTAINED_ONLY")
Utility.addToolMessages()
checkRecordCount(vector_3_bound_path)
arcpy.SimplifyPolygon_cartography(
in_features=vector_3_bound_path,
out_feature_class=vector_2_bound_path,
algorithm="POINT_REMOVE",
tolerance="{} Meters".format(C_SIMPLE_DIST),
minimum_area="0 Unknown",
error_option="RESOLVE_ERRORS",
collapsed_point_option="NO_KEEP",
in_barriers=""
)
Utility.addToolMessages()
checkRecordCount(vector_2_bound_path)
arcpy.AddMessage('ZFlag: ' + arcpy.env.outputZFlag)
arcpy.AddMessage('MFlag: ' + arcpy.env.outputMFlag)
arcpy.Dissolve_management(in_features=vector_2_bound_path, out_feature_class=vector_1_bound_path, dissolve_field="", statistics_fields="", multi_part="MULTI_PART", unsplit_lines="DISSOLVE_LINES")
Utility.addToolMessages()
checkRecordCount(vector_1_bound_path)
deleteFields(vector_1_bound_path)
record_count = checkRecordCount(vector_1_bound_path)
footprint_area = 0
for row in arcpy.da.SearchCursor(vector_1_bound_path, ["SHAPE@"]): # @UndefinedVariable
shape = row[0]
footprint_area = shape.getArea ("PRESERVE_SHAPE", "SQUAREMETERS")
if footprint_area <= 0:
arcpy.AddMessage("\tWARNGING: Area is 0 in {} '{}' bound '{}'".format(elev_type, f_path, vector_bound_path))
addField(in_table=vector_1_bound_path, field_name=FIELD_INFO[PATH][0], field_alias=FIELD_INFO[PATH][1], field_type=FIELD_INFO[PATH][2], field_length=FIELD_INFO[PATH][3])
addField(in_table=vector_1_bound_path, field_name=FIELD_INFO[NAME][0], field_alias=FIELD_INFO[NAME][1], field_type=FIELD_INFO[NAME][2], field_length=FIELD_INFO[NAME][3])
addField(in_table=vector_1_bound_path, field_name=FIELD_INFO[AREA][0], field_alias=FIELD_INFO[AREA][1], field_type=FIELD_INFO[AREA][2], field_length=FIELD_INFO[AREA][3])
addField(in_table=vector_1_bound_path, field_name=FIELD_INFO[ELEV_TYPE][0], field_alias=FIELD_INFO[ELEV_TYPE][1], field_type=FIELD_INFO[ELEV_TYPE][2], field_length=FIELD_INFO[ELEV_TYPE][3])
addField(in_table=vector_1_bound_path, field_name=FIELD_INFO[RANGE][0], field_alias=FIELD_INFO[RANGE][1], field_type=FIELD_INFO[RANGE][2], field_length=FIELD_INFO[RANGE][3])
deleteFields(vector_1_bound_path)
arcpy.AddMessage(raster_props)
for field_name in KEY_LIST:
time.sleep(0.25)
field_shpname = FIELD_INFO[field_name][0]
field_alias = FIELD_INFO[field_name][1]
field_type = FIELD_INFO[field_name][2]
field_length = FIELD_INFO[field_name][3]
field_value = raster_props[field_name]
if field_type == "TEXT":
if str(field_value).endswith('\\'):
field_value = str(field_value)[0:-1]
field_value = r'"{}"'.format(field_value)
addField(in_table=vector_1_bound_path, field_name=field_shpname, field_alias=field_alias, field_type=field_type, field_length=field_length, expression=field_value)
b_f_path, b_f_name = os.path.split(f_path)
b_f_name = os.path.splitext(b_f_name)[0]
arcpy.CalculateField_management(in_table=vector_1_bound_path, field=FIELD_INFO[PATH][0], expression='"{}"'.format(b_f_path), expression_type="PYTHON_9.3")
arcpy.CalculateField_management(in_table=vector_1_bound_path, field=FIELD_INFO[NAME][0], expression='"{}"'.format(b_f_name), expression_type="PYTHON_9.3")
arcpy.CalculateField_management(in_table=vector_1_bound_path, field=FIELD_INFO[AREA][0], expression=footprint_area, expression_type="PYTHON_9.3")
arcpy.CalculateField_management(in_table=vector_1_bound_path, field=FIELD_INFO[ELEV_TYPE][0], expression='"{}"'.format(elev_type), expression_type="PYTHON_9.3")
try:
z_expr = "!{}! - !{}!".format(FIELD_INFO[MAX][0], FIELD_INFO[MIN][0])
arcpy.CalculateField_management(in_table=vector_1_bound_path, field=FIELD_INFO[RANGE][0], expression=z_expr, expression_type="PYTHON_9.3")
except:
pass
deleteFileIfExists(vector_bound_path, True)
arcpy.Clip_analysis(in_features=vector_1_bound_path, clip_features=bound_path, out_feature_class=vector_bound_path, cluster_tolerance="")
Utility.addToolMessages()
checkRecordCount(vector_bound_path)
deleteFields(vector_bound_path)
#debug = False
#try:
# debug = (str(f_path).find("alamazoo") >= 0)
#except:
# debug = False
#if not debug:
deleteFileIfExists(vector_1_bound_path, useArcpy=True)
deleteFileIfExists(vector_2_bound_path, useArcpy=True)
deleteFileIfExists(vector_3_bound_path, useArcpy=True)
deleteFileIfExists(vector_4_bound_path, useArcpy=True)
deleteFileIfExists(vector_5_bound_path, useArcpy=True)
#else:
# arcpy.AddMessage("\tleaving artifacts for {} '{}'".format(elev_type, vector_bound_path))
doTime(a, "\tCreated BOUND {}".format(vector_bound_path))
def checkSpatialOnLas(start_dir, target_path, createQARasters, isClassified):
las_spatial_ref = None
prj_spatial_ref = None
las_f_path = getLasFileProcessList(start_dir,
target_path,
createQARasters,
isClassified,
returnFirst=True)
lasd_f_path = "{}d".format(las_f_path)
a = datetime.now()
deleteFileIfExists(lasd_f_path, True)
arcpy.AddMessage(
"{} Testing spatial reference on .las file: '{}' '{}'".format(
datetime.now(), las_f_path, lasd_f_path))
arcpy.CreateLasDataset_management(input=las_f_path,
spatial_reference=None,
out_las_dataset=lasd_f_path,
folder_recursion="NO_RECURSION",
in_surface_constraints="",
compute_stats="COMPUTE_STATS",
relative_paths="RELATIVE_PATHS",
create_las_prj="NO_FILES")
doTime(a, "\t{} Created LASD {}".format(datetime.now(), lasd_f_path))
desc = arcpy.Describe(lasd_f_path)
if desc is not None:
las_spatial_ref = desc.SpatialReference
if las_spatial_ref is not None:
try:
arcpy.AddMessage("\tFound spatial reference in LAS: {}".format(
las_spatial_ref.exportToString()))
except:
pass
prj_Count, prj_File = Utility.fileCounter(start_dir, '.prj')
arcpy.AddMessage("\tFound {} PRJ files, the first is: {}".format(
prj_Count, prj_File))
if prj_Count > 0 and prj_File is not None and len(str(prj_File)) > 0:
prj_Path = os.path.join(start_dir, prj_File)
arcpy.AddMessage(
"\tReading spatial reference from PRJ file: {}".format(prj_Path))
prj_spatial_ref = arcpy.SpatialReference(prj_Path)
arcpy.AddMessage("\tGot from PRJ file spatial reference: {}".format(
prj_spatial_ref.name))
if prj_spatial_ref is not None:
try:
arcpy.AddMessage("\tFound spatial reference in PRJ: {}".format(
prj_spatial_ref.exportToString()))
except:
pass
arcpy.AddMessage("Decoding LAS File Spatial Reference")
las_horz_cs_name, las_horz_cs_unit_name, las_horz_cs_factory_code, las_vert_cs_name, las_vert_cs_unit_name = Utility.getSRValues(
las_spatial_ref)
prj_horz_cs_name, prj_horz_cs_unit_name, prj_horz_cs_factory_code, prj_vert_cs_name, prj_vert_cs_unit_name = None, None, None, None, None
if prj_spatial_ref is not None:
arcpy.AddMessage("Decoding PRJ File Spatial Reference")
prj_horz_cs_name, prj_horz_cs_unit_name, prj_horz_cs_factory_code, prj_vert_cs_name, prj_vert_cs_unit_name = Utility.getSRValues(
prj_spatial_ref)
arcpy.AddMessage(
"LAS File Spatial Reference:\n\tH_Name: '{}'\n\tH_Unit: '{}'\n\tH_WKID: '{}'\n\tV_Name: '{}'\n\tV_Unit: '{}'"
.format(las_horz_cs_name, las_horz_cs_unit_name,
las_horz_cs_factory_code, las_vert_cs_name,
las_vert_cs_unit_name))
arcpy.AddMessage(
"PRJ File Spatial Reference:\n\tH_Name: '{}'\n\tH_Unit: '{}'\n\tH_WKID: '{}'\n\tV_Name: '{}'\n\tV_Unit: '{}'"
.format(prj_horz_cs_name, prj_horz_cs_unit_name,
prj_horz_cs_factory_code, prj_vert_cs_name,
prj_vert_cs_unit_name))
prj_horz_name_isValid = isSrValueValid(prj_horz_cs_name)
prj_vert_name_isValid = isSrValueValid(prj_vert_cs_name)
prj_horz_unit_isValid = isSrValueValid(prj_horz_cs_unit_name)
prj_vert_unit_isValid = isSrValueValid(prj_vert_cs_unit_name)
las_horz_name_isValid = isSrValueValid(las_horz_cs_name)
las_vert_name_isValid = isSrValueValid(las_vert_cs_name)
las_horz_unit_isValid = isSrValueValid(las_horz_cs_unit_name)
las_vert_unit_isValid = isSrValueValid(las_vert_cs_unit_name)
prj_isValid = prj_horz_name_isValid and prj_vert_name_isValid and prj_horz_unit_isValid and prj_vert_unit_isValid
las_isValid = las_horz_name_isValid and las_vert_name_isValid and las_horz_unit_isValid and las_vert_unit_isValid
sr_horz_name_isSame = prj_horz_name_isValid and las_horz_name_isValid and prj_horz_cs_name == las_horz_cs_name
sr_horz_unit_isSame = prj_horz_unit_isValid and las_horz_unit_isValid and prj_horz_cs_unit_name == las_horz_cs_unit_name
sr_vert_name_isSame = prj_vert_name_isValid and las_vert_name_isValid and prj_vert_cs_name == las_vert_cs_name
sr_vert_unit_isSame = prj_vert_unit_isValid and las_vert_unit_isValid and prj_vert_cs_unit_name == las_vert_cs_unit_name
sr_horz_isSame = sr_horz_name_isSame and sr_horz_unit_isSame
sr_vert_isSame = sr_vert_name_isSame and sr_vert_unit_isSame
sr_isSame = sr_horz_isSame and sr_vert_isSame
if prj_isValid or las_isValid:
if sr_horz_isSame:
arcpy.AddMessage(
" The LAS and PRJ horizontal spatial references MATCH".
format(Utility.getSpatialReferenceInfo(prj_spatial_ref)))
else:
arcpy.AddWarning(
"WARNING: The LAS and PRJ horizontal spatial references DO NOT MATCH."
)
if sr_vert_isSame:
arcpy.AddMessage(
" The LAS and PRJ vertical spatial references MATCH".
format(Utility.getSpatialReferenceInfo(prj_spatial_ref)))
else:
arcpy.AddWarning(
"WARNING: The LAS and PRJ vertical spatial references DO NOT MATCH."
)
if sr_isSame:
arcpy.AddMessage(
" The LAS and PRJ spatial references MATCH".format(
Utility.getSpatialReferenceInfo(prj_spatial_ref)))
else:
arcpy.AddWarning(
"WARNING: The LAS and PRJ spatial references DO NOT MATCH.")
result = None
if prj_isValid:
arcpy.AddMessage(
" Found a valid spatial reference in a PRJ file. Using this as the spatial reference: {}"
.format(Utility.getSpatialReferenceInfo(prj_spatial_ref)))
result = os.path.join(start_dir, prj_File)
elif las_isValid:
arcpy.AddMessage(
" Found a valid spatial reference in a LAS file. Using this as the spatial reference: {}"
.format(Utility.getSpatialReferenceInfo(las_spatial_ref)))
result = las_spatial_ref
return result