अजगर के साथ वर्ग ग्रिड बहुभुज आकार का निर्माण?

Question

मेरे पास निम्नलिखित निर्देशांक हैं

minx, maxx, miny ,maxy = 448262.080078, 450360.750122, 6262492.020081, 6262938.950073

मैं अजगर का उपयोग करते हुए आकार 1 मीटर का एक वर्ग ग्रिड बनाना चाहता हूं।

import math


minx,maxx,miny,maxy = 448262.080078, 450360.750122, 6262492.020081, 6262938.950073
size = 1

def set_bbox(minx, maxx, miny, maxy, distx, disty):
    nx = int(math.ceil(abs(maxx - minx)/distx))
    ny = int(math.ceil(abs(maxy - miny)/disty))
    new_maxx = minx + (nx*distx)
    new_miny = maxy - (ny*disty)
    return ((minx, new_maxx, new_miny, maxy),ny,nx)

# shift the bottom (right - down)
coord, ny, nx = set_bbox(minx,maxx,miny,maxy,size,size)
# left-up origin
origin = coord[0],coord[3]
# number of tiles
ncell = ny*nx

Comments

क्या यह किसी विशिष्ट जीआईएस प्लेटफॉर्म से जुड़ा हुआ है या बिना किसी निर्दिष्ट आउटपुट फॉर्मेट के (जैसे

धन्यवाद @Dan, मैं शुद्ध अजगर में प्रदर्शन करना चाहता हूं और आउटपुट आकार प्रारूप में होगा

— Gianni

ArcMap के लाइसेंस के ArcInfo स्तर में फिशनेट टूल है लेकिन आपने यह संकेत नहीं दिया है कि आप कैसे आकृति बनाने का इरादा रखते हैं।

क्षमा करें, मैं व्यावसायिक सॉफ्टवेयर का उपयोग नहीं करता। मैं शुद्ध भाषा जावा, पायथन, सी ++ में कार्यक्रम पसंद करता हूं।

— गियान्नी

लेकिन आपको GDAL / OGR ( pypi.python.org/pypi/GDAL ) या pyshp ( pypi.python.org/pypi/pyshp ) जैसी लाइब्रेरी का उपयोग करने में कोई आपत्ति नहीं है ?

— स्नोरफॉर्पलागस

Answer 1

निम्न स्क्रिप्ट GDAL और पायथन के साथ काम करेगी:

import os, sys
import ogr
from math import ceil

def main(outputGridfn,xmin,xmax,ymin,ymax,gridHeight,gridWidth):

    # convert sys.argv to float
    xmin = float(xmin)
    xmax = float(xmax)
    ymin = float(ymin)
    ymax = float(ymax)
    gridWidth = float(gridWidth)
    gridHeight = float(gridHeight)

    # get rows
    rows = ceil((ymax-ymin)/gridHeight)
    # get columns
    cols = ceil((xmax-xmin)/gridWidth)

    # start grid cell envelope
    ringXleftOrigin = xmin
    ringXrightOrigin = xmin + gridWidth
    ringYtopOrigin = ymax
    ringYbottomOrigin = ymax-gridHeight

    # create output file
    outDriver = ogr.GetDriverByName('ESRI Shapefile')
    if os.path.exists(outputGridfn):
        os.remove(outputGridfn)
    outDataSource = outDriver.CreateDataSource(outputGridfn)
    outLayer = outDataSource.CreateLayer(outputGridfn,geom_type=ogr.wkbPolygon )
    featureDefn = outLayer.GetLayerDefn()

    # create grid cells
    countcols = 0
    while countcols < cols:
        countcols += 1

        # reset envelope for rows
        ringYtop = ringYtopOrigin
        ringYbottom =ringYbottomOrigin
        countrows = 0

        while countrows < rows:
            countrows += 1
            ring = ogr.Geometry(ogr.wkbLinearRing)
            ring.AddPoint(ringXleftOrigin, ringYtop)
            ring.AddPoint(ringXrightOrigin, ringYtop)
            ring.AddPoint(ringXrightOrigin, ringYbottom)
            ring.AddPoint(ringXleftOrigin, ringYbottom)
            ring.AddPoint(ringXleftOrigin, ringYtop)
            poly = ogr.Geometry(ogr.wkbPolygon)
            poly.AddGeometry(ring)

            # add new geom to layer
            outFeature = ogr.Feature(featureDefn)
            outFeature.SetGeometry(poly)
            outLayer.CreateFeature(outFeature)
            outFeature.Destroy

            # new envelope for next poly
            ringYtop = ringYtop - gridHeight
            ringYbottom = ringYbottom - gridHeight

        # new envelope for next poly
        ringXleftOrigin = ringXleftOrigin + gridWidth
        ringXrightOrigin = ringXrightOrigin + gridWidth

    # Close DataSources
    outDataSource.Destroy()


if __name__ == "__main__":

    #
    # example run : $ python grid.py <full-path><output-shapefile-name>.shp xmin xmax ymin ymax gridHeight gridWidth
    #

    if len( sys.argv ) != 8:
        print "[ ERROR ] you must supply seven arguments: output-shapefile-name.shp xmin xmax ymin ymax gridHeight gridWidth"
        sys.exit( 1 )

    main( sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4], sys.argv[5], sys.argv[6], sys.argv[7] )

Answer 2

यह पायथन लिपि pyshp लाइब्रेरी का उपयोग करती है, जैसा कि user16044 द्वारा सुझाया गया है:

import shapefile as shp
import math

minx,maxx,miny,maxy = 448262.080078, 450360.750122, 6262492.020081, 6262938.950073
dx = 100
dy = 100

nx = int(math.ceil(abs(maxx - minx)/dx))
ny = int(math.ceil(abs(maxy - miny)/dy))

w = shp.Writer(shp.POLYGON)
w.autoBalance = 1
w.field("ID")
id=0

for i in range(ny):
    for j in range(nx):
        id+=1
        vertices = []
        parts = []
        vertices.append([min(minx+dx*j,maxx),max(maxy-dy*i,miny)])
        vertices.append([min(minx+dx*(j+1),maxx),max(maxy-dy*i,miny)])
        vertices.append([min(minx+dx*(j+1),maxx),max(maxy-dy*(i+1),miny)])
        vertices.append([min(minx+dx*j,maxx),max(maxy-dy*(i+1),miny)])
        parts.append(vertices)
        w.poly(parts)
        w.record(id)

w.save('polygon_grid')

नोट: इस तरह की सीमा के साथ आकार 1 मीटर का एक वर्ग ग्रिड लगभग 1 मिलियन पॉलीगोन की परत के बराबर होता है और इसलिए स्क्रिप्ट का प्रदर्शन समझदारी से कम हो जाता है।

Answer 3

इस सवाल का जवाब समय से पहले दिया गया है, लेकिन मैं सुडौल और फियोना लाइब्रेरी का उपयोग करके एक और समाधान जोड़ता हूं:

import fiona
from shapely.geometry import mapping, LineString, MultiLineString

file = 'input.shp'
with fiona.open(file, 'r') as ds_in:
    num_tiles = 5
    schema = {
    "geometry": "MultiLineString",
    "properties": {"id": "int"}
     }
minx, miny, maxx, maxy = ds_in.bounds
dx = (maxx - minx) / num_tiles
dy = (maxy - miny) / num_tiles

lines = []
for x in range(num_tiles + 1):
    lines.append(LineString([(minx + x * dx, miny), (minx + x * dx, maxy)]))
for y in range(num_tiles + 1):
    lines.append(LineString([(minx, miny + y * dy), (maxx, miny + y * dy)]))
grid = MultiLineString(lines)
out = 'gridtest.shp'
with fiona.open(out, 'w', driver=ds_in.driver, schema=schema, crs=ds_in.crs) as ds_dst:
    ds_dst.write({'geometry': mapping(grid), "properties": {"id": 0}})

Answer 4

QGIS में फिशनेट ग्रिड शेपफाइल बनाने का उत्तर ? QGIS प्रसंस्करण टूलबॉक्स में एक ग्रिड बनाएँ विकल्प दिखाता है।

Comments

ओपी ने कहा कि वह एक सॉफ्टवेयर के बजाय शुद्ध पायथन में एक उदाहरण पसंद करते हैं

— LaughU

अन्य उत्तर आयात पुस्तकालयों को देखते हुए, क्यूजीआईएस मॉड्यूल आयात करना एक जीयूआई से बचने के लिए एक वैध तरीका है। जैसे इस उत्तर में gis.stackexchange.com/questions/79916/…

— user965586

अन्य उत्तर कोड प्रदान करते हैं इसलिए यदि आपका भी किया गया है तो मुझे लगता है कि यह बेहतर प्राप्त होगा।

— PolyGeo