Criando grande quantidade de pontos aleatórios em varredura binária?

Quero criar um conjunto de dados de vetores de pontos de 10000 pontos (ou maiores) em uma varredura binária, em que os pontos devem ser restritos a áreas onde o valor da varredura é 1.

Eu tentei os seguintes passos.

1. Polygonize raster
2. QGIS: Vetor -> Ferramentas de pesquisa -> Pontos aleatórios

Isso funciona bem até 2000 pontos, mas qualquer coisa acima apenas causa o travamento do QGIS.

Existe uma maneira de criar um conjunto de dados vetoriais com um grande número de recursos de pontos restringidos por uma varredura binária (ou a versão poligonalizada)?

As seguintes ferramentas estão à minha disposição, classificadas da mais à menos favorável: QGIS, Python, R, ArcGIS

É isso que eu pretendo, apenas com 10x os recursos pontuais.

Aqui está uma maneira no R:

Faça uma varredura de teste, 20x30 células, faça 1/10 das células definidas como 1, plote:

> require(raster)
> m = raster(nrow=20, ncol=30)
> m[] = as.numeric(runif(20*30)>.9)
> plot(m)

Para uma varredura existente em um arquivo, por exemplo, um geoTIFF, você pode apenas fazer:

> m = raster("mydata.tif")

Agora obtenha uma matriz das coordenadas xy das células 1, plote esses pontos e vemos que temos centros celulares:

> ones = xyFromCell(m,1:prod(dim(m)))[getValues(m)==1,]
> head(ones)
       x    y
[1,] -42 85.5
[2,] 102 85.5
[3,] 162 85.5
[4,]  42 76.5
[5,] -54 67.5
[6,]  30 67.5
> points(ones[,1],ones[,2])

Etapa 1. Gere 1000 pares (xo, yo) centralizados em 0 em uma caixa do tamanho de uma única célula. Observe o uso de respara obter o tamanho da célula:

> pts = data.frame(xo=runif(1000,-.5,.5)*res(m)[1], yo=runif(1000,-.5,.5)*res(m)[2])

Etapa 2. Calcule em qual célula cada um dos pontos acima está entrando, amostrando aleatoriamente 1000 valores de 1 ao número de 1 células:

> pts$cell = sample(nrow(ones), 1000, replace=TRUE)

Por fim, calcule a coordenada adicionando o centro da célula ao deslocamento. Traçar para verificar:

> pts$x = ones[pts$cell,1]+pts$xo
> pts$y = ones[pts$cell,2]+pts$yo
> plot(m)
> points(pts$x, pts$y)

Aqui estão 10.000 pontos (substitua os 1000 acima por 10000), plotados com pch=".":

Instantâneo para 10.000 pontos em uma varredura de 200x300 com metade dos pontos. Aumentará no tempo linearmente com quantos na varredura, eu acho.

Para salvar como um shapefile, converta para um SpatialPointsobjeto, forneça a referência correta do sistema de coordenadas (o mesmo que sua varredura) e salve:

> coordinates(pts)=~x+y
> proj4string(pts)=CRS("+init=epsg:4326") # WGS84 lat-long here
> shapefile(pts,"/tmp/pts.shp")

Isso criará um shapefile que inclui o número da célula e as compensações como atributos.

Sempre que trabalho com grandes conjuntos de dados, gosto de executar ferramentas / comandos fora do QGIS, como em um script independente ou no OSGeo4W Shell . Não muito porque o QGIS trava (mesmo que diga "Não responda", provavelmente ainda está processando os dados que você pode verificar no Gerenciador de tarefas ), mas porque mais recursos da CPU, como RAM, estão disponíveis para processar os dados. O próprio QGIS consome um bom pedaço de memória para executar.

De qualquer forma, para executar uma ferramenta fora do QGIS ( você precisaria instalar o QGIS por meio do instalador OSGeo4W ), siga as 2 primeiras etapas, conforme descrito por @gcarrillo nesta postagem: Problema com a importação do qgis.core ao escrever um script PyQGIS independente (Sugiro baixar e usar o arquivo .bat).

Depois que os PATHS estiverem definidos, digite pythonna linha de comando. Por conveniência, copie o código a seguir em um editor de texto como o Bloco de Notas, edite os parâmetros como o nome do caminho do seu shapefile etc. e cole tudo na linha de comando clicando com o botão direito do mouse> Colar :

import os, sys
from qgis.core import *
from qgis.gui import *
from PyQt4.QtGui import *

from os.path import expanduser
home = expanduser("~")

QgsApplication( [], False, home + "/AppData/Local/Temp" )

QgsApplication.setPrefixPath("C://OSGeo4W64//apps//qgis", True)
QgsApplication.initQgis()
app = QApplication([])

sys.path.append(home + '/.qgis2/python/plugins')
from processing.core.Processing import Processing
Processing.initialize()
from processing.tools import *

shape = home + "/Desktop/Polygon.shp"
result = home + "/Desktop/Point.shp"
general.runalg("qgis:randompointsinlayerbounds", shape, 10000, 0, result)

Usando o script, executei a ferramenta Pontos aleatórios nos limites da camada para obter um arquivo de forma bastante grande e levou menos de 20 segundos para gerar 10 mil pontos. A execução no QGIS levou quase 2 minutos, pelo menos para mim, há uma diferença significativa.

Você também pode usar o GRASS GIS diretamente para este trabalho - Amostragem aleatória estratificada: Amostragem aleatória a partir de um mapa vetorial com restrições espaciais :

https://grass.osgeo.org/grass72/manuals/v.random.html#stratified-random-sampling:-random-sampling-from-vector-map-with-spatial-constraints

Além disso, a amostragem aleatória do mapa vetorial por atributo e alguns outros métodos são implementados no comando.

Nota: A versão v.random exposta no QGIS através do processamento não reflete a funcionalidade completa, mas apenas uma visualização simplificada.