v.overlaygrass - En ligne dans le Cloud

PROGRAMME:

Nom

v.superposition - Superpose deux cartes vectorielles.

MOTS-CLÉS

vecteur, géométrie, requête spatiale, intersection, union, clip

SYNOPSIS

v.superposition
v.superposition --Aidez-moi
v.superposition [-t] une entrée=nom [une couche=string] [un type=string[,string,...]] binput=nom
[blaireau=string] [type b=string[,string,...]] opérateur=string sortie=nom
[ocouche=string[,string,...]] [casser=flotter] [--écraser] [--vous aider] [--verbeux]
[--calme] [--ui]

Drapeaux:
-t
Ne pas créer de table attributaire

--écraser
Autoriser les fichiers de sortie à écraser les fichiers existants

--Aidez-moi
Imprimer le récapitulatif d'utilisation

--verbeux
Sortie du module verbeux

--silencieux
Sortie module silencieuse

--interface utilisateur
Forcer le lancement de la boîte de dialogue GUI

Paramètres:
une entrée=nom [obligatoire]
Nom de la carte vectorielle d'entrée (A)
Ou source de données pour un accès OGR direct

une couche=string
Numéro ou nom de la couche (carte vectorielle A)
Les entités vectorielles peuvent avoir des valeurs de catégorie dans différentes couches. Ce nombre détermine
quelle couche utiliser. Lorsqu'il est utilisé avec un accès OGR direct, il s'agit du nom de la couche.
Valeur par défaut: 1

un type=chaîne[,chaîne,...]
Type d'entité (carte vectorielle A)
Type d'entité en entrée
Options : ligne, région, auto
Valeur par défaut: auto

binput=nom [obligatoire]
Nom de la carte vectorielle d'entrée (B)
Ou source de données pour un accès OGR direct

blaireau=string
Numéro ou nom de la couche (carte vectorielle B)
Les entités vectorielles peuvent avoir des valeurs de catégorie dans différentes couches. Ce nombre détermine
quelle couche utiliser. Lorsqu'il est utilisé avec un accès OGR direct, il s'agit du nom de la couche.
Valeur par défaut: 1

type b=chaîne[,chaîne,...]
Type d'entité (carte vectorielle B)
Type d'entité en entrée
Options : la surface
Valeur par défaut: la surface

opérateur=string [obligatoire]
L'opérateur définit les caractéristiques écrites sur la carte vectorielle de sortie
La fonction est écrite en sortie si le résultat de l'opération 'input operator binput' est
vrai. L'entité en entrée est considérée comme vraie si la catégorie d'une couche donnée est définie.
Options : et, ou, ne pas, xor
et: également connu sous le nom d'« intersection » dans les SIG
or: également appelé 'union' dans les SIG (uniquement pour atype=area)
pas: fonctionnalités de ainput non superposées par les fonctionnalités de binput
xor: fonctionnalités de ainput ou binput mais pas celles de ainput superposées par
binput (uniquement pour atype=area)

sortie=nom [obligatoire]
Nom de la carte vectorielle de sortie

ocouche=chaîne[,chaîne,...]
Couche de sortie pour la nouvelle catégorie, ainput et binput
Si 0 ou non donné, la catégorie n'est pas écrite
Valeur par défaut: 1,0,0

casser=flotter
Seuil d'accrochage pour les limites
Désactiver l'accrochage avec accrochage <= 0
Valeur par défaut: 1e-8

DESCRIPTION

v.superposition permet à l'utilisateur de superposer deux cartes vectorielles. Caractéristiques dans une entrée peut être des lignes ou
zones et sont coupés avec des zones en binput. Facile coupure peut être réalisée avec le et
.

Si les zones de une entrée sont recouverts de zones dans binput, il est parfois nécessaire de casser
domaines de binput à ceux de une entrée, sinon des zones peuvent disparaître ou de nombreuses zones de ruban
peut être créé. La capture est activée par défaut et peut être désactivée en définissant le casser
option à une valeur négative. Les valeurs recommandées sont comprises entre 0.00000001 et 0.0001. À l'aide de
des valeurs plus élevées pour l'accrochage peuvent avoir des effets secondaires indésirables, mais peuvent parfois être nécessaires
pour obtenir une sortie propre (voir l'exemple ci-dessous). En général, il est recommandé de commencer par un
petit seuil d'accrochage, augmentant progressivement le seuil jusqu'à ce que le résultat soit
raisonnablement propre. L'accrochage modifie uniquement les limites dans binput, qui sont accrochées à
limites en entrée. Limites dans une entrée ne sont pas modifiés.

Si la premier nombre de ocouche option est supérieure à 0, alors la carte de sortie résultante
a une table attributaire fusionnée dans le numéro de couche donné. Les noms de colonnes d'origine ont un
préfixe (a_ et b_) correspond à une entrée et binput carte

Si la seconde nombre de ocouche option est supérieure à 0, alors les catégories de une entrée
en couche une couche sont transférés vers la couche de sortie avec le deuxième numéro.

Si la troisième nombre de ocouche option est supérieure à 0, alors les catégories de binput
en couche blaireau sont transférés vers la couche de sortie avec le troisième numéro.

NOTES

Actuellement, seules les zones de une entrée sont pris en charge pour les opérateurs or et xor! Voir également
v.sélectionner. L'opérateur définit le type d'opération qui sera effectué. Les fonctionnalités sont écrites
à sortir, si le résultat d'une opération une entrée opérateur binput est vrai.

Si la premier nombre de ocouche option est supérieure à 0, alors les attributs des tables
à partir de une entrée et binput sont joints dans une nouvelle table liée à la carte de sortie avec un nouveau chat
colonne.

Si la seconde nombre de ocouche option est supérieure à 0, alors la table attributaire de
une entrée est copié dans la carte de sortie.

Si la troisième nombre de ocouche option est supérieure à 0, alors la table attributaire de
binput est copié dans la carte de sortie.

If un type=auto est donné que v.superposition détermine le type d'entité pour une entrée Depuis le premier
caractéristique trouvée.

EXEMPLES

Préparation d'exemples de données (exemple de jeu de données de Caroline du Nord) :
# Créez une boîte vide pour superposer à la carte vectorielle du code postal
v.mkgrid map=box grid=1,1 position=coor \
coordonnées=584037.093198,201970.387191 case=50000,50000
# définir la région sur les codes postaux et les cartes vectorielles de boîte
g.region vector=codes_postaux_wake,box -p res=100 -a
# agrandir un peu la région pour la "bordure blanche" autour de la carte dans le moniteur
g.région n=n+1000 s=s-1000 w=w-1000 e=e+1000 -p
d.lun wx0

ET opérateur
d.vect map=codes postaux_wake fill_color=0:128:0
d.vect map=box fill_color=85:130:176
v.overlay -t ainput=box binput=zipcodes_wake Operator=and output=v_overlay_AND
d.vect map=v_overlay_AND
v.overlay avec opérateur AND (polygones sélectionnés en gris)

OR opérateur
d.vect map=codes postaux_wake fill_color=0:128:0
d.vect map=box fill_color=85:130:176
v.overlay -t ainput=box binput=zipcodes_wake Operator=or output=v_overlay_OR
d.vect map=v_overlay_OR
v.overlay avec l'opérateur OR (polygones sélectionnés en gris)

GRATUIT opérateur
d.vect map=codes postaux_wake fill_color=0:128:0
d.vect map=box fill_color=85:130:176
v.overlay -t ainput=box binput=zipcodes_wake Operator=xor output=v_overlay_XOR
d.vect map=v_overlay_XOR
v.overlay avec opérateur XOR (polygones sélectionnés en gris)

ne pas opérateur
d.vect map=codes postaux_wake fill_color=0:128:0
d.vect map=box fill_color=85:130:176
v.overlay -t ainput=box binput=zipcodes_wake Operator=not output=v_overlay_NOT
d.vect map=v_overlay_NOT
v.overlay avec l'opérateur NOT (polygone sélectionné en gris)

Recouvrir opérations: ET, OU, NE PAS, GRATUIT
Exemples basés sur l'ensemble de données d'échantillons de Caroline du Nord :
# création d'un jeu de données simple
v.extract input=zipcodes_wake output=poly1 where="cat = 42"
v.extract input=urbanarea output=poly2 where="cat = 55"
v.overlay ainput=poly1 binput=poly2 opérateur=et sortie=poly_1_2_and
v.overlay ainput=poly1 binput=poly2 opérateur=ou sortie=poly_1_2_or
v.overlay ainput=poly1 binput=poly2 Operator=not output=poly_1_2_not
v.overlay ainput=poly1 binput=poly2 Operator=xor output=poly_1_2_xor
v.superposition opérations: personnages numériques originaux contribution polygones

v.superposition résultats of ET, OU, NE PAS, GRATUIT

Polygones superposé avec polygones
v.overlay ainput=lac binput=province output=lakeXprovince operator=ou
Union de polygones de la zone urbaine et des zones du recensement de 2000 (ensemble de données de la Caroline du Nord) :
# cartes d'entrée
zone urbaine d.vect
d.vect recensement_wake2000
# syndicat
v.overlay ain=census_wake2000 bin=urbanarea out=urban_census2000 operator=ou
# afficher le résultat, zoomer graphiquement un sous-ensemble
g.région n=230400 s=223800 w=655800 e=662400
effacer
d.vect urban_census2000
# afficher la table attributaire fusionnée
v.db.select urban_census2000 où="cat=108" -v
chat|108
un_chat|98
a_AREA|231001264
a_PÉRIMÈTE|67804.305
a_TRACT_|98
a_TRACT_ID|98
a_RINGS_OK|1
a_RINGS_NO|0
a_ID|98
a_FIPSSTCO|37183
a_TRT2000|054108
a_STFID|37183054108
a_TRACTID|541.08
a_TRACT|541.08
b_chat|55
b_OBJECTID|55
b_UA|73261
b_NAME|Raleigh
b_UA_TYPE|UA
v.superposition : Polygone union (À droite) of mobilier urbain la surface (la gauche) et Recensement 2000 (milieu) à fort trafic
(Nord Carolina base de données)

Comme on peut le voir par le grand nombre de centroïdes qui en résulte sur les limites, les zones urbaines
ne correspondent pas exactement aux régions du Recensement de 2000. Dans ce cas, un résultat net peut être obtenu en
encliquetage avec un seuil de 0.1 m.

Lignés superposé avec polygones
À l'aide de l'exemple de jeu de données de Caroline du Nord, nous découpons la carte des routes à la zone de la ville de
Raleigh, en préservant les attributs de la route dans la couche 1 :
g.region vector=codes postaux_wake
# extrait de la ville de Raleigh :
v.extract in=codes postaux_wake out=raleigh \
où = "ZIPNAME = 'RALEIGH'"
# couper le réseau routier au polygone de la ville :
v.overlay ainput=roadsmajor atype=line binput=raleigh \
out=roadsmajor_raleigh opérateur=et \
ocouche=0,1,0

v.superposition : Line à polygone coupure

Utilisez v.overlaygrass en ligne en utilisant les services onworks.net