Resample.h

Go to the documentation of this file.

/*
SyneRBI Synergistic Image Reconstruction Framework (SIRF)
Copyright 2017 - 2020 University College London
 
This is software developed for the Collaborative Computational
Project in Synergistic Reconstruction for Biomedical Imaging (formerly CCP PETMR)
(http://www.ccpsynerbi.ac.uk/).
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
 
*/
 
#pragma once
 
#include <vector>
#include <memory>
#include "sirf/Reg/Transformation.h"
#include "sirf/iUtilities/iutilities.h"
#include "sirf/common/JacobiCG.h"
 
 
namespace sirf {
 
// Forward declarations
template<class dataType> class Transformation;
class ImageData;
 
template<class dataType>
class Resampler
{
public:
 
    enum InterpolationType {
        NOTSET           = -1,
        NEARESTNEIGHBOUR =  0,
        LINEAR           =  1,
        CUBICSPLINE      =  3,
        SINC             =  4
    };
 
    Resampler() { _interpolation_type = NOTSET; }
 
    virtual ~Resampler() {}
 
    virtual void set_reference_image(const std::shared_ptr<const ImageData> reference_image_sptr);
 
    virtual void set_floating_image(const std::shared_ptr<const ImageData> floating_image_sptr);
 
    virtual void add_transformation(const std::shared_ptr<const Transformation<dataType> > transformation_sptr);
 
    void clear_transformations() { _transformations.clear(); }
 
    virtual void set_interpolation_type(const enum InterpolationType type);
 
    void set_interpolation_type_to_nearest_neighbour() { set_interpolation_type(NEARESTNEIGHBOUR); }
 
    void set_interpolation_type_to_linear() { set_interpolation_type(LINEAR); }
 
    void set_interpolation_type_to_cubic_spline() { set_interpolation_type(CUBICSPLINE); }
 
    void set_interpolation_type_to_sinc() { set_interpolation_type(SINC); }
 
    const InterpolationType get_interpolation_type() const { return _interpolation_type; }
 
    void set_padding_value(const float padding_value) { _padding_value = padding_value; }
 
    virtual void process() = 0;
 
    const std::shared_ptr<const ImageData> get_output_sptr() const { return _output_image_sptr; }
 
    virtual std::shared_ptr<ImageData> forward(const std::shared_ptr<const ImageData> input_sptr) = 0;
 
    virtual void forward(std::shared_ptr<ImageData> output_sptr, const std::shared_ptr<const ImageData> input_sptr) = 0;
 
    virtual std::shared_ptr<ImageData> adjoint(const std::shared_ptr<const ImageData> input_sptr) = 0;
 
    virtual void adjoint(std::shared_ptr<ImageData> output_sptr, const std::shared_ptr<const ImageData> input_sptr) = 0;
 
    virtual std::shared_ptr<ImageData> backward(const std::shared_ptr<const ImageData> input_sptr);
 
    virtual void backward(std::shared_ptr<ImageData> output_sptr, const std::shared_ptr<const ImageData> input_sptr);
 
    std::shared_ptr<const ImageData> reference_image_sptr() const
    {
        return _reference_image_sptr;
    }
    std::shared_ptr<const ImageData> floating_image_sptr() const
    {
        return _floating_image_sptr;
    }
    std::vector<std::shared_ptr<const Transformation<dataType> > > transformations_sptr() const
    {
    return _transformations;
    }
    virtual float norm(int num_iter, int verb) const = 0;
 
protected:
 
    virtual void set_up() = 0;
 
    virtual void set_up_forward() = 0;
 
    virtual void set_up_adjoint() = 0;
 
    virtual void check_parameters();
 
    std::shared_ptr<const ImageData> _reference_image_sptr;
    std::shared_ptr<const ImageData> _floating_image_sptr;
 
    std::vector<std::shared_ptr<const Transformation<dataType> > > _transformations;
 
    InterpolationType  _interpolation_type;
 
    std::shared_ptr<ImageData> _output_image_sptr;
 
    float _padding_value = 0;
    bool _need_to_set_up = true;
    bool _need_to_set_up_forward = true;
    bool _need_to_set_up_adjoint = true;
};
 
template<class dataType>
class BFOperator : public Operator<Wrapped_sptr<ImageData, dataType> >{
public:
    BFOperator(std::shared_ptr<Resampler<dataType> > sptr_r) : sptr_r_(sptr_r) {}
    std::shared_ptr<Wrapped_sptr<ImageData, dataType> > apply(const Wrapped_sptr<ImageData, dataType>& wsptr)
    {
        std::shared_ptr<const ImageData> sptr_im = wsptr.sptr();
        std::shared_ptr<ImageData> sptr_f = sptr_r_->forward(sptr_im);
        std::shared_ptr<ImageData> sptr_bf = sptr_r_->backward(sptr_f);
        return std::unique_ptr<Wrapped_sptr<ImageData, dataType> >(new Wrapped_sptr<ImageData, dataType>(sptr_bf));
    }
private:
        std::shared_ptr<Resampler<dataType> > sptr_r_;
};
 
}