ScanTypes.hpp

Go to the documentation of this file.

#ifndef __SCANTYPES_HPP__
#define __SCANTYPES_HPP__

#include "lvr2/io/PointBuffer.hpp"
#include "lvr2/geometry/BoundingBox.hpp"
#include "lvr2/types/MatrixTypes.hpp"
#include "lvr2/registration/CameraModels.hpp"

#include <boost/optional.hpp>
#include <boost/filesystem.hpp>
#include <string_view>

#include <opencv2/core.hpp>

#include <memory>
#include <vector>

namespace lvr2
{

/*****************************************************************************
 * @brief Class to represent a scan within a scan project
 ****************************************************************************/
struct Scan
{
    Scan() :
        points(nullptr),
        registration(Transformd::Identity()),
        poseEstimation(Transformd::Identity()),
        thetaMin(0), thetaMax(0),
        phiMin(0), phiMax(0),
        hResolution(0),
        vResolution(0),
        pointsLoaded(false),
        positionNumber(0),
        numPoints(0),
        scanRoot(boost::filesystem::path("./"))
    {}

    ~Scan() {};

    static constexpr char           sensorType[] = "Scan";

    PointBufferPtr                  points;

    Transformd                      registration;

    Transformd                      poseEstimation;

    BoundingBox<BaseVector<float> > boundingBox;

    double                           thetaMin;

    double                           thetaMax;

    double                           phiMin;

    double                           phiMax;

    double                           hResolution;

    double                           vResolution;

    double                           startTime;

    double                           endTime;

    bool                            pointsLoaded;

    int                             positionNumber;

    boost::filesystem::path         scanRoot;

    boost::filesystem::path         scanFile;

    size_t                          numPoints;
};

using ScanPtr = std::shared_ptr<Scan>;
using ScanOptional = boost::optional<Scan>;

/*****************************************************************************
 * @brief   Struct to hold a camera image together with intrinsic 
 *          and extrinsic camera parameters
 * 
 *****************************************************************************/

struct ScanImage
{
    static constexpr char           sensorType[] = "ScanImage";

    Extrinsicsd                     extrinsics;

    Extrinsicsd                     extrinsicsEstimate;

    boost::filesystem::path         imageFile;

    cv::Mat                         image;
};



using ScanImagePtr = std::shared_ptr<ScanImage>;
using ScanImageOptional = boost::optional<ScanImage>;


/*****************************************************************************
 * @brief   Represents a camera that was used at a specific scan
 *          position. The intrinsic calibration is stored in the
 *          camera's camera field. Each image has its owen orientation
 *          (extrinsic matrix) with respect to the laser scanner
 * 
 ****************************************************************************/
struct ScanCamera 
{
    static constexpr char           sensorType[] = "ScanCamera";

    std::string                     sensorName = "Camera";

    PinholeModeld                   camera;

    std::vector<ScanImagePtr>       images;
};

using ScanCameraPtr = std::shared_ptr<ScanCamera>;


/*****************************************************************************
 * @brief   Struct to hold a camera hyperspectral panorama
 *          together with a timestamp
 * 
 *****************************************************************************/

struct HyperspectralPanoramaChannel
{
    static constexpr char           sensorType[] = "HyperspectralPanoramaChannel";

    double                          timestamp;

    boost::filesystem::path         channelFile;

    cv::Mat                         channel;
};

using HyperspectralPanoramaChannelPtr = std::shared_ptr<HyperspectralPanoramaChannel>;
using HyperspectralPanoramaChannelOptional = boost::optional<HyperspectralPanoramaChannel>;

/*****************************************************************************
 * @brief   Struct to hold a camera hyperspectral panorama
 *          together with a timestamp
 * 
 *****************************************************************************/

struct HyperspectralPanorama
{
    static constexpr char                          sensorType[] = "HyperspectralPanorama";

    std::vector<HyperspectralPanoramaChannelPtr>   channels;
};

using HyperspectralPanoramaPtr = std::shared_ptr<HyperspectralPanorama>;
using HyperspectralPanoramaOptional = boost::optional<HyperspectralPanorama>;


/*****************************************************************************
 * @brief   Struct to hold a hyperspectral camera model
 *          together with intrinsic, extrinsic and further parameters
 * 
 *****************************************************************************/

struct HyperspectralCameraModel
{
    static constexpr char           sensorType[] = "HyperspectralCameraModel";

    Extrinsicsd                     extrinsics;

    Extrinsicsd                     extrinsicsEstimate;

    double                          focalLength;

    double                          offsetAngle;

    Vector3d                        principal;

    Vector3d                        distortion;
};

using HyperspectralCameraModelPtr = std::shared_ptr<HyperspectralCameraModel>;


/*****************************************************************************
 * @brief   Struct to hold a hyperspectral camera
 *          together with it's camera model and panoramas
 * 
 *****************************************************************************/

struct HyperspectralCamera
{
    static constexpr char                    sensorType[] = "HyperspectralCamera";

    // HyperspectralCameraModelPtr              cameraModel;

    Extrinsicsd                              extrinsics;

    Extrinsicsd                              extrinsicsEstimate;

    double                                   focalLength;

    double                                   offsetAngle;

    Vector3d                                 principal;

    Vector3d                                 distortion;

    std::vector<HyperspectralPanoramaPtr>    panoramas;
};

using HyperspectralCameraPtr = std::shared_ptr<HyperspectralCamera>;


/*****************************************************************************
 * @brief   Represents a scan position consisting of a scan and
 *          images taken at this position
 * 
 ****************************************************************************/
struct ScanPosition
{
    static constexpr char           sensorType[] = "ScanPosition";

    std::vector<ScanPtr>            scans;

    std::vector<ScanCameraPtr>      cams;

    HyperspectralCameraPtr          hyperspectralCamera;

    double                          latitude = 0.0;

    double                          longitude = 0.0;

    double                          altitude = 0.0;

    Transformd                      pose_estimate;

    Transformd                      registration;

    double                          timestamp = 0.0;

};

using ScanPositionPtr = std::shared_ptr<ScanPosition>;

/*****************************************************************************
 * @brief   Struct to represent a scan project consisting
 *          of a set of scan position. Each scan position 
 *          can consist of a laser scan and an set of acquired
 *          images. All scan position are numbered incrementally.
 *          If an optional for a scan position returns false,
 *          the corresponding data is not available for this 
 *          scan position number.
 *****************************************************************************/
struct ScanProject
{
    static constexpr char           sensorType[] = "ScanProject";

    std::string                     sensorName;

    Transformd                      pose;

    std::vector<ScanPositionPtr>    positions;

    std::string                     coordinateSystem;
};

using ScanProjectPtr = std::shared_ptr<ScanProject>;

/*****************************************************************************
 * @brief   Struct to represent a scan project with marker showing if a scan
 *          pose has been changed
 *****************************************************************************/
struct ScanProjectEditMark
{
    ScanProjectPtr project;
    std::vector<bool> changed;
};

using ScanProjectEditMarkPtr = std::shared_ptr<ScanProjectEditMark>;

} // namespace lvr2

#endif