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