Polygone de la zone de calcul à l'aide de la Latitude et de la Longitude générés à partir de l'espace Cartésien et un fichier de l'univers

Donné une série de paires de coordonnées GPS, j'ai besoin de calculer l'aire d'un polygone (n-gon). C'est relativement petite (pas plus de 50 000 pieds carrés). Les géocodes sont créés par l'application d'une transformation affine avec des données provenant d'un fichier de l'univers.

J'ai essayé d'utiliser une approche en deux étapes en faisant la conversion des géocodes en coordonnées cartésiennes:

double xPos = (lon-lonAnchor)*( Math.toRadians( 6378137 ) )*Math.cos( latAnchor );
double yPos = (lat-latAnchor)*( Math.toRadians( 6378137 ) );

puis-je utiliser un la croix du produit de calcul pour déterminer la surface.

Le problème est que les résultats sont un peu en précision (environ 1%). Est-ce que je peux regarder dans pour améliorer cela?

Grâce.

OriginalL'auteur Heath Lilley | 2010-05-18

2

1% d'erreur semble un peu élevé en raison de juste votre rapprochement. Êtes-vous une comparaison avec des mesures réelles, ou un idéal de calcul? Rappelez-vous qu'il y a erreur dans le GPS, ainsi que peut-être contribuer.

Si vous voulez une méthode plus précise pour ce faire, il y a une bonne réponse à cette question. Si vous allez pour un moyen plus rapide, vous pouvez utiliser le WGS84 géoïde au lieu de votre sphère de référence pour la conversion de coordonnées cartésiennes (ECEF). Voici la lien wiki pour cette conversion.

Je suis une comparaison avec des mesures réelles de zones connues. Une note intéressante est que si je lance les coordonnées GPS par l'intermédiaire d'un Haversine méthode je reçois très précise de la distance de calculs de rendement précis de périmètre valeurs.
Désolé pour la réponse tardive, a fini par utiliser le WGs84 géoïde avec le proj4 bibliothèque java. Très travaillé, merci pour l'aide.

OriginalL'auteur Ron Warholic
3

Je suis à la modification d'une Carte de Google, de sorte qu'un utilisateur peut calculer la surface
d'un polygone en cliquant sur les sommets. Il ne donnait pas correct
les zones jusqu'à ce que j'ai fait en sorte que le calcul.cos(latAnchor) était en radians première

Donc:
```
double xPos = (lon-lonAnchor)*( Math.toRadians( 6378137 ) )*Math.cos( latAnchor );
```
est devenu:
```
double xPos = (lon-lonAnchor)*( 6378137*PI/180 ) )*Math.cos( latAnchor*PI/180 );
```
où lon, lonAnchor et latAnchor sont en degrés. Fonctionne comme un charme maintenant.

OriginalL'auteur Sandy
2

J'ai vérifié sur internet pour diverses polygone de la zone de formules(ou code) mais n'a pas trouver un bon ou facile à mettre en œuvre.

Maintenant, j'ai écrit l'extrait de code pour calculer l'aire d'un polygone dessiné sur la surface de la terre. Le polygone peut avoir n sommets avec chaque sommet a, de son propre latitude longitude.

Quelques Points Importants
1. Le tableau d'entrée de cette fonction aura "n + 1". Le dernier élément va avoir les mêmes valeurs que celle de la première.
2. J'ai écrit très de base de code C#, de sorte que les gars peuvent aussi s'adapter à d'autres langues.
3. 6378137 est la valeur du rayon de la terre en mètres.
4. La zone de sortie aura de l'unité de mètres carrés
```
private static double CalculatePolygonArea(IList<MapPoint> coordinates)
{
    double area = 0;

    if (coordinates.Count > 2)
    {
        for (var i = 0; i < coordinates.Count - 1; i++)
        {
            MapPoint p1 = coordinates[i];
            MapPoint p2 = coordinates[i + 1];
            area += ConvertToRadian(p2.Longitude - p1.Longitude) * (2 + Math.Sin(ConvertToRadian(p1.Latitude)) + Math.Sin(ConvertToRadian(p2.Latitude)));
        }

        area = area * 6378137 * 6378137 /2;
    }

    return Math.Abs(area);
}

private static double ConvertToRadian(double input)
{
    return input * Math.PI /180;
}
```
J'ai essayé ton code, mais quelque chose est faux. des idées? Voir: code
vous avez mis "area = zone * R * R / 2;" à l'intérieur de la boucle alors qu'il devrait être en dehors de la boucle.
Je pense que vous devriez convertir p1.Longitude et p2.Longitude en radians. Après avoir fait cette modification, je me suis vraiment similaire résultat que j'ai obtenu à partir de google.maps.geometry.spherical.computeArea fonction.
Après les corrections, cela semble très bien. Et est très similaire en getGeodesicArea à Ouvrir les Calques (moins de projection de la partie). Voir: github.com/openlayers/openlayers/blob/v2.13.1/lib/OpenLayers/...
tks pour le code, adapté à PHP et affiché comme une réponse distincte. UPVOTED 🙂

OriginalL'auteur Risky Pathak

Basé sur la solution par Risqué Pathak voici la solution pour SQL (Redshift) pour calculer les zones de GeoJSON multipolygons (avec l'hypothèse que linestring 0 est le plus éloigné du polygone)

create or replace view geo_area_area as 
with points as (
    select ga.id as key_geo_area
    , ga.name, gag.linestring
    , gag.position
    , radians(gag.longitude) as x
    , radians(gag.latitude) as y
    from geo_area ga
    join geo_area_geometry gag on (gag.key_geo_area = ga.id)
)
polygons as (
    select key_geo_area, name, linestring, position 
    , x
    , lag(x) over (partition by key_geo_area, linestring order by position) as prev_x
    , y
    , lag(y) over (partition by key_geo_area, linestring order by position) as prev_y
    from points
)
area_linestrings as (
    select key_geo_area, name, linestring
    , abs( sum( (x - prev_x) * (2 + sin(y) + sin(prev_y)) ) ) * 6378137 * 6378137 /2 /10^6 as area_km_squared
    from polygons
    where position != 0
    group by 1, 2, 3
)
select key_geo_area, name
sum(case when linestring = 0 then area_km_squared else -area_km_squared end) as area_km_squared
from area_linestrings
group by 1, 2
;

OriginalL'auteur LauriK

Adapté RiskyPathak de l'extrait de code PHP

function CalculatePolygonArea($coordinates) {
    $area = 0;
    $coordinatesCount = sizeof($coordinates);
    if ($coordinatesCount > 2) {
      for ($i = 0; $i < $coordinatesCount - 1; $i++) {
        $p1 = $coordinates[$i];
        $p2 = $coordinates[$i + 1];
        $p1Longitude = $p1[0];
        $p2Longitude = $p2[0];
        $p1Latitude = $p1[1];
        $p2Latitude = $p2[1];
        $area += ConvertToRadian($p2Longitude - $p1Longitude) * (2 + sin(ConvertToRadian($p1Latitude)) + sin(ConvertToRadian($p2Latitude)));
      }
    $area = $area * 6378137 * 6378137 /2;
    }
    return abs(round(($area));
}

function ConvertToRadian($input) {
    $output = $input * pi() /180;
    return $output;
}

OriginalL'auteur tony gil

Vous devez vous connecter pour publier un commentaire.