Arcgeo
From DreamsteepWiki
Here is a (mostly) working collection of python to process geometry MY WAY using ESRI
#################################
"""
import sys_arclink_geometry
#TL= sys_arclink_geometry.TYPELESS()
#TL.set_query_obj('C:/test.shp')
#TL.list_query_objects()
#TL.list_all_folder('C:/keith')
#TL.do_query()
####################################
################################################
#THE "GATHERER "
GATH= sys_arclink_geometry.GIS_GATHER()
#GATH.walkFoldersGetFilenames('C:/data','shp','C:/eatmee.txt')
############
############
GATH.scan_all_known('C:/data')
GATH.show_all_data_found()
############
#GATH.getinfo_ESRI( GATH.sorted_rasters[0])
GATH.getinfo_feature( GATH.sorted_vectors[0])
GATH.getinfo_raster( GATH.sorted_rasters[0])
############
#ATTR INFO
#GATH.getinfo_attrs( GATH.sorted_vectors[0])
############
############
"""
#### ### ### ### #### ### ### ### #### ### ### ### #### ### ### ###
#### ### ### ### #### ### ### ### #### ### ### ### #### ### ### ###
import win32com.client, sys, os, math
import os
##
import sys_file_io
import sys_arclink_ATTRS
import sys_sp_treat
#### ### ### ### #### ### ### ### #### ### ### ### #### ### ### ###
#### ### ### ### #### ### ### ### #### ### ### ### #### ### ### ###
try:
#import relevant modules, create geoprocessing dispatch object
import win32com.client
gp = win32com.client.Dispatch("esriGeoprocessing.gpDispatch.1")
except:
print 'WARN NO ESRI SUPPORT FROM CURRENT SHELL '
def AddPrintMessage(msg, severity):
print msg
if severity == 0: gp.AddMessage(msg)
elif severity == 1: gp.AddWarning(msg)
elif severity == 2: gp.AddError(msg)
#### ### ### ### #### ### ### ### #### ### ### ### #### ### ### ###
#### ### ### ### #### ### ### ### #### ### ### ### #### ### ### ###
"""
##############
EXAMPLE USAGE:
##############
###
import sys_arclink_geometry
TL = sys_arclink_geometry.TYPELESS()
TL.set_base_fr_data('C:/foo.tiff')
###
###
## BUILD A BBOX AROUND AN EXTENT
## [ xmin,ymin , xmax,ymax]
XTNTS= TL.getinfo_extents('C:/crap1.shp')
TL.gen_box_xtnts(XTNTS,'C:/data','beetbeets')
TL.set_projection ( 'C:/data/beetbeets.shp','C:/base.prj' )
###########
###
#GEOMETRY
import sys_arclink_geometry
######
#USING TEXT POINTS
TYPLESS =sys_arclink_geometry.TYPELESS()
ARRAY = TYPLESS.load_feature_points('C:/spring_crp_1.shp')
if len(ARRAY)>1:
print 'is multipart ..'
for ietm in ARRAY[1]:
print ietm
else:
print ARRAY
##
#GET THE FIRST VERTEX OF EACH FEATURE ##
ARRAY = TL.load_feature_points('C:/beetbeets.shp')
lenar=len(ARRAY)
if lenar>1:
print 'is multipart .. '+str(lenar)
for ietm in ARRAY:
print ietm[1]
else:
print ARRAY
TYPLESS.report_multipart_point_buffer_size()
####################################################
import sys_arclink_geometry
TYPLESS =sys_arclink_geometry.TYPELESS()
ARRAY = TYPLESS.load_feature_points('C:/tigernoty.shp')
TYPLESS.point_array_to_poly(ARRAY[1],'C:/','fuckheed.shp')
#################################
#CHECK IF FEATURES IN A SHAPE ARE CLOSED
##
ARRAY = TL.load_feature_points('C:/tigernoty.shp')
##
count = 0
for poly in ARRAY:
if TL.check_if_closed(poly) :
print str(count)+' IS CLOSED '
count=count+1
###
"""
#### ### ### ### #### ### ### ### #### ### ### ### #### ### ### ###
#### ### ### ### #### ### ### ### #### ### ### ### #### ### ### ###
"""
## typeless GIS data interaction ##
##
ARRAY = TL.load_feature_points('C:/bonkers.shp')
##
#TL.point_array_to_polyline(ARRAY[2],'C:/','allfuck.shp')
#TL.point_array_to_poly(ARRAY[0],'C:/','fuckall.shp')
#TL.point_array_to_points(ARRAY[2],'fuckalltree.shp')
"""
class TYPELESS:
def __init__(self):
self.prj_file = ''
self.units = 'meter' #meter foot arcdegree , etc
self.ORIGIN = []
####################
self.geodatabase = ''
self.USE_PROJECTION = 1
####################
self.SP_INFO = sys_sp_treat.GET_INFO()
self.ATTRED = sys_arclink_ATTRS.ESRI_ATTR_EDIT()
####################
self.MULTIPART_PNT_BUFFER = []
#####################
#####################
def getinfo_datatype(self,dataset):
return self.SP_INFO.getDataClassType(dataset)
############
def getinfo_featuretype(self,dataset):
OUT= self.SP_INFO.getSHPType(dataset)
#print OUT
return OUT[0]
#getinfo_featuretype
############
def getinfo_numparts(self,dataset):
ARRAY = self.load_feature_points(dataset)
return len(ARRAY)
############
## ([ xmin,ymin , xmax,ymax])
def getinfo_extents(self,dataset):
#print self.SP_INFO.getEXTNTS(dataset)
return self.SP_INFO.getEXTNTS(dataset)
###########################################
###########################################
# ([ xmin,ymin , xmax,ymax | ((zmin,zmax)) ])
###########################################
def getinfo_extents_array(self,ARRAY):
XMIN =0
YMIN =0
ZMIN =0
XMAX =0
YMAX =0
ZMAX =0
##
storex = []
storey = []
storez = []
##
for point in ARRAY:
storex.append(point[0])
storey.append(point[1])
storez.append(point[2])
##
storex.sort()
storey.sort()
storez.sort()
##
sort_x = storex
sort_y = storey
sort_z = storez
#
length = (len(sort_x)-1)
XMIN =sort_x[0]
YMIN =sort_y[0]
ZMIN =sort_z[0]
XMAX =sort_x[length]
YMAX =sort_y[length]
ZMAX =sort_z[length]
#XMIN YMIN XMAX YMAX ( ZMIN ZMAX )
OUTPUT = [XMIN,YMIN,XMAX,YMAX,ZMIN,ZMAX]
##
return OUTPUT
#####################
def getinfo_lengthXYZ_XTNTX(self,XTNTX):
XLENGTH = XTNTX[2]-XTNTX[0]
YLENGTH = XTNTX[3]-XTNTX[1]
#debug
#ZLENGTH = XTNTX[5]-XTNTX[4]
ZLENGTH = 0
## ##
OUTPUT = [XLENGTH,YLENGTH,ZLENGTH]
return OUTPUT
#####################
def getinfo_lengthXYZ_array(self,ARRAY):
#XMIN YMIN XMAX YMAX ( ZMIN ZMAX )
XTNTX = self.getinfo_extents_array(ARRAY)
XLENGTH = XTNTX[2]-XTNTX[0]
YLENGTH = XTNTX[3]-XTNTX[1]
ZLENGTH = XTNTX[5]-XTNTX[4]
## ##
OUTPUT = [XLENGTH,YLENGTH,ZLENGTH]
return OUTPUT
#####################
def getinfo_centroidXYZ_array(self,array):
lengthXYZ = self.getinfo_lengthXYZ_array(array)
XTNTX = self.getinfo_extents_array(array)
#XMIN YMIN XMAX YMAX ( ZMIN ZMAX )
## ##
mid_x = XTNTX[0]+lengthXYZ[0]/2
mid_y = XTNTX[1]+lengthXYZ[1]/2
mid_z = XTNTX[4]+lengthXYZ[2]/2
return [mid_x,mid_y,mid_z]
#######
#ATTR EDITING
# attr_edit_setattr(object,attr,newvalue)
#######
def attr_edit_listAttrs(self,obj):
attrs = self.ATTRED.listAttrs(obj)
print attrs
#######
"""
TYPES ARE
Text - Names or other textual qualities.
Float - Numeric values with fractional values within a specific range.
Double - Numeric values with fractional values within a specific range.
Short - Numeric values without fractional values within a specific range; coded values.
Long - Numeric values without fractional values within a specific range.
Date - Date and/or Time.
Blob - images or other multimedia.
"""
##
"""
attr_edit_addattr('C:/crap1.shp','hyperlink','Text')
"""
def attr_edit_addattr (self,feature,attrname,fldtype):
self.ATTRED.addAttr(feature,attrname,fldtype)
#list all GIS data in a folder
def list_all_folder(self,folderpath):
print 'GIS DATA SETS '
print self.SP_INFO.listAllDataSets(folderpath,'dataset')
print 'RASTER '
print self.SP_INFO.listAllDataSets(folderpath,'raster')
print 'VECTOR '
print self.SP_INFO.listAllDataSets(folderpath,'vector')
#######
# def show(self):
# print 'CURRENT PROJECTION IS '
#######
"""
build smaller grid system based on extents
"""
#def subdivide(self,numX,numY,extents,base_attrs):
#######
"""
set_projection ( 'C:/grid_0_0.shp','C:/base.prj' )
"""
def set_projection(self,dataset,projection):
print '### define projection : '+ dataset
###
if self.USE_PROJECTION == 1: #??WHY IS THIS A TOGGLE?
gp.DefineProjection(dataset,projection )#grid_0_0 C:/base.prj
######################################################################
######################################################################
"""
read a ; seperated xyz text file
shapeindex;X;Y; (Z?)
"""
#def array_to_file()
def file_to_array(self,inputfile):
fhandler = sys_file_io.file_io_three()
fhandler.readfilelines( inputfile )
return fhandler.filecontents_list
## ############################################
"""
#build 20 interwoven concentric shapefiles #
#
num = 10
for a in range(num):
scale = a * 1000
TL.gengenbox([5000,5000],scale,'C://', ('skeeter'+str(a)) )
TL.gengenbox([0,0] ,scale,'C://', ('cheater'+str(a)) )
##
#extents
# gengenbox (self,ORIGIN,scale,outpath,outshapename):
"""
## ############################################
def gengenbox (self,ORIGIN,scale,outpath,outshapename):
array = []
#
extnts_x_min = str(ORIGIN[0]+-scale)
extnts_x_max = str(ORIGIN[0]+scale)
extnts_y_min = str(ORIGIN[1]+-scale)
extnts_y_max = str(ORIGIN[1]+scale )
##
si = str(1) #(shapeindex)
array.append(si+';'+extnts_x_min+';'+extnts_y_max+';' )
array.append(si+';'+extnts_x_min+';'+extnts_y_max+';' )
array.append(si+';'+extnts_x_max+';'+extnts_y_max+';' )
si = str(2) #(shapeindex)
array.append(si+';'+extnts_x_max+';'+extnts_y_max+';' )
array.append(si+';'+extnts_x_max+';'+extnts_y_min+';' )
si = str(3) #(shapeindex)
array.append(si+';'+extnts_x_max+';'+extnts_y_min+';' )
array.append(si+';'+extnts_x_min+';'+extnts_y_min+';' )
si = str(4) #(shapeindex)
array.append(si+';'+extnts_x_min+';'+extnts_y_min+';' )
array.append(si+';'+extnts_x_min+';'+extnts_y_max+';' )
si = str(5) #(shapeindex)
array.append(si+';'+extnts_x_min+';'+extnts_y_max+';' )
array.append(si+';'+extnts_x_max+';'+extnts_y_max+';' )
##
self.point_array_to_polyline( array,outpath,(outshapename+'.shp'))
##
## ############################################
"""
[ xmin,ymin , xmax,ymax]
build a scaled box around extents of a feature
##
"""
def gen_box_xtnts (self,XTNTS,outpath,outshapename):
array = []
MODE = 'closed_polyline' #'polygon' # 'polyline' # ' ' #
#
#scale = 100
##
extnts_x_min = str( XTNTS[0] )
extnts_y_min = str( XTNTS[1] )
extnts_x_max = str( XTNTS[2] )
extnts_y_max = str( XTNTS[3] )
###########
if MODE=='polyline':
##
si = str(1) #(shapeindex)
array.append(si+';'+extnts_x_min+';'+extnts_y_max+';' )
array.append(si+';'+extnts_x_min+';'+extnts_y_max+';' )
array.append(si+';'+extnts_x_max+';'+extnts_y_max+';' )
si = str(2) #(shapeindex)
array.append(si+';'+extnts_x_max+';'+extnts_y_max+';' )
array.append(si+';'+extnts_x_max+';'+extnts_y_min+';' )
si = str(3) #(shapeindex)
array.append(si+';'+extnts_x_max+';'+extnts_y_min+';' )
array.append(si+';'+extnts_x_min+';'+extnts_y_min+';' )
si = str(4) #(shapeindex)
array.append(si+';'+extnts_x_min+';'+extnts_y_min+';' )
array.append(si+';'+extnts_x_min+';'+extnts_y_max+';' )
si = str(5) #(shapeindex)
array.append(si+';'+extnts_x_min+';'+extnts_y_max+';' )
array.append(si+';'+extnts_x_max+';'+extnts_y_max+';' )
##
self.point_array_to_polyline( array,outpath,(outshapename+'.shp'))
###########
#if MODE=='closed_polyline':
#if MODE=='polygon':
return (outshapename+'.shp')
######################################################################
#### ##########################################################
"""
output ; number of shapes , number of vertecies per shape
"""
def report_multipart_point_buffer_size(self):
number = len(self.MULTIPART_PNT_BUFFER)
lengths =[]
for a in range (number):
lengths.append( len(self.MULTIPART_PNT_BUFFER[a]) )
#debug add pointid in
print 'Total :'+str(number)
for ind in lengths:
print 'Individual :'+str(ind)
##################
"""
make an array of array of points for each part (line only?)
DEBUG ?unfinished
"""
def check_if_closed(self,array):
firstArray = array[0]
lastArray = array[len(array)-1]
if firstArray[0] == lastArray[0] and firstArray[1] == lastArray[1]:
return 1
return 0
####
#debug , add a function to close open segments
def close_point_array(self,array):
check = self.check_if_closed(array)
if check==0:
print 'DEBUG CLOSE '
first = array[0]
array.append(first)
return array
####
def open_point_array(self,array):
check = self.check_if_closed(array)
if check==1:
print 'DEBUG OPEN '
array.pop()
return array
####
#debug untested#
#could be used to query extents of a multi part feature
def flatten_array(self,ARRAY_MULTI):
OUTPUT = []
for ARRAYY in ARRAY_MULTI:
for element in ARRAYY:
OUTPUT.append(element)
return OUTPUT
### ### ### #### ## # ### ### ### #### ##
## ### ### ### #### # ### ### ### #### ##
"""
#TYPLESSLY LOAD POINTS FROM A SHAPEFILE #
point,line,polygon type is indifferent
returns an array , or an array of arrays depending on type and number of features
copies it to the self.MULTIPART_PNT_BUFFER
"""
def load_feature_points(self,inSF):
##CHECK FILE TYPE ###
GIS_TYPE = self.getinfo_datatype(inSF)
if GIS_TYPE!='FeatureClass':
print 'DATA TYPE '+ GIS_TYPE +' IS NOT ALLOWED ONLY FEATURE CLASS '
return None
#### ###
DATATYPE = self.getinfo_featuretype(inSF)
if DATATYPE==None:
print 'ERROR NO TYPE DEFINED'
print 'Feature is ' +inSF
print '###################'
return None
#### ###
if DATATYPE=='Point' :
self.MULTIPART_PNT_BUFFER = []
if os.path.lexists(inSF)==0:
print 'load_feature_points no file ' +inSF+' exists '
return '' #debug
## ##
desc_inSF = gp.describe(inSF)
sr = desc_inSF.spatialreference
searchRecs = gp.searchcursor(inSF)
searchRec = searchRecs.next()
while searchRec:
OUTVERTS =[]
testPt = searchRec.shape.getpart()
OUTVERTS.append( [testPt.x,testPt.y,testPt.z] )
searchRec = searchRecs.next()
self.MULTIPART_PNT_BUFFER.append(OUTVERTS)
return self.MULTIPART_PNT_BUFFER
########
if DATATYPE=='Polygon' or DATATYPE=='Polyline':
########
self.MULTIPART_PNT_BUFFER = []
if os.path.lexists(inSF)==0:
print 'load_feature_points no file ' +inSF+' exists '
return '' #debug
#
desc_inSF = gp.describe(inSF)
sr = desc_inSF.spatialreference
searchRecs = gp.searchcursor(inSF)
searchRec = searchRecs.next()
while searchRec:
OUTVERTS =[]
lastArray = searchRec.shape.getpart(0)
testPt = lastArray.next()
while testPt:
lastPt = testPt
OUTVERTS.append( [testPt.x,testPt.y,testPt.z] ) #testPt.id #XYZ POINTS AS TEXT
#
testPt = lastArray.next()
searchRec = searchRecs.next()
#get verts for each (closed line ) PART
self.MULTIPART_PNT_BUFFER.append(OUTVERTS)
#??
return self.MULTIPART_PNT_BUFFER
########################################################################
########################################################################
#### ##########################################################
def get_spat_ref(self,object):
return self.SP_INFO.getSpatRef(object)
###############################
"""
#SINGLE POLYGON #
[ [0.0,0.0,0.0] , [1.0,1.0,1.0] ]
"""
###############################
def point_array_to_poly(self,ARRAY,outpath,outSF ):#,spatref):
gp.overwriteoutput = 1
#outpath ='C:/'
gp.CreateFeatureclass( outpath , outSF ,'POLYGON' ) #,spatref)
cur = gp.InsertCursor(outSF)
lineArray = gp.CreateObject("Array")
pnt = gp.CreateObject("Point")
######################
#iterate the array ( [ [x,y,z],[x,y,z] ])
for element in ARRAY:
pnt.x = float(element[0])
pnt.y = float(element[1])
#pnt.z = float(element[2])
lineArray.Add(pnt)
######################
# Create a new row, or feature, in the feature class
feat = cur.NewRow()
# Set the geometry of the new feature to the array of points
feat.shape = lineArray
# Insert the feature
cur.InsertRow(feat)
########
# def point_multiarray_to_poly
########################################################################
########################################################################
"""
#SINGLE POLYLINE #
"""
def point_array_to_polyline (self,arraydata,outpath,outSF):
#outpath = 'C:/'
gp.overwriteoutput = 1
gp.CreateFeatureclass( outpath , outSF ,'POLYLINE')
cur = gp.InsertCursor( outSF )
lineArray = gp.CreateObject("Array")
pnt = gp.CreateObject("Point")
for line in arraydata:
#pnt.id = line[0]
pnt.x = float(line[0])
pnt.y = float(line[1])
#pnt.z = line[2]
#
lineArray.add(pnt)
#####
feat = cur.NewRow()
feat.shape = lineArray
cur.InsertRow(feat)
#####
lineArray.add(pnt)
##############
"""
#MULTI POLYLINE #
"""
def point_multiarray_to_polyline (self,arraydata,outpath,outSF):
#outpath = 'C:/'
gp.overwriteoutput = 1
gp.CreateFeatureclass( outpath , outSF ,'POLYLINE')
cur = gp.InsertCursor( outSF )
lineArray = gp.CreateObject("Array")
pnt = gp.CreateObject("Point")
#ID = -1
for line in arraydata:
#pnt.id = line[0]
pnt.x = float(line[0])
pnt.y = float(line[1])
#pnt.z = line[2]
#
lineArray.add(pnt)
#####
feat = cur.NewRow()
feat.shape = lineArray
cur.InsertRow(feat)
#####
lineArray.add(pnt)
#ID=pnt.id
#### ##########################################################
"""
# POINT #
"""
def point_array_to_points (self,arraydata,outpath,outSF):
#outpath = 'C:/'
gp.overwriteoutput = 1
gp.CreateFeatureclass( outpath , outSF ,'POINT')
cur = gp.InsertCursor( outSF )
pnt = gp.CreateObject("Point")
for line in arraydata:
pnt.x = float(line[0])
pnt.y = float(line[1])
#pnt.z = float(line[2])
#####
feat = cur.NewRow()
feat.shape = pnt
cur.InsertRow(feat)
#####
#### ##########################################################
#### ##########################################################
"""
make an array of points , centroid to the make grid_lattice function
"""
def gen_pointgrid (self,sFcName,sType,XTNTS,stepMode,MDAT,NDAT):
EXTNTS_LENGTH = []
#XYZ_LENGTHS= self.getinfo_lengthXYZ_array(XTNTS)
XYZ_LENGTHS=self.getinfo_lengthXYZ_XTNTX(XTNTS)
#########################
theLeft =XTNTS[0]
theRight =XTNTS[2]
theBottom =XTNTS[1]
theTop =XTNTS[3]
##########################
OUTARRAY = []
##########################
if stepMode == 'GRIDSIZE':
m = float(MDAT)
n = float(NDAT)
##########################
if stepMode == 'CELLSIZE':
xsize = float(MDAT)
ysize = float(NDAT)
m=(theRight-theLeft)/xsize
n=(theTop-theBottom)/ysize
if sType == 'POINT':
m = m+1
n = n+1
##########################
NUMX = MDAT
NUMY = NDAT
LENGTH_DIVX = (XYZ_LENGTHS[0]/NUMX)
LENGTH_DIVY = (XYZ_LENGTHS[1]/NUMY)
#
HALF_X = LENGTH_DIVX/2
HALF_Y = LENGTH_DIVY/2
#
cent_x = theRight- theLeft
cent_y = theTop- theBottom
#
point = []
#
for a in range(NUMX):
## ##
for b in range(NUMY):
xdist = HALF_X+(theLeft + (a*LENGTH_DIVX))
ydist = HALF_Y+(theBottom + (b*LENGTH_DIVY))
#point = [(xdist-HALF_X),(ydist-HALF_Y) ,0 ]
point = [xdist ,ydist ,0 ]
OUTARRAY.append(point)
##############################
return OUTARRAY
###########################################
def sjm_linesegments_to_angle_csv(self,infile,outfile):
strFeatureLayer = infile#gp.GetParameterAsText(0)
strfilename = outfile.replace("\\","/")
if ".csv" not in strfilename:
strfilename += ".csv"
descFeatureLayer = gp.describe(strFeatureLayer)
#FID is the feature identifier
strFID1 = "-1"
strFID2 = "-1"
#open the file for
csvRotationFile = open(strfilename, "w")
strWriteline = "FID,rotation_Angle" + "\n"
csvRotationFile.write(strWriteline)
#Ensure this is a polyline layer
if descFeatureLayer.ShapeType == "Polyline":
#Name of the feature layer
gp.AddMessage(strFeatureLayer)
rows = gp.searchcursor(strFeatureLayer)
row = rows.next()
#Loop through the features
while row:
#Get the points the make up the polyline
lstPoints = row.shape.GetPart(0)
#Loop through the point string for the polylines
pnt = lstPoints.next()
while pnt:
#compute the rotation angle
if str(strFID1) == str(row.FID):
#Get the current point
strX2 = str(pnt.X)
strY2 = str(pnt.Y)
strFID2 = str(row.FID)
#Figure out the delta
deltaX = float(strX2) - float(strX1)
if deltaX == 0:
deltaX = 0.1
deltaY = float(strY2) - float(strY1)
angle = math.atan2 (deltaY, deltaX)
angle = math.degrees (angle)
angle = 90 - angle
#Print the results to the file and the console
strWriteline = str(row.FID) + "," + str(angle) + "\n"
csvRotationFile.write(strWriteline)
gp.AddMessage(strWriteline)
#Next point in the collection
strX1 = str(pnt.X)
strY1 = str(pnt.Y)
strFID1 = str(row.FID)
pnt = lstPoints.next()
#Next feature in the dataset
#gp.AddMessage("**** " + str(row.FID))
row = rows.next()
else:
gp.AddMessage ("Not a polyline layer")
#Print the completion message
csvRotationFile.close()
gp.AddMessage("All done")
#### ### ### ### #### ### ### ### #### ### ### ### #### ### ### ###
#### ### ### ### #### ### ### ### #### ### ### ### #### ### ### ###
"""
this is the "mfolderloader" ptyhon model ,put into a function since its
so durn handy
"""
class GIS_GATHER:
def __init__(self):
#self.FOUND_DATASETS = []
#
self.sorted_rasters = [] #targz,tiff etc
self.sorted_elevations = [] #dem,arcgrid
self.sorted_vectors = [] #shp,txt, etc
self.sorted_geodatabases = [] #
self.sorted_kgraphs = [] #
##
#self.spatial_treatment = sys_sp_treat.SP_TREATMENT()
self.sp_INFO = sys_sp_treat.GET_INFO()
############
#find out the type of a dataset
def getinfo_type(self,dataset):
print self.sp_INFO.getDataClassType(dataset)
# # #
#find out about feature classes
def getinfo_feature(self,dataset):
print self.sp_INFO.getFeatureInfo(dataset)
return self.sp_INFO.getFeatureInfo(dataset)
# # #
def getinfo_extents(self,dataset):
print self.sp_INFO.getEXTNTS(dataset)
return self.sp_INFO.getEXTNTS(dataset)
# # #
#find out about rasters
def getinfo_raster(self,dataset):
print self.sp_INFO.getDataClassType(dataset)
return self.sp_INFO.getDataClassType(dataset)
# # #
#esri GIS info
def getinfo_ESRI(self,dataset):
print self.sp_INFO.getDataClassInfo(dataset)
# # #
#get the centroid of a dataset
def getinfo_centroid(self,dataset):
XTNTS= self.sp_INFO.getEXTNTS(dataset)
#DEBUG UNTESTED
#return self.sp_INFO.getEXTNTS(dataset)
length_x=XTNTS[0]-XTNTS[2]
length_y=XTNTS[1]-XTNTS[3]
center_x = length_x/2
center_y = length_y/2
#DEBUG UNTESTED
# # #
#get the attrs from a dataset
def getinfo_attrs(self,dataset):
print self.sp_INFO.listAttrs(dataset)
############
def show_all_data_found(self):
out=[]
out.append(self.sorted_rasters )
out.append(self.sorted_elevations )
out.append(self.sorted_vectors )
out.append(self.sorted_geodatabases )
out.append(self.sorted_kgraphs )
##
print '## rasters '
print self.sorted_rasters #targz,tiff etc
print '## elevations '
print self.sorted_elevations #dem,arcgrid
print '## vectors '
print self.sorted_vectors #shp,txt, etc
print '## geodatabases '
print self.sorted_geodatabases #
print '## kgraphs '
print self.sorted_kgraphs
"""
scan a folder for feature classes
"""
def scan_features(self,folder):
print 'scanning folder '+folder+' for all features '
return self.walkFoldersGetFilenames( folder,'fc')
#return out
############
"""
scan a folder for rasters
"""
def scan_rasters(self,folder):
print 'scanning folder '+folder+' for all features '
return self.walkFoldersGetFilenames( folder,'raster')
############
############
############
"""
do a recursive scan (walkFoldersGetFilenames) for each type of data (. extention)
"""
def scan_all_known(self,folder):
out= []
print 'scanning folder '+folder+' for all known GIS data types '
print 'feature classes..'
out.append(self.walkFoldersGetFilenames(folder,'fc') )
print 'rasters ..'
out.append(self.walkFoldersGetFilenames(folder,'raster') )
print 'tag.gz ..'
out.append(self.walkFoldersGetFilenames(folder,'TARGZ') )
out.append(self.walkFoldersGetFilenames(folder,'targz') )
print 'png ..'
out.append(self.walkFoldersGetFilenames(folder,'png') )
print 'tiff files ..'
out.append(self.walkFoldersGetFilenames(folder,'tiff') )
out.append(self.walkFoldersGetFilenames(folder,'TIF') )
print 'dems ..'
out.append(self.walkFoldersGetFilenames(folder,'dem') )
print 'kgraphs ..'
out.append(self.walkFoldersGetFilenames(folder,'klsys') )
return out #kind of redundant
############
"""
look through a folder for a file with a certain extention
"""
def walkFoldersGetFilenames (self,foldervar,extention):
ARGONE = foldervar
ARGONE =foldervar.replace('\\','/')
ARGTWO = extention
#filenames =[]
if len(ARGONE)==0 or len(ARGTWO)==0:
print 'ERROR REQUIRES TWO ARGS'
return 0
if os.path.lexists(foldervar)==0:
print 'folder '+foldervar+' does not exist'
if os.path.lexists(foldervar):
folders = os.listdir(foldervar)
folder= foldervar.replace('\\','/')
gp.workspace = folder
#print ' LOOKING IN FOLDER : ' + folder #DEBUG
if ARGTWO == 'fc':
fcs= gp.ListFeatureClasses()
fcs.reset()
fc = fcs.next()
while fc :
self.sorted_vectors.append('\n'+folder+'/'+fc)
fc=fcs.next()
##
if ARGTWO == 'raster':
fcs= gp.ListRasters()
fcs.reset()
fc = fcs.next()
while fc :
bufferdata = (folder+'/'+fc+'/w001001.adf')
if os.path.lexists(bufferdata):
self.sorted_elevations.append('\n'+bufferdata)
else:
if os.path.lexists((folder+'/'+fc)):
self.sorted_rasters.append( ('\n'+folder+'/'+fc) )
######
fc=fcs.next()
## NON-GP objects
####case for objects NOT recognized by gp (like TGZ, etc)
if ARGTWO == 'TARGZ':
fhandler = sys_file_io.file_io_three()
fhandler.getcontentsdir_filter(folder,'TAR.GZ')
buffervar = fhandler.dir_contents_list
for filename in buffervar:
self.sorted_elevations.append('\n'+folder+'/'+filename)
##
if ARGTWO == 'targz':
fhandler = sys_file_io.file_io_three()
fhandler.getcontentsdir_filter(folder,'tar.gz')
buffervar = fhandler.dir_contents_list
for filename in buffervar:
self.sorted_elevations.append('\n'+folder+'/'+filename)
##ALTHOUGH THESE MAY BE RECOGNIZED BY GP , I WANTED MY OWN WAY TO DO IT ALSO
if ARGTWO == 'png':
fhandler = sys_file_io.file_io_three()
fhandler.getcontentsdir_filter(folder,'.png')
buffervar = fhandler.dir_contents_list
for filename in buffervar:
self.sorted_rasters.append('\n'+folder+'/'+filename)
##ALTHOUGH THESE MAY BE RECOGNIZED BY GP , I WANTED MY OWN WAY TO DO IT ALSO
if ARGTWO == 'tiff':
fhandler = sys_file_io.file_io_three()
fhandler.getcontentsdir_filter(folder,'.tiff')
buffervar = fhandler.dir_contents_list
for filename in buffervar:
self.sorted_rasters.append('\n'+folder+'/'+filename)
if ARGTWO == 'TIF':
fhandler = sys_file_io.file_io_three()
fhandler.getcontentsdir_filter(folder,'.TIF')
buffervar = fhandler.dir_contents_list
for filename in buffervar:
self.sorted_rasters.append('\n'+folder+'/'+filename)
##ALTHOUGH THESE MAY BE RECOGNIZED BY GP , I WANTED MY OWN WAY TO DO IT ALSO
if ARGTWO == 'dem':
fhandler = sys_file_io.file_io_three()
fhandler.getcontentsdir_filter(folder,'.dem')
buffervar = fhandler.dir_contents_list
for filename in buffervar:
self.sorted_elevations.append('\n'+folder+'/'+filename)
#DEBUG DOES NOT SEEM TO WORK
if ARGTWO == 'klsys':
fhandler = sys_file_io.file_io_three()
fhandler.getcontentsdir_filter(folder,'.klsys')
buffervar = fhandler.dir_contents_list
for filename in buffervar:
self.sorted_kgraphs.append('\n'+folder+'/'+filename)
##########################
#####Recursive call ######
for folder in folders:
if os.path.isdir((foldervar+'/'+folder)):
self.walkFoldersGetFilenames ((foldervar+'/'+folder),extention)
