View.hpp

// This file is part of the AliceVision project.
// Copyright (c) 2016 AliceVision contributors.
// Copyright (c) 2012 openMVG contributors.
// This Source Code Form is subject to the terms of the Mozilla Public License,
// v. 2.0. If a copy of the MPL was not distributed with this file,
// You can obtain one at https://mozilla.org/MPL/2.0/.
 
#pragma once
 
#include <aliceVision/types.hpp>
#include <aliceVision/numeric/numeric.hpp>
#include <aliceVision/image/dcp.hpp>
#include <aliceVision/sensorDB/Datasheet.hpp>
#include <aliceVision/camera/IntrinsicInitMode.hpp>
#include <aliceVision/lensCorrectionProfile/lcp.hpp>
 
#include <aliceVision/sfmData/ImageInfo.hpp>
#include <aliceVision/sfmData/exif.hpp>
#include <aliceVision/sfmData/ExposureSetting.hpp>
 
#include <regex>
#include <string>
#include <utility>
 
namespace aliceVision {
namespace sfmData {
 
class View
{
  public:
    using sptr = std::shared_ptr<View>;
    using ptr = View*;
 
  public:
    View(const std::string& imagePath = "",
         IndexT viewId = UndefinedIndexT,
         IndexT intrinsicId = UndefinedIndexT,
         IndexT poseId = UndefinedIndexT,
         std::size_t width = 0,
         std::size_t height = 0,
         IndexT rigId = UndefinedIndexT,
         IndexT subPoseId = UndefinedIndexT,
         const std::map<std::string, std::string>& metadata = std::map<std::string, std::string>())
      : _viewId(viewId),
        _intrinsicId(intrinsicId),
        _poseId(poseId),
        _rigId(rigId),
        _subPoseId(subPoseId),
        _image(new ImageInfo(imagePath, width, height, metadata))
    {}
 
    View(const View& v) = default;
 
 
    View* shallowClone() { return new View(*this); }
 
    View* clone() const
    {
        View* v = new View(*this);
        v->_image = std::make_shared<ImageInfo>(*this->_image);
        return v;
    }
 
    bool operator==(const View& other) const
    {
        // image paths can be different
        return _viewId == other._viewId && _intrinsicId == other._intrinsicId && _poseId == other._poseId && _rigId == other._rigId &&
               _subPoseId == other._subPoseId && _imageGroupId == other._imageGroupId;
    }
 
    inline bool operator!=(const View& other) const { return !(*this == other); }
 
    const ImageInfo& getImage() const { return *_image; }
 
    ImageInfo& getImage() { return *_image; }
 
    std::shared_ptr<ImageInfo> getImageInfo() { return _image; }
 
    IndexT getViewId() const { return _viewId; }
 
    IndexT getImageGroupId() const { return _imageGroupId; }
 
    IndexT getIntrinsicId() const { return _intrinsicId; }
 
    IndexT getPoseId() const { return _poseId; }
 
    IndexT getRigId() const { return _rigId; }
 
    IndexT getSubPoseId() const { return _subPoseId; }
 
    IndexT getFrameId() const { return _frameId; }
 
    IndexT getResectionId() const { return _resectionId; }
 
    bool isPartOfRig() const { return _rigId != UndefinedIndexT; }
 
    bool isPoseIndependant() const { return (!isPartOfRig() || _isPoseIndependent); }
 
    void setViewId(IndexT viewId) { _viewId = viewId; }
 
    void setImageGroupId(IndexT imageGroupId) { _imageGroupId = imageGroupId; }
 
    void setIntrinsicId(IndexT intrinsicId) { _intrinsicId = intrinsicId; }
 
    void setPoseId(IndexT poseId) { _poseId = poseId; }
 
    void setIndependantPose(bool independent) { _isPoseIndependent = independent; }
 
    void setRigAndSubPoseId(IndexT rigId, IndexT subPoseId)
    {
        _rigId = rigId;
        _subPoseId = subPoseId;
    }
 
    void setFrameId(IndexT frameId) { _frameId = frameId; }
 
    const std::vector<IndexT>& getAncestors() const { return _ancestors; }
 
    void addAncestor(IndexT image)
    {
        if (std::find(_ancestors.begin(), _ancestors.end(), image) == _ancestors.end())
        {
            _ancestors.push_back(image);
        }
    }
 
    void setResectionId(IndexT resectionId) { _resectionId = resectionId; }
 
    bool isFullySetup()
    {
        return (getViewId() != UndefinedIndexT && getIntrinsicId() != UndefinedIndexT && getPoseId() == getViewId());
    }
 
  private:
    IndexT _viewId;
    IndexT _intrinsicId;
    IndexT _poseId;
    IndexT _rigId;
    IndexT _subPoseId;
    IndexT _imageGroupId = UndefinedIndexT;
    IndexT _frameId = UndefinedIndexT;
    IndexT _resectionId = UndefinedIndexT;
    bool _isPoseIndependent = true;
    std::vector<IndexT> _ancestors;
    std::shared_ptr<ImageInfo> _image;
};
 
}  // namespace sfmData
}  // namespace aliceVision