Parcours d'apprentissage de l'API GDAL C++ (5) Classe de géométrie OGRGeometry OGRGeometry

Distance

distance virtuelle double(const  OGRGeometry *) const

Calculer la distance entre deux géométries Renvoie la distance la plus courte entre deux géométries. Les distances sont exprimées dans les mêmes unités que les coordonnées géométriques

paramètre:

poOtherGeom  – Une autre géométrie à comparer.

Renvoie : la distance entre les géométries, ou -1 en cas d'erreur

// 创建两个点
OGRPoint point1(0, 0);
OGRPoint point2(3, 4);

// 计算两个点之间的距离
double distance = point1.Distance(&point2);

cout << "Distance between point1 and point2: " << distance << endl;

Enveloppe convexe

OGRGéométrie virtuelle   *ConvexHull（） const

Compute Convex Hull créera et renverra un nouvel objet Geometry contenant la coque convexe de la géométrie sur laquelle la méthode est appelée

Renvoie : la géométrie nouvellement allouée appartenant maintenant à l'appelant, ou NULL en cas d'échec

    // 创建一个线环（LinearRing）
    OGRLinearRing ring;
    ring.addPoint(0, 0);
    ring.addPoint(1, 0);
    ring.addPoint(1, 1);
    ring.addPoint(0, 1);
    ring.addPoint(0, 0);

    // 创建一个多边形（Polygon）
    OGRPolygon polygon;
    polygon.addRing(&ring);

    // 计算凸包
    OGRGeometry* convexHull = polygon.ConvexHull();

    // 输出凸包的WKT表示
    char* wkt;
    convexHull->exportToWkt(&wkt);
    std::cout << "Convex Hull: " << wkt << std::endl;

    // 释放内存
    CPLFree(wkt);
    delete convexHull;

ConcaveCoque

OGRGéométrie virtuelle   *ConcaveHull(double dfRatio, bool bAllowHoles) const

Calcul de la "coque concave" d'une géométrie Calcul de la "coque concave" d'une géométrie

La coque concave est entièrement contenue dans la coque convexe et contient également tous les points de l'entrée, mais avec une zone plus petite. Le rapport de surface est le rapport des surfaces des coques convexes et concaves. Couramment utilisé pour convertir des multipoints en régions polygonales. contient tous les points de la géométrie d'entrée

paramètre:

• dfRatio  - le rapport de la surface des coques convexes et concaves.

• bAllowHole  -- si les trous sont autorisés.

Renvoie : la géométrie nouvellement allouée appartenant maintenant à l'appelant, ou NULL en cas d'échec

    // 创建一个线环（LinearRing）
    OGRLinearRing ring;
    ring.addPoint(0, 0);
    ring.addPoint(1, 0);
    ring.addPoint(1, 1);
    ring.addPoint(0, 1);
    ring.addPoint(0, 0);

    // 创建一个多边形（Polygon）
    OGRPolygon polygon;
    polygon.addRing(&ring);

    // 计算凹多边形凸包
    double concaveHullRatio = 0.8; // 指定一个凹多边形凸包的压缩比例
    bool allowHoles = true;        // 允许生成含有洞的凹多边形凸包
    OGRGeometry* concaveHull = polygon.ConcaveHull(concaveHullRatio, allowHoles);

    // 输出凹多边形凸包的WKT表示
    char* wkt;
    concaveHull->exportToWkt(&wkt);
    std::cout << "Concave Hull: " << wkt << std::endl;

    // 释放内存
    CPLFree(wkt);
    delete concaveHull;

Amortir

OGRGeometry virtuelle   *Buffer（double dfDist， int nQuadSegs = 30） const

Tampon de géométrie computationnelle

Génère une nouvelle géométrie contenant le tampon à partir duquel elle a été appelée. Une zone tampon est un polygone qui contient la zone à l'intérieur de la distance de la zone tampon de la géométrie d'origine

Certaines parties de la zone tampon sont correctement décrites comme des courbes, mais sont converties en polygones approximatifs. Le paramètre nQuadSegs peut être utilisé pour contrôler le nombre de lignes à utiliser pour définir les quadrants du cercle de courbe à 90 degrés. Une valeur de 30 est une valeur par défaut raisonnable. Des valeurs plus grandes entraînent un grand nombre de sommets dans la géométrie de tampon résultante, tandis que des nombres plus petits réduisent la précision des résultats

paramètre:

• dfDist  – La distance tampon à appliquer. Doit être exprimé dans les mêmes unités que les coordonnées géométriques.

• nQuadSegs  -- Nombre de segments utilisés pour approximer une courbure de 90 degrés (quadrant).

Renvoie : la géométrie nouvellement créée, ou NULL si une erreur s'est produite

 // 创建一个点（Point）
 OGRPoint point(0, 0);

// 对点进行缓冲区分析，生成一个缓冲区几何对象
double bufferDistance = 1.0; // 缓冲区的距离
int numQuadSegments = 30;    // 四边形段数，用于控制缓冲区的平滑程度
OGRGeometry* buffer = point.Buffer(bufferDistance, numQuadSegments);

Intersection

OGRGeometry virtuelle *Intersection（const  OGRGeometry *） const

Calculer l'intersection

Génère une nouvelle géométrie qui est la région d'intersection des deux géométries sur lesquelles s'effectue l'opération. La  méthode Intersects() peut être utilisée pour tester si deux géométries se croisent

La validité de la géométrie n'est pas vérifiée. Si vous n'êtes pas sûr de la validité de la géométrie d'entrée, appelez IsValid() avant  , sinon le résultat peut être erroné

paramètre:

poOtherGeom  -- Une autre géométrie qui croise "cette" géométrie.

Renvoie : la nouvelle géométrie représentant le point d'intersection, ou NULL s'il n'y a pas d'intersection ou si une erreur se produit

    // 创建两个多边形对象
    OGRLinearRing ring1, ring2;
    ring1.addPoint(0, 0);
    ring1.addPoint(0, 1);
    ring1.addPoint(1, 1);
    ring1.addPoint(1, 0);
    ring1.addPoint(0, 0);

    ring2.addPoint(0.5, 0.5);
    ring2.addPoint(0.5, 1.5);
    ring2.addPoint(1.5, 1.5);
    ring2.addPoint(1.5, 0.5);
    ring2.addPoint(0.5, 0.5);

    OGRPolygon polygon1, polygon2;
    polygon1.addRing(&ring1);
    polygon2.addRing(&ring2);

    // 计算两个多边形的交集
    OGRGeometry* intersection = polygon1.Intersection(&polygon2);

syndicat

OGRGeometry virtuelle *Union（const  OGRGeometry *） const 

Fédération de calcul

Génère une nouvelle géométrie qui est la région d'union des deux géométries opérées

La validité de la géométrie n'est pas vérifiée. Si vous n'êtes pas sûr de la validité de la géométrie d'entrée, appelez IsValid() avant  , sinon le résultat peut être erroné

paramètre:

poOtherGeom  -- L'autre géométrie à combiner avec "cette" géométrie.

Renvoie : la nouvelle géométrie représentant l'union ou NULL en cas d'erreur

// 创建两个多边形对象
    OGRLinearRing ring1, ring2;
    ring1.addPoint(0, 0);
    ring1.addPoint(0, 1);
    ring1.addPoint(1, 1);
    ring1.addPoint(1, 0);
    ring1.addPoint(0, 0);

    ring2.addPoint(0.5, 0.5);
    ring2.addPoint(0.5, 1.5);
    ring2.addPoint(1.5, 1.5);
    ring2.addPoint(1.5, 0.5);
    ring2.addPoint(0.5, 0.5);

    OGRPolygon polygon1, polygon2;
    polygon1.addRing(&ring1);
    polygon2.addRing(&ring2);

    // 计算两个多边形的并集
    OGRGeometry* unionGeometry = polygon1.Union(&polygon2);

UnionEn cascade

OGRGéométrie virtuelle   *UnionCascaded（） const

Calculer l'union en cascade Les géométries d'entrée doivent avoir plusieurs facettes

La validité de la géométrie n'est pas vérifiée. Si vous n'êtes pas sûr de la validité de la géométrie d'entrée, appelez IsValid() avant  , sinon le résultat peut être erroné

Renvoie : la nouvelle géométrie représentant l'union ou NULL en cas d'erreur

    // 创建一个多边形对象
    OGRLinearRing ring;
    ring.addPoint(0, 0);
    ring.addPoint(0, 1);
    ring.addPoint(1, 1);
    ring.addPoint(1, 0);
    ring.addPoint(0, 0);

    OGRPolygon polygon;
    polygon.addRing(&ring);

    // 计算多边形与其自身的并集
    OGRGeometry* unionGeometry = polygon.UnionCascaded();

• Virtual OGRGeometry *UnionCascaded() const: Cette fonction permet de retourner l'union (Union) de l'objet géométrie courant avec lui-même. C'est-à-dire qu'il combine tous les composants géométriques de l'objet géométrique courant pour obtenir un nouvel objet géométrique contenant tous les composants. Par exemple, si l'objet géométrique actuel est un polygone qui contient plusieurs anneaux disjoints, la fonction renvoie un nouveau polygone qui contient l'union de tous les anneaux.

• Virtual OGRGeometry *Union(const OGRGeometry*) const: Cette fonction permet de retourner l'union (Union) de l'objet géométrie courant et d'un autre objet géométrie. Autrement dit, il effectue une opération d'union sur l'objet géométrique actuel avec un autre objet géométrique pour obtenir un nouvel objet géométrique qui contient tous les composants des deux objets géométriques. Par exemple, si l'objet géométrique actuel est un polygone et que le paramètre passé est un autre polygone, la fonction renverra un nouveau polygone qui contient le résultat de l'union des deux polygones

• Résumer:

• UnionCascaded()La fonction est utilisée pour calculer le résultat de l'union à l'intérieur de l'objet géométrique courant.
• Union(const OGRGeometry*)La fonction est utilisée pour calculer le résultat de l'union de l'objet géométrique courant et d'un autre objet géométrique

UnaryUnion

OGRGéométrie  *UnaryUnion（） const

Renvoie l'union de tous les composants d'une même géométrie, généralement utilisée pour convertir une collection en le plus petit ensemble de polygones couvrant la même zone

Renvoie : la nouvelle géométrie représentant l'union ou NULL en cas d'erreur

    // 创建两个多边形对象
    OGRLinearRing ring1;
    ring1.addPoint(0, 0);
    ring1.addPoint(0, 1);
    ring1.addPoint(1, 1);
    ring1.addPoint(1, 0);
    ring1.addPoint(0, 0);

    OGRPolygon polygon1;
    polygon1.addRing(&ring1);

    OGRLinearRing ring2;
    ring2.addPoint(1, 1);
    ring2.addPoint(1, 2);
    ring2.addPoint(2, 2);
    ring2.addPoint(2, 1);
    ring2.addPoint(1, 1);

    OGRPolygon polygon2;
    polygon2.addRing(&ring2);

    // 计算两个多边形对象的一元并集
    OGRGeometry* unaryUnionGeometry = polygon1.Union(&polygon2);

Différence

virtuelle  OGRGeometry  *Difference(const  OGRGeometry *) const

calculer la différence

Génère une nouvelle géométrie qui est la région de cette géométrie avec la région de la deuxième géométrie supprimée

La validité de la géométrie n'est pas vérifiée. Si vous n'êtes pas sûr de la validité de la géométrie d'entrée, appelez IsValid() avant  , sinon le résultat peut être erroné

paramètre:

poOtherGeom  – L'autre géométrie à supprimer de la géométrie "this".

Renvoie : la nouvelle géométrie représentant la différence, ou NULL si la différence est vide ou si une erreur s'est produite

    // 创建两个多边形对象
    OGRLinearRing ring1;
    ring1.addPoint(0, 0);
    ring1.addPoint(0, 2);
    ring1.addPoint(2, 2);
    ring1.addPoint(2, 0);
    ring1.addPoint(0, 0);

    OGRPolygon polygon1;
    polygon1.addRing(&ring1);

    OGRLinearRing ring2;
    ring2.addPoint(1, 1);
    ring2.addPoint(1, 3);
    ring2.addPoint(3, 3);
    ring2.addPoint(3, 1);
    ring2.addPoint(1, 1);

    OGRPolygon polygon2;
    polygon2.addRing(&ring2);

    // 计算两个多边形对象的差异
    OGRGeometry* differenceGeometry = polygon1.Difference(&polygon2);

SymDifférence

OGRGeometry virtuelle *SymDifference（const  OGRGeometry *） const

Calculer la différence symétrique

Génère une nouvelle géométrie qui est la différence symétrique de cette géométrie et de la deuxième géométrie passée dans la méthode

La validité de la géométrie n'est pas vérifiée. Si vous n'êtes pas sûr de la validité de la géométrie d'entrée, appelez IsValid() avant  , sinon le résultat peut être erroné

paramètre:

poOtherGeom  -- l'autre géométrie.

Renvoie : la nouvelle géométrie représentant la différence symétrique, ou NULL si la différence est vide ou si une erreur se produit

    // 创建两个多边形对象
    OGRLinearRing ring1;
    ring1.addPoint(0, 0);
    ring1.addPoint(0, 2);
    ring1.addPoint(2, 2);
    ring1.addPoint(2, 0);
    ring1.addPoint(0, 0);

    OGRPolygon polygon1;
    polygon1.addRing(&ring1);

    OGRLinearRing ring2;
    ring2.addPoint(1, 1);
    ring2.addPoint(1, 3);
    ring2.addPoint(3, 3);
    ring2.addPoint(3, 1);
    ring2.addPoint(1, 1);

    OGRPolygon polygon2;
    polygon2.addRing(&ring2);

    // 计算两个多边形对象的对称差异
    OGRGeometry* symDifferenceGeometry = polygon1.SymDifference(&polygon2);

Centroïde

virtuel OGRErr Centroid（OGRPoint  *poPoint） const

Calculer le centroïde géométrique

La position du centroïde est appliquée à l'  objet OGRPoint entrant  . Le centroïde n'est pas nécessairement dans la géométrie

Renvoie : OGRERR_NONE en cas de succès ou OGRERR_FAILURE en cas d'erreur

    // 创建一个多边形对象
    OGRLinearRing ring;
    ring.addPoint(0, 0);
    ring.addPoint(0, 4);
    ring.addPoint(4, 4);
    ring.addPoint(4, 0);
    ring.addPoint(0, 0);

    OGRPolygon polygon;
    polygon.addRing(&ring);

    // 创建一个空的 OGRPoint 对象用于存储质心
    OGRPoint centroidPoint;

    // 计算多边形对象的质心
    OGRErr err = polygon.Centroid(&centroidPoint);

    if (err == OGRERR_NONE) {
        // 输出质心的坐标
        double x = centroidPoint.getX();
        double y = centroidPoint.getY();
        std::cout << "Centroid coordinates: (" << x << ", " << y << ")" << std::endl;
    } else {
        std::cout << "Error calculating centroid." << std::endl;