geometry.cpp - mozsearch

++ // Copyright (C) 2023 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause

++

++ #include "geometry.h"

++

++ #include <QColor>

++ #include <QGeoPolygon>

++ #include <QRandomGenerator>

++ #include <QThreadPool>

++

++ QT_WARNING_PUSH

++ QT_WARNING_DISABLE_CLANG("-Wunused-but-set-variable")

++ QT_WARNING_DISABLE_GCC("-Wunused-but-set-variable")

++ #include "3rdparty/mapbox/earcut.h"

++ QT_WARNING_POP

++

++ using namespace Qt::StringLiterals;

++

++ OSMGeometry::OSMGeometry(QQuick3DGeometry *parent): QQuick3DGeometry{ parent }

++ {

++

++ }

++

++ void OSMGeometry::updateData(const QList<QVariant> &geoVariantsList)

++ {

++     QThreadPool::globalInstance()->start([this, geoVariantsList](){

++         loadGeometryFromData(geoVariantsList);

++     });

++ }

++

++ static inline void writeIndex(uint32_t *&ibPtr, uint32_t i1, uint32_t i2, uint32_t i3)

++ {

++     *ibPtr++ = i1;

++     *ibPtr++ = i2;

++     *ibPtr++ = i3;

++ }

++

++ static inline void writeVertex(float *&vbPtr, QVector3D pos, QVector3D normal,

++                                QVector3D tangent, QVector3D binormal,

++                                QColor color, float alpha,

++                                float texCoordX, float texCoordY,

++                                float levels, float isRoofTop)

++ {

++     //position

++     *vbPtr++ = pos.x();

++     *vbPtr++ = pos.y();

++     *vbPtr++ = pos.z();

++

++     *vbPtr++ = normal.x();

++     *vbPtr++ = normal.y();

++     *vbPtr++ = normal.z();

++

++            //tangent

++     *vbPtr++ = tangent.x();

++     *vbPtr++ = tangent.y();

++     *vbPtr++ = tangent.z();

++

++            //binormal

++     *vbPtr++ = binormal.x();

++     *vbPtr++ = binormal.y();

++     *vbPtr++ = binormal.z();

++

++     *vbPtr++ = color.redF();

++     *vbPtr++ = color.greenF();

++     *vbPtr++ = color.blueF();

++     *vbPtr++ = alpha;

++

++            //texcoord

++     *vbPtr++ = texCoordX;

++     *vbPtr++ = texCoordY;

++

++     *vbPtr++ = levels;

++     *vbPtr++ = isRoofTop;

++ }

++

++ void OSMGeometry::loadGeometryFromData(const QList<QVariant> &geoVariantsList)

++ {

++     constexpr int strideVertexLen = 20;

++     /* 3 Position + 3 Normal + 3 Tangent + 3 Binormal + 4 Color + 2 Texcoord0

++        + 2 Texcoord1 as Number of Levels and Is Rooftop */

++     constexpr int strideVertex = strideVertexLen * sizeof(float);

++     constexpr auto convertGeoCoordToVertexPosition = [](const float lat, const float lon) -> QVector3D {

++

++         const double scale = 1.212;

++         const double geoToPositionScale = 1000000 * scale;

++         const double XOffsetFromCenter = 537277 * scale;

++         const double YOffsetFromCenter = 327957 * scale;

++         double x = (lon/360.0 + 0.5) * geoToPositionScale;

++         double y = (1.0-log(qTan(qDegreesToRadians(lat)) + 1.0 / qCos(qDegreesToRadians(lat))) / M_PI) * 0.5 * geoToPositionScale;

++         return QVector3D( x - XOffsetFromCenter, YOffsetFromCenter - y, 0.0 );

++     };

++

++     constexpr int stridePrimitive = 3 * sizeof(uint32_t);

++

++     QByteArray vertexData;

++     QByteArray indexData;

++

++     const float maxFloat = std::numeric_limits<float>::max();

++     const float minFloat = std::numeric_limits<float>::min();

++

++     QVector3D meshMinBound = QVector3D(maxFloat, maxFloat, maxFloat);

++     QVector3D meshMaxBound = QVector3D(minFloat, minFloat, minFloat);

++

++     qsizetype globalVertexCounter = 0;

++     qsizetype globalPrimitiveCounter = 0;

++

++     for ( const QVariant &baseData : geoVariantsList ) {

++         for ( const QVariant &dataValue : baseData.toMap()["data"_L1].toList() ) {

++             const auto featureMap = dataValue.toMap();

++             const auto properties = featureMap["properties"_L1].toMap();

++             const auto buildingCoords = featureMap["data"_L1].value<QGeoPolygon>().perimeter();

++             float height = 0.15 * properties["height"_L1].toLongLong();

++             float levels = static_cast<float>(properties["levels"_L1].toLongLong());

++             QColor color = QColor::fromString( properties["color"_L1].toString());

++             if ( !color.isValid() || color == QColor(Qt::GlobalColor::black))

++                 color = QColor(Qt::GlobalColor::white);

++             QColor roofColor = QColor::fromString( properties["roofColor"_L1].toString());

++             if ( !roofColor.isValid() || roofColor == QColor(Qt::GlobalColor::black) )

++                 roofColor = color;

++

++             QVector3D subsetMinBound = QVector3D(maxFloat, maxFloat, maxFloat);

++             QVector3D subsetMaxBound = QVector3D(minFloat, minFloat, minFloat);

++

++             qsizetype numSubsetVertices = buildingCoords.size() * 2;

++             qsizetype lastVertexDataCount = vertexData.size();

++             qsizetype lastIndexDataCount = indexData.size();

++             vertexData.resize( lastVertexDataCount + numSubsetVertices * strideVertex );

++             indexData.resize( lastIndexDataCount + ( numSubsetVertices - 2 ) * stridePrimitive );

++

++             float *vbPtr = &reinterpret_cast<float *>(vertexData.data())[globalVertexCounter * strideVertexLen];

++             uint32_t *ibPtr = &reinterpret_cast<uint32_t *>(indexData.data())[globalPrimitiveCounter * 3];

++

++             qsizetype subsetVertexCounter = 0;

++

++             QVector3D lastBaseVertexPos;

++             QVector3D lastExtrudedVertexPos;

++             QVector3D currentBaseVertexPos;

++             QVector3D currentExtrudedVertexPos;

++             QVector3D subsetPolygonCenter;

++

++             using PolygonVertex = std::array<double, 2>;

++             using PolygonVertices = std::vector<PolygonVertex>;

++

++             PolygonVertices roofPolygonVertices;

++

++             for ( const QGeoCoordinate &buildingPoint : buildingCoords ) {

++

++                 lastBaseVertexPos = currentBaseVertexPos;

++                 lastExtrudedVertexPos = currentExtrudedVertexPos;

++

++                 currentBaseVertexPos = convertGeoCoordToVertexPosition( buildingPoint.latitude(), buildingPoint.longitude() );

++                 currentExtrudedVertexPos = QVector3D(currentBaseVertexPos.x(), currentBaseVertexPos.y(), height);

++

++                 roofPolygonVertices.push_back( {currentBaseVertexPos.x(),currentBaseVertexPos.y()} );

++                 subsetPolygonCenter.setX( subsetPolygonCenter.x() + currentBaseVertexPos.x() );

++                 subsetPolygonCenter.setY( subsetPolygonCenter.y() + currentBaseVertexPos.y() );

++

++                 meshMinBound.setX( qMin( meshMinBound.x(), currentBaseVertexPos.x() ) );

++                 meshMinBound.setY( qMin( meshMinBound.y(), currentBaseVertexPos.y() ) );

++                 meshMinBound.setZ( qMin( meshMinBound.z(), currentBaseVertexPos.z() ) );

++

++                 meshMaxBound.setX( qMax( meshMaxBound.x(), currentExtrudedVertexPos.x() ) );

++                 meshMaxBound.setY( qMax( meshMaxBound.y(), currentExtrudedVertexPos.y() ) );

++                 meshMaxBound.setZ( qMax( meshMaxBound.z(), currentExtrudedVertexPos.z() ) );

++

++                 subsetMinBound.setX( qMin( subsetMinBound.x(), currentBaseVertexPos.x() ) );

++                 subsetMinBound.setY( qMin( subsetMinBound.y(), currentBaseVertexPos.y() ) );

++                 subsetMinBound.setZ( qMin( subsetMinBound.z(), currentBaseVertexPos.z() ) );

++

++                 subsetMaxBound.setX( qMax( subsetMaxBound.x(), currentExtrudedVertexPos.x() ) );

++                 subsetMaxBound.setY( qMax( subsetMaxBound.y(), currentExtrudedVertexPos.y() ) );

++                 subsetMaxBound.setZ( qMax( subsetMaxBound.z(), currentExtrudedVertexPos.z() ) );

++

++                 if ( subsetVertexCounter < numSubsetVertices - 2 ) {

++                     writeIndex(ibPtr, globalVertexCounter + 3, globalVertexCounter + 2,

++                                globalVertexCounter + 0);

++                     writeIndex(ibPtr, globalVertexCounter + 1, globalVertexCounter + 3,

++                                globalVertexCounter + 0);

++                     globalPrimitiveCounter += 2;

++                 }

++

++                 if ( subsetVertexCounter == 2 ) {

++

++                     QVector3D tangent = (currentExtrudedVertexPos - currentBaseVertexPos).normalized();

++                     QVector3D binormal = (lastBaseVertexPos - currentBaseVertexPos).normalized();

++                     QVector3D normal = QVector3D::crossProduct( binormal, tangent).normalized();

++

++                     writeVertex(vbPtr, lastBaseVertexPos, normal, tangent, binormal, color,

++                                 1.0F, 0.0F, 0.0F, levels, 0.0F);

++                     writeVertex(vbPtr, lastExtrudedVertexPos, normal, tangent, binormal, color,

++                                 1.0F, 0.0F, 1.0F, levels, 0.0F);

++                 }

++

++                 if ( subsetVertexCounter >= 2 ) {

++

++                     QVector3D tangent = (currentExtrudedVertexPos - currentBaseVertexPos).normalized();

++                     QVector3D binormal = (lastBaseVertexPos - currentBaseVertexPos).normalized();

++                     QVector3D normal = QVector3D::crossProduct( binormal, tangent).normalized();

++

++                     const float xCoord = ( subsetVertexCounter % 4 != 0) ? 1.0F : 0.0F;

++

++                     writeVertex(vbPtr, currentBaseVertexPos, normal, tangent, binormal, color,

++                                 1.0, xCoord, 0.0, levels, 0.0);

++                     writeVertex(vbPtr, currentExtrudedVertexPos, normal, tangent, binormal, color,

++                                 1.0, xCoord, 1.0, levels, 0.0);

++                 }

++

++                 subsetVertexCounter += 2;

++                 globalVertexCounter += 2;

++

++             }

++

++             const auto shape = properties["shape"_L1].toString();

++             {

++

++                 if ( shape == "sphere"_L1) {

++

++                     subsetPolygonCenter = QVector3D(subsetPolygonCenter.x() / roofPolygonVertices.size(),

++                                                     subsetPolygonCenter.y() / roofPolygonVertices.size(), height );

++

++                     float sphereRadius = 2.0F * qAbs(roofPolygonVertices[0][0] - subsetPolygonCenter.x());

++

++                     sphereRadius = qMax(sphereRadius, 1.0);

++                     float sphereRadiuslengthInv = 1.0F / sphereRadius;

++

++                     const uint32_t sphereSectorCount = 10;

++                     const uint32_t sphereStackCount = 10;

++

++                     constexpr double sphereSectorStep = 2.0 * M_PI / sphereSectorCount;

++                     constexpr double sphereStackStep = M_PI / sphereStackCount;

++

++                     lastVertexDataCount = vertexData.size();

++                     lastIndexDataCount = indexData.size();

++                     uint32_t sphereVertexCount = (sphereStackCount + 1) * (sphereSectorCount + 1);

++                     uint32_t indexCount = 2 * (sphereStackCount - 2) * (sphereSectorCount + 1)

++                             + 2 * (sphereSectorCount + 1); // one index only for stack 0, n-1

++                     vertexData.resize( lastVertexDataCount + sphereVertexCount * strideVertex );

++                     indexData.resize( lastIndexDataCount + indexCount * 3 * sizeof(uint32_t) );

++                     vbPtr = &reinterpret_cast<float *>(vertexData.data())[globalVertexCounter * strideVertexLen];

++                     ibPtr = &reinterpret_cast<uint32_t *>(indexData.data())[globalPrimitiveCounter * 3];

++

++                     for (uint32_t stackIndex = 0; stackIndex <= sphereStackCount; ++stackIndex) {

++                         float k1 = stackIndex * (sphereSectorCount + 1);

++                         float k2 = k1 + sphereSectorCount + 1;

++

++                         const float sphereStackAngle = M_PI / 2.0 - stackIndex * sphereStackStep;

++                         float xy = sphereRadius * qCos(sphereStackAngle);

++                         float z = sphereRadius * qSin(sphereStackAngle);

++

++                         for (uint32_t sectorIndex = 0; sectorIndex <= sphereSectorCount; ++sectorIndex,  ++k1, ++k2) {

++                             if (stackIndex != sphereStackCount) {

++                                 if (stackIndex != 0) {

++                                     writeIndex(ibPtr, k1 + globalVertexCounter,

++                                                k2 + globalVertexCounter,

++                                                k1 + 1 + globalVertexCounter);

++                                     ++globalPrimitiveCounter;

++                                 }

++

++                                 if (stackIndex != (sphereStackCount - 1)) {

++                                     writeIndex(ibPtr, k1 + 1 + globalVertexCounter,

++                                                k2 + globalVertexCounter,

++                                                k2 + 1 + globalVertexCounter);

++                                     ++globalPrimitiveCounter;

++                                 }

++                             }

++

++                             const float sphereSectorAngle = sectorIndex * sphereSectorStep;

++

++                             float x = xy * qCos(sphereSectorAngle);

++                             float y = xy * qSin(sphereSectorAngle);

++

++                             QVector3D position{x + subsetPolygonCenter.x(),

++                                                y + subsetPolygonCenter.y(),

++                                                z + subsetPolygonCenter.z()};

++

++                             QVector3D normal{x * sphereRadiuslengthInv,

++                                              y * sphereRadiuslengthInv,

++                                              z * sphereRadiuslengthInv};

++                             QVector3D tangent{0.0F, 0.0F, 0.0F};

++                             QVector3D binormal{0.0F, 0.0F, 0.0F};

++                             writeVertex(vbPtr, position, normal, tangent, binormal, roofColor,

++                                         1.0F, 1.0F, 1.0F, 0.0F, 1.0F);

++                         }

++                     }

++                     subsetVertexCounter += sphereVertexCount;

++                     globalVertexCounter += sphereVertexCount;

++                 }

++                 {

++

++                     std::vector<PolygonVertices> roofPolygonsVertices;

++                     roofPolygonsVertices.push_back( roofPolygonVertices );

++                     std::vector<uint32_t> roofIndices = mapbox::earcut<uint32_t>(roofPolygonsVertices);

++

++                     lastVertexDataCount = vertexData.size();

++                     lastIndexDataCount = indexData.size();

++                     vertexData.resize( lastVertexDataCount + roofPolygonVertices.size() * strideVertex );

++                     indexData.resize( lastIndexDataCount + roofIndices.size() * sizeof(uint32_t) );

++

++                     vbPtr = &reinterpret_cast<float *>(vertexData.data())[globalVertexCounter * strideVertexLen];

++                     ibPtr = &reinterpret_cast<uint32_t *>(indexData.data())[globalPrimitiveCounter * 3];

++

++                     for ( const uint32_t &roofIndex : roofIndices ) {

++                         *ibPtr++ = roofIndex + globalVertexCounter;

++                     }

++                     qsizetype roofPrimitiveCount = roofIndices.size() / 3;

++                     globalPrimitiveCounter += roofPrimitiveCount;

++

++                     for ( const PolygonVertex &polygonVertex : roofPolygonVertices ) {

++                         QVector3D position{float(polygonVertex.at(0)),

++                                            float(polygonVertex.at(1)), height};

++                         QVector3D normal{0.0F, 0.0F, 1.0F};

++                         QVector3D tangent{1.0F, 0.0F, 0.0F};

++                         QVector3D binormal{0.0F, 1.0F, 0.0F};

++                         writeVertex(vbPtr, position, normal, tangent, binormal, roofColor,

++                                     1.0F, 1.0F, 1.0F, 0.0F, 1.0F);

++                         ++subsetVertexCounter;

++                         ++globalVertexCounter;

++                     }

++

++                 }

++

++             }

++         }

++     }

++

++     clear();

++

++     setIndexData(indexData);

++

++     setVertexData(vertexData);

++

++     setStride(strideVertex);

++

++     setBounds(meshMinBound, meshMaxBound);

++

++     setPrimitiveType(QQuick3DGeometry::PrimitiveType::Triangles);

++

++     addAttribute(QQuick3DGeometry::Attribute::IndexSemantic, 0, QQuick3DGeometry::Attribute::U32Type);

++

++     addAttribute(QQuick3DGeometry::Attribute::PositionSemantic, 0, QQuick3DGeometry::Attribute::F32Type);

++

++     addAttribute(QQuick3DGeometry::Attribute::NormalSemantic, 3 * sizeof(float), QQuick3DGeometry::Attribute::F32Type);

++

++     addAttribute(QQuick3DGeometry::Attribute::TangentSemantic, 6 * sizeof(float), QQuick3DGeometry::Attribute::F32Type);

++

++     addAttribute(QQuick3DGeometry::Attribute::BinormalSemantic, 9 * sizeof(float), QQuick3DGeometry::Attribute::F32Type);

++

++     addAttribute(QQuick3DGeometry::Attribute::ColorSemantic, 12 * sizeof(float), QQuick3DGeometry::Attribute::F32Type);

++

++     addAttribute(QQuick3DGeometry::Attribute::TexCoord0Semantic, 16 * sizeof(float), QQuick3DGeometry::Attribute::F32Type);

++

++     addAttribute(QQuick3DGeometry::Attribute::TexCoord1Semantic, 18 * sizeof(float), QQuick3DGeometry::Attribute::F32Type);

++

++     update();

++

++     emit geometryReady();

++

++ }

++

Revision control