Utilities.h

Go to the documentation of this file.

/*
 *
 *                             C@@o         ____  _____   __ _
 *                        oC8@@@@@@@o      |___ \|  __ \ / _| |
 *                    o@@@@@@@@@@@@O         __) | |  | | |_| | _____      __
 *         O@O        8@@@@@@@@@O           |__ <| |  | |  _| |/ _ \ \ /\ / /
 *       o@@@@@@@O    OOOOOCo               ___) | |__| | | | | (_) \ V  V /
 *       C@@@@@@@@@@@@Oo                   |____/|_____/|_| |_|\___/ \_/\_/
 *          o8@@@@@@@@@@@@@@@@8OOCCCC
 *              oO@@@@@@@@@@@@@@@@@@@o          3Dflow s.r.l. - www.3dflow.net
 *                   oO8@@@@@@@@@@@@o           Copyright 2022
 *       oO88@@@@@@@@8OCo                       All Rights Reserved
 *  O@@@@@@@@@@@@@@@@@@@@@@@@@8OCCoooooooCCo
 *   @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@O
 *    @@@Oo            oO8@@@@@@@@@@@@@@@@8
 *
 */
 
#pragma once
 
#include "CommonDef.h"
#include "LogListenerInterface.h"
#include "ProgressBarInterface.h"
#include "CameraInterface.h"
#include "CameraCalibrationInterface.h"
#include "SettingsInterface.h"
#include "BoundingBoxInterface.h"
#include "SparsePointCloudInterface.h"
#include "StereoPointCloudInterface.h"
#include "StereoMeshInterface.h"
#include "StereoTexturedMeshInterface.h"
#include "ControlPointConstraintInterface.h"
#include "CamerasLoaderInterface.h"
#include "DistanceConstraintInterface.h"
#include "WorkspaceSaverInterface.h"
#include "WorkspaceLoaderInterface.h"
#include "OrthophotoInterface.h"
#include "ProjectedCoordinateSystemInterface.h"
#include "CameraConstraintInterface.h"
#include "DynamicBufferInterface.h"
#include "LicenseInfoInterface.h"
#include "CameraGroupManagerInterface.h"
#include "GaussianSplatsInterface.h"
 
#include <string>
#include <cstring>
#include <memory>
#include <iostream>
 
namespace FlowEngine
{
    extern "C" FLE_DLL const char *GetResultMessage( Result inResult );
 
    namespace Detail
    {
        template< typename T >
        struct Destroyer;
 
        template< >
        struct Destroyer< SettingsInterface >
        {
            static void destroy( SettingsInterface *settings )
            {
                DestroySettings( settings );
            }
        };
 
        template< >
        struct Destroyer< CameraInterface >
        {
            static void destroy( CameraInterface *camera )
            {
                DestroyCamera( camera );
            }
        };
 
        template< >
        struct Destroyer< CameraCalibrationInterface >
        {
            static void destroy( CameraCalibrationInterface *calib )
            {
                DestroyCameraCalibration( calib );
            }
        };
 
        template< >
        struct Destroyer< CamerasLoaderInterface >
        {
            static void destroy( CamerasLoaderInterface *camerasLoader )
            {
                DestroyCamerasLoader( camerasLoader );
            }
        };
 
        template< >
        struct Destroyer< SparsePointCloudInterface >
        {
            static void destroy( SparsePointCloudInterface *pointCloud )
            {
                DestroySparsePointCloud( pointCloud );
            }
        };
 
        template< >
        struct Destroyer< StereoPointCloudInterface >
        {
            static void destroy( StereoPointCloudInterface *pointCloud )
            {
                DestroyStereoPointCloud( pointCloud );
            }
        };
 
        template< >
        struct Destroyer< StereoMeshInterface >
        {
            static void destroy( StereoMeshInterface *mesh )
            {
                DestroyStereoMesh( mesh );
            }
        };
 
        template< >
        struct Destroyer< StereoTexturedMeshInterface >
        {
            static void destroy( StereoTexturedMeshInterface *texturedMesh )
            {
                DestroyStereoTexturedMesh( texturedMesh );
            }
        };
 
        template< >
        struct Destroyer< WorkspaceLoaderInterface >
        {
            static void destroy( WorkspaceLoaderInterface *workspaceLoader )
            {
                DestroyWorkspaceLoader( workspaceLoader );
            }
        };
 
        template< >
        struct Destroyer< WorkspaceSaverInterface >
        {
            static void destroy( WorkspaceSaverInterface *workspaceSaver )
            {
                DestroyWorkspaceSaver( workspaceSaver );
            }
        };
 
        template< >
        struct Destroyer< ControlPointConstraintInterface >
        {
            static void destroy( ControlPointConstraintInterface *controlPoint )
            {
                DestroyControlPointConstraint( controlPoint );
            }
        };
 
        template< >
        struct Destroyer< BoundingBoxInterface >
        {
            static void destroy( BoundingBoxInterface *bb )
            {
                DestroyBoundingBox( bb );
            }
        };
 
        template< >
        struct Destroyer< OrthophotoInterface >
        {
            static void destroy( OrthophotoInterface *op )
            {
                DestroyOrthophoto( op );
            }
        };
 
        template< >
        struct Destroyer< ProjectedCoordinateSystemInterface >
        {
            static void destroy( ProjectedCoordinateSystemInterface *pcs )
            {
                DestroyProjectedCoordinateSystem( pcs );
            }
        };
 
        template< >
        struct Destroyer< CameraConstraintInterface >
        {
            static void destroy( CameraConstraintInterface *cc )
            {
                DestroyCameraConstraint( cc );
            }
        };
 
        template< >
        struct Destroyer< DynamicBufferInterface >
        {
            static void destroy( DynamicBufferInterface *ptr )
            {
                DestroyDynamicBuffer( ptr );
            }
        };
 
        template< >
        struct Destroyer< LicenseInfoInterface >
        {
            static void destroy( LicenseInfoInterface *ptr )
            {
                DestroyLicenseInfo( ptr );
            }
        };
 
        template< >
        struct Destroyer< DistanceConstraintInterface >
        {
            static void destroy( DistanceConstraintInterface *ptr )
            {
                DestroyDistanceConstraint( ptr );
            }
        };
 
        template< >
        struct Destroyer< CameraGroupManagerInterface >
        {
            static void destroy( CameraGroupManagerInterface *ptr )
            {
                DestroyCameraGroupManager( ptr );
            }
        };
 
        template< >
        struct Destroyer< GaussianSplatsInterface >
        {
            static void destroy( GaussianSplatsInterface *ptr )
            {
                DestroyGaussianSplats( ptr );
            }
        };
 
        template< typename T >
        class UniquePtr final
        {
            public:
 
                UniquePtr() = default;
 
                UniquePtr( T *object )
                    : mObject( object )
                { }
 
                UniquePtr( UniquePtr &&other )
                    : mObject( other.release() )
                { }
 
                UniquePtr &operator =( UniquePtr &&other )
                {
                    if ( this != &other )
                    {
                        reset( other.release() );
                    }
 
                    return *this;
                }
 
                ~UniquePtr()
                {
                    reset();
                }
 
            public:
 
                explicit operator bool() const
                {
                    return mObject != nullptr;
                }
 
                T *operator ->()
                {
                    return mObject;
                }
 
                const T *operator ->() const
                {
                    return mObject;
                }
 
                T &operator *()
                {
                    return *mObject;
                }
 
                const T &operator *() const
                {
                    return *mObject;
                }
 
                operator T *() const
                {
                    return mObject;
                }
 
            public:
 
                T *get() const
                {
                    return mObject;
                }
 
                void reset( T *object = nullptr )
                {
                    if ( mObject )
                        Detail::Destroyer< T >::destroy( mObject );
 
                    mObject = object;
                }
 
                T *release()
                {
                    auto temp = mObject;
                    mObject = nullptr;
                    return temp;
                }
 
            private:
 
                T *mObject = nullptr;
        };
    } // Detail namespace
 
    template< typename T >
    struct Buffer< T * >
    {
        static_assert( std::is_same< CameraInterface, T >::value ||
                       std::is_same< CamerasLoaderInterface, T >::value ||
                       std::is_same< ControlPointConstraintInterface, T >::value ||
                       std::is_same< SparsePointCloudInterface, T >::value ||
                       std::is_same< StereoPointCloudInterface, T >::value ||
                       std::is_same< StereoMeshInterface, T >::value ||
                       std::is_same< StereoTexturedMeshInterface, T >::value ||
                       std::is_same< CameraConstraintInterface, T >::value ||
                       std::is_same< ProjectedCoordinateSystemInterface, T >::value ||
                       std::is_same< BoundingBoxInterface, T >::value ||
                       std::is_same< DistanceConstraintInterface, T >::value ||
                       std::is_same< OrthophotoInterface, T >::value ||
                       std::is_same< GaussianSplatsInterface, T >::value ||
                       std::is_same< CameraGroupManagerInterface, T >::value,
                       "This kind of buffer can only be used with object classes" );
 
        T **data = nullptr;
 
        Size count = 0;
 
        Buffer() = default;
 
        Buffer( std::vector< T * > &v )
            : data( v.empty() ? nullptr : v.data() )
            , count( v.empty() ? 0 : v.size() )
        {
 
        }
 
        Buffer( std::vector< Detail::UniquePtr< T > > &v )
            : data( v.empty() ? nullptr : reinterpret_cast< T ** >( v.data() ) )
            , count( v.empty() ? 0 : v.size() )
        {
            static_assert( sizeof( Detail::UniquePtr< T > ) ==
                           sizeof( std::ptrdiff_t ), "" );
        }
 
        explicit operator bool() const
        {
            return data != nullptr;
        }
    };
 
    template< typename T >
    struct ConstBuffer< T * >
    {
        static_assert( std::is_same< CameraInterface, T >::value ||
                       std::is_same< CamerasLoaderInterface, T >::value ||
                       std::is_same< ControlPointConstraintInterface, T >::value ||
                       std::is_same< SparsePointCloudInterface, T >::value ||
                       std::is_same< StereoPointCloudInterface, T >::value ||
                       std::is_same< StereoMeshInterface, T >::value ||
                       std::is_same< StereoTexturedMeshInterface, T >::value ||
                       std::is_same< ProjectedCoordinateSystemInterface, T >::value ||
                       std::is_same< CameraConstraintInterface, T >::value ||
                       std::is_same< DistanceConstraintInterface, T >::value ||
                       std::is_same< BoundingBoxInterface, T >::value ||
                       std::is_same< OrthophotoInterface, T >::value ||
                       std::is_same< GaussianSplatsInterface, T >::value ||
                       std::is_same< CameraGroupManagerInterface, T >::value,
                       "This kind of buffer can only be used with object classes" );
 
        const T *const *data = nullptr;
 
        Size count = 0;
 
        ConstBuffer() = default;
 
        ConstBuffer( const std::vector< T * > &v )
            : data( v.empty() ? nullptr : v.data() )
            , count( v.empty() ? 0 : v.size() )
        {
            static_assert( sizeof( Detail::UniquePtr< T > ) ==
                           sizeof( std::ptrdiff_t ), "" );
        }
 
        ConstBuffer( const std::vector< Detail::UniquePtr< T > > &v )
            : data( v.empty() ? nullptr : reinterpret_cast< const T *const * >( v.data() ) )
            , count( v.empty() ? 0 : v.size() )
        {
            static_assert( sizeof( Detail::UniquePtr< T > ) ==
                           sizeof( std::ptrdiff_t ), "" );
        }
 
        explicit operator bool() const
        {
            return data != nullptr;
        }
    };
 
    struct LogListenerOStream : public LogListenerInterface
    {
        void messageLogged( const char *nMessage )
        {
            // strip log type
            const std::size_t len = std::strlen( nMessage );
 
            if ( len > 3 && nMessage[ 0 ] == '[' && nMessage[ 2 ] == ']' )
                nMessage = nMessage + 3;
 
            if ( mFileStream )
            {
                ( *mFileStream ) << nMessage;
                mFileStream->flush();
            }
 
            std::cout << nMessage;
            std::cout.flush();
        }
 
        std::ostream *mFileStream = nullptr;
    };
 
    struct ProgressBarEmpty : public ProgressBarInterface
    {
        void start( const char *nWindowTitle, bool nShowGlobalProgress, bool nShowCancelButton )
        {
 
        }
 
        void finish()
        {
 
        }
 
        void resetTicks( unsigned int nTicks, const char *nLoadingText )
        {
 
        }
 
        void resetGlobalTicks( unsigned int nGlobalTicks, const char *nLoadingText )
        {
 
        }
 
        void update()
        {
 
        }
 
        void updateGlobal()
        {
 
        }
    };
 
    using UniqueCameraPtr = Detail::UniquePtr< CameraInterface >;
 
    using UniqueCameraCalibrationPtr = Detail::UniquePtr< CameraCalibrationInterface >;
 
    using UniqueCamerasLoaderPtr = Detail::UniquePtr< CamerasLoaderInterface >;
 
    using UniqueSparsePointCloudPtr = Detail::UniquePtr< SparsePointCloudInterface >;
 
    using UniqueStereoPointCloudPtr = Detail::UniquePtr< StereoPointCloudInterface >;
 
    using UniqueStereoMeshPtr = Detail::UniquePtr< StereoMeshInterface >;
 
    using UniqueStereoTexturedMeshPtr = Detail::UniquePtr< StereoTexturedMeshInterface >;
 
    using UniqueSettingsPtr = Detail::UniquePtr< SettingsInterface >;
 
    using UniqueBoundingBoxPtr = Detail::UniquePtr< BoundingBoxInterface >;
 
    using UniqueWorkspaceSaverPtr = Detail::UniquePtr< WorkspaceSaverInterface >;
 
    using UniqueWorkspaceLoaderPtr = Detail::UniquePtr< WorkspaceLoaderInterface >;
 
    using UniqueControlPointConstraintPtr = Detail::UniquePtr< ControlPointConstraintInterface >;
 
    using UniqueOrthophotoPtr = Detail::UniquePtr< OrthophotoInterface >;
 
    using UniqueProjectedCoordinateSystemPtr = Detail::UniquePtr< ProjectedCoordinateSystemInterface >;
 
    using UniqueCameraConstraintPtr = Detail::UniquePtr< CameraConstraintInterface >;
 
    using UniqueDynamicBufferPtr = Detail::UniquePtr< DynamicBufferInterface >;
 
    using UniqueLicenseInfoPtr = Detail::UniquePtr< LicenseInfoInterface >;
 
    using UniqueDistanceConstraintPtr = Detail::UniquePtr< DistanceConstraintInterface >;
 
    using UniqueCameraGroupManagerPtr = Detail::UniquePtr< CameraGroupManagerInterface >;
 
    using UniqueGaussianSplatsPtr = Detail::UniquePtr< GaussianSplatsInterface >;
 
    extern "C" FLE_DLL
    Result SampleEpipolarLine( const CameraInterface &referenceCamera,
                               const Point2 &referencePoint,
                               const CameraInterface &targetCamera,
                               int sampleCount,
                               Buffer< Point2 > inOutPoints );
 
    extern "C" FLE_DLL
    Result ComputeCamerasRating( Buffer< CameraInterface * > cameras,
                                 Buffer< Pair< CameraInterface *, Point2 > > selectedPoints,
                                 Buffer< int > inOutRatings );
}