def extentGeometry(geometries): 'create extent geometry filters' extent_geometries = [] for geometry in geometries: extent = geometry.extent array = arcpy.Array() extent_vertices = [arcpy.Point(extent.XMin, extent.YMin),arcpy.Point(extent.XMin, extent.YMax), arcpy.Point(extent.XMax, extent.YMax),arcpy.Point(extent.XMax, extent.YMin)] array.extend(extent_vertices) extent_geometry = arcpy.Polygon(array,geometry.spatialReference) extent_filter = arcrest.filters.GeometryFilter(extent_geometry) extent_geometries.append(extent_filter) return extent_geometries
def asShape(self): """returns JSON as arcpy.Geometry() object""" if self.geometryType != ESRI_ENVELOPE: return arcpy.AsShape(self.json, True) else: ar = arcpy.Array([ arcpy.Point(self.json[XMIN], self.json[YMAX]), arcpy.Point(self.json[XMAX], self.json[YMAX]), arcpy.Point(self.json[XMAX], self.json[YMIN]), arcpy.Point(self.json[XMIN], self.json[YMIN]) ]) return arcpy.Polygon(ar, arcpy.SpatialReference(self.spatialReference))
def getCurrentBBinWGS84(self): cmapdoc = arcpy.mapping.MapDocument("CURRENT") cdf = arcpy.mapping.ListDataFrames(cmapdoc, "Layers")[0] extentPolygon = arcpy.Polygon( arcpy.Array([ cdf.extent.lowerLeft, cdf.extent.lowerRight, cdf.extent.upperRight, cdf.extent.upperLeft ]), cdf.spatialReference) self.rs = cdf.spatialReference extentPolygoninWGS84 = extentPolygon.projectAs( "WGS 1984") #arcpy.SpatialReference(4326) ex = extentPolygoninWGS84.extent return [ex.YMin, ex.XMin, ex.YMax, ex.XMax] del cmapdoc
def getHoles(input_fc): # Getting the holes with arcpy.da.UpdateCursor(input_fc, "SHAPE@") as cur: for polygon, in cur: if polygon is None: continue SR = polygon.spatialReference polygon = arcpy.Polygon( arcpy.Array( (pt for pt in takewhile(bool, part)) for part in polygon.getPart() or arcpy.Array(arcpy.Array()) ), SR ) cur.updateRow([polygon])
def process_nadir(row): # Longitude and latitude may be switched in arcmap data OR this script coords = (row['longitude'], row['latitude']) heading = row['yaw'] width, height = calculate_width_height(row['flying_height']) width = width / 2 * 0.75 height = height / 2 * 0.75 poly_array, corners = get_nadir_footprint(calculate_headings(heading), coords, width, height) # Turn poly_array into a polygon and add to the shapefile return arcpy.Polygon(poly_array)
def create_polygon(coord_l): point = arcpy.Point() array = arcpy.Array() featureList = [] for feature in coord_l: point.x = coord[0] point.y = coord[1] array.add(point) array.add(array.getaObject(0)) polygon = arcpy.Polygon(array) array.removeAll() featureList.append(polygon) return featureList
def poly_filling_up(in_poly_fc, out_poly_fc): """ メソッド名 : poly_filling_up メソッド 引数 1 : 入力フィーチャ 引数 2 : 出力フィーチャ 概要 : ポリゴンを穴埋め """ try: arcpy.AddMessage(u"処理開始:") in_fc_name = os.path.basename(in_poly_fc) in_ws = os.path.dirname(in_poly_fc) out_fc_name = os.path.basename(out_poly_fc) out_ws = os.path.dirname(out_poly_fc) # 出力データの作成 arcpy.CopyFeatures_management(in_poly_fc, out_poly_fc) outcur = arcpy.da.UpdateCursor(out_poly_fc, "SHAPE@") for inrow in outcur: polygon = arcpy.Array() for part in inrow[0]: new_part = arcpy.Array() # Nullになるポイント(interior ring の最初)を取得 null_point = 0 for i in range(len(part)): if part[i] == None: null_point = i break # 穴あきポリゴンでない場合パートの数そのまま if null_point == 0: polygon.add(part) # 穴あきポリゴンの場合パートの数をinterior ringの一つ前のポイントまでに else: for j in range(null_point): new_part.add(part[j]) polygon.add(new_part) if len(polygon) > 0: new_poly = arcpy.Polygon(polygon) inrow[0] = new_poly outcur.updateRow(inrow) # 後始末 del outcur arcpy.AddMessage(u"処理終了:") except arcpy.ExecuteError: arcpy.AddError(arcpy.GetMessages(2)) except Exception as e: arcpy.AddError(e.args[0])
def selectSqueeSARData(extent, layer): """ This function translates the extent selected by the user into the spatial reference of the SqueeSAR layer and identifies the features within the selected area. Args: extent (Extent): the extent object identifying the user-selected area. layer (Layer): a reference to the layer containing the SqueeSAR data. Returns: nfeat (int): the number of features (scatterers) within the selected area. spatref (SpatialReference): the spatial reference of the SqueeSAR layer. Raises: UserWarning: if there is no data within the selection. """ # Get the spatial reference of the SqueeSAR layer spatref = ap.Describe(layer).spatialReference # Convert the rectangle extent to a polygon area = ap.Array() # Create empty array area.add(extent.lowerLeft) area.add(extent.lowerRight) area.add(extent.upperRight) area.add(extent.upperLeft) area.add(extent.lowerLeft) poly = ap.Polygon(area, spatref) # Select the data ap.SelectLayerByLocation_management(layer, "WITHIN", poly, 0.0, "NEW_SELECTION") # Evaluate the number of selected features nfeat = ap.GetCount_management(layer).getOutput(0) if nfeat == "0": pa.MessageBox("No features were available within the selection boundaries", "Warning", 0) raise UserWarning("No features!") print("{0} feature(s) selected within:\n".format(nfeat) + "Lat: {0} to {1}\n".format(extent.YMin, extent.YMax) + "Lon: {0} to {1}\n".format(extent.XMin, extent.XMax)) return (int(float(nfeat)), spatref)
def _read_multipolygon(geojson_coords, sr): #AFAIK ArcGIS doesn't actually support the creation of multipart polygons #from the command line. So instead, return a set of polygons to be #processed individually. #Therefore we will return a set of geometries, and logger.debug("Reading multipolygon") geom_list = [] for poly in geojson_coords: poly_obj = arcpy.Array() for coords in poly: poly_obj.add(_get_array(coords)) geom_list.append(arcpy.Polygon(poly_obj, sr)) geom = _dissolve_multipart(geom_list) return geom, "polygon"
def create_sector2(x, y, radius, angle, SectorName): print "x,y,radius,angle,SectorName:" + str(x) + "," + str(y) + "," + str( radius) + "," + str(angle) + "," + str(SectorName) angle_sjx = 90 #默认的扇形的角度 n = int(20) #默认扇形上选取20个点 angle_x = x + radius #x旋转的开始位置 angle_y = y #y旋转的开始位置 #创建扇形上的点数组 array_k = arcpy.Array() pnt = arcpy.Point() pnt.X = x pnt.Y = y array_k.add(pnt) angle1 = (angle - angle_sjx / 2) * math.pi / 180.0000 angle2 = (angle + angle_sjx / 2) * math.pi / 180.0000 #根据角度来计算扇形上的起始点坐标 x1 = (angle_x - x) * math.cos(angle1) + (angle_y - y) * math.sin(angle1) + x y1 = -(angle_x - x) * math.sin(angle1) + (angle_y - y) * math.cos(angle1) + y x2 = (angle_x - x) * math.cos(angle2) + (angle_y - y) * math.sin(angle2) + x y2 = -(angle_x - x) * math.sin(angle2) + (angle_y - y) * math.cos(angle2) + y pnt1 = arcpy.Point(x1, y1) pnt2 = arcpy.Point(x2, y2) #扇形上的起始点为所有点的第二个点 array_k.add(pnt1) for k in range(n): #计算angle_sjx个点的坐标 anglek = (angle - angle_sjx / 2 + k * angle_sjx / n) * math.pi / 180.0 xk = (angle_x - x) * math.cos(anglek) + (angle_y - y) * math.sin(anglek) + x yk = -(angle_x - x) * math.sin(anglek) + (angle_y - y) * math.cos(anglek) + y pntk = arcpy.Point(xk, yk) array_k.add(pntk) #print "pntk:x"+str(k)+":"+str(xk)+",y"+str(k)+":"+str(yk) array_k.add(pnt2) array_k.add(array_k.getObject(0)) #这里又加了一次起始点 print "array_k的长度为:" + str(len(array_k)) poly = arcpy.Polygon(array_k) array_k.removeAll() #清空array_k #生成扇形图层 outputSectorFeatureF = os.path.join( os.path.split(outputSectorFeature)[0], SectorName) arcpy.CopyFeatures_management(poly, outputSectorFeatureF) arcpy.DefineProjection_management(outputSectorFeatureF, arcpy.SpatialReference(2436)) arcpy.SetParameterAsText(5, outputSectorFeatureF)
def get_squares(self, line, length): squares = list() angle = get_angle(line) arcpy.AddMessage(angle) x = line.firstPoint.X y = line.firstPoint.Y arcpy.AddMessage(line.firstPoint.X) arcpy.AddMessage(line.lastPoint.X) arcpy.AddMessage(" ") if angle < 45 and angle > -45: a = arcpy.Point(x - (length / 2), y + length) b = arcpy.Point(x + (length / 2), y + length) c = arcpy.Point(x + (length / 2), y) d = arcpy.Point(x - (length / 2), y) p = arcpy.Point(x - (length / 2), y) q = arcpy.Point(x + (length / 2), y) r = arcpy.Point(x + (length / 2), y - length) s = arcpy.Point(x - (length / 2), y - length) squares.append(arcpy.Polygon(arcpy.Array([a, b, c, d]))) squares.append(arcpy.Polygon(arcpy.Array([p, q, r, s]))) else: a = arcpy.Point(x - length, y + (length / 2)) b = arcpy.Point(x, y + (length / 2)) c = arcpy.Point(x, y - (length / 2)) d = arcpy.Point(x - length, y - (length / 2)) p = arcpy.Point(x + length, y + (length / 2)) q = arcpy.Point(x, y + (length / 2)) r = arcpy.Point(x, y - (length / 2)) s = arcpy.Point(x + length, y - (length / 2)) squares.append(arcpy.Polygon(arcpy.Array([a, b, c, d]))) squares.append(arcpy.Polygon(arcpy.Array([p, q, r, s]))) return squares
def changeStartingVertex(fcInputPoints, fcInputPolygons): ## Create Geometry Object for Processing input points. g = arcpy.Geometry() geomPoints = arcpy.CopyFeatures_management(fcInputPoints, g) listPointCoords = [] for point in geomPoints: listPointCoords.append([point.centroid.X, point.centroid.Y]) #arcpy.AddMessage(str(point.centroid.X) + ","+ str(point.centroid.Y)) with arcpy.da.UpdateCursor(fcInputPolygons, ["OID@", "SHAPE@"]) as ucPolygons: for featPolygon in ucPolygons: vertexList = [] #arcpy.AddMessage("Feature: " + str(featPolygon[0])) i = 0 iStart = 0 for polygonVertex in featPolygon[1].getPart(0): # shape,firstpart if polygonVertex: #arcpy.AddMessage(' Vertex:' + str(i)) vertexList.append([polygonVertex.X, polygonVertex.Y]) if [polygonVertex.X, polygonVertex.Y] in listPointCoords: #arcpy.AddMessage(" Point-Vertex Match!") iStart = i else: pass #arcpy.AddMessage(" No Match") i = i + 1 if iStart == 0: newVertexList = vertexList #arcpy.AddMessage("No Change for: " + str(featPolygon[0])) else: #arcpy.AddMessage("Changing Vertex List for: " + str(featPolygon[0])) newVertexList = vertexList[iStart:i] + vertexList[0:iStart] for v in newVertexList: arcpy.AddMessage(str(v[0]) + "," + str(v[1])) #listVertexPointObjects = [] newShapeArray = arcpy.Array() for newVertex in newVertexList: #arcpy.AddMessage("Changing Vertex: " + str(newVertex[0]) + ',' + str(newVertex[1])) newShapeArray.add(arcpy.Point(newVertex[0], newVertex[1])) #listVertexPointObjects.append(arcpy.Point(newVertex[0],newVertex[1])) #newShapeArray = arcpy.Array(listVertexPointObjects) newPolygonArray = arcpy.Polygon(newShapeArray) ucPolygons.updateRow([featPolygon[0], newPolygonArray]) return
def IsoplethLinesToPolygons(lineFC, polyFC, fieldname="contour"): """Builds a featureclass named polyFC, by creating a polygon from all the lines in lineFC that have the same value in the field named fieldname. The largest values in fieldname are written first, this will provide the expected polygon stacking. arcpy.FeatureToPolygon_management creates polygons from lines, but it does not copy attributes, doesn't guarantee order, and doesn't merge polygons with the same value.""" uniqueValues = GetUniqueValues(lineFC,fieldname) if not uniqueValues: utils.warn("No field named '"+fieldname+"' in "+lineFC) return workspace,featureClass = os.path.split(polyFC) arcpy.CreateFeatureclass_management(workspace,featureClass, "Polygon", lineFC, "SAME_AS_TEMPLATE", "SAME_AS_TEMPLATE", lineFC) # I use lineFC as a template for polyFC, even though I don't need all fields # (typically there is only the 'contour' field, besides the standard fields) # I do this to avoid adding a field (schema lock bug with PGDB) # and I don't want to worry about the data type (float or int) of 'contour' lineDescription = arcpy.Describe(lineFC) polyDescription = arcpy.Describe(polyFC) uniqueValues = list(uniqueValues) uniqueValues.sort() uniqueValues.reverse() #builds biggest to smallest polys = arcpy.InsertCursor(polyFC) for value in uniqueValues: query = BuildQuery(lineFC,fieldname,value) lines = arcpy.SearchCursor(lineFC,query) poly = polys.newRow() array = arcpy.Array() for line in lines: shape = line.getValue(lineDescription.shapeFieldName) for i in range(shape.partCount): array.add(shape.getPart(i)) newshape = arcpy.Polygon(array) poly.setValue(polyDescription.shapeFieldName, newshape) poly.setValue(fieldname, value) polys.insertRow(poly) #Close/Delete row/cursor objects to remove the exclusive lock del poly del polys
def create_polygon(self): point = arcpy.Point() array = arcpy.Array() featureList = [] for feature in self: for coord in feature: point.X = coord[0] point.Y = coord[1] array.add(point) array.add(array.getObject(0)) polygon = arcpy.Polygon(array) array.removeAll() featureList.append(polygon) return featureList
def draw_poly(coord_list, sr, y, x): """ Convert a Python list of coordinates to an ArcPy polygon feature Reference from : Curtis Price, USGS, [email protected] coord_list(List): list of coordinates, example: [ [ ['J1', '4', '3436538.1950', '34012885.9660'], ['J2', '4', '3436540.7970', '34012503.6880'], ['J16', '4', '3436517.6030', '34012500.1670'], ['J17', '4', '3436520.2950', '34012503.2740'] ] [ ['J1', '5', '3465542.0410', '34102863.3320'], ['J2', '5', '3436538.9340', '34702571.2020'], ['J3', '5', '3536539.5550', '35762578.0360'], ['J4', '5', '3536544.1120', '35762582.1780'], ['J5', '5', '3536550.5320', '35762585.2840'], ['J6', '5', '3536556.9520', '35762586.9410'] ] ] sr: 投影系 y(Int): y坐标行数 x(Int): x坐标行数 """ parts = arcpy.Array() yuans = arcpy.Array() yuan = arcpy.Array() for part in coord_list: for pnt in part: if pnt: yuan.add(arcpy.Point(pnt[y], pnt[x])) else: # null point - we are at the start of a new ring yuans.add(yuan) yuan.removeAll() # we have our last ring, add it yuans.add(yuan) yuan.removeAll() # if we only have one ring: remove nesting if len(yuans) == 1: yuans = yuans.getObject(0) parts.add(yuans) yuans.removeAll() # if single-part (only one part) remove nesting if len(parts) == 1: parts = parts.getObject(0) return arcpy.Polygon(parts, sr)
def createFeatures(coordList): for feature in coordList: point = arcpy.Point() array = arcpy.Array() for coordPair in feature: point.X = coordPair[0] point.Y = coordPair[1] array.add(point) array.add(array.getObject(0)) polygon = arcpy.Polygon(array) featureList.append(polygon)
def generatePolygon(self,latLonList): try: lll = eval(latLonList) innerArray = [] log.debug("Appending points") for p in lll: innerArray.append(arcpy.Point(float(p["lng"]),float(p["lat"]))) if len(innerArray) < 3: return False log.debug("Creating arcPy array") array = arcpy.Array(innerArray) log.debug("Creating polyline") polygon = arcpy.Polygon(array,arcpy.SpatialReference(4326)) return polygon except Exception as e: log.exception("Error in generatePolygon()")
def makePolygon(pointArray): n = 0 pts = arcpy.Array() while n < len(pointArray): longitude = pointArray[n] latitude = pointArray[n + 1] pt = arcpy.Point(X = longitude, Y = latitude) pts.add(pt) n += 2 pts.add(pts[0]) poly = arcpy.Polygon(pts) if poly.area == 0: polyline = arcpy.Polyline(pts) poly = polyline.buffer(0.0015) return poly
def Farmpoint_polygon(farm_point): polygonGeometryList = [] for farm_point_list in farm_point: array = arcpy.Array() for dict in farm_point_list: point = arcpy.Point() point.X = dict['X'] point.Y = dict['Y'] array.append(point) polygon = arcpy.Polygon(array) print(array.count) polygonGeometryList.append(polygon) print(len(polygonGeometryList)) arcpy.CopyFeatures_management(polygonGeometryList, r'E:\first_addin_picture\polygon\house\farm.shp')
def arcpnts_poly(in_, out_type='Polygon', SR=None): """Convert arcpy Point lists to poly* features : out_type - either 'Polygon' or 'Polyline' : """ s = [] for i in in_: arr = arcpy.Array(i) if out_type == 'Polyline': g = arcpy.Polyline(arr, SR) elif out_type == 'Polygon': g = arcpy.Polygon(arr, SR) elif out_type == 'Points': g = arcpy.arcpy.Multipoint(arr[0], SR) s.append(g) return s
def onLine(self, line_geometry): array = arcpy.Array() part = line_geometry.getPart(0) for pt in part: array.add(pt) array.add(line_geometry.firstPoint) polygon = arcpy.Polygon(array) if arcpy.Exists("in_memory/polygons"): arcpy.Delete_management("in_memory/polygons") arcpy.RefreshActiveView() arcpy.CopyFeatures_management(polygon, "in_memory/polygons") mxd = arcpy.mapping.MapDocument("CURRENT") aes = [x for x in arcpy.mapping.ListLayers(mxd) if x.name[0:3] == 'AES'][0] poligono = [x for x in arcpy.mapping.ListLayers(mxd) if x.name == 'polygons'][0] arcpy.SelectLayerByLocation_management(ccpp, "INTERSECT", poligono, "#", "NEW_SELECTION") suma = sum([x[0] for x in arcpy.da.SearchCursor(ccpp, ["CANT_EST"])])
def from_wkt(wkt, sr): """Creates a polygon geometry from a list of well-known text coordinates. :param wkt: well-known text :param sr: arcpy spatial reference object :rtype : arcpy.Polygon """ import arcpy coordinates = wkt[wkt.find('(') + 2: wkt.find(')')].split(',') array = arcpy.Array() for p in coordinates: p = p.replace('(', '') pt = p.strip().split(' ') array.add(arcpy.Point(float(pt[0]), float(pt[1]))) poly = arcpy.Polygon(array, sr) return poly
def createGeometry(pntCoords, geometry_type): geometry = arcpy.Geometry() spatialRef = arcpy.SpatialReference(4326) if geometry_type.lower() == 'point': geometry = arcpy.Multipoint( arcpy.Array([arcpy.Point(*coords) for coords in pntCoords]), spatialRef) elif geometry_type.lower() == 'polyline': geometry = arcpy.Polyline( arcpy.Array([arcpy.Point(*coords) for coords in pntCoords]), spatialRef) elif geometry_type.lower() == 'polygon': geometry = arcpy.Polygon( arcpy.Array([arcpy.Point(*coords) for coords in pntCoords]), spatialRef) return geometry
def NewGeom_d(self): l = [45, 135, 225, 315] cursor = arcpy.da.SearchCursor(self.feature, ["SHAPE@XY", self.d_attr]) cursor_new = arcpy.da.InsertCursor(self.fullpathname, ["SHAPE@"]) for row in cursor: p = row[0] d = row[1] az = float(self.az) array = arcpy.Array() for i in l: x = p[0] + (d * sqrt(2.0)) * cos(((i + (90 - az)) * pi) / 180) y = p[1] + (d * sqrt(2.0)) * sin(((i + (90 - az)) * pi) / 180) array.add(arcpy.Point(x, y)) cursor_new.insertRow([arcpy.Polygon(array)]) array.removeAll() return
def polygon_to_line_no_gap(input_line_, output_polygon): array = arcpy.da.FeatureClassToNumPyArray( input_line_, ["SHAPE@X", "SHAPE@Y"], spatial_reference=coord_system, explode_to_points=True) if array.size == 0: arcpy.AddError( "Line has no features, check to ensure it is OK") else: array2 = arcpy.Array() for x, y in array: pnt = arcpy.Point(x, y) array2.add(pnt) polygon = arcpy.Polygon(array2) arcpy.CopyFeatures_management(polygon, output_polygon) return
def get_polygon_from_rings(rings): array = arcpy.Array() for ring in rings: sub_array = arcpy.Array() for coords in ring: x, y = coords pnt = arcpy.Point(x, y) sub_array.add(pnt) array.add(sub_array) sr = arcpy.SpatialReference(4326) polygon = arcpy.Polygon(array, sr) return polygon
def parseFeatures(cls, maskGmlFile): tree = cacheElementTree(maskGmlFile) wkid = tree.find('./gml:boundedBy/gml:Envelope', cls.ns).attrib["srsName"].split(":")[-1] rids = tree.getroot().attrib["{"+cls.ns["gml"]+"}id"].split("_") ts = datetime.datetime.strptime(rids[6], '%Y%m%dT%H%M%S') tile = rids[8] features = [] maskFeatures = tree.findall('.//eop:MaskFeature', cls.ns) for feature in maskFeatures: fid = (feature.attrib["{"+cls.ns["gml"]+"}id"]) ftype = feature.find("eop:maskType", cls.ns).text parray = feature.find("eop:extentOf/gml:Polygon/gml:exterior/gml:LinearRing/gml:posList", cls.ns).text coords = [int(coor) for coor in parray.split(" ")] points = [[coords[2*i], coords[2*i+1]] for i in range(len(coords)//2)] shape = arcpy.Polygon(arcpy.Array([arcpy.Point(*pc) for pc in points]), arcpy.SpatialReference(int(wkid))) features.append((fid, ftype, tile, ts, shape)) return features
def pointinpolytest(self): polyarray = [[0, 0], [5, 0], [5, 5], [0, 5]] px = 2 py = 2 array = arcpy.Array([arcpy.Point(*coords) for coords in polyarray]) wb_geometry = arcpy.Polygon(array) pTestPoint = arcpy.Point(px, py) #containflag = wb_geometry.contains(pTestPoint) containflag = pTestPoint.within(wb_geometry) if (containflag): print("Point in side") else: print("Point Out side")
def arcpnts_poly(in_, out_type='Polygon', SR=None): """Convert arcpy Point lists to poly* features : out_type - either 'Polygon' or 'Polyline' : """ s = [] for i in in_: for j in i: if out_type == 'Polygon': g = arcpy.Polygon(arcpy.Array(j), SR) elif out_type == 'Polyline': g = arcpy.Polyline(arcpy.Array(j), SR) elif out_type == 'Points': j = _flat_(j) g = arcpy.Multipoint(arcpy.Array(j), SR) # check s.append(g) return s
def MakeFeatureClass(self): print "Building shapefile..." arc_start = time.time() spatial_ref = "NAD 1983" # Arcpy housekeeping arcpy.env.workspace = "D:/Faaiz/PythonProjects/SSURGO-GIS-Downloader" arcpy.env.overwriteOutput = True # Create output FC to store final result arcpy.CreateFeatureclass_management("/Results", "SoilCells.shp", "POLYGON", "", "", "", spatial_ref) # Add "SOILTYPE" field arcpy.AddField_management("/Results/SoilCells.shp", "SOILTYPE", "TEXT") # Iterate through Cells in divided area, create array of points from corner coords, make Polygon. for cell in self.areaList: pointArray = arcpy.Array() pointArray.add(arcpy.Point(cell.lon1, cell.lat1)) pointArray.add(arcpy.Point(cell.lon2, cell.lat1)) pointArray.add(arcpy.Point(cell.lon2, cell.lat2)) pointArray.add(arcpy.Point(cell.lon1, cell.lat2)) cellPolygon = arcpy.Polygon(pointArray, spatial_ref) # Add current polygon to final result FC arcpy.Append_management(cellPolygon, "/Results/SoilCells.shp", "NO_TEST") print "Done building shapefile." arc_time = (time.time() - arc_start) / 60 / 60 print str(arc_time) + " hours" # Create update cursor for SOILTYPE field cursor = arcpy.da.UpdateCursor("/Results/SoilCells.shp", ['SOILTYPE']) # Create index variables for populating SOILTYPE field i = 0 # Iterate through returned results, and update SOILTYPE to corresponding Cells soilType using index (i) print "Populating SOILTYPE field..." pop_start = time.time() for row in cursor: row[0] = self.areaList[i].soilType cursor.updateRow(row) i += 1 # Delete cursor, row, and index del cursor del row del i print "Done populating" pop_time = (time.time() - pop_start) / 60 print str(pop_time) + " minutes to populate"