MRChangePointCloudAction.h

Go to the documentation of this file.

#pragma once
#include "MRHistoryAction.h"
#include "MRObjectPoints.h"
#include "MRPointCloud.h"
#include "MRHeapBytes.h"
#include <memory>
 
 
namespace MR
{
 

class ChangePointCloudAction : public HistoryAction
{
public:
    using Obj = ObjectPoints;

    ChangePointCloudAction( std::string name, const std::shared_ptr<ObjectPoints>& obj ) :
        objPoints_{ obj },
        name_{ std::move( name ) }
    {
        if ( obj )
        {
            if ( auto m = obj->pointCloudPtr() )
                clonePointCloud_ = std::make_shared<PointCloud>( *m );
        }
    }

    ChangePointCloudAction( std::string name, const std::shared_ptr<ObjectPoints>& obj, std::shared_ptr<PointCloud> newPointCloud ) :
        objPoints_{ obj },
        name_{ std::move( name ) }
    {
        if ( objPoints_ )
        {
            clonePointCloud_ = std::move( newPointCloud );
            objPoints_->swapPointCloud( clonePointCloud_ );
        }
    }
 
    virtual std::string name() const override { return name_; }
 
    virtual void action( HistoryAction::Type ) override
    {
        if ( !objPoints_ )
            return;
 
        objPoints_->swapPointCloud( clonePointCloud_ );
    }
 
    static void setObjectDirty( const std::shared_ptr<ObjectPoints>& obj )
    {
        if ( obj )
            obj->setDirtyFlags( DIRTY_ALL );
    }
 
    [[nodiscard]] virtual size_t heapBytes() const override
    { return name_.capacity() + MR::heapBytes( clonePointCloud_ ); }
 
private:
    std::shared_ptr<ObjectPoints> objPoints_;
    std::shared_ptr<PointCloud> clonePointCloud_;
 
    std::string name_;
};

class ChangePointCloudPointsAction : public HistoryAction
{
public:
    using Obj = ObjectPoints;

    ChangePointCloudPointsAction( std::string name, const std::shared_ptr<ObjectPoints>& obj ) :
        objPoints_{ obj },
        name_{ std::move( name ) }
    {
        if ( obj )
        {
            if ( auto m = obj->pointCloudPtr() )
                clonePoints_ = m->points;
        }
    }

    ChangePointCloudPointsAction( std::string name, const std::shared_ptr<ObjectPoints>& obj, VertCoords && newPoints ) :
        objPoints_{ obj },
        clonePoints_{ std::move( newPoints ) },
        name_{ std::move( name ) }
    {
        action( HistoryAction::Type::Redo );
    }
 
    virtual std::string name() const override
    {
        return name_;
    }
 
    virtual void action( HistoryAction::Type ) override
    {
        if ( !objPoints_ )
            return;
 
        if ( auto m = objPoints_->varPointCloud() )
        {
            std::swap( m->points, clonePoints_ );
            objPoints_->setDirtyFlags( DIRTY_POSITION );
        }
    }
 
    static void setObjectDirty( const std::shared_ptr<ObjectPoints>& obj )
    {
        if ( obj )
            obj->setDirtyFlags( DIRTY_POSITION );
    }
 
    [[nodiscard]] virtual size_t heapBytes() const override
    {
        return name_.capacity() + clonePoints_.heapBytes();
    }
 
private:
    std::shared_ptr<ObjectPoints> objPoints_;
    VertCoords clonePoints_;
 
    std::string name_;
};

class ChangeOnePointInCloudAction : public HistoryAction
{
public:
    using Obj = ObjectPoints;

    ChangeOnePointInCloudAction( std::string name, const std::shared_ptr<ObjectPoints>& obj, VertId pointId ) :
        objPoints_{ obj },
        pointId_{ pointId },
        name_{ std::move( name ) }
    {
        if ( obj )
        {
            if ( auto m = obj->pointCloudPtr() )
                if ( m->points.size() > pointId_ )
                    safeCoords_ = m->points[pointId_];
        }
    }

    ChangeOnePointInCloudAction( std::string name, const std::shared_ptr<ObjectPoints>& obj, VertId pointId, const Vector3f & newCoords ) :
        objPoints_{ obj },
        pointId_{ pointId },
        safeCoords_{ newCoords },
        name_{ std::move( name ) }
    {
        action( HistoryAction::Type::Redo );
    }
 
    virtual std::string name() const override
    {
        return name_;
    }
 
    virtual void action( HistoryAction::Type ) override
    {
        if ( !objPoints_ )
            return;
 
        if ( auto m = objPoints_->varPointCloud() )
        {
            if ( m->points.size() > pointId_ )
            {
                std::swap( safeCoords_, m->points[pointId_] );
                objPoints_->setDirtyFlags( DIRTY_POSITION );
            }
        }
    }
 
    static void setObjectDirty( const std::shared_ptr<ObjectPoints>& obj )
    {
        if ( obj )
            obj->setDirtyFlags( DIRTY_POSITION );
    }
 
    [[nodiscard]] virtual size_t heapBytes() const override
    {
        return name_.capacity();
    }
 
private:
    std::shared_ptr<ObjectPoints> objPoints_;
    VertId pointId_;
    Vector3f safeCoords_;
 
    std::string name_;
};
 
}