Program Listing for File layer.h

↰ Return to documentation for file (include/cpphots/layer.h)

#ifndef CPPHOTS_LAYER_H
#define CPPHOTS_LAYER_H

#include "assert.h"
#include "types.h"
#include "clustering/utils.h"
#include "interfaces/all.h"


namespace cpphots {

class Layer : public virtual interfaces::TimeSurfacePoolCalculator, public virtual interfaces::Clusterer {

public:
    Layer(interfaces::TimeSurfacePoolCalculator* tspool = nullptr,
          interfaces::Clusterer* clusterer = nullptr,
          interfaces::EventRemapper* remapper = nullptr,
          interfaces::SuperCell* supercell = nullptr);

    ~Layer();

    Layer(const Layer& other);

    Layer(Layer&& other);

    Layer& operator=(const Layer& other);

    Layer& operator=(Layer&& other);

    void addTSPool(interfaces::TimeSurfacePoolCalculator* tspool);

    template<typename T, typename... Args>
    void createTSPool(const Args&... args) {
        delete tspool;

        tspool = new T(args...);

    }

    interfaces::TimeSurfacePoolCalculator& getTSPool();

    const interfaces::TimeSurfacePoolCalculator& getTSPool() const;

    void addClusterer(interfaces::Clusterer* clusterer);

    template<typename T, typename... Args>
    void createClusterer(const Args&... args) {
        delete clusterer;

        clusterer = new T(args...);

    }

    interfaces::Clusterer& getClusterer();

    const interfaces::Clusterer& getClusterer() const;

    void addRemapper(interfaces::EventRemapper* remapper);

    template<typename T, typename... Args>
    void createRemapper(const Args&... args) {
        delete remapper;

        remapper = new T(args...);

    }

    interfaces::EventRemapper& getRemapper();

    const interfaces::EventRemapper& getRemapper() const;

    void addSuperCell(interfaces::SuperCell* supercell);

    template<typename T, typename... Args>
    void createSuperCell(const Args&... args) {
        delete supercell;

        supercell = new T(args...);

    }

    interfaces::SuperCell& getSuperCell();

    const interfaces::SuperCell& getSuperCell() const;

    event process(uint64_t t, uint16_t x, uint16_t y, uint16_t p, bool skip_check = false);

    event process(const event& ev, bool skip_check = false) {
        return process(ev.t, ev.x, ev.y, ev.p, skip_check);
    }

    bool canCluster() const;

    // interfaces::TimeSurfacePoolCalculator
    void update(uint64_t t, uint16_t x, uint16_t y, uint16_t p) override {
        tspool->update(t, x, y, p);
    }

    void update(const event& ev) override {
        tspool->update(ev);
    }

    std::pair<TimeSurfaceType, bool> compute(uint64_t t, uint16_t x, uint16_t y, uint16_t p) const override {
        return tspool->compute(t, x, y, p);
    }

    std::pair<TimeSurfaceType, bool> compute(const event& ev) const override {
        return tspool->compute(ev);
    }

    std::pair<TimeSurfaceType, bool> updateAndCompute(uint64_t t, uint16_t x, uint16_t y, uint16_t p) override {
        return tspool->updateAndCompute(t, x, y, p);
    }

    std::pair<TimeSurfaceType, bool> updateAndCompute(const event& ev) override {
        return tspool->updateAndCompute(ev);
    }

    std::pair<uint16_t, uint16_t> getSize() const override {
        return tspool->getSize();
    }

    TimeSurfacePtr& getSurface(size_t idx) override {
        return tspool->getSurface(idx);
    }

    const TimeSurfacePtr& getSurface(size_t idx) const override {
        return tspool->getSurface(idx);
    }

    std::vector<TimeSurfaceType> sampleContexts(uint64_t t) const override {
        return tspool->sampleContexts(t);
    }

    size_t getNumSurfaces() const override {
        return tspool->getNumSurfaces();
    }

    // interfaces::Clusterer
    uint16_t cluster(const TimeSurfaceType& surface) override {
        cpphots_assert(clusterer != nullptr);
        return clusterer->cluster(surface);
    }

    uint16_t getNumClusters() const override {
        cpphots_assert(clusterer != nullptr);
        return clusterer->getNumClusters();
    }

    void addCentroid(const TimeSurfaceType& centroid) override {
        cpphots_assert(clusterer != nullptr);
        clusterer->addCentroid(centroid);
    }

    const std::vector<TimeSurfaceType>& getCentroids() const override {
        cpphots_assert(clusterer != nullptr);
        return clusterer->getCentroids();
    }

    void clearCentroids() override {
        cpphots_assert(clusterer != nullptr);
        return clusterer->clearCentroids();
    }

    bool hasCentroids() const override {
        cpphots_assert(clusterer != nullptr);
        return clusterer->hasCentroids();
    }

    bool isOnline() const override {
        cpphots_assert(clusterer != nullptr);
        return clusterer->isOnline();
    }

    bool toggleLearning(bool enable = true) override {
        cpphots_assert(clusterer != nullptr);
        return clusterer->toggleLearning(enable);
    }

    void train(const std::vector<TimeSurfaceType>& tss) {
        cpphots_assert(clusterer != nullptr);
        return clusterer->train(tss);
    }

    std::vector<uint32_t> getHistogram() const override {
        cpphots_assert(clusterer != nullptr);
        return clusterer->getHistogram();
    }

    void reset() override;

    void toStream(std::ostream& out) const override;

    void fromStream(std::istream& in) override;

    Layer* clone() const override;

private:
    interfaces::TimeSurfacePoolCalculator* tspool = nullptr;
    interfaces::Clusterer* clusterer = nullptr;
    interfaces::EventRemapper* remapper = nullptr;
    interfaces::SuperCell* supercell = nullptr;

    void delete_components();

};


void layerSeedCentroids(const ClustererSeedingType& seeding, Layer& layer, const Events& events, bool valid_only = true);


void layerSeedCentroids(const ClustererSeedingType& seeding, Layer& layer, const std::vector<Events>& event_streams, bool valid_only = true);

}

#endif