def __init__(self, path, layer_type=None): """Initialize the class. Required: path - """ try: desc = Describe(path) except IOError as e: raise LayerError(e) workspace, name = os.path.split(desc.catalogPath) dataset = "" workspace_desc = Describe(workspace) if hasattr(workspace_desc, "datasetType") and \ workspace_desc.datasetType == DATASET_TYPECODE: workspace, dataset = os.path.split(workspace) self.workspace = workspace self.dataset = dataset self.name = name if not layer_type: try: layer_type = desc.dataType except AttributeError: raise LayerError("Could not determine layer type.") self.type = layer_type print name, layer_type
def get_images_and_stats(in_mosaic): images = get_image_paths(in_mosaic) s_list = [] if isinstance(images, str): # If input is single image set as list images = [images] # Obtain Extent Coords of each image for i in images: if i.lower().endswith('.jpg'): desc = Describe(i + "/Band_1") s_list.append([ i, desc.extent.XMin, desc.extent.XMax, desc.extent.YMin, desc.extent.YMax, desc.height, desc.width ]) else: if ".Overviews" not in i: desc = Describe(i) from arcpy import RasterToNumPyArray arr = RasterToNumPyArray(i + "/Blue", nodata_to_value=0) height, width = arr.shape s_list.append([ i, desc.extent.XMin, desc.extent.XMax, desc.extent.YMin, desc.extent.YMax, height, width ]) del arr # Determine Maximum and Minimum coord values from list # -- Note: The extent values from the mosaic differ from the actual tiles... esri bug on mosaics probably. XMin = min(s_list, key=lambda x: x[1])[1] XMax = max(s_list, key=lambda x: x[2])[2] YMin = min(s_list, key=lambda x: x[3])[3] YMax = max(s_list, key=lambda x: x[4])[4] extent = [XMin, XMax, YMin, YMax] # Detect of each image within the mosaic dataset c = 0 for i in s_list: iXMin = i[1] iXMax = i[2] iYMin = i[3] iYMax = i[4] # Check for Corners if XMin == iXMin and YMin == iYMin: s_list[c].append("bl") elif XMin == iXMin and YMax == iYMax: s_list[c].append("tl") elif XMax == iXMax and YMax == iYMax: s_list[c].append("tr") elif XMax == iXMax and YMin == iYMin: s_list[c].append("br") # Check for Edges elif XMin == iXMin: s_list[c].append("l") elif YMax == iYMax: s_list[c].append("t") elif XMax == iXMax: s_list[c].append("r") elif YMin == iYMin: s_list[c].append("b") else: s_list[c].append("i") c += 1 return s_list, extent
def calculatePointElevationField(points, raster, field_name): #monitor progress by counting features view = MakeTableView_management(points, 'points') count = int(GetCount_management('points').getOutput(0)) SetProgressor('step', 'Extracting point elevations', 0, count) AddMessage('{} features to process'.format(count)) # Get the object id field oid = Describe(points).OIDFieldName # make an update cursor and update each row's elevation field cursor = UpdateCursor(points, [field_name, 'SHAPE@', oid]) # make a temporary dict to store our elevation values we extract elevations = {} for row in cursor: row[0] = getElevationAtPoint(raster, row[1]) cursor.updateRow(row) AddMessage('row updated to {}; oid: {}'.format(row[0], row[2])) SetProgressorPosition() # release the data del cursor #reset this progressor ResetProgressor()
def select_edges_from_network(network, edges, directory, name): """ Selects the edges in the given |network| path whose edge ids are in the given |edges| set, and saves a shapefile of the selected edges at the given location. Also saves a symbolized layer of the shapefile. Returns a mapping from the ids in the created file to ids in the original edges file, as recorded in the |edges| set. Also returns the path to the created shape file. """ network_edges = getEdgePathFromNetwork(network) id_name = ("FID" if Describe(network_edges).extension == "shp" else "OBJECTID") query = ' OR '.join( ['"%s" = %d' % (id_name, edge_id) for edge_id in edges]) selected_edges = "%s.shp" % join(directory, name) Select_analysis(network_edges, selected_edges, query) edges_layer = "%s.lyr" % join(directory, name) MakeFeatureLayer_management(in_features=selected_edges, out_layer=name) SaveToLayerFile_management(name, edges_layer, "ABSOLUTE") ApplySymbologyFromLayer_management( edges_layer, join(path[0], "Symbology_Layers\sample_edges_symbology.lyr")) add_layer_to_display(edges_layer) # TODO(mikemeko): this is a bit hacky, relies on the fact that ids appear in # sorted order in tables, and that ids for shape files start from 0 id_mapping = dict(zip(range(len(edges)), sorted(edges))) return id_mapping, selected_edges
def restrictDomain(self, object, operation): """ Restricts current instance's domain based on object's domain @param object: extent to which the field is restricted @param operation: valid options: "inside", "outside" """ if operation == 'inside': name = "restDom_in_" + str(self.sObj) outputLocation = "in_memory\\" + name + ".tif" # extract by mask outRaster = ExtractByMask(self.filepath, object.filepath) CopyRaster_management(outRaster, outputLocation) restDom = utils.makeField(outputLocation) elif operation == 'outside': raise NotImplementedError("restrictDomain 'outside'") else: raise NotImplementedError(operation) # update cc instance's attributes desc = Describe(outputLocation) restDom.filepath = outputLocation restDom.domain = desc.extent restDom.filename = os.path.basename(outputLocation) return restDom
def determine_domain(filepath): """ :param filepath: data source filepath :return: ArcPy domain extent """ desc = Describe(filepath) return desc.extent
def buffer(self, distance, unitType): """ Buffer input object @param distance: buffer distance @param unitType: unit type """ # determine temporary unique file distName = str(distance) distName2 = distName.replace(".", "_") print("distName2", distName2) name = "buf_" + str(self.sObj) + distName2 outputLocation = "in_memory\\" + name # calculate buffer concatDistance = str(distance) + " " + unitType Buffer_analysis(self.filepath, outputLocation, concatDistance) bufObj = utils.makeObject(outputLocation) # update cc instance's attributes desc = Describe(outputLocation) bufObj.domain = desc.extent bufObj.filepath = outputLocation bufObj.filename = os.path.basename(outputLocation) return bufObj
def preparingSourceCountyData(): print("Starting the preparingSourceCountyData function!") if Exists(preRouteSourceCRML): try: Delete_management(preRouteSourceCRML) except: print("Could not delete the features located at: " + str(preRouteSourceCRML) + ".") else: pass # Make a copy CopyFeatures_management(routesSourceCountyLRSArnold, preRouteSourceCRML) # Remove unnecessary fields preRouteSourceCRMLDescription = Describe(preRouteSourceCRML) preRouteSourceCRMLOIDFieldName = preRouteSourceCRMLDescription.OIDFieldName preRouteSourceCRMLShapeFieldName = preRouteSourceCRMLDescription.shapeFieldName preRouteSourceCRMLShapeAndOIDFieldNames = [ preRouteSourceCRMLOIDFieldName, preRouteSourceCRMLShapeFieldName ] preRouteSourceCRMLFieldObjectsList = ListFields(preRouteSourceCRML) preRouteSourceFieldNames = [ x.name for x in preRouteSourceCRMLFieldObjectsList ] fieldNamesToKeep = [ y for y in preRouteSourceFieldNames if y in preRouteSourceCRMLFields or y in preRouteSourceCRMLShapeAndOIDFieldNames ] fieldNamesToRemove = [ z for z in preRouteSourceFieldNames if z not in fieldNamesToKeep ] for fieldNameItem in fieldNamesToRemove: DeleteField_management(preRouteSourceCRML, fieldNameItem) print("Done deleting unnecessary fields.") MakeFeatureLayer_management(preRouteSourceCRML, fcAsFeatureLayerLG) selectionQueryL1 = """ SourceRouteId IS NULL OR LRS_ROUTE_PREFIX IN ('I', 'U', 'K') """ SelectLayerByAttribute(fcAsFeatureLayerLG, NEW_SELECTION_CONST, selectionQueryL1) CopyFeatures_management(fcAsFeatureLayerLG, stateRoutesAndNullRouteIDs) DeleteRows_management(fcAsFeatureLayerLG) selectionQueryL2 = """ SourceFromMeasure IS NULL OR SourceToMeasure IS NULL """ SelectLayerByAttribute(fcAsFeatureLayerLG, NEW_SELECTION_CONST, selectionQueryL2) CopyFeatures_management(fcAsFeatureLayerLG, preRouteSourceNoMeasures) selectionQueryL3 = """ SourceFromMeasure IS NULL """ SelectLayerByAttribute(fcAsFeatureLayerLG, NEW_SELECTION_CONST, selectionQueryL3) CalculateField_management(fcAsFeatureLayerLG, "SourceFromMeasure", "0", PYTHON_9_3_CONST) selectionQueryL4 = """ SourceToMeasure IS NULL """ SelectLayerByAttribute(fcAsFeatureLayerLG, NEW_SELECTION_CONST, selectionQueryL4) CalculateField_management(fcAsFeatureLayerLG, "SourceToMeasure", "!SHAPE.LENGTH@MILES!", PYTHON_9_3_CONST)
def ReturnStreetstoTopology(): from arcpy import (AddFeatureClassToTopology_management, ListDatasets, AddRuleToTopology_management, Delete_management, Describe) env.workspace = currentPathSettings.gdbPath fd = ListDatasets("*", "Feature") gdbw = os.path.join(currentPathSettings.gdbPath, fd[0]) env.workspace = gdbw topoDatasetList = ListDatasets("*", "TOPOLOGY") geonetDatasetList = ListDatasets("*", "GeometricNetwork") authbnd = os.path.join(gdbw, "AuthoritativeBoundary") ESZBnd = os.path.join(gdbw, "ESZ") if geonetDatasetList == []: print "no geometric network created yet" else: Delete_management(geonetDatasetList[0]) desc = Describe(topoDatasetList[0]) print "%-27s %s" % ("FeatureClassNames:", desc.featureClassNames) if lyr in desc.featureClassNames: print "Road Centerlines already exist in topology dataset" else: print "adding road centerlines to topology" inputTopology = os.path.join(gdbw, topoDatasetList[0]) inputRoadCenterline = os.path.join(gdbw, "RoadCenterline") AddFeatureClassToTopology_management(inputTopology, inputRoadCenterline, "1", "1") AddRuleToTopology_management(inputTopology, "Must Not Overlap (line)", inputRoadCenterline, "", "", "") AddRuleToTopology_management(inputTopology, "Must Not Intersect (line)", inputRoadCenterline, "", "", "") AddRuleToTopology_management(inputTopology, "Must Not Have Dangles (Line)", inputRoadCenterline, "", "", "") AddRuleToTopology_management(inputTopology, "Must Not Self-Overlap (Line)", inputRoadCenterline, "", "", "") AddRuleToTopology_management(inputTopology, "Must Not Self-Intersect (Line)", inputRoadCenterline, "", "", "") AddRuleToTopology_management(inputTopology, "Must Be Single Part (Line)", inputRoadCenterline, "", "", "") AddRuleToTopology_management( inputTopology, "Must Not Intersect Or Touch Interior (Line)", inputRoadCenterline, "", "", "") AddRuleToTopology_management( inputTopology, "Must Not Intersect Or Touch Interior (Line)", inputRoadCenterline, "", "", "") AddRuleToTopology_management(inputTopology, "Must Be Inside (Line-Area)", inputRoadCenterline, "", authbnd, "") #write for loop - must be inside ESZ boundaries AddRuleToTopology_management( inputTopology, "Boundary Must Be Covered By (Area-Line)", authbnd, "", inputRoadCenterline, "") AddRuleToTopology_management( inputTopology, "Boundary Must Be Covered By (Area-Line)", ESZBnd, "", inputRoadCenterline, "")
def network_cost_attributes(network): """ Returns a set of the cost attributes for the given |network|. """ return set([ attribute.name for attribute in Describe(network).attributes if attribute.usageType == "Cost" ])
def __get_domain_codes(self, domain_name): env.workspace = self.in_db db_described = Describe(self.in_db) if domain_name in db_described.domains: domain_table = DomainToTable_management(self.in_db, domain_name, r"in_memory\domain", "code", "desc") return domain_table else: return False
def get_describe(self): """Returns a describe object if the table exists, otherwise returns None. Gets around an OSError if the table is corrupted.""" try: desc = Describe(self.full_path) return desc except OSError: return None
def __init__(self, tuple_path): self.tuple_path = tuple_path self.full_path = path.join(*self.tuple_path) self.connection = tuple_path[0] self._desc = self.get_describe() self.database = Describe(self.connection).connectionProperties.instance.split(":")[-1].upper() self.dataset = self.tuple_path[1] if len(self.tuple_path) == 3 else None self.owner, self.name = self.tuple_path[-1].split(".") self.unique_name = ".".join([self.database, self.owner, self.name]).upper()
def subset_image(in_raster, area, out_raster): from arcpy import Describe from math import sqrt desc = Describe(in_raster) XMin = desc.extent.XMin YMin = desc.extent.YMin len = sqrt(area) clipping_extent = '{0} {1} {2} {3}'.format(XMin, YMin, XMin+len, YMin+len) ClipRaster(in_raster, clipping_extent, out_raster, "#", "#", "NONE")
def getEdgePathFromNetwork(NETWORK_FILE_PATH): desc = Describe(NETWORK_FILE_PATH) assert desc.dataType in ("NetworkDataset", "NetworkDatasetLayer") assert len(desc.edgeSources) > 0 featureClassPath = join(desc.path, desc.edgeSources[0].name) if len(desc.extension) > 0: # it is file featureClassPath = featureClassPath + ".shp" return featureClassPath
def addProperty(self, in_raster): """ get value of a field and write it to a column named RASTERVALU in the object @param in_raster: raster where the value is taken from """ desc = Describe(self.filepath) name = "addProperty" + str(self.sObj) outputLocation = "in_memory\\" + name if desc.shapeType == "Point": ExtractValuesToPoints(self.filepath, in_raster.filepath, outputLocation) addProperty = utils.makeObject(outputLocation) elif desc.shapeType == "Line": raise NotImplementedError(desc.shapeType) elif desc.shapeType == "Polygon": polyToPoint = "in_memory\\polyToPoint_" + str(self.sObj) FeatureToPoint_management(self.filepath, polyToPoint, "CENTROID") valueToPoint = "in_memory\\valueToPoint_" + str(self.sObj) ExtractValuesToPoints(polyToPoint, in_raster.filepath, valueToPoint) CopyFeatures_management(self.filepath, outputLocation) JoinField_management(outputLocation, "FID", valueToPoint, "FID", "RASTERVALU") addProperty = utils.makeObject(outputLocation) Delete_management(polyToPoint) Delete_management(valueToPoint) #TODO implement method that the parameters "CENTROID" or "INSIDE" for FeatureToPoint_management() can be selected else: raise NotImplementedError("unknown shapeType:", desc.shapeType) # update cc instance's attributes desc = Describe(outputLocation) addProperty.domain = desc.extent addProperty.filepath = outputLocation addProperty.filename = os.path.basename(outputLocation) return addProperty
def __init__(self, helper, iter_layer='Industrial Development Sites', expand_extent=25): from arcpy.da import SearchCursor from arcpy import Describe layer = helper.map.map.listLayers(iter_layer)[0] fields = ['SHAPE@'] + [f.name for f in Describe(layer).fields] self.helper = helper self.cursor = SearchCursor(layer, fields) self.expand_extent = expand_extent
def validate_geodatabase(path): """ """ try: desc = Describe(path) assert desc.DataType == 'Workspace' assert desc.workspacetype == 'LocalDatabase' except IOError as e: raise GeodatabaseError(e) except AssertionError: raise GeodatabaseError( "{} is not a valid geodatabase.".format(path))
def getElevationAtPoint(raster, point): """ retrieves the elevation at a point """ # project the point sr = Describe(raster).spatialReference projected_point = point.projectAs(sr).getPart(0) # Get the first cell that starts at the point result = RasterToNumPyArray(raster, projected_point, 1, 1, -999) return result[0][0]
def polygon_to_point(input_fc, output_fc): """ copies the centroid of polygon geometry to a point feature class """ oid_field = Describe(input_fc).OIDFieldName new_field = 'Rel_OID' AddField_management(output_fc, new_field, 'Long') search_cursor = SearchCursor(input_fc, ['SHAPE@', oid_field]) insert_cursor = InsertCursor(output_fc, ["SHAPE@", new_field]) spatial_reference = Describe(output_fc).spatialReference for row in search_cursor: point = row[0].projectAs(spatial_reference).centroid oid = row[1] insert_cursor.insertRow([point, oid]) del search_cursor, insert_cursor, spatial_reference
def line_to_endpoints(input_fc, output_fc, id_field=None): """ copies the endpoints of a feature class into a point feature class """ # id field can either be provided or obtained automagically oid_field = id_field if id_field else Describe(input_fc).OIDFieldName # we add two custom fields to track the related id and the type of end point related_field = 'related_oid' type_field = 'point_type' AddField_management(output_fc, related_field, 'LONG') AddField_management(output_fc, type_field, 'TEXT', field_length=10) fields = [f.name for f in Describe(input_fc).fields if f.name not in ['SHAPE@', 'Shape', 'Shape_Length']] output_fields = fields + ['SHAPE@', related_field, type_field] #shape will be the last column selected search_cursor = SearchCursor(input_fc, fields + ['SHAPE@']) #our insert cursor insert_cursor = InsertCursor(output_fc, output_fields) #identify the spatial reference for projecting the geometry spatial_reference = Describe(output_fc).spatialReference for row in search_cursor: # project and store the geometry geom = row[len(row) - 1].projectAs(spatial_reference) # get the row id oid = row[fields.index(oid_field)] # insert two entries but with our new custom geometry insert_cursor.insertRow(row[:-1] + (geom.firstPoint, oid, 'START')) insert_cursor.insertRow(row[:-1] + (geom.lastPoint, oid, 'END')) del search_cursor, insert_cursor, spatial_reference
def KDOTKeyCalculation_Modified(): # Until the KDOT process is included here, # this defaults to the Transcend process. #FieldPopulation with selections and FieldCalculate: MakeFeatureLayer_management(routesSourceCenterlines, featureLayer) tempDesc = Describe(featureLayer) print("Calculating values for new LRS and measure fields in " + returnFeatureClass(tempDesc.catalogPath) + ".") try: del tempDesc except: pass # Select LRS_ROUTE_PREFIX IN ('I', 'U', 'K') selectionQuery = """ "LRS_ROUTE_PREFIX" IN ('I', 'U', 'K') """ SelectLayerByAttribute_management(featureLayer, "NEW_SELECTION", selectionQuery) # SourceRouteId = StateKey1 CalculateField_management(featureLayer, "SourceRouteId", "!StateKey1!", "PYTHON_9.3") # SourceFromMeasure = STATE_BEGIN_MP CalculateField_management(featureLayer, "SourceFromMeasure", "!STATE_BEGIN_MP!", "PYTHON_9.3") # SourceToMeasure = STATE_END_MP CalculateField_management(featureLayer, "SourceToMeasure", "!STATE_END_MP!", "PYTHON_9.3") # Select LRS_ROUTE_PREFIX NOT IN ('I', 'U', 'K') AND LRSKEY IS NOT NULL selectionQuery = """ "LRS_ROUTE_PREFIX" NOT IN ('I', 'U', 'K') AND "LRSKEY" IS NOT NULL """ SelectLayerByAttribute_management(featureLayer, "NEW_SELECTION", selectionQuery) # SourceRouteId = LRSKEY CalculateField_management(featureLayer, "SourceRouteId", "!LRSKEY!", "PYTHON_9.3") # SourceFromMeasure = NON_STATE_BEGIN_MP CalculateField_management(featureLayer, "SourceFromMeasure", "!NON_STATE_BEGIN_MP!", "PYTHON_9.3") # SourceToMeasure = NON_STATE_END_MP CalculateField_management(featureLayer, "SourceToMeasure", "!NON_STATE_END_MP!", "PYTHON_9.3") # Select LRS_ROUTE_PREFIX IN ('C') AND LRSKEY NOT LIKE '%W0' selectionQuery = """ "LRS_ROUTE_PREFIX" IN ('C') AND "LRSKEY" NOT LIKE '%W0' """ SelectLayerByAttribute_management(featureLayer, "NEW_SELECTION", selectionQuery) # SourceRouteID = left([LRSKEY], 11) & "W0" # This is the VB version. # Python version would be calcExpression1 = "!LRSKEY![0:11] + 'W0'" calcExpression1 = 'Left([LRSKEY] ,11 ) & "W0"' CalculateField_management(featureLayer, "SourceRouteID", calcExpression1, "VB")
def MergeCatchment(self, inbasin): dstemp = None try: catchments = Config()["catchment"] env.workspace = self._TempLocation resultworkspace = os.path.join(self._WorkspaceDirectory, self.WorkspaceID + '.gdb', "Layers") downstreamcatchment = os.path.join(resultworkspace, catchments["downstream"]) dsDesc = Describe(downstreamcatchment) if not Exists(downstreamcatchment): raise Exception("downstream catchment doesn't exist") sr = dsDesc.spatialReference wrkingbasin = self.ProjectFeature(inbasin, sr) #strip downstream catchment from mask dstemp = Erase_analysis(wrkingbasin, downstreamcatchment, "dstemp") #remove any weird verticies associated with Erase globalbasin = os.path.join(resultworkspace, catchments["global"]) FeatureToPolygon_management(dstemp, globalbasin, cluster_tolerance="50 Meters", attributes="ATTRIBUTES", label_features="") #Delete multipolys created by Featuretopolygon maxOid = max({ key: value for (key, value) in arcpy.da.SearchCursor( globalbasin, ['OID@', 'Shape_Area']) }.iteritems(), key=operator.itemgetter(1))[0] with arcpy.da.UpdateCursor(globalbasin, 'OID@') as cursor: for row in cursor: if row[0] != maxOid: cursor.deleteRow() #https://gis.stackexchange.com/questions/152481/how-to-delete-selected-rows-using-arcpy if not Exists(globalbasin): raise Exception("Failed to create basin " + GetMessages()) return True except: tb = traceback.format_exc() self._sm("Merge basin Error " + tb, "ERROR") return False finally: #cleanup for fs in arcpy.ListFeatureClasses(): arcpy.Delete_management(fs) for rs in arcpy.ListRasters(): arcpy.Delete_management(rs)
def list_transformations(self, in_mosaic_dataset, in_spatial_reference, to_spatial_reference): desc_mosaic = Describe(in_mosaic_dataset) xmin = desc_mosaic.extent.XMin xmax = desc_mosaic.extent.XMax ymin = desc_mosaic.extent.YMin ymax = desc_mosaic.extent.YMax extent = Extent(xmin, xmax, ymin, ymax) # in_sr = Describe(in_mosaic_dataset).spatialReference in_sr = in_spatial_reference out_sr = to_spatial_reference # out_sr = arcpy.SpatialReference(to_spatial_reference) # out_sr = arcpy.SpatialReference() # out_sr = out_sr.loadFromString(to_spatial_reference) return ListTransformations(in_sr, out_sr, extent)
def raster_extent_polygon(in_raster): from arcpy import Array, Point, Polygon, Describe desc = Describe(in_raster) XMin = desc.extent.XMin XMax = desc.extent.XMax YMin = desc.extent.YMin YMax = desc.extent.YMax # Create a polygon geometry array = Array([ Point(XMin, YMin), Point(XMin, YMax), Point(XMax, YMax), Point(XMax, YMin) ]) return Polygon(array)
def process(): # Detect Unit of Measurement (Feet -vs- Meter) cell_factor = getCellFactor(in_mosaic_dataset) # Obatin List of Raster Files in Mosaic Dataset temp_table = join("memory", "temp_table") ExportMosaicDatasetPaths(in_mosaic_dataset, temp_table, "#", "ALL", "RASTER") rasters = set(row[0] for row in da.SearchCursor(temp_table, "Path")) Delete(temp_table) if not exists(out_directory): makedirs(out_directory) # Process each raster for in_raster in rasters: root_dir, file = split(in_raster) AddMessage("da filename is: {}".format(file)) out_raster = join(out_directory, file) desc = Describe(in_raster) cell_size_height = desc.children[0].meanCellHeight # Cell size in the Y axis and / or cell_size_width = desc.children[0].meanCellWidth # Cell size in the X axis cell_size = "{0} {1}".format(cell_size_height*cell_factor, cell_size_width*cell_factor) if unitsCalc(in_mosaic_dataset) == "Foot": outTimes = Times(in_raster, 0.3048) ProjectRaster(in_raster=outTimes, out_raster=out_raster, out_coor_system=out_spatial_reference, resampling_type=resampling_type, cell_size=cell_size, geographic_transform=geographic_transform, in_coor_system=input_spatial_reference) else: ProjectRaster(in_raster=in_raster, out_raster=out_raster, out_coor_system=out_spatial_reference, resampling_type=resampling_type, cell_size=cell_size, geographic_transform=geographic_transform, in_coor_system=input_spatial_reference) # Delete Intermediate Data del rasters if out_mosaic_dataset: root_dir, file = split(out_mosaic_dataset) # TODO: Automatically detect Pixel Type from input Mosaic Dataset Rasters and pass below createMosaics(root_dir, file, out_directory, out_spatial_reference, "32_BIT_UNSIGNED")
def writeAggregateTableToKanDrive(): try: #truncating CDRS segments in KanDrive Spatial print str(datetime.datetime.now()) + " truncating RCRS segments in KanDrive Spatial." TruncateTable_management(kanDriveSpatialConditions) featuresToTransfer = list() # searchCursorFields go to r"in_memory\RCRS". (Input table)(Indirect) descObject = Describe(r"in_memory\RCRS") searchCursorFields = [field.name for field in descObject.fields if field.name != descObject.OIDFieldName and field.name != "Shape" and field.name != "ID1"] searchCursorFields.append('SHAPE@') RCRS_SearchCursor = daSearchCursor(aggregateTable, searchCursorFields) for RCRS_CursorItem in RCRS_SearchCursor: featureItem = list(RCRS_CursorItem) featuresToTransfer.append(featureItem) # Make the insertCursor use the same fields as the searchCursor. insertCursorFields = searchCursorFields RCRS_InsertCursor = daInsertCursor(kanDriveSpatialConditions, insertCursorFields) for RCRS_Feature in featuresToTransfer: insertOID = RCRS_InsertCursor.insertRow(RCRS_Feature) print "Inserted a row with the OID of: " + str(insertOID) except: print "An error occurred." errorItem = sys.exc_info()[1] errorStatement = str(errorItem.args[0]) print errorStatement if len(errorStatement) > 253: errorStatement = errorStatement[0:253] else: pass endTime = datetime.datetime.now() ScriptStatusLogging('KanDrive_Spatial_Conditions_Update', 'kandrive_spatial.DBO.Conditions', scriptFailure, startTime, endTime, errorItem.args[0], pythonLogTable) try: del errorItem except: pass
def updateParameters(self): # Modify parameter values and properties. # This gets called each time a parameter is modified, before # standard validation. if self.params[0].value: self.params[1].enabled = True self.params[1].value = Describe(self.params[0]).spatialReference if self.params[1].value: self.params[2].enabled = True if self.params[2].value: self.params[3].enabled = True transformations = self.list_transformations( self.params[0].value, self.params[1].value, self.params[2].value) # self.params[3].value = transformations[0] self.params[3].filter.list = transformations return
def PathReSet(): #use the path from the NG911 config file to create address locators and perform operations that output to the NG911 geodatabase environment try: from NG911_Config import gdb except: gdb = r'\\gisdata\arcgis\GISdata\DASC\NG911\Final\Region1_BA_Final.gdb' from arcpy import env, Describe env.overwriteOutput = 1 print gdb OriginalGDB = gdb gdbdesc = Describe(OriginalGDB) gdbpath = gdbdesc.Path gdbbasename = gdbdesc.Basename gdbexts = gdbdesc.Extension del gdb gdb = gdbpath + "/" + gdbbasename + "_RoadChecks." + gdbexts return gdb
def SetProjection(): env.workspace = OracleDB fclist = ListFeatureClasses() for fc in fclist: if str(fc)[-2:] == 'MV': print "no actions taken on a Materialized View" pass else: spatial_ref = Describe(fc).spatialReference # If the spatial reference is unknown if spatial_ref.name == "Unknown": print("{0} has an unknown spatial reference".format(fc)) DefineProjection_management(OracleDB + "/" + fc, coor_system) # Otherwise, print out the feature class name and # spatial reference else: print("{0} : {1}".format(fc, spatial_ref.name))
def buildNonstateRoutes(systemToRoute, routedSystemExport): print "Building NonstateRoutes..." inMemoryNonStateSystem = r'in_memory\nonStateSystem' inMemoryNonStateSystemLyr = "featureClassAsALayer" # Semi-ugly notation to get the all but the last item from the split output. gdb = os.path.split(routedSystemExport)[:-1][0] print gdb env.workspace = gdb env.outputMFlag = "Enabled" spatialReferenceToUse = Describe(systemToRoute).spatialReference spatialReferenceToUse.setMDomain(0, 500) spatialReferenceToUse.MTolerance = 0.001 spatialReferenceToUse.MResolution = 0.001 env.outputCoordinateSystem = spatialReferenceToUse try: Delete_management("in_memory") except: print "Can't delete in_memory" mainWhereClause = "FUNCLASS in (4,5,6,7) AND MILEAGE_COUNTED = -1 AND LENGTH <> 0 AND PROPOSED <> SOMETHING" loadedNonStateSystem = "loadedNonStateSystem" # Loads the systemToRoute as loadedNonStateSystem MakeFeatureLayer_management(systemToRoute, loadedNonStateSystem, mainWhereClause) debugFeatureCount = GetCount_management(loadedNonStateSystem) print "Total loaded rows = " + str(debugFeatureCount) CopyFeatures_management(loadedNonStateSystem, inMemoryNonStateSystem) del loadedNonStateSystem debugFeatureCount = GetCount_management(inMemoryNonStateSystem) print "Total copied rows = " + str(debugFeatureCount) MakeFeatureLayer_management(inMemoryNonStateSystem, inMemoryNonStateSystemLyr) # Needed to use select by attribute. lrsBackwardsWhereClause = "LRS_BACKWARDS = -1" SelectLayerByAttribute_management(inMemoryNonStateSystemLyr, "NEW_SELECTION", lrsBackwardsWhereClause) debugFeatureCount = GetCount_management(inMemoryNonStateSystemLyr) print "LRS backwards rows = " + str(debugFeatureCount) # Reverse line direction for selected lines # Used on the loaded (to memory) version of the non state system because it modifies the # feature class (not the layer, but the feature class it references) in place without output. FlipLine_edit(inMemoryNonStateSystemLyr) SelectLayerByAttribute_management(inMemoryNonStateSystemLyr, "CLEAR_SELECTION") debugFeatureCount = GetCount_management(inMemoryNonStateSystemLyr) print "Total (non)selected rows = " + str(debugFeatureCount) routeIDField = "LRS_KEY" measureSource = "TWO_FIELDS" beginField = "LRS_BEG_CNTY_LOGMILE" endField = "LRS_END_CNTY_LOGMILE" CreateRoutes_lr(inMemoryNonStateSystemLyr, routeIDField, routedSystemExport, measureSource, beginField, endField) debugFeatureCount = GetCount_management(routedSystemExport) print "Total routes written = " + str(debugFeatureCount) # Delete the loaded in_memory layer. del inMemoryNonStateSystemLyr # Delete the in_memory feature class. try: Delete_management(inMemoryNonStateSystem) except: print "Can't delete in_memory\nonStateSystem" # Delete the variable that referenced the path to the in_memory\nonStateSystem feature class. del inMemoryNonStateSystem