slicer.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2014 Micah C Chambers (micahc.vt@gmail.com)
 *
 * NPL is free software: you can redistribute it and/or modify it under the
 * terms of the BSD 2-Clause License available in LICENSE or at
 * http://opensource.org/licenses/BSD-2-Clause
 *
 * @file slicer.h
 *
 *****************************************************************************/

#ifndef SLICER_H
#define SLICER_H

#include <vector>
#include <cstdint>
#include <cstddef>
#include <cassert>

using namespace std;

namespace npl {

class Slicer
{
public:

    /****************************************
     *
     * Constructors
     *
     ****************************************/

    Slicer();

    Slicer(size_t ndim, const size_t* dim);

    void setDim(size_t ndim, const size_t* dim);

    /****************************************
     *
     * Query Location
     *
     ****************************************/

    bool isBegin() const { return !isEnd() && m_linpos==m_linfirst; };

    bool isEnd() const { return m_end; };

    bool eof() const { return m_end; };

    /*************************************
     * Movement
     ***********************************/

    Slicer& operator++();

    Slicer& operator--();

    void goBegin();

    void goEnd();

    void goIndex(size_t len, int64_t* newpos);

    void goIndex(std::vector<int64_t> newpos);

    /****************************************
     *
     * Actually get the linear location
     *
     ***************************************/

    inline int64_t operator*() const { return m_linpos; };

    void index(size_t len, int64_t* index) const;

    void index(size_t len, int* index) const;

    void index(size_t len, double* index) const;

    inline void index(std::vector<int64_t>& ind) const
    {
        index(ind.size(), ind.data());
    }

    inline void index(std::vector<int>& ind) const
    {
        index(ind.size(), ind.data());
    };

    inline void index(std::vector<double>& ind) const
    {
        index(ind.size(), ind.data());
    };

    inline int64_t index(size_t dd) const
    {
        assert(dd<m_ndim);
        return m_pos[dd];
    };

    inline size_t linIndex() const
    {
        return m_linpos;
    }

    inline int64_t getStride(size_t dd)
    {
        assert(dd < m_ndim); return m_strides[dd];
    };

    /***********************************************
     *
     * Modification
     *
     **********************************************/

    void setROI(size_t len, const size_t* roisize, const int64_t* roistart = NULL);

    void setROI(const std::vector<std::pair<int64_t, int64_t>>& roi);

    void setOrder(const std::vector<size_t>& order, bool revorder = false);

    void setOrder(std::initializer_list<size_t> order, bool revorder = false);

    void setOrder();

    const std::vector<size_t>& getOrder() const { return m_order; } ;

protected:

    /******************************************
     *
     * Offset, useful to kernel processing
     *
     ******************************************/

    size_t m_linpos;
    size_t m_linfirst;
    std::vector<int64_t> m_pos;
    bool m_end;

    size_t m_ndim;
    std::vector<size_t> m_order;
    std::vector<std::pair<int64_t,int64_t>> m_roi;
    std::vector<size_t> m_dim;
    std::vector<size_t> m_strides;
};

class ChunkSlicer
{
public:

    /****************************************
     *
     * Constructors
     *
     ****************************************/

    ChunkSlicer();

    ChunkSlicer(size_t ndim, const size_t* dim);

    void setDim(size_t ndim, const size_t* dim);

    /****************************************
     *
     * Query Location
     *
     ****************************************/

    bool isBegin() const { return !isEnd() && m_linpos==m_linfirst; };

    bool isEnd() const { return m_end; };

    bool eof() const { return m_end; };

    bool isChunkBegin() const { return m_linpos==m_chunkfirst; };

    bool isChunkEnd() const { return m_chunkend; };

    bool eoc() const { return m_chunkend; };

    /*************************************
     * Movement
     ***********************************/

    ChunkSlicer& operator++();

    ChunkSlicer& operator--();

    ChunkSlicer& nextChunk();

    ChunkSlicer& prevChunk();

    void goChunkBegin();

    void goChunkEnd();

    void goBegin();

    void goEnd();

    void goIndex(size_t len, int64_t* newpos);

    void goIndex(std::vector<int64_t> newpos);

    /****************************************
     *
     * Actually get the linear location
     *
     ***************************************/

    inline int64_t operator*() const { return m_linpos; };

    void index(size_t len, int64_t* index) const;

    void index(size_t len, int* index) const;

    void index(size_t len, double* index) const;

    inline void index(std::vector<int64_t>& ind) const
    {
        index(ind.size(), ind.data());
    };

    inline void index(std::vector<int>& ind) const
    {
        index(ind.size(), ind.data());
    };

    inline void index(std::vector<double>& ind) const
    {
        index(ind.size(), ind.data());
    };

    inline int64_t index(size_t dd) const
    {
        assert(dd<m_ndim);
        return m_pos[dd];
    };

    inline size_t linIndex() const
    {
        return m_linpos;
    }

    inline int64_t getStride(size_t dd)
    {
        assert(dd < m_ndim);
        return m_strides[dd];
    };

    /***********************************************
     *
     * Modification
     *
     **********************************************/

    void setROI(size_t len,  const size_t* roisize, const int64_t* roistart = NULL);

    void setROI(const std::vector<std::pair<int64_t, int64_t>>& roi);

    void setChunkSize(size_t len, const int64_t* sizes, bool defunity = false);

    void setChunkSize(size_t len, const size_t* sizes, bool defunity = false);

    void setLineChunk(size_t dir);

    void setOrder(const std::vector<size_t>& order, bool revorder = false);

    void setOrder(std::initializer_list<size_t> order, bool revorder = false);

    const std::vector<size_t>& getOrder() const { return m_order; } ;

protected:

    /******************************************
     *
     * Offset, useful to kernel processing
     *
     ******************************************/

    // used to determine begin/end status
    size_t m_linfirst;
    size_t m_chunkfirst;
    bool m_end;
    bool m_chunkend;

    // position
    size_t m_linpos;
    std::vector<int64_t> m_pos;
    std::vector<std::pair<int64_t,int64_t>> m_chunk;

    // relatively static
    std::vector<size_t> m_order;
    std::vector<std::pair<int64_t,int64_t>> m_roi;
    std::vector<int64_t> m_chunksizes;

    size_t m_ndim;
    std::vector<size_t> m_dim;
    std::vector<size_t> m_strides;
};

class KSlicer
{
public:

    /****************************************
     *
     * Constructors
     *
     ****************************************/

    KSlicer();

    KSlicer(size_t ndim, const size_t* dim);

    /***************************************************
     *
     * Basic Settings
     *
     ***************************************************/

    void setROI(const std::vector<std::pair<int64_t, int64_t>> roi = {});

    void setROI(size_t len, const size_t* roisize, const int64_t* roistart = NULL);

    void setOrder(const std::vector<size_t> order = {}, bool revorder = false);

    const std::vector<size_t>& getOrder() const { return m_order; } ;

    void setRadius(std::vector<size_t> kradius = {});

    void setRadius(size_t kradius);

    void setWindow(const std::vector<std::pair<int64_t, int64_t>>& krange);

    /****************************************
     *
     * Query Location
     *
     ****************************************/

    bool isBegin() const { return m_linpos[m_center] == m_begin; };

    bool isEnd() const { return m_end; };

    bool eof() const { return m_end; };

    inline int64_t linIndex() const
    {
        return m_linpos[m_center];
    }

    inline int64_t getStride(size_t dd)
    {
        assert(dd < m_ndim);
        return m_strides[dd];
    };

    /*************************************
     * Movement
     ***********************************/

    KSlicer& operator++();

    KSlicer& operator--();

    void goBegin();

    void goEnd();

    void goIndex(const std::vector<int64_t>& newpos);

    /****************************************
     *
     * Actually get the linear location
     *
     ***************************************/

    inline int64_t getC() const
    {
        assert(!m_end);
        return m_linpos[m_center];
    };

    inline int64_t operator*() const
    {
        assert(!m_end);
        return m_linpos[m_center];
    };


    void indexC(size_t len, int64_t* index) const;

    inline int64_t getK(int64_t kit) const
    {
        assert(!m_end);
        assert(kit < m_numoffs);
        assert(m_linpos[kit] >= 0);
        return m_linpos[kit];
    };

    inline int64_t operator[](int64_t kit) const
    {
        assert(!m_end);
        assert(kit < m_numoffs);
        assert(m_linpos[kit] >= 0);
        return m_linpos[kit];
    };

    void indexK(size_t kit, size_t len, int64_t* index, bool bound = true) const;

    int64_t offsetK(size_t kit, size_t dim);

    bool insideK(size_t k);

    void offsetK(size_t kit, size_t len, int64_t* dindex) const;

    size_t ksize() const
    {
        return m_numoffs;
    };

    void setDim(size_t ndim, const size_t* dim);

protected:

    // order of traversal, constructor initializes
    size_t m_ndim; // constructor
    std::vector<size_t> m_size; // constructor
    std::vector<size_t> m_strides; //constructor

    // setOrder
    std::vector<size_t> m_order;

    // setRadius/setWindow
    // for each of the neighbors we need to know
    size_t m_numoffs; // setRadius/setWindow/

    // NDIM*OFFSET, D0O0, D1O0, D2O0, D0O1, ...
    std::vector<int64_t*> m_offs; // setRadius/setWindow
    std::vector<int64_t> m_offs_raw; // setRadius/setWindow
    size_t m_center;  // setRadius/setWindow
    int64_t m_fradius; //forward radius, should be positive
    int64_t m_rradius; //reverse radius, should be positive

    // setROI
    std::vector<std::pair<int64_t,int64_t>> m_roi;
    size_t m_begin;

    // goBegin/goEnd/goIndex
    bool m_end;
    std::vector<int64_t*> m_pos;
    std::vector<int64_t> m_pos_raw;
    std::vector<int64_t> m_linpos;

};

} // npl

#endif //SLICER_H