PhotoScanFilter.cpp

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#include "PhotoScanFilter.h"
 
// Qt
#include <CVLog.h>
 
#include <QDir>
#include <QFileInfo>
#include <QXmlStreamReader>
 
// Qt5/Qt6 Compatibility
#include <QtCompat.h>
 
// qCC_db
#include <ecvCameraSensor.h>
#include <ecvHObject.h>
#include <ecvImage.h>
#include <ecvMesh.h>
#include <ecvPointCloud.h>
#include <ecvProgressDialog.h>
 
// qCC_io
#include <PlyFilter.h>
 
// quazip
#include <quazip.h>
#include <quazipfile.h>
 
// System
#include <assert.h>
#include <string.h>
 
struct CameraDesc {
    CameraDesc() : id(-1), sensorId(-1) {}
 
    ccGLMatrix trans;
    QString imageFilename;
    int id, sensorId;
};
 
struct CloudDesc {
    QString filename;
    QString type;
};
 
struct MeshDesc {
    QString filename;
    QString texture;
};
 
enum Sections {
    DOCUMENT,
    CHUNKS,
    CHUNK,
    SENSORS,
    CAMERAS,
    FRAMES,
    FRAME,
    TRANSFORM
};
 
QString ToName(Sections section) {
    switch (section) {
        case DOCUMENT:
            return QStringLiteral("DOCUMENT");
        case CHUNKS:
            return QStringLiteral("CHUNKS");
        case CHUNK:
            return QStringLiteral("CHUNK");
        case SENSORS:
            return QStringLiteral("SENSORS");
        case CAMERAS:
            return QStringLiteral("CAMERAS");
        case FRAMES:
            return QStringLiteral("FRAMES");
        case FRAME:
            return QStringLiteral("FRAME");
        case TRANSFORM:
            return QStringLiteral("TRANSFORM");
        default:
            assert(false);
    }
 
    return QString();
}
 
template <typename T>
bool DecodeRotation(const QString& rotationValues, ccGLMatrixTpl<T>& output) {
    QStringList tokens = rotationValues.split(" ", QtCompat::SkipEmptyParts);
    if (tokens.size() != 9) {
        return false;
    }
 
    T* m = output.data();
    for (int i = 0; i < 9; ++i) {
        int col = (i / 3);
        int row = (i % 3);
        bool ok = true;
        m[col * 4 + row] = static_cast<T>(tokens[i].toDouble(&ok));
        if (!ok) {
            // invalid input string
            return false;
        }
    }
    output.transpose();
 
    return true;
}
 
template <typename T>
bool DecodeTransformation(const QString& transformationValues,
                          ccGLMatrixTpl<T>& output) {
    QStringList tokens =
            transformationValues.split(" ", QtCompat::SkipEmptyParts);
    if (tokens.size() != 16) {
        return false;
    }
 
    T* m = output.data();
    for (int i = 0; i < 16; ++i) {
        bool ok = true;
        m[i] = static_cast<T>(tokens[i].toDouble(&ok));
        if (!ok) {
            // invalid input string
            return false;
        }
    }
    output.transpose();
 
    return true;
}
 
static void DisplayCurrentNodeInfo(QXmlStreamReader& stream) {
    CVLog::Warning(
            QStringLiteral("--> ") + stream.name().toString() +
            (stream.isStartElement() ? QStringLiteral(" [start]") : QString()) +
            (stream.isEndElement() ? QStringLiteral(" [end]") : QString()));
    for (int i = 0; i < stream.attributes().size(); ++i) {
        CVLog::Warning(QStringLiteral("\t") +
                       stream.attributes().at(i).qualifiedName().toString());
    }
}
 
static ccCameraSensor* DecodeSensor(QXmlStreamReader& stream, int& sensorId) {
    assert(stream.name() == QStringLiteral("sensor"));
    sensorId = -1;
 
    QXmlStreamAttributes sensorAttributes = stream.attributes();
    if (!sensorAttributes.hasAttribute(QStringLiteral("type")) ||
        sensorAttributes.value(QStringLiteral("type")) !=
                QStringLiteral("frame")) {
        // unhandled sensor type
        return nullptr;
    }
    if (!sensorAttributes.hasAttribute(QStringLiteral("id"))) {
        // invalid sensor?!
        assert(false);
        return nullptr;
    }
    sensorId = sensorAttributes.value(QStringLiteral("id")).toInt();
 
    ccCameraSensor* sensor = nullptr;
    ccCameraSensor::IntrinsicParameters params;
    bool hasPixelSize = false;
 
    while (stream.readNextStartElement()) {
#ifdef _DEBUG
        DisplayCurrentNodeInfo(stream);
#endif
 
        if (stream.name() == QStringLiteral("property")) {
            if (stream.attributes().value(QStringLiteral("name")) ==
                QStringLiteral("pixel_width")) {
                params.pixelSize_mm[0] = stream.attributes()
                                                 .value(QStringLiteral("value"))
                                                 .toDouble();
                // hasPixelSize = true;
            } else if (stream.attributes().value(QStringLiteral("name")) ==
                       QStringLiteral("pixel_height")) {
                params.pixelSize_mm[1] = stream.attributes()
                                                 .value(QStringLiteral("value"))
                                                 .toDouble();
                hasPixelSize = true;
            }
            stream.skipCurrentElement();
        } else if (stream.name() == QStringLiteral("calibration") &&
                   stream.attributes().value(QStringLiteral("type")) ==
                           QStringLiteral("frame")) {
            ccCameraSensor::ExtendedRadialDistortionParameters distParams;
            bool hasDistortion = false;
            bool hasResolution = false;
            bool hasVertFocal = false;
            bool hasCentralPoint = false;
            while (stream.readNextStartElement()) {
#ifdef _DEBUG
                // DisplayCurrentNodeInfo(stream);
#endif
 
                if (stream.name() == QStringLiteral("resolution")) {
                    int width = stream.attributes()
                                        .value(QStringLiteral("width"))
                                        .toInt();
                    int height = stream.attributes()
                                         .value(QStringLiteral("height"))
                                         .toInt();
                    if (width > 0 && height > 0) {
                        params.arrayWidth = width;
                        params.arrayHeight = height;
                        hasResolution = true;
                    }
                    stream.skipCurrentElement();
                } else if (stream.name() == QStringLiteral("fx")) {
                    double horizFocal_pix = stream.readElementText().toDouble();
                    //++paramsCount;
                } else if (stream.name() == QStringLiteral("fy")) {
                    params.vertFocal_pix = stream.readElementText().toDouble();
                    hasVertFocal = true;
                } else if (stream.name() == QStringLiteral("cx")) {
                    params.principal_point[0] =
                            stream.readElementText().toDouble();
                    hasCentralPoint = true;
                } else if (stream.name() == QStringLiteral("cy")) {
                    params.principal_point[1] =
                            stream.readElementText().toDouble();
                    hasCentralPoint = true;
                } else if (stream.name() == QStringLiteral("k1")) {
                    distParams.k1 = stream.readElementText().toDouble();
                    hasDistortion = true;
                } else if (stream.name() == QStringLiteral("k2")) {
                    distParams.k2 = stream.readElementText().toDouble();
                    hasDistortion = true;
                } else if (stream.name() == QStringLiteral("k3")) {
                    distParams.k3 = stream.readElementText().toDouble();
                    hasDistortion = true;
                } else {
                    stream.skipCurrentElement();
                }
            }
 
            if (hasResolution && hasVertFocal) {
                if (!hasCentralPoint) {
                    // we define an arbitrary principal point
                    params.principal_point[0] = params.arrayWidth / 2.0f;
                    params.principal_point[1] = params.arrayHeight / 2.0f;
                }
                if (!hasPixelSize) {
                    // we use an arbitrary 'pixel size'
                    params.pixelSize_mm[0] = params.pixelSize_mm[1] =
                            1.0f /
                            std::max(params.arrayWidth, params.arrayHeight);
                }
                params.vFOV_rad = ccCameraSensor::ComputeFovRadFromFocalPix(
                        params.vertFocal_pix, params.arrayHeight);
 
                sensor = new ccCameraSensor(params);
                if (sensorAttributes.hasAttribute("label")) {
                    sensor->setName(sensorAttributes.value("label").toString());
                }
                if (hasDistortion) {
                    sensor->setDistortionParameters(
                            ccCameraSensor::LensDistortionParameters::Shared(
                                    new ccCameraSensor::
                                            ExtendedRadialDistortionParameters(
                                                    distParams)));
                }
            }
 
        }  //"calibration"
        else {
            stream.skipCurrentElement();
        }
    }
 
    return sensor;
}
 
static bool DecodeCamera(QXmlStreamReader& stream, CameraDesc& camera) {
    assert(stream.name() == QStringLiteral("camera"));
 
    QXmlStreamAttributes cameraAttributes = stream.attributes();
    if (!cameraAttributes.hasAttribute(QStringLiteral("id")) ||
        !cameraAttributes.hasAttribute(QStringLiteral("sensor_id")) ||
        !cameraAttributes.hasAttribute(QStringLiteral("label"))) {
        // invalid camera?!
        assert(false);
        return false;
    }
 
    camera.id = cameraAttributes.value(QStringLiteral("id")).toInt();
    camera.sensorId =
            cameraAttributes.value(QStringLiteral("sensor_id")).toInt();
    camera.imageFilename =
            cameraAttributes.value(QStringLiteral("label")).toString();
 
    while (stream.readNextStartElement()) {
#ifdef _DEBUG
        // DisplayCurrentNodeInfo(stream);
#endif
 
        if (stream.name() == QStringLiteral("transform")) {
            QString transformationValues = stream.readElementText();
            DecodeTransformation<float>(transformationValues, camera.trans);
        } else if (stream.name() == QStringLiteral("reference")) {
            QXmlStreamAttributes attributes = stream.attributes();
            if (attributes.value(QStringLiteral("enabled")).toString() ==
                QStringLiteral("true")) {
                CCVector3d T = {
                        attributes.value(QStringLiteral("x")).toDouble(),
                        attributes.value(QStringLiteral("y")).toDouble(),
                        attributes.value(QStringLiteral("z")).toDouble()};
                // What is exactly the "reference" point?!
                // camera.trans.setTranslation(CCVector3::fromArray(T.u));
            }
            stream.skipCurrentElement();
        } else  // orientation? Not sure what it corresponds to!
        {
            stream.skipCurrentElement();
        }
    }
 
    return true;
}
 
static QString CreateTempFile(QuaZip& zip, QString zipFilename) {
    if (!zip.setCurrentFile(zipFilename)) {
        CVLog::Warning(QString("[Photoscan] Failed to locate '%1' in the "
                               "Photoscan archive")
                               .arg(zipFilename));
        return QString();
    }
 
    // decompress the file
    QuaZipFile zipFile(&zip);
    if (!zipFile.open(QFile::ReadOnly)) {
        CVLog::Warning(QString("[Photoscan] Failed to extract '%1' from "
                               "Photoscan archive")
                               .arg(zipFilename));
        return QString();
    }
 
    QDir tempDir = QDir::temp();
    QString tempFilename = tempDir.absoluteFilePath(zipFilename);
    QFile tempFile(tempFilename);
    if (!tempFile.open(QFile::WriteOnly)) {
        CVLog::Warning(QString("[Photoscan] Failed to create temp file '%1'")
                               .arg(tempFilename));
        return QString();
    }
    tempFile.write(zipFile.readAll());
    tempFile.close();
 
    return tempFilename;
}
 
PhotoScanFilter::PhotoScanFilter()
    : FileIOFilter({"_PhotoScan Filter",
                    18.0f,  // priority
                    QStringList{"psz"}, "psz",
                    QStringList{"Photoscan project (*.psz)"}, QStringList(),
                    Import}) {}
 
CC_FILE_ERROR PhotoScanFilter::loadFile(const QString& filename,
                                        ccHObject& container,
                                        LoadParameters& parameters) {
    QuaZip zip(filename);
 
    if (!zip.open(QuaZip::mdUnzip)) {
        // failed to open or read the zip file
        return CC_FERR_READING;
    }
 
    QStringList fileList = zip.getFileNameList();
    if (fileList.isEmpty()) {
        // empty archive?
        return CC_FERR_NO_LOAD;
    }
 
    static const QString s_defaultXMLFilename("doc.xml");
 
    if (!fileList.contains(s_defaultXMLFilename)) {
        // empty archive?
        CVLog::Warning(
                QString("[Photoscan] Couldn't find '%1' in Photoscan archive")
                        .arg(s_defaultXMLFilename));
        return CC_FERR_NO_LOAD;
    }
 
    // look for the XML file
    if (!zip.setCurrentFile(s_defaultXMLFilename)) {
        CVLog::Warning(QString("[Photoscan] Failed to locate '%1' in the "
                               "Photoscan archive")
                               .arg(s_defaultXMLFilename));
        return CC_FERR_MALFORMED_FILE;
    }
 
    // decompress the XML file
    QuaZipFile zipXML(&zip);
    if (!zipXML.open(QFile::ReadOnly)) {
        CVLog::Warning(QString("[Photoscan] Failed to extract '%1' from "
                               "Photoscan archive")
                               .arg(s_defaultXMLFilename));
        return CC_FERR_NO_LOAD;
    }
 
    QXmlStreamReader stream(&zipXML);
 
    // expected: "document"
    if (!stream.readNextStartElement() ||
        stream.name() != QStringLiteral("document")) {
        return CC_FERR_MALFORMED_FILE;
    }
 
    std::vector<Sections> sections;
    sections.push_back(DOCUMENT);
 
    QMap<int, ccCameraSensor*> sensors;
    QMap<int, CameraDesc> cameras;
    QList<CloudDesc> clouds;
    QList<MeshDesc> meshes;
    ccGLMatrixd globalTransform;
    bool hasGlobalTransform = false;
 
    while (true) {
        if (!stream.readNextStartElement()) {
            // end of section?
            if (!sections.empty()) {
                CVLog::PrintDebug(
                        QStringLiteral(" < ") + stream.name().toString() +
                        QStringLiteral(" [%1]").arg(ToName(sections.back())));
                sections.pop_back();
                // stream.skipCurrentElement();
                continue;
            } else {
                // end of file
                break;
            }
        }
        CVLog::PrintDebug(QStringLiteral(" > ") + stream.name().toString());
 
        switch (sections.back()) {
            case DOCUMENT:
                if (stream.name() == QStringLiteral("chunks")) {
                    sections.push_back(CHUNKS);
                } else {
                    // not handled
                    stream.skipCurrentElement();
                }
                break;
 
            case CHUNKS:
                if (stream.name() == QStringLiteral("chunk")) {
                    sections.push_back(CHUNK);
                } else {
                    // not handled
                    stream.skipCurrentElement();
                }
                break;
 
            case CHUNK:
                if (stream.name() == QStringLiteral("sensors")) {
                    sections.push_back(SENSORS);
                } else if (stream.name() == QStringLiteral("cameras")) {
                    sections.push_back(CAMERAS);
                } else if (stream.name() == QStringLiteral("frames")) {
                    sections.push_back(FRAMES);
                } else if (stream.name() == QStringLiteral("transform")) {
                    // inner loop
                    while (stream.readNextStartElement()) {
                        if (stream.name() == QStringLiteral("rotation")) {
                            QString rotationValues = stream.readElementText();
                            if (DecodeRotation<double>(rotationValues,
                                                       globalTransform)) {
                                hasGlobalTransform = true;
                            } else {
                                assert(false);
                            }
                        }
                        stream.skipCurrentElement();
                    }
                } else  // frames, reference, region, settings, meta, etc.
                {
                    // not handled for now
                    stream.skipCurrentElement();
                }
                break;
 
            case SENSORS:
                if (stream.name() == QStringLiteral("sensor")) {
                    int sensorId = -1;
                    ccCameraSensor* sensor = DecodeSensor(stream, sensorId);
                    if (sensor) {
                        assert(!sensors.contains(sensorId));
                        sensors.insert(sensorId, sensor);
                        // currentContainer->addChild(sensor);
                    }
                } else {
                    // not handled
                    stream.skipCurrentElement();
                }
                break;
 
            case CAMERAS:
                if (stream.name() == QStringLiteral("camera")) {
                    CameraDesc camera;
                    ccGLMatrix trans;
                    if (DecodeCamera(stream, camera)) {
                        assert(!cameras.contains(camera.id));
                        cameras.insert(camera.id, camera);
                        // currentContainer->addChild(camera.image);
                    }
                } else {
                    // not handled
                    stream.skipCurrentElement();
                }
                break;
 
            case FRAMES:
                if (stream.name() == QStringLiteral("frame")) {
                    sections.push_back(FRAME);
                } else {
                    // not handled
                    stream.skipCurrentElement();
                }
                break;
 
            case FRAME:
                if (stream.name() == QStringLiteral("point_cloud") ||
                    stream.name() == QStringLiteral("dense_cloud")) {
                    // inner loop
                    bool denseCloud =
                            (stream.name() == QStringLiteral("dense_cloud"));
                    while (stream.readNextStartElement()) {
                        if (stream.name() == QStringLiteral("points")) {
                            if (stream.attributes().hasAttribute(
                                        QStringLiteral("path"))) {
                                CloudDesc desc;
                                desc.filename =
                                        stream.attributes()
                                                .value(QStringLiteral("path"))
                                                .toString();
                                desc.type =
                                        (denseCloud
                                                 ? QStringLiteral("dense cloud")
                                                 : QStringLiteral("keypoints"));
                                clouds.push_back(desc);
                            } else {
                                assert(false);
                            }
                        }
                        stream.skipCurrentElement();
                    }
                } else if (stream.name() == QStringLiteral("model")) {
                    MeshDesc desc;
 
                    // inner loop
                    while (stream.readNextStartElement()) {
                        if (stream.name() == QStringLiteral("mesh")) {
                            if (stream.attributes().hasAttribute(
                                        QStringLiteral("path"))) {
                                desc.filename =
                                        stream.attributes()
                                                .value(QStringLiteral("path"))
                                                .toString();
                            } else {
                                assert(false);
                            }
                        } else if (stream.name() == QStringLiteral("texture")) {
                            if (stream.attributes().hasAttribute(
                                        QStringLiteral("path"))) {
                                desc.texture =
                                        stream.attributes()
                                                .value(QStringLiteral("path"))
                                                .toString();
                            } else {
                                assert(false);
                            }
                        }
                        stream.skipCurrentElement();
                    }
                    if (!desc.filename.isEmpty()) {
                        meshes.push_back(desc);
                    }
                } else {
                    // not handled
                    stream.skipCurrentElement();
                }
                break;
 
            case TRANSFORM:
                // not handled
                stream.skipCurrentElement();
                break;
 
            default:
                break;
        }
    }
 
    QScopedPointer<ecvProgressDialog> progressDialog(nullptr);
    if (parameters.parentWidget) {
        progressDialog.reset(new ecvProgressDialog(parameters.parentWidget));
        progressDialog->setRange(
                0, cameras.size() + clouds.size() + meshes.size());
        progressDialog->setWindowTitle(QStringLiteral("Loading data"));
        progressDialog->start();
    }
    bool wasCanceled = false;
    int currentProgress = 0;
 
    // end of file: now we can sort the various extracted components
    QDir dir = QFileInfo(filename).dir();
    ccHObject* imageGroup = new ccHObject(QStringLiteral("Images"));
    if (progressDialog && !cameras.empty()) {
        progressDialog->setInfo(
                QString("Loading %1 image(s)").arg(cameras.size()));
    }
    for (CameraDesc& camera : cameras) {
        // progress
        if (progressDialog) {
            progressDialog->setValue(++currentProgress);
            if (progressDialog->wasCanceled()) {
                wasCanceled = true;
                break;
            }
        }
        if (camera.imageFilename.isEmpty()) {
            assert(false);
            continue;
        }
 
        // DGM: the images are not in the archive!
        // if (!zip.setCurrentFile(camera.imageFilename))
        //{
        //  CVLog::Warning(QString("[Photoscan] Failed to locate image '%1'
        // in the Photoscan archive").arg(camera.imageFilename)); continue;
        //}
 
        // QuaZipFile zipImage(&zip);
        // if (!zipImage.open(QFile::ReadOnly))
        //{
        //  CVLog::Warning(QString("[Photoscan] Failed to extract '%1' from
        // Photoscan archive").arg(camera.imageFilename));  continue;
        //}
 
        QImage qImage;
        QString absoluteImageFilename =
                dir.absoluteFilePath(camera.imageFilename);
        // if (!qImage.load(&zipImage,
        // qPrintable(QFileInfo(camera.imageFilename).suffix())))
        if (!qImage.load(absoluteImageFilename)) {
            CVLog::Warning(QString("[Photoscan] Failed to load image '%1'")
                                   .arg(camera.imageFilename));
            continue;
        }
 
        ccCameraSensor* const origSensor = sensors[camera.sensorId];
        if (origSensor) {
            origSensor->undistort(qImage);
        }
 
        ccImage* image = new ccImage(qImage);
        image->setName(camera.imageFilename);
        image->setAlpha(0.5f);
        image->setVisible(false);
 
        // associated sensor (if any)
        if (origSensor) {
            // make a copy of the original sensor
            ccCameraSensor* sensor = new ccCameraSensor(*origSensor);
 
            camera.trans.setColumn(1, -camera.trans.getColumnAsVec3D(1));
            camera.trans.setColumn(2, -camera.trans.getColumnAsVec3D(2));
 
            // FIXME: we would have to transform the clouds and meshes as well!
            // if (hasGlobalTransform)
            //{
            //  //apply global transformation (if any)
            //  camera.trans = ccGLMatrix(globalTransform.data()) *
            // camera.trans;
            // }
            sensor->setRigidTransformation(camera.trans);
            sensor->setVisible(true);
            sensor->setGraphicScale(0.1f);
            image->setAssociatedSensor(sensor);
            image->addChild(sensor);
            imageGroup->addChild(image);
        }
    }
    if (imageGroup->getChildrenNumber()) {
        container.addChild(imageGroup);
    } else {
        // no image?!
        delete imageGroup;
        imageGroup = nullptr;
    }
 
    // we can get rid of the original sensors
    for (ccCameraSensor*& sensor : sensors) {
        delete sensor;
        sensor = nullptr;
    }
    sensors.clear();
 
    // clouds
    if (!wasCanceled) {
        if (progressDialog && !clouds.empty()) {
            progressDialog->setInfo(
                    QString("Loading %1 cloud(s)").arg(cameras.size()));
        }
        for (CloudDesc& desc : clouds) {
            // progress
            if (progressDialog) {
                progressDialog->setValue(++currentProgress);
                if (progressDialog->wasCanceled()) {
                    wasCanceled = true;
                    break;
                }
            }
 
            if (desc.filename.isEmpty()) {
                assert(false);
                continue;
            }
 
            if (desc.filename.endsWith(QStringLiteral(".oc3"),
                                       Qt::CaseInsensitive)) {
                CVLog::Warning(
                        QString("[Photoscan] OC3 format not supported. Can't "
                                "import %1 from the Photoscan archive")
                                .arg(desc.type));
                continue;
            }
 
            QString tempFilename = CreateTempFile(zip, desc.filename);
            if (tempFilename.isNull()) {
                continue;
            }
 
            ccHObject tempContainer;
            FileIOFilter::LoadParameters params;
            params.alwaysDisplayLoadDialog = false;
            params.autoComputeNormals = false;
            params.parentWidget = nullptr;
            CC_FILE_ERROR result = CC_FERR_NO_ERROR;
            ccHObject* newGroup =
                    FileIOFilter::LoadFromFile(tempFilename, params, result);
            if (newGroup) {
                newGroup->setName(desc.type);
                if (desc.type == QStringLiteral("keypoints")) {
                    newGroup->setEnabled(false);
                }
                container.addChild(newGroup);
            } else {
                CVLog::Warning(QString("[Photoscan] Failed to extract '%1' "
                                       "from Photoscan archive")
                                       .arg(desc.filename));
            }
            QFile::remove(tempFilename);
        }
    }
 
    // meshes
    if (!wasCanceled) {
        if (progressDialog && !meshes.empty()) {
            progressDialog->setInfo(
                    QString("Loading %1 mesh(es)").arg(cameras.size()));
        }
        for (MeshDesc& desc : meshes) {
            // progress
            if (progressDialog) {
                progressDialog->setValue(++currentProgress);
                if (progressDialog->wasCanceled()) {
                    wasCanceled = true;
                    break;
                }
            }
 
            if (desc.filename.isEmpty()) {
                assert(false);
                continue;
            }
 
            QString tempFilename = CreateTempFile(zip, desc.filename);
            if (tempFilename.isNull()) {
                continue;
            }
 
            FileIOFilter::LoadParameters params;
            params.alwaysDisplayLoadDialog = false;
            params.autoComputeNormals = false;
            params.parentWidget = nullptr;
 
            bool success = false;
            if (!desc.texture.isEmpty() &&
                desc.filename.endsWith(QStringLiteral("ply"),
                                       Qt::CaseInsensitive)) {
                QString tempTextureFilename = CreateTempFile(zip, desc.texture);
 
                ccHObject tempContainer;
                if (PlyFilter().loadFile(tempFilename, desc.texture,
                                         tempContainer,
                                         params) == CC_FERR_NO_ERROR) {
                    success = true;
                    // transfer the loaded entities to the current container
                    for (unsigned i = 0; i < tempContainer.getChildrenNumber();
                         ++i) {
                        container.addChild(tempContainer.getChild(i));
                    }
                    tempContainer.detachAllChildren();
                }
 
                if (!tempTextureFilename.isNull()) {
                    QFile::remove(tempTextureFilename);
                }
            } else {
                CC_FILE_ERROR result = CC_FERR_NO_ERROR;
                ccHObject* newGroup = FileIOFilter::LoadFromFile(
                        tempFilename, params, result);
                if (newGroup) {
                    success = true;
                    // transfer the loaded entities to the current container
                    for (unsigned i = 0; i < newGroup->getChildrenNumber();
                         ++i) {
                        container.addChild(newGroup->getChild(i));
                    }
                    newGroup->detachAllChildren();
                    delete newGroup;
                    newGroup = nullptr;
                }
            }
 
            if (!success) {
                CVLog::Warning(QString("[Photoscan] Failed to extract '%1' "
                                       "from Photoscan archive")
                                       .arg(desc.filename));
            }
 
            QFile::remove(tempFilename);
        }
    }
 
    if (progressDialog) {
        progressDialog->stop();
    }
 
    return wasCanceled ? CC_FERR_CANCELED_BY_USER : CC_FERR_NO_ERROR;
}