Cube.h

//-*- C++ -*-
//-*- coding: utf-8 -*-
//
// Author: Piyush Agram
// Copyright 2017-2019

#pragma once

#include "forward.h"

#include <cmath>
#include <valarray>
#include <vector>
#include <pyre/grid.h>

// isce3::core::Cube definition
template <typename cell_t>
class isce3::core::Cube {

    public:
        // Types for interfacing with pyre::grid
        using rep_t = std::array<size_t, 3>;
        using index_t = pyre::grid::index_t<rep_t>;
        using layout_t = pyre::grid::layout_t<index_t>;

        // Use a grid with view memory storage
        using grid_t = pyre::grid::grid_t<cell_t, layout_t, pyre::memory::view_t<cell_t>>;

        // Dependent types
        using view_t = typename grid_t::view_type;
        using shape_t = typename layout_t::shape_type;
        using slice_t = typename layout_t::slice_type;
        using packing_t = typename layout_t::packing_type;

    public:
        inline Cube();

        inline Cube(size_t nslices, size_t nrows, size_t ncols);
        
        inline Cube(const Cube<cell_t> & m);

        inline Cube(Cube<cell_t> & m);

        inline Cube(cell_t * data, size_t nslices, size_t nrows, size_t ncols);

        inline Cube(std::valarray<cell_t> & data, size_t nrows, size_t ncols);

        inline Cube(std::vector<cell_t> & data, size_t nrows, size_t ncols);

        inline ~Cube();

        inline Cube<cell_t> & operator=(const Cube<cell_t> & m);

        inline Cube<cell_t> & operator=(Cube<cell_t> & m);
        
        inline void resize(size_t nslices, size_t nrows, size_t ncols);

        inline const view_t subcube(size_t slice, size_t row, size_t col, size_t slicespan, size_t rowspan, size_t colspan);
            
        inline cell_t * data();

        inline const cell_t * data() const;

        inline cell_t * sliceptr(size_t slice);

        inline const cell_t * sliceptr(size_t slice) const;

        inline cell_t & operator()(size_t slice, size_t row, size_t col);

        inline const cell_t & operator()(size_t slice, size_t row, size_t col) const;

        inline cell_t & operator()(size_t index);

        inline const cell_t & operator()(size_t index) const;

        inline cell_t & operator[](const index_t & index);

        inline const cell_t & operator[](const index_t & index) const;

        inline void zeros();

        inline void fill(cell_t value);

        inline shape_t shape() const;

        inline size_t width() const;

        inline size_t length() const;

        inline size_t height() const;

        inline shape_t byteoffset() const;

    // Data members
    private:
        // Shape information
        size_t _nslices;
        size_t _nrows;
        size_t _ncols;

        // Dynamic memory data
        cell_t * _buffer;
        bool _owner;

        // grid pointer for slicing support
        grid_t * _grid;

    // Utility functions
    private:
        // Reset grid pointer
        inline void _resetGrid();
};

// Get inline implementations for Cube
#define ISCE_CORE_CUBE_ICC
#include "Cube.icc"
#undef ISCE_CORE_CUBE_ICC