NeuralNetwork.hpp

Go to the documentation of this file.

#pragma once
 
#include <FAST/ProcessObject.hpp>
#include <FAST/Data/Tensor.hpp>
#include <FAST/Data/SimpleDataObject.hpp>
#include "InferenceEngine.hpp"
 
namespace fast {
 
class Image;
class Tensor;
 
class FAST_EXPORT InferenceDataList {
    public:
        explicit InferenceDataList(std::vector<std::shared_ptr<Image>> images) {
            m_images = images;
        }
        explicit InferenceDataList(std::vector<std::shared_ptr<Tensor>> tensors) {
            m_tensors = tensors;
        }
        InferenceDataList() {
 
        }
        std::vector<std::shared_ptr<Image>> getImages() const {
            if(!isImages())
                throw Exception("The inference that list contains tensors, not images");
 
            return m_images;
        }
        std::vector<std::shared_ptr<Tensor>> getTensors() const {
            if(!isTensors())
                throw Exception("The inference that list contains images, not tensors");
 
            return m_tensors;
        }
        bool isTensors() const { return !m_tensors.empty(); };
        bool isImages() const { return !m_images.empty(); };
        int getSize() const {
            return isImages() ? m_images.size() : m_tensors.size();
        }
    private:
        std::vector<std::shared_ptr<Image>> m_images;
        std::vector<std::shared_ptr<Tensor>> m_tensors;
};
 
class Sequence : public SimpleDataObject<InferenceDataList> {
    FAST_OBJECT(Sequence)
    public:
        void create(std::vector<std::shared_ptr<Image>> images) {
            mData = InferenceDataList(images);
        };
        void create(std::vector<std::shared_ptr<Tensor>> tensors) {
            mData = InferenceDataList(tensors);
        };
        typedef DataAccess<InferenceDataList>::pointer access;
    private:
        Sequence() {};
};
 
class Batch : public SimpleDataObject<InferenceDataList> {
    FAST_OBJECT(Batch)
    public:
        void create(std::vector<std::shared_ptr<Image>> images) {
            mData = InferenceDataList(images);
        };
        void create(std::vector<std::shared_ptr<Tensor>> tensors) {
            mData = InferenceDataList(tensors);
        };
        typedef DataAccess<InferenceDataList>::pointer access;
    private:
        Batch() {};
};
 
class FAST_EXPORT NeuralNetwork : public ProcessObject {
    FAST_OBJECT(NeuralNetwork)
    public:
        void load(std::string filename);
        void load(std::vector<uint8_t> model, std::vector<uint8_t> weights);
        void setInferenceEngine(InferenceEngine::pointer engine);
        void setInferenceEngine(std::string engine);
        InferenceEngine::pointer getInferenceEngine() const;
        void setInputNode(uint portID, std::string name, NodeType type = NodeType::IMAGE, TensorShape shape = {});
        void setOutputNode(uint portID, std::string name, NodeType type = NodeType::IMAGE, TensorShape shape = {});
        void setScaleFactor(float scale);
        void setMeanAndStandardDeviation(float mean, float std);
        void setMinAndMaxIntensity(float min, float max);
        void setSignedInputNormalization(bool signedInputNormalization);
        void setPreserveAspectRatio(bool preserve);
        void setHorizontalFlipping(bool flip);
 
        void setTemporalWindow(uint window);
 
        virtual void setInputSize(std::string name, std::vector<int> size);
 
        void loadAttributes();
 
        virtual ~NeuralNetwork();
    protected:
        NeuralNetwork();
        bool mPreserveAspectRatio;
        bool mHorizontalImageFlipping = false;
        bool mSignedInputNormalization = false;
        int mTemporalWindow = 0;
        int m_batchSize;
        float mScaleFactor, mMean, mStd, mMinIntensity, mMaxIntensity;
        bool mMinAndMaxIntensitySet = false;
        Vector3f mNewInputSpacing;
        std::unordered_map<std::string, std::vector<int>> mInputSizes;
        std::unordered_map<int, DataObject::pointer> m_processedOutputData;
 
        virtual void run();
 
        std::shared_ptr<InferenceEngine> m_engine;
 
        std::unordered_map<std::string, std::vector<std::shared_ptr<Image>>> mInputImages;
        std::unordered_map<std::string, std::vector<std::shared_ptr<Tensor>>> mInputTensors;
 
        std::unordered_map<std::string, Tensor::pointer> processInputData();
        std::vector<std::shared_ptr<Image>> resizeImages(const std::vector<std::shared_ptr<Image>>& images, int width, int height, int depth);
        Tensor::pointer convertImagesToTensor(std::vector<std::shared_ptr<Image>> image, const TensorShape& shape, bool temporal);
 
        Tensor::pointer standardizeOutputTensorData(Tensor::pointer tensor, int sample = 0);
 
    private:
        void execute();
};
 
}