qgsalgorithmgltftovector.cpp

Go to the documentation of this file.

/***************************************************************************
                         qgsalgorithmgltftovector.cpp
                         ---------------------
    begin                : August 2023
    copyright            : (C) 2023 by 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 "qgsalgorithmgltftovector.h"
 
#include <memory>
 
#include "qgsgltfutils.h"
#include "qgslinestring.h"
#include "qgsmatrix4x4.h"
#include "qgsmultilinestring.h"
#include "qgsmultipolygon.h"
#include "qgspolygon.h"
#include "qgsvector3d.h"
 
#include <QFileInfo>
#include <QMatrix4x4>
#include <QString>
 
using namespace Qt::StringLiterals;
 
#define TINYGLTF_NO_STB_IMAGE       // we use QImage-based reading of images
#define TINYGLTF_NO_STB_IMAGE_WRITE // we don't need writing of images
 
#include "tiny_gltf.h"

 
QString QgsGltfToVectorFeaturesAlgorithm::name() const
{
  return u"gltftovector"_s;
}
 
QString QgsGltfToVectorFeaturesAlgorithm::displayName() const
{
  return QObject::tr( "Convert GLTF to vector features" );
}
 
QStringList QgsGltfToVectorFeaturesAlgorithm::tags() const
{
  return QObject::tr( "3d,tiles,cesium" ).split( ',' );
}
 
QString QgsGltfToVectorFeaturesAlgorithm::group() const
{
  return QObject::tr( "3D Tiles" );
}
 
QString QgsGltfToVectorFeaturesAlgorithm::groupId() const
{
  return u"3dtiles"_s;
}
 
QString QgsGltfToVectorFeaturesAlgorithm::shortHelpString() const
{
  return QObject::tr( "This algorithm converts GLTF content to standard vector layer formats." );
}
 
QString QgsGltfToVectorFeaturesAlgorithm::shortDescription() const
{
  return QObject::tr( "Converts GLTF content to standard vector layer formats." );
}
 
QgsGltfToVectorFeaturesAlgorithm *QgsGltfToVectorFeaturesAlgorithm::createInstance() const
{
  return new QgsGltfToVectorFeaturesAlgorithm();
}
 
void QgsGltfToVectorFeaturesAlgorithm::initAlgorithm( const QVariantMap & )
{
  addParameter(
    new QgsProcessingParameterFile( u"INPUT"_s, QObject::tr( "Input GLTF" ), Qgis::ProcessingFileParameterBehavior::File, u"gltf"_s, QVariant(), false, u"GLTF (*.gltf *.GLTF);;GLB (*.glb *.GLB)"_s )
  );
 
  addParameter( new QgsProcessingParameterFeatureSink( u"OUTPUT_POLYGONS"_s, QObject::tr( "Output polygons" ), Qgis::ProcessingSourceType::VectorPolygon, QVariant(), true, true ) );
  addParameter( new QgsProcessingParameterFeatureSink( u"OUTPUT_LINES"_s, QObject::tr( "Output lines" ), Qgis::ProcessingSourceType::VectorLine, QVariant(), true, true ) );
}
 
std::unique_ptr<QgsAbstractGeometry> extractTriangles(
  const tinygltf::Model &model,
  const tinygltf::Primitive &primitive,
  const QgsCoordinateTransform &ecefTransform,
  const QgsVector3D &tileTranslationEcef,
  const QMatrix4x4 *gltfLocalTransform,
  QgsProcessingFeedback *feedback
)
{
  auto posIt = primitive.attributes.find( "POSITION" );
  if ( posIt == primitive.attributes.end() )
  {
    feedback->reportError( QObject::tr( "Could not find POSITION attribute for primitive" ) );
    return nullptr;
  }
  int positionAccessorIndex = posIt->second;
 
  QVector<double> x;
  QVector<double> y;
  QVector<double> z;
  QgsGltfUtils::accessorToMapCoordinates( model, positionAccessorIndex, QgsMatrix4x4(), &ecefTransform, tileTranslationEcef, gltfLocalTransform, Qgis::Axis::Y, x, y, z );
 
  auto mp = std::make_unique<QgsMultiPolygon>();
 
  if ( primitive.indices == -1 )
  {
    Q_ASSERT( x.size() % 3 == 0 );
 
    mp->reserve( x.size() );
    for ( int i = 0; i < x.size(); i += 3 )
    {
      mp->addGeometry( new QgsPolygon(
        new QgsLineString( QVector<QgsPoint> { QgsPoint( x[i], y[i], z[i] ), QgsPoint( x[i + 1], y[i + 1], z[i + 1] ), QgsPoint( x[i + 2], y[i + 2], z[i + 2] ), QgsPoint( x[i], y[i], z[i] ) } )
      ) );
    }
  }
  else
  {
    const tinygltf::Accessor &primitiveAccessor = model.accessors[primitive.indices];
    const tinygltf::BufferView &bvPrimitive = model.bufferViews[primitiveAccessor.bufferView];
    const tinygltf::Buffer &bPrimitive = model.buffers[bvPrimitive.buffer];
 
    Q_ASSERT(
      ( primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT
        || primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT
        || primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE )
      && primitiveAccessor.type == TINYGLTF_TYPE_SCALAR
    );
 
    const char *primitivePtr = reinterpret_cast<const char *>( bPrimitive.data.data() ) + bvPrimitive.byteOffset + primitiveAccessor.byteOffset;
 
    mp->reserve( primitiveAccessor.count / 3 );
    for ( std::size_t i = 0; i < primitiveAccessor.count / 3; i++ )
    {
      unsigned int index1 = 0;
      unsigned int index2 = 0;
      unsigned int index3 = 0;
 
      if ( primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT )
      {
        const unsigned short *usPtrPrimitive = reinterpret_cast<const unsigned short *>( primitivePtr );
        if ( bvPrimitive.byteStride )
          primitivePtr += bvPrimitive.byteStride;
        else
          primitivePtr += 3 * sizeof( unsigned short );
 
        index1 = usPtrPrimitive[0];
        index2 = usPtrPrimitive[1];
        index3 = usPtrPrimitive[2];
      }
      else if ( primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE )
      {
        const unsigned char *usPtrPrimitive = reinterpret_cast<const unsigned char *>( primitivePtr );
        if ( bvPrimitive.byteStride )
          primitivePtr += bvPrimitive.byteStride;
        else
          primitivePtr += 3 * sizeof( unsigned char );
 
        index1 = usPtrPrimitive[0];
        index2 = usPtrPrimitive[1];
        index3 = usPtrPrimitive[2];
      }
      else
      {
        const unsigned int *uintPtrPrimitive = reinterpret_cast<const unsigned int *>( primitivePtr );
        if ( bvPrimitive.byteStride )
          primitivePtr += bvPrimitive.byteStride;
        else
          primitivePtr += 3 * sizeof( unsigned int );
 
        index1 = uintPtrPrimitive[0];
        index2 = uintPtrPrimitive[1];
        index3 = uintPtrPrimitive[2];
      }
 
      mp->addGeometry( new QgsPolygon( new QgsLineString(
        QVector<QgsPoint> { QgsPoint( x[index1], y[index1], z[index1] ), QgsPoint( x[index2], y[index2], z[index2] ), QgsPoint( x[index3], y[index3], z[index3] ), QgsPoint( x[index1], y[index1], z[index1] ) }
      ) ) );
    }
  }
  return mp;
}
 
std::unique_ptr<QgsAbstractGeometry> extractLines(
  const tinygltf::Model &model,
  const tinygltf::Primitive &primitive,
  const QgsCoordinateTransform &ecefTransform,
  const QgsVector3D &tileTranslationEcef,
  const QMatrix4x4 *gltfLocalTransform,
  QgsProcessingFeedback *feedback
)
{
  auto posIt = primitive.attributes.find( "POSITION" );
  if ( posIt == primitive.attributes.end() )
  {
    feedback->reportError( QObject::tr( "Could not find POSITION attribute for primitive" ) );
    return nullptr;
  }
  int positionAccessorIndex = posIt->second;
 
  QVector<double> x;
  QVector<double> y;
  QVector<double> z;
  QgsGltfUtils::accessorToMapCoordinates( model, positionAccessorIndex, QgsMatrix4x4(), &ecefTransform, tileTranslationEcef, gltfLocalTransform, Qgis::Axis::Y, x, y, z );
 
  auto ml = std::make_unique<QgsMultiLineString>();
 
  if ( primitive.indices == -1 )
  {
    Q_ASSERT( x.size() % 2 == 0 );
 
    ml->reserve( x.size() );
    for ( int i = 0; i < x.size(); i += 2 )
    {
      ml->addGeometry( new QgsLineString( QVector<QgsPoint> { QgsPoint( x[i], y[i], z[i] ), QgsPoint( x[i + 1], y[i + 1], z[i + 1] ) } ) );
    }
  }
  else
  {
    const tinygltf::Accessor &primitiveAccessor = model.accessors[primitive.indices];
    const tinygltf::BufferView &bvPrimitive = model.bufferViews[primitiveAccessor.bufferView];
    const tinygltf::Buffer &bPrimitive = model.buffers[bvPrimitive.buffer];
 
    Q_ASSERT(
      ( primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT
        || primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT
        || primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE )
      && primitiveAccessor.type == TINYGLTF_TYPE_SCALAR
    );
 
    const char *primitivePtr = reinterpret_cast<const char *>( bPrimitive.data.data() ) + bvPrimitive.byteOffset + primitiveAccessor.byteOffset;
 
    ml->reserve( primitiveAccessor.count / 2 );
    for ( std::size_t i = 0; i < primitiveAccessor.count / 2; i++ )
    {
      unsigned int index1 = 0;
      unsigned int index2 = 0;
 
      if ( primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT )
      {
        const unsigned short *usPtrPrimitive = reinterpret_cast<const unsigned short *>( primitivePtr );
        if ( bvPrimitive.byteStride )
          primitivePtr += bvPrimitive.byteStride;
        else
          primitivePtr += 2 * sizeof( unsigned short );
 
        index1 = usPtrPrimitive[0];
        index2 = usPtrPrimitive[1];
      }
      else if ( primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE )
      {
        const unsigned char *usPtrPrimitive = reinterpret_cast<const unsigned char *>( primitivePtr );
        if ( bvPrimitive.byteStride )
          primitivePtr += bvPrimitive.byteStride;
        else
          primitivePtr += 2 * sizeof( unsigned char );
 
        index1 = usPtrPrimitive[0];
        index2 = usPtrPrimitive[1];
      }
      else
      {
        const unsigned int *uintPtrPrimitive = reinterpret_cast<const unsigned int *>( primitivePtr );
        if ( bvPrimitive.byteStride )
          primitivePtr += bvPrimitive.byteStride;
        else
          primitivePtr += 2 * sizeof( unsigned int );
 
        index1 = uintPtrPrimitive[0];
        index2 = uintPtrPrimitive[1];
      }
 
      ml->addGeometry( new QgsLineString( QVector<QgsPoint> { QgsPoint( x[index1], y[index1], z[index1] ), QgsPoint( x[index2], y[index2], z[index2] ) } ) );
    }
  }
  return ml;
}
 
QVariantMap QgsGltfToVectorFeaturesAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
  QGS_MARK_ALGORITHM_SOURCE
 
  const QString path = parameterAsFile( parameters, u"INPUT"_s, context );
 
  const QgsCoordinateReferenceSystem destCrs( u"EPSG:4326"_s );
  QgsFields fields;
 
  QString polygonDest;
  std::unique_ptr<QgsFeatureSink> polygonSink( parameterAsSink( parameters, u"OUTPUT_POLYGONS"_s, context, polygonDest, fields, Qgis::WkbType::MultiPolygonZ, destCrs ) );
  if ( !polygonSink && parameters.value( u"OUTPUT_POLYGONS"_s ).isValid() )
    throw QgsProcessingException( invalidSinkError( parameters, u"OUTPUT_POLYGONS"_s ) );
  QString lineDest;
  std::unique_ptr<QgsFeatureSink> lineSink( parameterAsSink( parameters, u"OUTPUT_LINES"_s, context, lineDest, fields, Qgis::WkbType::MultiLineStringZ, destCrs ) );
  if ( !lineSink && parameters.value( u"OUTPUT_LINES"_s ).isValid() )
    throw QgsProcessingException( invalidSinkError( parameters, u"OUTPUT_LINES"_s ) );
 
  QFile f( path );
  QByteArray fileContent;
  if ( f.open( QIODevice::ReadOnly ) )
  {
    fileContent = f.readAll();
  }
  else
  {
    throw QgsProcessingException( QObject::tr( "Could not load source file %1." ).arg( path ) );
  }
 
  const QgsCoordinateTransform ecefTransform( QgsCoordinateReferenceSystem( u"EPSG:4978"_s ), destCrs, context.transformContext() );
 
  tinygltf::Model model;
  QString errors;
  QString warnings;
  if ( !QgsGltfUtils::loadGltfModel( fileContent, model, &errors, &warnings, QFileInfo( path ).absolutePath() ) )
  {
    throw QgsProcessingException( QObject::tr( "Error loading GLTF model: %1" ).arg( errors ) );
  }
  if ( !warnings.isEmpty() )
  {
    feedback->pushWarning( warnings );
  }
  feedback->pushDebugInfo( QObject::tr( "Found %1 scenes" ).arg( model.scenes.size() ) );
 
  bool sceneOk = false;
  const std::size_t sceneIndex = QgsGltfUtils::sourceSceneForModel( model, sceneOk );
  if ( !sceneOk )
  {
    throw QgsProcessingException( QObject::tr( "No scenes found in model" ) );
  }
 
  const tinygltf::Scene &scene = model.scenes[sceneIndex];
  feedback->pushDebugInfo( QObject::tr( "Found %1 nodes in default scene [%2]" ).arg( scene.nodes.size() ).arg( sceneIndex ) );
 
  QSet<int> warnedPrimitiveTypes;
 
  const QgsVector3D tileTranslationEcef = QgsGltfUtils::extractTileTranslation( model );
  std::function<void( int nodeIndex, const QMatrix4x4 &transform )> traverseNode;
  traverseNode =
    [&model, feedback, &polygonSink, &lineSink, &warnedPrimitiveTypes, &ecefTransform, &tileTranslationEcef, &traverseNode, &parameters, polygonDest, lineDest]( int nodeIndex, const QMatrix4x4 &parentTransform ) {
      const tinygltf::Node &gltfNode = model.nodes[nodeIndex];
      std::unique_ptr<QMatrix4x4> gltfLocalTransform = QgsGltfUtils::parseNodeTransform( gltfNode );
      if ( !parentTransform.isIdentity() )
      {
        if ( gltfLocalTransform )
          *gltfLocalTransform = parentTransform * *gltfLocalTransform;
        else
        {
          gltfLocalTransform = std::make_unique<QMatrix4x4>( parentTransform );
        }
      }
 
      if ( gltfNode.mesh >= 0 )
      {
        const tinygltf::Mesh &mesh = model.meshes[gltfNode.mesh];
        feedback->pushDebugInfo( QObject::tr( "Found %1 primitives in node [%2]" ).arg( mesh.primitives.size() ).arg( nodeIndex ) );
 
        for ( const tinygltf::Primitive &primitive : mesh.primitives )
        {
          switch ( primitive.mode )
          {
            case TINYGLTF_MODE_TRIANGLES:
            {
              if ( polygonSink )
              {
                std::unique_ptr<QgsAbstractGeometry> geometry = extractTriangles( model, primitive, ecefTransform, tileTranslationEcef, gltfLocalTransform.get(), feedback );
                if ( geometry )
                {
                  QgsFeature f;
                  f.setGeometry( std::move( geometry ) );
                  if ( !polygonSink->addFeature( f, QgsFeatureSink::FastInsert ) )
                    throw QgsProcessingException( writeFeatureError( polygonSink.get(), parameters, u"OUTPUT_POLYGONS"_s ) );
                  else
                    feedback->featureAddedToSink( u"OUTPUT_POLYGONS"_s );
                }
              }
              break;
            }
 
            case TINYGLTF_MODE_LINE:
            {
              if ( lineSink )
              {
                std::unique_ptr<QgsAbstractGeometry> geometry = extractLines( model, primitive, ecefTransform, tileTranslationEcef, gltfLocalTransform.get(), feedback );
                if ( geometry )
                {
                  QgsFeature f;
                  f.setGeometry( std::move( geometry ) );
                  if ( !lineSink->addFeature( f, QgsFeatureSink::FastInsert ) )
                    throw QgsProcessingException( writeFeatureError( lineSink.get(), parameters, u"OUTPUT_LINES"_s ) );
                  else
                    feedback->featureAddedToSink( u"OUTPUT_LINES"_s );
                }
              }
              break;
            }
 
            case TINYGLTF_MODE_POINTS:
              if ( !warnedPrimitiveTypes.contains( TINYGLTF_MODE_POINTS ) )
              {
                feedback->reportError( QObject::tr( "Point objects are not supported" ) );
                warnedPrimitiveTypes.insert( TINYGLTF_MODE_POINTS );
              }
              break;
 
            case TINYGLTF_MODE_LINE_LOOP:
              if ( !warnedPrimitiveTypes.contains( TINYGLTF_MODE_LINE_LOOP ) )
              {
                feedback->reportError( QObject::tr( "Line loops in are not supported" ) );
                warnedPrimitiveTypes.insert( TINYGLTF_MODE_LINE_LOOP );
              }
              break;
 
            case TINYGLTF_MODE_LINE_STRIP:
              if ( !warnedPrimitiveTypes.contains( TINYGLTF_MODE_LINE_STRIP ) )
              {
                feedback->reportError( QObject::tr( "Line strips in are not supported" ) );
                warnedPrimitiveTypes.insert( TINYGLTF_MODE_LINE_STRIP );
              }
              break;
 
            case TINYGLTF_MODE_TRIANGLE_STRIP:
              if ( !warnedPrimitiveTypes.contains( TINYGLTF_MODE_TRIANGLE_STRIP ) )
              {
                feedback->reportError( QObject::tr( "Triangular strips are not supported" ) );
                warnedPrimitiveTypes.insert( TINYGLTF_MODE_TRIANGLE_STRIP );
              }
              break;
 
            case TINYGLTF_MODE_TRIANGLE_FAN:
              if ( !warnedPrimitiveTypes.contains( TINYGLTF_MODE_TRIANGLE_FAN ) )
              {
                feedback->reportError( QObject::tr( "Triangular fans are not supported" ) );
                warnedPrimitiveTypes.insert( TINYGLTF_MODE_TRIANGLE_FAN );
              }
              break;
 
            default:
              if ( !warnedPrimitiveTypes.contains( primitive.mode ) )
              {
                feedback->reportError( QObject::tr( "Primitive type %1 are not supported" ).arg( primitive.mode ) );
                warnedPrimitiveTypes.insert( primitive.mode );
              }
              break;
          }
        }
      }
 
      for ( int childNode : gltfNode.children )
      {
        traverseNode( childNode, gltfLocalTransform ? *gltfLocalTransform : QMatrix4x4() );
      }
    };
 
  if ( !scene.nodes.empty() )
  {
    for ( const int nodeIndex : scene.nodes )
    {
      traverseNode( nodeIndex, QMatrix4x4() );
    }
  }
 
  QVariantMap outputs;
  if ( polygonSink )
  {
    polygonSink->finalize();
    feedback->featureSinkFinalized( u"OUTPUT_POLYGONS"_s );
    outputs.insert( u"OUTPUT_POLYGONS"_s, polygonDest );
  }
  if ( lineSink )
  {
    lineSink->finalize();
    feedback->featureSinkFinalized( u"OUTPUT_LINES"_s );
    outputs.insert( u"OUTPUT_LINES"_s, lineDest );
  }
  return outputs;
}