qgsjsonutils.cpp

Go to the documentation of this file.

/***************************************************************************
    qgsjsonutils.h
     -------------
    Date                 : May 206
    Copyright            : (C) 2016 Nyall Dawson
    Email                : nyall dot dawson at gmail dot com
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "qgsjsonutils.h"
 
#include <nlohmann/json.hpp>
 
#include "qgsapplication.h"
#include "qgscircularstring.h"
#include "qgscompoundcurve.h"
#include "qgscurvepolygon.h"
#include "qgsexception.h"
#include "qgsfeatureid.h"
#include "qgsfeatureiterator.h"
#include "qgsfieldformatter.h"
#include "qgsfieldformatterregistry.h"
#include "qgsgeometry.h"
#include "qgslinestring.h"
#include "qgslogger.h"
#include "qgsmulticurve.h"
#include "qgsmultilinestring.h"
#include "qgsmultipoint.h"
#include "qgsmultipolygon.h"
#include "qgsmultisurface.h"
#include "qgsogrutils.h"
#include "qgspolygon.h"
#include "qgsproject.h"
#include "qgsrelation.h"
#include "qgsrelationmanager.h"
#include "qgsvectorlayer.h"
 
#include <QJsonArray>
#include <QJsonDocument>
#include <QString>
#include <QTextCodec>
 
#include "moc_qgsjsonutils.cpp"
 
using namespace Qt::StringLiterals;
 
QgsJsonExporter::QgsJsonExporter( QgsVectorLayer *vectorLayer, int precision )
  : mPrecision( precision )
  , mLayer( vectorLayer )
{
  if ( vectorLayer )
  {
    mCrs = vectorLayer->crs();
    mTransform.setSourceCrs( mCrs );
  }
 
  // Default CRS84
  mDestinationCrs = QgsCoordinateReferenceSystem( u"OGC:CRS84"_s );
  mTransform.setDestinationCrs( mDestinationCrs );
}
 
void QgsJsonExporter::setVectorLayer( QgsVectorLayer *vectorLayer )
{
  mLayer = vectorLayer;
  if ( vectorLayer )
  {
    mCrs = vectorLayer->crs();
    mTransform.setSourceCrs( mCrs );
  }
}
 
QgsVectorLayer *QgsJsonExporter::vectorLayer() const
{
  return mLayer.data();
}
 
void QgsJsonExporter::setSourceCrs( const QgsCoordinateReferenceSystem &crs )
{
  mCrs = crs;
  mTransform.setSourceCrs( mCrs );
}
 
QgsCoordinateReferenceSystem QgsJsonExporter::sourceCrs() const
{
  return mCrs;
}
 
QString QgsJsonExporter::exportFeature( const QgsFeature &feature, const QVariantMap &extraProperties, const QVariant &id, int indent, const QVariantMap &extraMembers ) const
{
  try
  {
    return QString::fromStdString( exportFeatureToJsonObject( feature, extraProperties, id, extraMembers ).dump( indent ) );
  }
  catch ( json::type_error &ex )
  {
    QgsLogger::warning( u"Cannot export feature to json: %1"_s.arg( ex.what() ) );
    return QString();
  }
  catch ( json::other_error &ex )
  {
    QgsLogger::warning( u"Cannot export feature to json: %1"_s.arg( ex.what() ) );
    return QString();
  }
}
 
json QgsJsonExporter::exportFeatureToJsonObject( const QgsFeature &feature, const QVariantMap &extraProperties, const QVariant &id, const QVariantMap &extraMembers ) const
{
  // Required by RFC7946, but also needed for JSON-FG profiles if the source (or destination) CRS is not CRS84
  QgsCoordinateTransform transformToCRS84 { mTransform };
  transformToCRS84.setDestinationCrs( QgsCoordinateReferenceSystem( u"OGC:CRS84"_s ) );
 
  const bool destinationCrsIsRfc7946Compliant = mDestinationCrs.authid() == "OGC:CRS84" || mDestinationCrs.authid() == "EPSG:4326" || mDestinationCrs.authid() == "CRS:84";
  const bool sourceCrsIsRfc7946Compliant = ( mCrs.authid() == "OGC:CRS84" || mCrs.authid() == "CRS:84" || mCrs.authid() == "EPSG:4326" );
  // Output requires CRS84 coordinates if the GeoJSON profile is RFC7946 or JSON-FG+ (which requires RFC7946 compliance for geometries) or if the requested CRS is CRS84
  const bool requiresCRS84geom = ( mGeoJsonProfile == Qgis::GeoJsonProfile::Rfc7946 || mGeoJsonProfile == Qgis::GeoJsonProfile::JsonFgPlus )
                                 || ( mTransformGeometries && destinationCrsIsRfc7946Compliant );
 
  // Already transformed
  const bool geomRequiresTransformToDestinationCrs = mCrs != mDestinationCrs;
 
  QgsGeometry geom = feature.geometry();
 
  const bool includeGeometryInformation { !geom.isNull() && mIncludeGeometry };
  const Qgis::WkbType flatType = QgsWkbTypes::flatType( feature.geometry().wkbType() );
  const bool featureHasM { QgsWkbTypes::hasM( geom.wkbType() ) };
  const bool mainGeometryIsRfc7946Compliant {
    !featureHasM
    && destinationCrsIsRfc7946Compliant
    && ( flatType == Qgis::WkbType::LineString || flatType == Qgis::WkbType::MultiLineString || flatType == Qgis::WkbType::Polygon || flatType == Qgis::WkbType::MultiPolygon || flatType == Qgis::WkbType::Point || flatType == Qgis::WkbType::MultiPoint || flatType == Qgis::WkbType::GeometryCollection )
  };
 
  json featureJson {
    { "type", "Feature" },
  };
 
  if ( !mOmitCollectionLevelInformation && ( mGeoJsonProfile == Qgis::GeoJsonProfile::JsonFgPlus || mGeoJsonProfile == Qgis::GeoJsonProfile::JsonFg ) )
  {
    featureJson["conformsTo"] = { "http://www.opengis.net/spec/json-fg-1/1.0/conf/core" };
    if ( includeGeometryInformation )
    {
      if ( featureHasM )
      {
        featureJson["conformsTo"].push_back( "http://www.opengis.net/spec/json-fg-1/1.0/conf/measures" );
        featureJson["measures"] = { { "enabled", true } };
      }
      QgsJsonUtils::addCrsInfo( featureJson, mDestinationCrs, mGeoJsonProfile );
    }
  }
 
  //foreign members
  if ( !extraMembers.isEmpty() )
  {
    QVariantMap::const_iterator it = extraMembers.constBegin();
    for ( ; it != extraMembers.constEnd(); ++it )
    {
      featureJson[it.key().toStdString()] = QgsJsonUtils::jsonFromVariant( it.value() );
    }
  }
 
  if ( id.isValid() )
  {
    bool ok = false;
    auto intId = id.toLongLong( &ok );
    if ( ok )
    {
      featureJson["id"] = intId;
    }
    else
    {
      featureJson["id"] = id.toString().toStdString();
    }
  }
  else if ( FID_IS_NULL( feature.id() ) )
  {
    featureJson["id"] = nullptr;
  }
  else
  {
    featureJson["id"] = feature.id();
  }
 
  // ////////////////////////////////////////
  // Geometry handling
 
  if ( includeGeometryInformation )
  {
    // If it is JSON-FG plus we need both CRS84 and the requested CRS
    QgsGeometry transformedCRS84Geom = geom;
 
    if ( requiresCRS84geom )
    {
      if ( sourceCrsIsRfc7946Compliant )
      {
        transformedCRS84Geom = geom;
      }
      else
      {
        try
        {
          transformedCRS84Geom.transform( transformToCRS84 );
        }
        catch ( QgsCsException &cse )
        {
          Q_UNUSED( cse )
        }
      }
    }
 
    // Do we need to transform the main geometry to the destination CRS?
    if ( mGeoJsonProfile != Qgis::GeoJsonProfile::Rfc7946 && geomRequiresTransformToDestinationCrs )
    {
      if ( destinationCrsIsRfc7946Compliant )
      {
        geom = transformedCRS84Geom;
      }
      else if ( mCrs.isValid() )
      {
        try
        {
          geom.transform( mTransform );
        }
        catch ( QgsCsException &cse )
        {
          Q_UNUSED( cse )
        }
      }
    }
 
 
    std::function<void( json & )> invertCoords;
    invertCoords = [&invertCoords]( json &geometry ) {
      if ( geometry.contains( "coordinates" ) )
      {
        invertCoords( geometry["coordinates"] );
      }
      else if ( geometry.contains( "geometries" ) )
      {
        for ( json &geom : geometry["geometries"] )
        {
          invertCoords( geom );
        }
      }
      else if ( geometry.is_array() && geometry.size() > 0 )
      {
        if ( geometry[0].is_array() )
        {
          for ( json &geom : geometry )
          {
            invertCoords( geom );
          }
        }
        else
        {
          if ( geometry.size() >= 2 && geometry[0].is_number() && geometry[1].is_number() )
          {
            std::swap( geometry[0], geometry[1] );
          }
        }
      }
    };
 
    auto addBbox = [&featureJson, &flatType, this]( const QgsGeometry &geometry ) {
      if ( flatType == Qgis::WkbType::Point )
      {
        // For points, the bbox is just the coordinates of the point (or the points)
        return;
      }
      auto bbox = geometry.boundingBox();
      featureJson["bbox"]
        = { qgsRound( bbox.xMinimum(), this->mPrecision ), qgsRound( bbox.yMinimum(), this->mPrecision ), qgsRound( bbox.xMaximum(), this->mPrecision ), qgsRound( bbox.yMaximum(), this->mPrecision ) };
    };
 
    switch ( mGeoJsonProfile )
    {
      case Qgis::GeoJsonProfile::Rfc7946:
      {
        featureJson["geometry"] = transformedCRS84Geom.asJsonObject( mPrecision, Qgis::GeoJsonProfile::Rfc7946 );
        addBbox( transformedCRS84Geom );
        break;
      }
      case Qgis::GeoJsonProfile::Legacy:
      {
        featureJson["geometry"] = geom.asJsonObject( mPrecision, Qgis::GeoJsonProfile::Rfc7946 );
        addBbox( geom );
        break;
      }
      case Qgis::GeoJsonProfile::JsonFgPlus:
      {
        // See: https://docs.ogc.org/is/21-045r1/21-045r1.html#_use_of_geometry_andor_place
        // If the geometry is a valid GeoJSON geometry (that is, conformant to the GeoJSON RFC7946 specification),
        // the geometry is encoded as the value of the "geometry" member. The "place" member then has the value null or is omitted.
 
        // PLUS version: always add the fallback geometry as "geometry" member, so that the output is always compliant with RFC7946.
        // If the geometry is not compliant with RFC7946 also add the original geometry as "place" member.
        featureJson["geometry"] = transformedCRS84Geom.asJsonObject( mPrecision, Qgis::GeoJsonProfile::Rfc7946 );
        addBbox( transformedCRS84Geom );
        if ( !mainGeometryIsRfc7946Compliant )
        {
          json place = geom.asJsonObject( mPrecision, mGeoJsonProfile );
          if ( mDestinationCrs.hasAxisInverted() )
          {
            invertCoords( place );
          }
          featureJson["place"] = place;
        }
        break;
      }
      case Qgis::GeoJsonProfile::JsonFg:
      {
        // See: https://docs.ogc.org/is/21-045r1/21-045r1.html#_use_of_geometry_andor_place
        // Add "geometry" or "place" depending on whether the geometry is compliant with RFC7946 or not.
        // In the latter case, the "geometry" member is omitted.
        if ( !mainGeometryIsRfc7946Compliant )
        {
          json place = geom.asJsonObject( mPrecision, mGeoJsonProfile );
          if ( mDestinationCrs.hasAxisInverted() )
          {
            invertCoords( place );
          }
          featureJson["place"] = place;
        }
        else
        {
          featureJson["geometry"] = geom.asJsonObject( mPrecision, mGeoJsonProfile );
        }
        break;
      }
    }
  }
  else
  {
    featureJson["geometry"] = nullptr;
  }
 
  // build up properties element
  json properties;
  if ( mIncludeAttributes || !extraProperties.isEmpty() )
  {
    //read all attribute values from the feature
    if ( mIncludeAttributes )
    {
      QgsFields fields = mLayer ? mLayer->fields() : feature.fields();
      // List of formatters through we want to pass the values
      QStringList formattersAllowList;
      formattersAllowList << u"KeyValue"_s << u"List"_s << u"ValueRelation"_s << u"ValueMap"_s;
 
      for ( int i = 0; i < fields.count(); ++i )
      {
        if ( ( !mAttributeIndexes.isEmpty() && !mAttributeIndexes.contains( i ) ) || mExcludedAttributeIndexes.contains( i ) )
          continue;
 
        QVariant val = feature.attributes().at( i );
 
        if ( mUseFieldFormatters && mLayer )
        {
          const QgsEditorWidgetSetup setup = fields.at( i ).editorWidgetSetup();
          const QgsFieldFormatter *fieldFormatter = QgsApplication::fieldFormatterRegistry()->fieldFormatter( setup.type() );
          if ( formattersAllowList.contains( fieldFormatter->id() ) )
            val = fieldFormatter->representValue( mLayer.data(), i, setup.config(), QVariant(), val );
        }
 
        QString name = fields.at( i ).name();
        if ( mAttributeDisplayName )
        {
          name = mLayer->attributeDisplayName( i );
        }
        properties[name.toStdString()] = QgsJsonUtils::jsonFromVariant( val );
      }
    }
 
    if ( !extraProperties.isEmpty() )
    {
      QVariantMap::const_iterator it = extraProperties.constBegin();
      for ( ; it != extraProperties.constEnd(); ++it )
      {
        properties[it.key().toStdString()] = QgsJsonUtils::jsonFromVariant( it.value() );
      }
    }
 
    // related attributes
    if ( mLayer && mIncludeRelatedAttributes )
    {
      QList< QgsRelation > relations = QgsProject::instance()->relationManager()->referencedRelations( mLayer.data() ); // skip-keyword-check
      for ( const auto &relation : std::as_const( relations ) )
      {
        QgsFeatureRequest req = relation.getRelatedFeaturesRequest( feature );
        req.setFlags( Qgis::FeatureRequestFlag::NoGeometry );
        QgsVectorLayer *childLayer = relation.referencingLayer();
        json relatedFeatureAttributes;
        if ( childLayer )
        {
          QgsFeatureIterator it = childLayer->getFeatures( req );
          QVector<QVariant> attributeWidgetCaches;
          int fieldIndex = 0;
          const QgsFields fields { childLayer->fields() };
          for ( const QgsField &field : fields )
          {
            QgsEditorWidgetSetup setup = field.editorWidgetSetup();
            QgsFieldFormatter *fieldFormatter = QgsApplication::fieldFormatterRegistry()->fieldFormatter( setup.type() );
            attributeWidgetCaches.append( fieldFormatter->createCache( childLayer, fieldIndex, setup.config() ) );
            fieldIndex++;
          }
          QgsFeature relatedFet;
          while ( it.nextFeature( relatedFet ) )
          {
            relatedFeatureAttributes += QgsJsonUtils::exportAttributesToJsonObject( relatedFet, childLayer, attributeWidgetCaches, mUseFieldFormatters );
          }
        }
        properties[relation.name().toStdString()] = relatedFeatureAttributes;
      }
    }
  }
  featureJson["properties"] = properties;
 
  return featureJson;
}
 
QString QgsJsonExporter::exportFeatures( const QgsFeatureList &features, int indent ) const
{
  return QString::fromStdString( exportFeaturesToJsonObject( features ).dump( indent ) );
}
 
json QgsJsonExporter::exportFeaturesToJsonObject( const QgsFeatureList &features ) const
{
  json data { { "type", "FeatureCollection" }, { "features", json::array() } };
  const bool omitCollectionLevelInformation = mOmitCollectionLevelInformation;
  mOmitCollectionLevelInformation = true;
  switch ( mGeoJsonProfile )
  {
    case Qgis::GeoJsonProfile::Legacy:
    case Qgis::GeoJsonProfile::Rfc7946:
    {
      for ( const QgsFeature &feature : features )
      {
        data["features"].push_back( exportFeatureToJsonObject( feature ) );
      }
      break;
    }
    case Qgis::GeoJsonProfile::JsonFg:
    case Qgis::GeoJsonProfile::JsonFgPlus:
    {
      json conformsTo = json::array( { { "http://www.opengis.net/spec/json-fg-1/1.0/conf/core" } } );
      QgsJsonUtils::addCrsInfo( data, mDestinationCrs, mGeoJsonProfile );
      bool hasCircularArcs = false;
      bool hasMeasure = false;
      for ( const QgsFeature &feature : features )
      {
        const QgsGeometry geom = feature.geometry();
        const Qgis::WkbType flatType = QgsWkbTypes::flatType( geom.wkbType() );
        if ( flatType == Qgis::WkbType::CircularString || flatType == Qgis::WkbType::CompoundCurve || flatType == Qgis::WkbType::CurvePolygon )
        {
          hasCircularArcs = true;
        }
        if ( QgsWkbTypes::hasM( feature.geometry().wkbType() ) )
        {
          hasMeasure = true;
        }
        data["features"].push_back( exportFeatureToJsonObject( feature ) );
      }
      if ( hasCircularArcs )
      {
        conformsTo.push_back( { "http://www.opengis.net/spec/json-fg-1/1.0/conf/circular-arcs" } );
      }
      if ( hasMeasure )
      {
        conformsTo.push_back( { "http://www.opengis.net/spec/json-fg-1/1.0/conf/measures" } );
        data["measures"] = { { "enabled", true } };
      }
      data["conformsTo"] = conformsTo;
      break;
    }
  }
  mOmitCollectionLevelInformation = omitCollectionLevelInformation;
  return data;
}
 
void QgsJsonExporter::setDestinationCrs( const QgsCoordinateReferenceSystem &destinationCrs )
{
  mDestinationCrs = destinationCrs;
  mTransform.setDestinationCrs( mDestinationCrs );
}
 
Qgis::GeoJsonProfile QgsJsonExporter::geoJsonProfile() const
{
  return mGeoJsonProfile;
}
 
void QgsJsonExporter::setGeoJsonProfile( Qgis::GeoJsonProfile profile )
{
  mGeoJsonProfile = profile;
}
 
//
// QgsJsonUtils
//
 
QgsFeatureList QgsJsonUtils::stringToFeatureList( const QString &string, const QgsFields &fields, QTextCodec *encoding )
{
  if ( !encoding )
    encoding = QTextCodec::codecForName( "UTF-8" );
 
  return QgsOgrUtils::stringToFeatureList( string, fields, encoding );
}
 
QgsFields QgsJsonUtils::stringToFields( const QString &string, QTextCodec *encoding )
{
  if ( !encoding )
    encoding = QTextCodec::codecForName( "UTF-8" );
 
  return QgsOgrUtils::stringToFields( string, encoding );
}
 
QString QgsJsonUtils::encodeValue( const QVariant &value )
{
  if ( QgsVariantUtils::isNull( value ) )
    return u"null"_s;
 
  switch ( value.userType() )
  {
    case QMetaType::Type::Int:
    case QMetaType::Type::UInt:
    case QMetaType::Type::LongLong:
    case QMetaType::Type::ULongLong:
    case QMetaType::Type::Double:
      return value.toString();
 
    case QMetaType::Type::Bool:
      return value.toBool() ? "true" : "false";
 
    case QMetaType::Type::QStringList:
    case QMetaType::Type::QVariantList:
    case QMetaType::Type::QVariantMap:
      return QString::fromUtf8( QJsonDocument::fromVariant( value ).toJson( QJsonDocument::Compact ) );
 
    default:
    case QMetaType::Type::QString:
      QString v
        = value.toString().replace( '\\', "\\\\"_L1 ).replace( '"', "\\\""_L1 ).replace( '\r', "\\r"_L1 ).replace( '\b', "\\b"_L1 ).replace( '\t', "\\t"_L1 ).replace( '/', "\\/"_L1 ).replace( '\n', "\\n"_L1 );
 
      return v.prepend( '"' ).append( '"' );
  }
}
 
QString QgsJsonUtils::exportAttributes( const QgsFeature &feature, QgsVectorLayer *layer, const QVector<QVariant> &attributeWidgetCaches )
{
  QgsFields fields = feature.fields();
  QString attrs;
  for ( int i = 0; i < fields.count(); ++i )
  {
    if ( i > 0 )
      attrs += ",\n"_L1;
 
    QVariant val = feature.attributes().at( i );
 
    if ( layer )
    {
      QgsEditorWidgetSetup setup = layer->fields().at( i ).editorWidgetSetup();
      QgsFieldFormatter *fieldFormatter = QgsApplication::fieldFormatterRegistry()->fieldFormatter( setup.type() );
      if ( fieldFormatter != QgsApplication::fieldFormatterRegistry()->fallbackFieldFormatter() )
        val = fieldFormatter->representValue( layer, i, setup.config(), attributeWidgetCaches.count() >= i ? attributeWidgetCaches.at( i ) : QVariant(), val );
    }
 
    attrs += encodeValue( fields.at( i ).name() ) + ':' + encodeValue( val );
  }
  return attrs.prepend( '{' ).append( '}' );
}
 
QVariantList QgsJsonUtils::parseArray( const QString &json, QMetaType::Type type )
{
  QString errorMessage;
  QVariantList result;
  try
  {
    const auto jObj( json::parse( json.toStdString() ) );
    if ( !jObj.is_array() )
    {
      throw json::parse_error::create( 0, 0, u"JSON value must be an array"_s.toStdString(), &jObj );
    }
    for ( const auto &item : jObj )
    {
      // Create a QVariant from the array item
      QVariant v;
      if ( item.is_number_integer() )
      {
        v = item.get<int>();
      }
      else if ( item.is_number_unsigned() )
      {
        v = item.get<unsigned>();
      }
      else if ( item.is_number_float() )
      {
        // Note: it's a double and not a float on purpose
        v = item.get<double>();
      }
      else if ( item.is_string() )
      {
        v = QString::fromStdString( item.get<std::string>() );
      }
      else if ( item.is_boolean() )
      {
        v = item.get<bool>();
      }
      else if ( item.is_null() )
      {
        // Fallback to int
        v = QgsVariantUtils::createNullVariant( type == QMetaType::Type::UnknownType ? QMetaType::Type::Int : type );
      }
 
      // If a destination type was specified (it's not invalid), try to convert
      if ( type != QMetaType::Type::UnknownType )
      {
        if ( !v.convert( static_cast<int>( type ) ) )
        {
          QgsLogger::warning( u"Cannot convert json array element to specified type, ignoring: %1"_s.arg( v.toString() ) );
        }
        else
        {
          result.push_back( v );
        }
      }
      else
      {
        result.push_back( v );
      }
    }
  }
  catch ( json::parse_error &ex )
  {
    errorMessage = ex.what();
    QgsLogger::warning( u"Cannot parse json (%1): %2"_s.arg( ex.what(), json ) );
  }
 
  return result;
}
 
QVariantList QgsJsonUtils::parseArray( const QString &json, QVariant::Type type )
{
  return parseArray( json, QgsVariantUtils::variantTypeToMetaType( type ) );
}
 
std::unique_ptr< QgsPoint> parsePointFromGeoJson( const json &coords, bool hasM = false )
{
  if ( !coords.is_array() || coords.size() < 2 || coords.size() > 4 )
  {
    QgsDebugError( u"JSON Point geometry coordinates must be an array of two, three or four numbers"_s );
    return nullptr;
  }
 
  const double x = coords[0].get< double >();
  const double y = coords[1].get< double >();
  if ( coords.size() == 2 )
  {
    return std::make_unique< QgsPoint >( x, y );
  }
  else if ( coords.size() == 3 )
  {
    const double zOrM = coords[2].get< double >();
    if ( hasM )
      return std::make_unique< QgsPoint >( x, y, std::numeric_limits<double>::quiet_NaN(), zOrM );
    else
      return std::make_unique< QgsPoint >( x, y, zOrM );
  }
  else
  {
    const double z = coords[2].get< double >();
    const double m = coords[3].get< double >();
    return std::make_unique< QgsPoint >( x, y, z, m );
  }
}
 
std::unique_ptr< QgsLineString> parseLineStringFromGeoJson( const json &coords, bool hasM = false )
{
  if ( !coords.is_array() )
  {
    QgsDebugError( u"JSON LineString geometry coordinates must be an array"_s );
    return nullptr;
  }
 
  const std::size_t coordsSize = coords.size();
 
  if ( coordsSize == 0 )
  {
    // Empty LineString is valid, return an empty geometry
    return std::make_unique< QgsLineString >();
  }
 
  if ( coordsSize < 2 )
  {
    QgsDebugError( u"JSON LineString geometry coordinates must contain at least two positions"_s );
    return nullptr;
  }
 
  QVector< double > x;
  QVector< double > y;
  QVector< double > z;
  QVector< double > m;
  x.resize( coordsSize );
  y.resize( coordsSize );
  z.resize( coordsSize );
  m.resize( coordsSize );
 
  double *xOut = x.data();
  double *yOut = y.data();
  double *zOut = z.data();
  double *mOut = m.data();
  bool hasZ = false;
  for ( const auto &coord : coords )
  {
    if ( !coord.is_array() || coord.size() < 2 || coord.size() > 4 )
    {
      QgsDebugError( u"JSON LineString geometry coordinates must be an array of two, three or four numbers"_s );
      return nullptr;
    }
 
    *xOut++ = coord[0].get< double >();
    *yOut++ = coord[1].get< double >();
    if ( coord.size() == 4 )
    {
      *zOut++ = coord[2].get< double >();
      *mOut++ = coord[3].get< double >();
    }
    else if ( coord.size() == 3 )
    {
      if ( hasM )
      {
        *mOut++ = coord[2].get< double >();
        *zOut++ = std::numeric_limits< double >::quiet_NaN();
      }
      else
      {
        *zOut++ = coord[2].get< double >();
        *mOut++ = std::numeric_limits< double >::quiet_NaN();
        hasZ = true;
      }
    }
    else
    {
      *zOut++ = std::numeric_limits< double >::quiet_NaN();
    }
  }
 
  return std::make_unique< QgsLineString >( x, y, hasZ ? z : QVector<double>(), hasM ? m : QVector<double>() );
}
 
std::unique_ptr< QgsPolygon > parsePolygonFromGeoJson( const json &coords, bool hasM = false )
{
  if ( !coords.is_array() )
  {
    QgsDebugError( u"JSON Polygon geometry coordinates must be an array"_s );
    return nullptr;
  }
 
  if ( coords.empty() )
  {
    // Empty polygon
    return std::make_unique< QgsPolygon >();
  }
 
  const std::size_t coordsSize = coords.size();
  std::unique_ptr< QgsLineString > exterior = parseLineStringFromGeoJson( coords[0], hasM );
  if ( !exterior )
  {
    return nullptr;
  }
 
  auto polygon = std::make_unique< QgsPolygon >( exterior.release() );
  for ( std::size_t i = 1; i < coordsSize; ++i )
  {
    std::unique_ptr< QgsLineString > ring = parseLineStringFromGeoJson( coords[i], hasM );
    if ( !ring )
    {
      return nullptr;
    }
    polygon->addInteriorRing( ring.release() );
  }
  return polygon;
}
 
std::unique_ptr< QgsAbstractGeometry > parseGeometryFromGeoJson( const json &geometry, bool hasMIn = false )
{
  const auto hasM = hasMIn || ( geometry.contains( "measures" ) && geometry["measures"].contains( "enabled" ) && geometry["measures"]["enabled"].get<bool>() );
 
  if ( !geometry.is_object() )
  {
    QgsDebugError( u"JSON geometry value must be an object"_s );
    return nullptr;
  }
 
  if ( !geometry.contains( "type" ) )
  {
    QgsDebugError( u"JSON geometry must contain 'type'"_s );
    return nullptr;
  }
 
  const QString type = QString::fromStdString( geometry["type"].get< std::string >() );
  if ( type.compare( "Point"_L1, Qt::CaseInsensitive ) == 0 )
  {
    if ( !geometry.contains( "coordinates" ) )
    {
      QgsDebugError( u"JSON Point geometry must contain 'coordinates'"_s );
      return nullptr;
    }
 
    const json &coords = geometry["coordinates"];
    return parsePointFromGeoJson( coords, hasM );
  }
  else if ( type.compare( "MultiPoint"_L1, Qt::CaseInsensitive ) == 0 )
  {
    if ( !geometry.contains( "coordinates" ) )
    {
      QgsDebugError( u"JSON MultiPoint geometry must contain 'coordinates'"_s );
      return nullptr;
    }
 
    const json &coords = geometry["coordinates"];
 
    if ( !coords.is_array() )
    {
      QgsDebugError( u"JSON MultiPoint geometry coordinates must be an array"_s );
      return nullptr;
    }
 
    auto multiPoint = std::make_unique< QgsMultiPoint >();
    multiPoint->reserve( static_cast< int >( coords.size() ) );
    for ( const auto &pointCoords : coords )
    {
      std::unique_ptr< QgsPoint > point = parsePointFromGeoJson( pointCoords, hasM );
      if ( !point )
      {
        return nullptr;
      }
      multiPoint->addGeometry( point.release() );
    }
 
    return multiPoint;
  }
  else if ( type.compare( "LineString"_L1, Qt::CaseInsensitive ) == 0 )
  {
    if ( !geometry.contains( "coordinates" ) )
    {
      QgsDebugError( u"JSON LineString geometry must contain 'coordinates'"_s );
      return nullptr;
    }
 
    const json &coords = geometry["coordinates"];
    return parseLineStringFromGeoJson( coords, hasM );
  }
  else if ( type.compare( "MultiLineString"_L1, Qt::CaseInsensitive ) == 0 )
  {
    if ( !geometry.contains( "coordinates" ) )
    {
      QgsDebugError( u"JSON MultiLineString geometry must contain 'coordinates'"_s );
      return nullptr;
    }
 
    const json &coords = geometry["coordinates"];
 
    if ( !coords.is_array() )
    {
      QgsDebugError( u"JSON MultiLineString geometry coordinates must be an array"_s );
      return nullptr;
    }
 
    auto multiLineString = std::make_unique< QgsMultiLineString >();
    multiLineString->reserve( static_cast< int >( coords.size() ) );
    for ( const auto &lineCoords : coords )
    {
      std::unique_ptr< QgsLineString > line = parseLineStringFromGeoJson( lineCoords, hasM );
      if ( !line )
      {
        return nullptr;
      }
      multiLineString->addGeometry( line.release() );
    }
 
    return multiLineString;
  }
  else if ( type.compare( "Polygon"_L1, Qt::CaseInsensitive ) == 0 )
  {
    if ( !geometry.contains( "coordinates" ) )
    {
      QgsDebugError( u"JSON Polygon geometry must contain 'coordinates'"_s );
      return nullptr;
    }
 
    const json &coords = geometry["coordinates"];
    if ( !coords.is_array() )
    {
      QgsDebugError( u"JSON Polygon geometry coordinates must be an array"_s );
      return nullptr;
    }
 
    return parsePolygonFromGeoJson( coords );
  }
  else if ( type.compare( "MultiPolygon"_L1, Qt::CaseInsensitive ) == 0 )
  {
    if ( !geometry.contains( "coordinates" ) )
    {
      QgsDebugError( u"JSON MultiPolygon geometry must contain 'coordinates'"_s );
      return nullptr;
    }
 
    const json &coords = geometry["coordinates"];
 
    if ( !coords.is_array() )
    {
      QgsDebugError( u"JSON MultiPolygon geometry coordinates must be an array"_s );
      return nullptr;
    }
 
    auto multiPolygon = std::make_unique< QgsMultiPolygon >();
    multiPolygon->reserve( static_cast< int >( coords.size() ) );
    for ( const auto &polygonCoords : coords )
    {
      std::unique_ptr< QgsPolygon > polygon = parsePolygonFromGeoJson( polygonCoords );
      if ( !polygon )
      {
        return nullptr;
      }
      multiPolygon->addGeometry( polygon.release() );
    }
 
    return multiPolygon;
  }
  // //////////////////////////////////////////////////////////////////////////////////////////////
  // Handle JSON-FG types CircularString, CompoundCurve, CurvePolygon, MultiCurve, or MultiSurface.
  else if ( type.compare( "CircularString"_L1, Qt::CaseInsensitive ) == 0 )
  {
    if ( !geometry.contains( "coordinates" ) )
    {
      QgsDebugError( u"JSON CircularString geometry must contain 'coordinates'"_s );
      return nullptr;
    }
 
    const json &coords = geometry["coordinates"];
 
    if ( coords.empty() )
    {
      return std::make_unique< QgsCircularString >();
    }
 
    if ( !coords.is_array() || coords.size() % 2 == 0 || coords.size() < 3 )
    {
      QgsDebugError( u"JSON CircularString geometry coordinates must be an array of at least 3 coordinates and the total number must be an odd number"_s );
      return nullptr;
    }
 
    const bool hasZ = coords[0].is_array() && ( coords[0].size() > 3 || ( coords[0].size() == 3 && !hasM ) );
 
    QVector<double> x;
    x.reserve( coords.size() );
    QVector<double> y;
    y.reserve( coords.size() );
    QVector<double> z;
    if ( hasZ )
      z.reserve( coords.size() );
    QVector<double> m;
    if ( hasM )
      m.reserve( coords.size() );
 
    for ( const auto &pointCoords : coords )
    {
      std::unique_ptr< QgsPoint > point = parsePointFromGeoJson( pointCoords, hasM );
      if ( !point )
      {
        QgsDebugError( u"Invalid point in CircularString geometry"_s );
        return nullptr;
      }
      x.append( point->x() );
      y.append( point->y() );
      if ( hasZ )
        z.append( point->z() );
      if ( hasM )
        m.append( point->m() );
    }
    return std::make_unique< QgsCircularString >( x, y, z, m );
  }
  else if ( type.compare( "CompoundCurve"_L1, Qt::CaseInsensitive ) == 0 )
  {
    if ( !geometry.contains( "geometries" ) )
    {
      QgsDebugError( u"JSON CompoundCurve geometry must contain 'geometries'"_s );
      return nullptr;
    }
    const json &geometries = geometry["geometries"];
    if ( !geometries.is_array() )
    {
      QgsDebugError( u"JSON CompoundCurve geometry geometries must be an array"_s );
      return nullptr;
    }
    auto compoundCurve = std::make_unique< QgsCompoundCurve >();
    for ( const auto &geometry : geometries )
    {
      std::unique_ptr< QgsAbstractGeometry > object = parseGeometryFromGeoJson( geometry, hasM );
      if ( !object )
      {
        return nullptr;
      }
      const Qgis::WkbType flatType = QgsWkbTypes::flatType( object->wkbType() );
      if ( flatType != Qgis::WkbType::LineString && flatType != Qgis::WkbType::CircularString )
      {
        QgsDebugError( u"JSON CompoundCurve geometries must be of type LineString or CircularString"_s );
        return nullptr;
      }
      compoundCurve->addCurve( static_cast< QgsCurve * >( object.release() ) );
    }
    return compoundCurve;
  }
  else if ( type.compare( "CurvePolygon"_L1, Qt::CaseInsensitive ) == 0 )
  {
    if ( !geometry.contains( "geometries" ) )
    {
      QgsDebugError( u"JSON CurvePolygon geometry must contain 'geometries'"_s );
      return nullptr;
    }
    const json &geometries = geometry["geometries"];
    if ( !geometries.is_array() )
    {
      QgsDebugError( u"JSON CurvePolygon geometries must be an array"_s );
      return nullptr;
    }
    auto curvePolygon = std::make_unique< QgsCurvePolygon>();
    bool isExterior = true;
    for ( const auto &geometry : geometries )
    {
      std::unique_ptr< QgsAbstractGeometry > object = parseGeometryFromGeoJson( geometry, hasM );
      if ( !object )
      {
        return nullptr;
      }
      const Qgis::WkbType flatType = QgsWkbTypes::flatType( object->wkbType() );
      if ( flatType != Qgis::WkbType::LineString && flatType != Qgis::WkbType::CircularString && flatType != Qgis::WkbType::CompoundCurve )
      {
        QgsDebugError( u"JSON CurvePolygon geometries must be of type LineString, CircularString or CompoundCurve"_s );
        return nullptr;
      }
      if ( isExterior )
      {
        curvePolygon->setExteriorRing( static_cast< QgsCurve * >( object.release() ) );
        isExterior = false;
      }
      else
      {
        curvePolygon->addInteriorRing( static_cast< QgsCurve * >( object.release() ) );
      }
    }
    return curvePolygon;
  }
  else if ( type.compare( "MultiCurve"_L1, Qt::CaseInsensitive ) == 0 )
  {
    if ( !geometry.contains( "geometries" ) )
    {
      QgsDebugError( u"JSON MultiCurve geometry must contain 'geometries'"_s );
      return nullptr;
    }
    const json &geometries = geometry["geometries"];
    if ( !geometries.is_array() )
    {
      QgsDebugError( u"JSON MultiCurve geometries must be an array"_s );
      return nullptr;
    }
    auto multiCurve = std::make_unique< QgsMultiCurve>();
    for ( const auto &geometry : geometries )
    {
      std::unique_ptr< QgsAbstractGeometry > object = parseGeometryFromGeoJson( geometry, hasM );
      if ( !object )
      {
        return nullptr;
      }
      const Qgis::WkbType flatType = QgsWkbTypes::flatType( object->wkbType() );
      if ( flatType != Qgis::WkbType::LineString && flatType != Qgis::WkbType::CircularString && flatType != Qgis::WkbType::CompoundCurve )
      {
        QgsDebugError( u"JSON MultiCurve geometries must be of type LineString, CircularString or CompoundCurve"_s );
        return nullptr;
      }
      multiCurve->addGeometry( static_cast< QgsCurve * >( object.release() ) );
    }
    return multiCurve;
  }
  else if ( type.compare( "MultiSurface"_L1, Qt::CaseInsensitive ) == 0 )
  {
    if ( !geometry.contains( "geometries" ) )
    {
      QgsDebugError( u"JSON MultiSurface geometry must contain 'geometries'"_s );
      return nullptr;
    }
    const json &geometries = geometry["geometries"];
    if ( !geometries.is_array() )
    {
      QgsDebugError( u"JSON MultiSurface geometries must be an array"_s );
      return nullptr;
    }
    auto multiSurface = std::make_unique< QgsMultiSurface >();
    for ( const auto &geometry : geometries )
    {
      std::unique_ptr< QgsAbstractGeometry > object = parseGeometryFromGeoJson( geometry, hasM );
      if ( !object )
      {
        return nullptr;
      }
      const Qgis::WkbType flatType = QgsWkbTypes::flatType( object->wkbType() );
      if ( flatType != Qgis::WkbType::Polygon && flatType != Qgis::WkbType::CurvePolygon )
      {
        QgsDebugError( u"JSON MultiSurface geometries must be of type Polygon or CurvePolygon"_s );
        return nullptr;
      }
      multiSurface->addGeometry( static_cast< QgsSurface * >( object.release() ) );
    }
    return multiSurface;
  }
  else if ( type.compare( "GeometryCollection"_L1, Qt::CaseInsensitive ) == 0 )
  {
    if ( !geometry.contains( "geometries" ) )
    {
      QgsDebugError( u"JSON GeometryCollection geometry must contain 'geometries'"_s );
      return nullptr;
    }
 
    const json &geometries = geometry["geometries"];
 
    if ( !geometries.is_array() )
    {
      QgsDebugError( u"JSON GeometryCollection geometries must be an array"_s );
      return nullptr;
    }
 
    auto collection = std::make_unique< QgsGeometryCollection >();
    collection->reserve( static_cast< int >( geometries.size() ) );
    for ( const auto &geometry : geometries )
    {
      std::unique_ptr< QgsAbstractGeometry > object = parseGeometryFromGeoJson( geometry, hasM );
      if ( !object )
      {
        return nullptr;
      }
      collection->addGeometry( object.release() );
    }
 
    return collection;
  }
 
  QgsDebugError( u"Unhandled GeoJSON geometry type: %1"_s.arg( type ) );
  return nullptr;
}
 
QgsGeometry QgsJsonUtils::geometryFromGeoJson( const json &geometry )
{
  if ( !geometry.is_object() )
  {
    QgsDebugError( u"JSON geometry value must be an object"_s );
    return QgsGeometry();
  }
 
  return QgsGeometry( parseGeometryFromGeoJson( geometry ) );
}
 
QgsGeometry QgsJsonUtils::geometryFromGeoJson( const QString &geometry )
{
  try
  {
    const auto jObj( json::parse( geometry.toStdString() ) );
    return geometryFromGeoJson( jObj );
  }
  catch ( json::parse_error &ex )
  {
    QgsDebugError( u"Cannot parse json (%1): %2"_s.arg( geometry, ex.what() ) );
    return QgsGeometry();
  }
}
 
QVariant QgsJsonUtils::geometryToGeoJsonVariant( const QgsGeometry &geometry )
{
  return jsonToVariant( geometry.asJsonObject() );
}
 
json QgsJsonUtils::jsonFromVariant( const QVariant &val )
{
  if ( QgsVariantUtils::isNull( val ) )
  {
    return nullptr;
  }
  json j;
  if ( val.userType() == QMetaType::Type::QVariantMap )
  {
    const QVariantMap &vMap = val.toMap();
    json jMap = json::object();
    for ( auto it = vMap.constBegin(); it != vMap.constEnd(); it++ )
    {
      jMap[it.key().toStdString()] = jsonFromVariant( it.value() );
    }
    j = jMap;
  }
  else if ( val.userType() == QMetaType::Type::QVariantList || val.userType() == QMetaType::Type::QStringList )
  {
    const QVariantList &vList = val.toList();
    json jList = json::array();
    for ( const auto &v : vList )
    {
      jList.push_back( jsonFromVariant( v ) );
    }
    j = jList;
  }
  else
  {
    switch ( val.userType() )
    {
      case QMetaType::Int:
      case QMetaType::UInt:
      case QMetaType::LongLong:
      case QMetaType::ULongLong:
        j = val.toLongLong();
        break;
      case QMetaType::Double:
      case QMetaType::Float:
        j = val.toDouble();
        break;
      case QMetaType::Bool:
        j = val.toBool();
        break;
      case QMetaType::QByteArray:
        j = val.toByteArray().toBase64().toStdString();
        break;
      default:
        j = val.toString().toStdString();
        break;
    }
  }
  return j;
}
 
QVariant QgsJsonUtils::parseJson( const std::string &jsonString )
{
  QString error;
  const QVariant res = parseJson( jsonString, error );
 
  if ( !error.isEmpty() )
  {
    QgsLogger::warning( u"Cannot parse json (%1): %2"_s.arg( error, QString::fromStdString( jsonString ) ) );
  }
  return res;
}
 
QVariant QgsJsonUtils::parseJson( const std::string &jsonString, QString &error )
{
  error.clear();
  try
  {
    const json j = json::parse( jsonString );
    return jsonToVariant( j );
  }
  catch ( json::parse_error &ex )
  {
    error = QString::fromStdString( ex.what() );
  }
  catch ( json::type_error &ex )
  {
    error = QString::fromStdString( ex.what() );
  }
  return QVariant();
}
 
QVariant QgsJsonUtils::jsonToVariant( const json &value )
{
  // tracks whether entire json string is a primitive
  bool isPrimitive = true;
 
  std::function<QVariant( json )> _parser { [&]( json jObj ) -> QVariant {
    QVariant result;
    if ( jObj.is_array() )
    {
      isPrimitive = false;
      QVariantList results;
      results.reserve( jObj.size() );
      for ( const auto &item : jObj )
      {
        results.push_back( _parser( item ) );
      }
      result = results;
    }
    else if ( jObj.is_object() )
    {
      isPrimitive = false;
      QVariantMap results;
      for ( const auto &item : jObj.items() )
      {
        const auto key { QString::fromStdString( item.key() ) };
        const auto value { _parser( item.value() ) };
        results[key] = value;
      }
      result = results;
    }
    else
    {
      if ( jObj.is_number_unsigned() )
      {
        // Try signed int and long long first, fall back
        // onto unsigned long long
        const qulonglong num { jObj.get<qulonglong>() };
        if ( num <= std::numeric_limits<int>::max() )
        {
          result = static_cast<int>( num );
        }
        else if ( num <= std::numeric_limits<qlonglong>::max() )
        {
          result = static_cast<qlonglong>( num );
        }
        else
        {
          result = num;
        }
      }
      else if ( jObj.is_number_integer() )
      {
        const qlonglong num { jObj.get<qlonglong>() };
        if ( num <= std::numeric_limits<int>::max() && num >= std::numeric_limits<int>::lowest() )
        {
          result = static_cast<int>( num );
        }
        else
        {
          result = num;
        }
      }
      else if ( jObj.is_boolean() )
      {
        result = jObj.get<bool>();
      }
      else if ( jObj.is_number_float() )
      {
        // Note: it's a double and not a float on purpose
        result = jObj.get<double>();
      }
      else if ( jObj.is_string() )
      {
        if ( isPrimitive && jObj.get<std::string>().length() == 0 )
        {
          result = QString::fromStdString( jObj.get<std::string>() ).append( "\"" ).insert( 0, "\"" );
        }
        else
        {
          result = QString::fromStdString( jObj.get<std::string>() );
        }
      }
      else if ( jObj.is_null() )
      {
        // Do nothing (leave invalid)
      }
    }
    return result;
  } };
 
  return _parser( value );
}
 
QVariant QgsJsonUtils::parseJson( const QString &jsonString )
{
  return jsonString.isEmpty() ? QVariant() : parseJson( jsonString.toStdString() );
}
 
json QgsJsonUtils::exportAttributesToJsonObject( const QgsFeature &feature, QgsVectorLayer *layer, const QVector<QVariant> &attributeWidgetCaches, bool useFieldFormatters )
{
  QgsFields fields = feature.fields();
  json attrs;
  for ( int i = 0; i < fields.count(); ++i )
  {
    QVariant val = feature.attributes().at( i );
 
    if ( layer && useFieldFormatters )
    {
      QgsEditorWidgetSetup setup = layer->fields().at( i ).editorWidgetSetup();
      QgsFieldFormatter *fieldFormatter = QgsApplication::fieldFormatterRegistry()->fieldFormatter( setup.type() );
      if ( fieldFormatter != QgsApplication::fieldFormatterRegistry()->fallbackFieldFormatter() )
        val = fieldFormatter->representValue( layer, i, setup.config(), attributeWidgetCaches.count() >= i ? attributeWidgetCaches.at( i ) : QVariant(), val );
    }
    attrs[fields.at( i ).name().toStdString()] = jsonFromVariant( val );
  }
  return attrs;
}
 
void QgsJsonUtils::addCrsInfo( json &value, const QgsCoordinateReferenceSystem &crs, Qgis::GeoJsonProfile profile )
{
  if ( !crs.isValid() )
    return;
 
  if ( crs.authid() == "EPSG:4326" || crs.authid() == "CRS:84" || crs.authid() == "OGC:CRS84" )
  {
    // per spec, default is WGS84, so no need to add anything
    return;
  }
 
  switch ( profile )
  {
    case Qgis::GeoJsonProfile::Legacy:
    case Qgis::GeoJsonProfile::Rfc7946:
    {
      value["crs"]["type"] = "name";
      value["crs"]["properties"]["name"] = crs.toOgcUrn().toStdString();
      break;
    }
    case Qgis::GeoJsonProfile::JsonFg:
    case Qgis::GeoJsonProfile::JsonFgPlus:
    {
      value["coordRefSys"] = crs.toOgcUri().toStdString();
      break;
    }
  }
}