Suite

Générez des points aléatoires pour les ID avec des coordonnées similaires avec ArcMap


J'ai un ensemble de données qui se compose d'identifiants avec des adresses et des coordonnées (long/lat). Certains identifiants ont des coordonnées similaires. Comment générer des points aléatoires pour les identifiants qui ont ces coordonnées similaires ? Par exemple, j'ai 60 ID avec le même long/lat et ils sont situés dans la même province. Comment utiliser l'outil Générer des points aléatoires dans ArcMap pour générer 60 points aléatoires dans la même province, puis créer ultérieurement une nouvelle colonne pour stocker ces nouvelles coordonnées ?

En ce moment, j'ai plus de 10 000 points dans l'ensemble de données. Je peux les cartographier, mais cela semble trompeur car certains identifiants se voient attribuer des coordonnées similaires à des fins de simplicité - et ils sont tous empilés les uns sur les autres sur la carte.

J'ai la couche province et tous les points sont récupérés à partir d'un fichier .csv


Générer des coordonnées géographiques aléatoires dans un rayon spécifique à partir du point de départ

J'utilise la fonction suivante pour générer des coordonnées géographiques aléatoires dans un rayon spécifié à partir d'un point de départ :

Je fais cela en boucle, plusieurs fois, en utilisant un rayon de 2000 m et le point de départ suivant :

Je m'attendrais plutôt à ce que tous ces résultats soient à moins de 2000 m, je vois des valeurs supérieures à 10000 m :

Étant donné que je (sans gêne!) a plagié cette solution d'ailleurs (bien que j'aie vu plusieurs implémentations similaires), je n'arrive pas à comprendre où les calculs vont mal.

(De plus, au cas où vous le voudriez, voici comment je calcule la distance. Je suis presque sûr que c'est correct.)


Création d'entités d'index de grille

Les entités d'index de grille peuvent être utilisées pour définir chaque page de votre atlas. Ces entités peuvent définir l'étendue spatiale, la référence spatiale et d'autres propriétés de la page de carte, ainsi qu'étiqueter les pages adjacentes. Les outils de géotraitement des pages dynamiques peuvent être utilisés pour créer les entités et les données nécessaires à la série de cartes.

L'exemple ci-dessus montre un livre de cartes topographiques pour le comté d'Arenac, dans le Michigan. Cette série de 22 pages peut être facilement créée par tout utilisateur d'ArcMap disposant d'une connexion Internet. Les données proviennent du service de cartes topographiques des États-Unis disponible sur ArcGIS Online. Aucune autre donnée n'est nécessaire pour recréer cette série de cartes. Vous pouvez facilement recréer cette série de référence à l'aide des pages dynamiques, des outils de géotraitement disponibles dans le jeu d'outils Pages dynamiques, des propriétés du bloc de données et du texte dynamique.

Les étapes suivantes utilisent l'outil de géotraitement Entités d'index de grille pour créer une classe d'entités d'index de grille. Il s'agit de la classe d'entités utilisée pour définir l'étendue de la carte pour l'exemple d'atlas ci-dessus. Ces étapes supposent que vous avez effectué les étapes décrites dans les rubriques suivantes :

Avertir:

Bien que vous puissiez adapter ces étapes pour vos propres cartes ou atlas, gardez à l'esprit que les étapes citées dans cet exemple sont spécifiques à l'exemple d'atlas illustré ci-dessus. L'utilisation de ces étapes exactes sur un autre ensemble de cartes peut entraîner des résultats inattendus.

    Ouvrez l'outil de géotraitement Entités d'index de grille.

Vous pouvez trouver l'outil en ouvrant Rechercher et en tapant Fonctionnalités d'index de grille , ou vous pouvez localiser l'outil sous Boîtes à outils > Boîtes à outils système > Outils de cartographie > Pages dynamiques .

Bien que vous puissiez enregistrer la sortie dans un fichier de formes, les fonctions d'indexation utilisées pour cet exemple doivent spécifier la zone UTM appropriée pour chaque page. La sortie nécessite un champ de texte contenant ces informations. Étant donné que ce champ peut être très long, beaucoup plus long que celui autorisé par un fichier de formes, vous allez écrire la sortie dans une géodatabase fichier.

Étant donné que cet exemple n'utilise pas d'entités en entrée pour définir l'étendue des entités d'index de grille, vous devez entrer les coordonnées x,y d'origine de la grille. L'origine de la grille est le coin inférieur gauche. Par conséquent, vous devez trouver un point pour commencer la grille. Pour que la grille s'adapte à toute la zone d'étude, la coordonnée x de l'origine doit être à gauche de la zone d'intérêt et la coordonnée y doit être en dessous de la zone d'intérêt. Assurez-vous que les valeurs des coordonnées sont dans les bonnes unités. Pour cet exemple, la carte est une projection UTM, les unités de la carte sont donc des mètres.

Une nouvelle classe d'entités, Arenac_grid_index est créée et, si ArcMap est ouvert, ajoutée à votre bloc de données actif. Comme vous pouvez le voir, certaines grilles ne couvrent que l'eau. Vous ne voudrez peut-être pas ces pages dans votre atlas. Pour éviter que des pages contenant uniquement de l'eau n'apparaissent dans votre atlas, supprimez simplement les entités de grille correspondantes. Pour savoir comment supprimer des entités, consultez Suppression d'une entité.

Bien que cette classe d'entités contienne des champs qui seront utiles pour la série de cartes, elle ne contient pas tout ce qui est nécessaire. Des champs supplémentaires pour étiqueter les pages adjacentes et un champ pour déterminer la zone UTM correcte pour chaque page doivent être créés. Voir Modification de la couche d'entités d'index de grille pour voir comment ces champs sont ajoutés aux entités d'index.


Exemple de code

Près de l'exemple 1 (fenêtre Python)

Le script de fenêtre interactive Python suivant montre comment utiliser la fonction Near en mode immédiat.

Près de l'exemple 2 (script autonome)

Le script Python suivant montre comment utiliser la fonction Near dans un script autonome.

Près de l'exemple 3 (script autonome)

Le script Python suivant montre comment convertir l'angle proche en azimut.

Près de l'exemple 4 (script autonome)

Le script Python suivant illustre le post-traitement avec la sortie dérivée de l'outil Near. Le script recherche, pour chaque entité proche, les entités en entrée dont elle est la plus proche.


Géométrie computationnelle.

  • Intervalles. Un intervalle est défini par deux Comparable objets du même type. Program Interval.java représente un intervalle 1D.
  • Intervalles. Un intervalle 2D est défini par deux intervalles 1D, éventuellement de types différents. (Peut-être devrions-nous les faire du même type pour plus de simplicité puisque c'est tout ce dont nous avons besoin.) Program Interval2D.java représente un intervalle 2D.
  • Polygones. Les polygones sont une abstraction mathématique utile pour représenter les formes d'objets du monde réel (lettres pour la reconnaissance optique de caractères, obstacles à éviter par un robot, district du Congrès américain, morceaux d'un profil aérodynamique). Le programme Polygon.java est un type de données pour les polygones fermés. Un polygone est une suite de points p0 à travers pN, où nous supposons que le premier point est égal au dernier point, c'est-à-dire que le polygone est fermé. Le périmètre est la somme des distances euclidiennes des N segments de droite. Le zone signée d'un polygone non auto-sécant est donnée par

Le polygone est dans le sens inverse des aiguilles d'une montre si la zone est positive. Nous supposons que les points sont indexés de 0 à N-1 et que le point N est égal au point 0. Le centre de gravité (ou centre de masse) d'un polygone non auto-sécant est donné par le point (x, y) où x et y sont définis par

Pour dessiner un polygone ombré à l'écran, nous devons savoir si chaque pixel (i, j) est à l'intérieur ou à l'extérieur du polygone. Le théorème de la courbe de Jordan implique n'importe quel plan de partitions de polygones dans un fini à l'intérieur région et un infini à l'extérieur Région. Solution (méthode de croisement de rayons) : tracez un rayon de (i, j) vers le bas et comptez le nombre de fois qu'il traverse le polygone (pair = extérieur, impair = intérieur). Intution : pensez au polygone comme à une clôture et comptez le nombre de fois où vous sautez par-dessus la clôture.


4 réponses 4

Vous voulez que la proportion de points soit uniformément proportionnelle à surface plutôt que la distance à l'origine. Puisque l'aire est proportionnelle à la distance au carré, générez des aires aléatoires uniformes et prendre leurs racines carrées mettre à l'échelle les résultats comme vous le souhaitez. Combinez cela avec un angle polaire uniforme.

C'est rapide et simple à coder, efficace dans l'exécution (surtout sur une plate-forme parallèle), et génère exactement le nombre de points prescrit.

Exemple

C'est du code R fonctionnel pour illustrer l'algorithme.

Je vais vous donner une réponse générale à n dimensions qui fonctionne aussi pour le cas à deux dimensions, bien sûr. En trois dimensions, l'analogue d'un disque est le volume d'une boule solide (sphère).

Il y a deux approches dont je vais discuter. L'un d'eux que j'appellerais "précis", et vous obtiendrez une solution complète dans R. Le second que j'appelle heuristique, et ce n'est que l'idée, aucune solution complète n'est fournie.


5 réponses 5

L'approche habituelle consiste à générer $n+1$ i.i.d. moyenne zéro variables aléatoires gaussiennes $X_1, dotsc, X_$ pour obtenir un point aléatoire $X$ dans l'espace $(n+1)$ avec une distribution invariante en rotation et normaliser.

Incidemment, si jamais vous avez réellement besoin de générer un point aléatoire dans une $n$-ball, le meilleur moyen est probablement de générer un point aléatoire dans la $(n+1)$-sphere comme ci-dessus et de supprimer les deux dernières coordonnées.

Voici un algorithme qui produit des nombres aléatoires distribués normaux :

En divisant le vecteur aléatoire de n+1 nombres aléatoires par la norme du vecteur, vous obtenez des nombres aléatoires sur la n-sphère.

Je ne peux pas résister à un lien vers ce joyau qui décrit une méthode simple pour une généralisation de votre problème.

Bonne question! J'ai rencontré un problème similaire il y a quelques années - même pour la dimension 10 $, la méthode de rejet était extrêmement lente. L'un des problèmes est que de telles questions chevauchent au moins trois domaines immenses (mathématiques discrètes, statistiques et informatique), si souvent on ne sait pas par où commencer.

Voici ce que nous avons finalement utilisé : une bonne solution explicite sur la façon de générer des points uniformément aléatoires sur la $n$-sphère peut être trouvée dans la section III de l'article non publié :

Cumbus, Damien, Marcheur, Échantillonnage uniforme dans l'hypersphère via des variables latentes et l'échantillonneur de Gibbs (1996).

Vous pouvez trouver une copie de leur travail ici. Si vous voulez échantillonner à partir d'un sous-ensemble mesurable de la $n$-sphère au lieu de l'ensemble, essayez le rapport technique (beaucoup moins explicite)

Shao, Badler, Échantillonnage sphérique par le théorème d'Archimède (aussi 1996)


Abstrait

La plaine Hamoon-Jazmoorian est située au sud-est de l'Iran. La surexploitation des eaux souterraines dans cette plaine a entraîné une baisse du niveau de l'eau et causé de graves problèmes tels que l'affaissement des terres, la destruction des aquifères et la dégradation de la qualité de l'eau. L'augmentation de la population et du développement agricole, ainsi que la sécheresse et le changement climatique, ont encore accru la pression sur les ressources en eau dans cette région au cours des dernières années. Afin de surmonter une telle crise, l'introduction d'eau de surface dans un aquifère à des endroits particuliers peut être une solution appropriée. Une grande variété de méthodes ont été développées pour recharger les eaux souterraines, dont l'une est le stockage et la récupération des aquifères (ASR). L'un des principes fondamentaux de la création de tels systèmes est la délimitation de zones appropriées sur la base de faits scientifiques et naturels afin d'atteindre les objectifs pertinents. À cette fin, la prise de décision multicritère (MCDM) en conjonction avec les systèmes d'information géographique (SIG) a été appliquée dans cette étude. Plus précisément, neuf paramètres principaux, y compris la profondeur du ruissellement comme source d'eau considérée, la morphologie des caractéristiques de la surface de la terre telles que la géologie, la géomorphologie, l'utilisation des terres et la couverture terrestre, les caractéristiques du drainage et de l'aquifère ainsi que la qualité de l'eau dans l'aquifère ont été considérés comme les principales couches du SIG. L'eau de ruissellement disponible pour la recharge artificielle dans le bassin a été estimée par la méthode du nombre de courbes du Soil Conservation Service (SCS). Le numéro de la courbe pondérée pour chaque bassin versant a été dérivé par intersection spatiale de l'utilisation des terres et des couches de groupes de sols hydrologiques. D'autres couches thématiques ont été extraites d'images satellites, de cartes topographiques et d'autres sources de données collatérales, puis pesées en fonction de leur influence dans le processus de localisation. La méthode Analytical Hierarchy Process (AHP) a ensuite été utilisée pour calculer les poids des paramètres individuels. Les couches pondérées normalisées ont ensuite été superposées pour construire la carte du potentiel de recharge. Les résultats ont révélé que 34% de la superficie totale est convenable et très convenable pour la recharge des eaux souterraines.


Vous voudrez peut-être que vos points voyagent à une vitesse de 0,5 point, n'est-ce pas ? Disons donc qu'une distance plus longue doit être parcourue en un temps plus long.

Obtenez la longueur de la distance Pour cela, vous aurez besoin de deux choses. Obtenez le vecteur de distance, puis trouvez sa valeur de longueur.

distancevec = final - départ
distance = distancevec.longueur()

Si vous ne connaissez pas les mathématiques des vecteurs, vous pouvez calculer la longueur d'un vecteur avec cette formule : d = sqrt(pow(v.x, 2) + pow(v.y, 2)) .

Obtenez le temps que cela prendra et mettez à jour la dernière fois. Celui-ci est facile. Comme vous voulez que chaque tick parcoure une longueur de 0,5, il suffit de faire une simple division et de voir combien de ticks nous avons.

AVIS: Peut-être que ce n'est peut-être pas la vitesse prévue pour vous, mais c'est la bonne. Vous avez donc un mouvement linéaire, même sur des mouvements diagonaux. Si vous appliquez x += 0.5f et y += 0.5f , la vitesse résultante serait différente aux diagonales (donnée par la formule de longueur ci-dessus)


9.5 Préparation des données pour R2WinBUGS

df <- read.table("SnowyFinal.txt", sep=" ")
tête (df)
str(df)
df$IDvar <- substr(df$id, 2,5)
df$IDvar <- as.integer(df$IDvar)
#Nettoyez et supprimez les données manquantes concernant l'état de la maladie, le sexe et l'âge
résumé(df$Statut)
df <- subset(df, df$Status !="Inconnu")
df$Status <- factor(df$Status)
résumé(df$Statut)
#Recoder les classes de sexe et supprimer les NA
résumé(df$Sexe)
df <- subset(df, df$Sexe !="")
df$Sexe <- factor(df$Sexe)
df$Sex2 <- as.character(df$Sex)
df$Sex2[df$Sex2 == "Homme"] <- "1"
df$Sex2[df$Sex2 == "Femme"] <- "0"
df$Sexe2
#Recoder les classes d'âge et supprimer les NA
résumé(df$Âge)
df <- subset(df, df$Age !="")
df$Age <- factor(df$Age)
table(df$Âge)
#Classes d'âge
# 2-5 3 6+ Veau adulte d'un an
# 188 1 79 5 36 30
#Combiner les classes d'âge
df$NewAge <- df$Age
niveaux(df$NewAge)<-list(Yearling=c("Veau","Yearling"),Adult=c("2-5","3","6+","Adult"))
résumé(df$NewAge)
#Maintenant, convertissez l'âge en numérique avec Yearling=0 (baseline) et Adult=1
df$Age2 <- df$NewAge
df$Age2 <- as.character(df$Age2)
df$Age2[df$Age2 == "Adulte"] <- "1"
df$Age2[df$Age2 == "Yearling"] <- "0"
df$Age2
df$KillYear <- as.factor(df$KillYear)

résumé(df$KillYear)
#2009 2011 2012
23 15 1

#Créez un cadre de données spatiales des emplacements après avoir supprimé les valeurs aberrantes
coords<-data.frame(x = df$X_Coordina, y = df$Y_Coordina)
utm.crs<-"+proj=utm +zone=12 +datum=NAD83 +units=m +no_defs +ellps=GRS80 +towgs84=0,0,0"
utm.spdf <- SpatialPointsDataFrame(coords= coords, data = df, proj4string = CRS(utm.crs))

#Maintenant, transformez toutes les projections pour qu'elles correspondent au DEM (c'est-à-dire Albers)
Albers.crs <-CRS("+proj=aea +lat_1=20 +lat_2=60 +lat_0=40 +lon_0=-96 +x_0=0 +y_0=0 +ellps=GRS80
+towgs84=0,0,0,0,0,0,0,0 +units=m +no_defs")
df.spdf <-spTransform(utm.spdf, CRS=Albers.crs)

#REMARQUE : nous avons ajouté 3 cellules autour de la plupart des échantillons externes pour englober toutes les maladies
#samples jusqu'à ce que vous puissiez comprendre comment étendre les polygones de la grille
snowy.df <- as.data.frame(df.spdf)
str(enneigé.df)
minx <- (min(snowy.df$x)-10830)
maxx <- (max(neige.df$x)+10830)
miny <- (min(snowy.df$y)-10830)
maxy <- (max(neige.df$y)+10830)

#Créer des vecteurs des points x et y
x <-seq(de = minx, à = maxx, par = 3610)
y <-seq(from = miny, to = maxy, by = 3610)

#Créer une grille de toutes les paires de coordonnées (sous forme de data.frame)
xy <- expand.grid(x = x, y = y)

Résultat<-df$Status2
Grid_ID<-df$ID
Sexe<-df$Sexe2
Âge<-df$Âge2
Dem <- df$dem
Pente<-df$pente
Aspect <- df$aspect
HSI <- df$HSI
Eau<-df$
Dev<-df$développé
Pour<-df$forêt
Arbuste<-df$arbuste
Herbe<-df$herbe
Recadrage<-df$recadrage
Zone humide<-df$humide
Maymax <- df$mayBigmax
Junmax <- df$juinBigmax
Jul1max <- df$jul1Bigmax
Jul2max <- df$jul2Bigmax
Augmax <- df$augBigmax
Sep1max <- df$sep1Bigmax
Sep2max <- df$sep2Bigmax
Maysum <- df$mayBigsum
Julsum <- df$julyBigsum
Sepsum <- df$sepBigsum

shape_nb <- poly2nb(grid)
NumCells= longueur(shape_nb)
num=sapply(shape_nb,length)
adj=unlist(forme_nb)
sumNumNeigh=length(unlist(shape_nb))


Voir la vidéo: échantillonnage systématique. aléatoire ArcGis (Octobre 2021).