GDAL का उपयोग करके छोटे विखंडू में रेखापुंज को विभाजित करना?

Question

मेरे पास एक रेखापुंज है (USGS DEM वास्तव में) और मुझे इसे नीचे की छवि की तरह छोटे टुकड़ों में विभाजित करने की आवश्यकता है। यह स्प्लिट रेखापुंज उपकरण का उपयोग करके आर्कगिस 10.0 में पूरा किया गया था। मैं ऐसा करने के लिए एक FOSS विधि चाहूंगा। मैंने GDAL को देखा है, यह सोचकर कि यह निश्चित रूप से ऐसा करेगा (किसी तरह gdal_translate के साथ), लेकिन कुछ भी नहीं मिल सकता है। अंततः, मैं रेखापुंज लेने में सक्षम होना चाहता हूं और कहना चाहता हूं कि कितने बड़े (4KM द्वारा 4KM चंक्स) मैं चाहूंगा कि इसमें विभाजन हो जाए।

Comments

मेरे पास एक उपयोगिता है जो उपप्रकार का उपयोग करता है। एक ही समय में कई गदल अनुवादों को चलाने के लिए। मैं एक बड़ी रास्टर को फ़िशनेट का उपयोग करके टाइल्स पर निकालने के लिए उपयोग करता हूं, विशेष रूप से उपयोगी अगर इनपुट और / या आउटपुट अत्यधिक संपीड़ित होता है (जैसे LZZ या डिफलेट जियो टिफ ), यदि न तो अत्यधिक संकुचित प्रक्रिया HDD पहुँच पर चोटियों और एक समय में एक चलाने की तुलना में बहुत तेज नहीं है। दुर्भाग्य से यह कठोर नामकरण सम्मेलनों के कारण साझा करने के लिए पर्याप्त सामान्य नहीं है, लेकिन वैसे भी भोजन के लिए। GDALWarp के लिए -multi विकल्प अक्सर परेशानी का कारण बनता है और केवल 2 थ्रेड्स का उपयोग करता है (एक पढ़ा, एक लिख) सभी उपलब्ध नहीं है।

— माइकल स्टिमसन

Answer 1

gdal_translate -srcwin या -projwin विकल्पों का उपयोग करके काम करेगा।

-srcwin xoff yoff xsize ysize: पिक्सेल / रेखा स्थान के आधार पर प्रतिलिपि बनाने के लिए स्रोत छवि से एक सबविंडो का चयन करता है।

-projwin ulx uly lrx lry: प्रतिलिपि बनाने के लिए स्रोत छवि से एक सबविंडो का चयन करता है (जैसे -srcwin) लेकिन भू-संदर्भ निर्देशांक में दिए गए कोनों के साथ।

आप पिक्सेल / लाइन स्थानों या कोने निर्देशांक के साथ आने की जरूरत है और फिर gdal_translate के साथ मूल्यों पर लूप करेंगे। नीचे दिए गए त्वरित और गंदे अजगर की तरह कुछ काम करेगा अगर पिक्सेल मूल्यों और -srcwin का उपयोग करना आपके लिए उपयुक्त है, तो निर्देशांक के साथ हल करने के लिए थोड़ा और काम होगा।

import os, gdal
from gdalconst import *

width = 512
height = 512
tilesize = 64

for i in range(0, width, tilesize):
    for j in range(0, height, tilesize):
        gdaltranString = "gdal_translate -of GTIFF -srcwin "+str(i)+", "+str(j)+", "+str(tilesize)+", " \
            +str(tilesize)+" utm.tif utm_"+str(i)+"_"+str(j)+".tif"
        os.system(gdaltranString)

Comments

नमस्ते, जब मैं एक भू-आकृति छवि के साथ -प्रोजेविन विकल्प की कोशिश करता हूं तो मुझे चेतावनी मिलती है "चेतावनी: गणना -srcwin -3005000 1879300 50 650 पूरी तरह से रेखापुंज सीमा से बाहर हो जाती है। हालांकि," मुझे यकीन नहीं है कि मैं गलत नहीं हूं, ऐसा लगता है कि ऐसा नहीं है। इसके भू-आकृतिक निर्देशांक का उपयोग करना।

— ncelik

@ncelik जो संभवतः इसलिए है क्योंकि आप अपने प्रोजविन में सेल निर्देशांक का उपयोग कर रहे हैं और इसके बजाय srcwin का उपयोग करना चाहिए। यदि आप कठिनाई का सामना कर रहे हैं, तो कृपया सभी प्रासंगिक जानकारी के साथ एक नया प्रश्न पोस्ट करें ताकि हम आपकी विशिष्ट समस्या पर सुझाव दे सकें।

— माइकल स्टिमसन

Answer 2

मेरा समाधान, @wwnick से एक पर आधारित फ़ाइल से रेखापुंज आयामों को पढ़ता है, और यदि आवश्यक हो तो किनारे की टाइलों को छोटा करके पूरी छवि को कवर करता है:

import os, sys
from osgeo import gdal

dset = gdal.Open(sys.argv[1])

width = dset.RasterXSize
height = dset.RasterYSize

print width, 'x', height

tilesize = 5000

for i in range(0, width, tilesize):
    for j in range(0, height, tilesize):
        w = min(i+tilesize, width) - i
        h = min(j+tilesize, height) - j
        gdaltranString = "gdal_translate -of GTIFF -srcwin "+str(i)+", "+str(j)+", "+str(w)+", " \
            +str(h)+" " + sys.argv[1] + " " + sys.argv[2] + "_"+str(i)+"_"+str(j)+".tif"
        os.system(gdaltranString)

Comments

मुझे लगता है कि यह sys.argv [1] होना चाहिए जहां यह sys.argv [2], सही कहता है?

— ऑस्करलिन जूल

sys.argv [2] का उपयोग आउटपुट फाइलों के लिए उपसर्ग के रूप में किया जाता है, मुझे विश्वास है। सुपर मददगार - धन्यवाद @Ries!

— चार्ली हॉफमैन

Answer 3

वहाँ एक बंडल अजगर स्क्रिप्ट है जो विशेष रूप से आपदाओं से बचने के लिए है , gdal_retile :

gdal_retile.py [-v] [-co NAME=VALUE]* [-of out_format] [-ps pixelWidth pixelHeight]
               [-overlap val_in_pixel]
               [-ot  {Byte/Int16/UInt16/UInt32/Int32/Float32/Float64/
                      CInt16/CInt32/CFloat32/CFloat64}]'
               [ -tileIndex tileIndexName [-tileIndexField tileIndexFieldName]]
               [ -csv fileName [-csvDelim delimiter]]
               [-s_srs srs_def]  [-pyramidOnly]
               [-r {near/bilinear/cubic/cubicspline/lanczos}]
               -levels numberoflevels
               [-useDirForEachRow]
               -targetDir TileDirectory input_files

उदाहरण के लिए:

gdal_retile.py -ps 512 512 -targetDir C:\example\dir some_dem.tif

Answer 4

@Aaron के लिए जिसने पूछा:

मैं @ wwnick के उत्तर के एक गालवार्प संस्करण को खोजने की उम्मीद कर रहा हूं जो कि बहु-स्तरीय और बहु-स्तरीय अभियानों के लिए -मुल्टी विकल्प का उपयोग करता है।

थोड़ा सा डिस्क्लेमर

यह उपयोग करता है gdalwarp, हालांकि मैं पूरी तरह से आश्वस्त नहीं हूं कि बहुत अधिक प्रदर्शन लाभ होगा। अब तक मैं I / O बाध्य रहा हूँ - इस स्क्रिप्ट को एक बड़े रेखापुंज पर चलाते हुए इसे कई छोटे भागों में काटते हुए CPU गहन नहीं लगता है, इसलिए मुझे लगता है कि अड़चन डिस्क पर लिख रही है। यदि आप एक साथ टाइल्स या किसी समान चीज को फिर से प्रोजेक्ट कर रहे हैं, तो यह बदल सकता है। यहाँ ट्यूनिंग युक्तियाँ हैं । एक संक्षिप्त नाटक ने मेरे लिए कोई सुधार नहीं दिया, और सीपीयू कभी भी सीमित कारक नहीं लगा।

एक तरफ डिस्क्लेमर, यहां एक स्क्रिप्ट है जो gdalwarpकई छोटे टाइलों में एक रेखापुंज को विभाजित करने के लिए उपयोग करेगी । फर्श के विभाजन के कारण कुछ नुकसान हो सकता है लेकिन टाइलों की संख्या को ध्यान में रखते हुए इस पर ध्यान दिया जा सकता है। यह वह जगह होगी n+1जहां nनंबर आप tile_widthऔर tile_heightचर प्राप्त करने के लिए विभाजित करते हैं ।

import subprocess
import gdal
import sys


def gdalwarp(*args):
    return subprocess.check_call(['gdalwarp'] + list(args))


src_path = sys.argv[1]
ds = gdal.Open(src_path)

try:
    out_base = sys.argv[2]
except IndexError:
    out_base = '/tmp/test_'

gt = ds.GetGeoTransform()

width_px = ds.RasterXSize
height_px = ds.RasterYSize

# Get coords for lower left corner
xmin = int(gt[0])
xmax = int(gt[0] + (gt[1] * width_px))

# get coords for upper right corner
if gt[5] > 0:
    ymin = int(gt[3] - (gt[5] * height_px))
else:
    ymin = int(gt[3] + (gt[5] * height_px))

ymax = int(gt[3])

# split height and width into four - i.e. this will produce 25 tiles
tile_width = (xmax - xmin) // 4
tile_height = (ymax - ymin) // 4

for x in range(xmin, xmax, tile_width):
    for y in range(ymin, ymax, tile_height):
        gdalwarp('-te', str(x), str(y), str(x + tile_width),
                 str(y + tile_height), '-multi', '-wo', 'NUM_THREADS=ALL_CPUS',
                 '-wm', '500', src_path, out_base + '{}_{}.tif'.format(x, y))

Answer 5

आप GRASS GIS के r.tile का उपयोग कर सकते हैं । r.tile उपयोगकर्ता परिभाषित उपसर्ग के आधार पर गिने मानचित्र नामों के साथ प्रत्येक टाइल के लिए एक अलग रेखापुंज मानचित्र बनाता है। टाइल्स की चौड़ाई (कॉलम) और टाइल्स की ऊँचाई (पंक्तियों) को परिभाषित किया जा सकता है।

घास-सत्र पायथन एपीआई का उपयोग करते हुए पायथन कोड की कुछ पंक्तियों को बाहर से r.tile कार्यक्षमता को कॉल करने की आवश्यकता होती है, अर्थात एक स्टैंडअलोन स्क्रिप्ट लिखने के लिए। R.external और r.external.out का उपयोग करना भी GRASS GIS प्रोसेसिंग चरण के दौरान कोई डेटा दोहराव नहीं होता है।

छद्म कोड:

1. घास के सत्र को प्रारंभ करें
2. r.external.out के साथ आउटपुट स्वरूप को परिभाषित करें
3. लिंक इनपुट फ़ाइल r.external के साथ
4. रन आर.टाइल जो ऊपर परिभाषित प्रारूप में टाइल्स को उत्पन्न करता है
5. अनलिंक r.external.out
6. करीब घास-सत्र