ndarray.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 ndarray.h
 * @brief This file contains the definition for NDarray and its derived types.
 * The derived types are templated over dimensionality and pixel type.
 ******************************************************************************/

#ifndef NDARRAY_H
#define NDARRAY_H

#include "npltypes.h"

#include "zlib.h"

#include <cstddef>
#include <cmath>
#include <initializer_list>
#include <vector>
#include <cstdint>
#include <complex>
#include <cassert>
#include <memory>


namespace npl {

/******************************************************************************
 * Define Types
 *****************************************************************************/
enum PixelT {UNKNOWN_TYPE=0, UINT8=2, INT16=4, INT32=8, FLOAT32=16,
    COMPLEX64=32, CFLOAT=32, FLOAT64=64, RGB24=128, INT8=256, UINT16=512,
    UINT32=768, INT64=1024, UINT64=1280, FLOAT128=1536, CDOUBLE=1792,
    COMPLEX128=1792, CQUAD=2048, COMPLEX256=2048, RGBA32=2304 };

class NDArray;

const size_t MAXDIM = 10;

/******************************************************************************
 * Basic Functions.
 ******************************************************************************/

ptr<NDArray> createNDArray(size_t ndim, const size_t* size, PixelT ptype);

ptr<NDArray> createNDArray(const std::vector<size_t>& dim, PixelT ptype);

ptr<NDArray> createNDArray(size_t ndim, const size_t* size,
        PixelT ptype, void* ptr, std::function<void(void*)> deleter);

ptr<NDArray> createNDArray(const std::vector<size_t>& dim,
        PixelT ptype, void* ptr, std::function<void(void*)> deleter);

void copyROI(ptr<const NDArray> in,
        const int64_t* inROIL, const size_t* inROIZ, ptr<NDArray> out,
        const int64_t* oROIL, const size_t* oROIZ, PixelT newtype);

std::ostream& operator<<(std::ostream &out, const NDArray& img);

std::string pixelTtoString(PixelT type);

PixelT stringToPixelT(std::string type);

/******************************************************************************
 * Classes.
 ******************************************************************************/

class NDArray : public std::enable_shared_from_this<NDArray>
{
public:
    /*
     * get / set functions
     */
    // Get Address

    virtual size_t ndim() const = 0;
    virtual size_t bytes() const = 0;
    virtual size_t bytesper() const = 0;
    virtual size_t elements() const = 0;
    virtual size_t dim(size_t dir) const = 0;
    virtual const size_t* dim() const = 0;

    virtual PixelT type() const = 0;

    bool floatType() const {
        return type()==FLOAT32 || type()==FLOAT64 || type()==FLOAT128;
    };

    bool complexType() const{
        return type()==COMPLEX64|| type()==COMPLEX128|| type()==COMPLEX256;
    };

    bool signedType() const {
        return type()==INT8|| type()==INT16 || type()==INT32 || type()==INT64;
    };

    bool unsignedType() const {
        return type()==UINT8||type()==UINT16||type()==UINT32||type()==UINT64;
    };


    ptr<NDArray> getPtr()  {
        return shared_from_this();
    };

    ptr<const NDArray> getConstPtr() const {
        return shared_from_this();
    };

    virtual void* data() = 0;
    virtual const void* data() const = 0;

    virtual ptr<NDArray> copy() const = 0;

    virtual ptr<NDArray> createAnother() const = 0;

    virtual ptr<NDArray> createAnother(size_t newdims, const size_t* newsize,
            PixelT newtype) const = 0;

    virtual ptr<NDArray> createAnother(PixelT newtype) const = 0;

    virtual ptr<NDArray> createAnother(size_t newdims,
            const size_t* newsize) const = 0;

    virtual ptr<NDArray> copyCast(size_t newdims, const size_t* newsize,
            PixelT newtype) const = 0;

    virtual ptr<NDArray> copyCast(PixelT newtype) const = 0;

    virtual ptr<NDArray> copyCast(size_t newdims,
                const size_t* newsize) const = 0;

    virtual ptr<NDArray> extractCast(size_t len, const int64_t* index,
            const size_t* size) const = 0;

    virtual ptr<NDArray> extractCast(size_t len, const size_t* size) const = 0;

    virtual ptr<NDArray> extractCast(size_t len,
            const int64_t* index, const size_t* size, PixelT newtype) const = 0;

    virtual ptr<NDArray> extractCast(size_t len, const size_t* size,
            PixelT newtype) const = 0;

    /********************************************
     * Output Functions
     *******************************************/

    virtual int write(std::string filename, double version = 1) const = 0;

    /********************************************
     * Helper Functions
     *******************************************/

    virtual void zero() = 0;

//  virtual int opself(const NDArray* right, double(*func)(double,double),
//          bool elevR) = 0;
//  virtual ptr<NDArray> opnew(const NDArray* right,
//          double(*func)(double,double), bool elevR) = 0;

    virtual void* __getAddr(std::initializer_list<int64_t> index) const = 0;
    virtual void* __getAddr(size_t len, const int64_t* index) const = 0;
    virtual void* __getAddr(const std::vector<int64_t>& index) const = 0;
    virtual void* __getAddr(int64_t i) const = 0;
    virtual void* __getAddr(int64_t x, int64_t y, int64_t z, int64_t t) const = 0;

    virtual int64_t getLinIndex(std::initializer_list<int64_t> index) const = 0;
    virtual int64_t getLinIndex(size_t len, const int64_t* index) const = 0;
    virtual int64_t getLinIndex(const std::vector<int64_t>& index) const = 0;
    virtual int64_t getLinIndex(int64_t x, int64_t y, int64_t z, int64_t t) const = 0;

    virtual int64_t tlen() const = 0;

protected:
    NDArray() {} ;

    std::function<void(void*)> m_freefunc;
};


template <size_t D, typename T>
class NDArrayStore : public virtual NDArray
{
public:
    NDArrayStore();

    NDArrayStore(const std::initializer_list<size_t>& dim);

    NDArrayStore(const std::vector<size_t>& dim);

    NDArrayStore(size_t len, const size_t* dim);

    NDArrayStore(size_t len, const size_t* dim, T* ptr,
            const std::function<void(void*)>& deleter);

    ~NDArrayStore() { m_freefunc(_m_data); };

    /*
     * get / set functions
     */
    T& operator[](const int64_t* index);
    T& operator[](const std::vector<int64_t>& index);
    T& operator[](std::initializer_list<int64_t> index);
    T& operator[](int64_t pixel);

    const T& operator[](const int64_t* index) const;
    const T& operator[](const std::vector<int64_t>& index) const;
    const T& operator[](std::initializer_list<int64_t> index) const;
    const T& operator[](int64_t pixel) const;

    /*
     * General Information
     */
    size_t ndim() const;
    size_t bytes() const;
    size_t bytesper() const;
    size_t elements() const;
    size_t dim(size_t dir) const;
    const size_t* dim() const;

    void resize(const size_t dim[D]);

    void resize(std::initializer_list<size_t> dim);

    // return the pixel type
    PixelT type() const;

    void* data() {return _m_data; };

    const void* data() const { return _m_data; };

    void graft(const size_t dim[D], T* ptr, const
            std::function<void(void*)>& deleter);

    virtual int write(std::string filename, double version = 1) const;

    /**************************************************************************
     * Duplication Functions
     *************************************************************************/

    virtual ptr<NDArray> copy() const;

    virtual ptr<NDArray> createAnother() const;

    virtual ptr<NDArray> createAnother(size_t newdims, const size_t* newsize,
            PixelT newtype) const;

    virtual ptr<NDArray> createAnother(PixelT newtype) const;

    virtual ptr<NDArray> createAnother(size_t newdims,
            const size_t* newsize) const;

    virtual ptr<NDArray> copyCast(size_t newdims, const size_t* newsize,
            PixelT newtype) const;

    virtual ptr<NDArray> copyCast(PixelT newtype) const;

    virtual ptr<NDArray> copyCast(size_t newdims, const size_t* newsize) const;

    virtual ptr<NDArray> extractCast(size_t len, const int64_t* index,
            const size_t* size) const;

    virtual ptr<NDArray> extractCast(size_t len, const size_t* size) const;

    virtual ptr<NDArray> extractCast(size_t len,
            const int64_t* index, const size_t* size, PixelT newtype) const;

    virtual ptr<NDArray> extractCast(size_t len, const size_t* size,
            PixelT newtype) const;
    /*
     * Higher Level Operations
     */

    void zero();

//  virtual int opself(const NDArray* right, double(*func)(double,double),
//          bool elevR);
//  virtual ptr<NDArray> opnew(const NDArray* right,
//          double(*func)(double,double), bool elevR);

    inline virtual void* __getAddr(std::initializer_list<int64_t> index) const
    {
        return &_m_data[getLinIndex(index)];
    };

    inline virtual void* __getAddr(size_t len, const int64_t* index) const
    {
        return &_m_data[getLinIndex(len, index)];
    };

    inline virtual void* __getAddr(const std::vector<int64_t>& index) const
    {
        return &_m_data[getLinIndex(index)];
    };

    inline virtual void* __getAddr(int64_t i) const
    {
        return &_m_data[i];
    };
    inline virtual void* __getAddr(int64_t x, int64_t y, int64_t z, int64_t t) const
    {
        return &_m_data[getLinIndex(x,y,z,t)];
    };

    virtual int64_t getLinIndex(std::initializer_list<int64_t> index) const;
    virtual int64_t getLinIndex(size_t len, const int64_t* index) const;
    virtual int64_t getLinIndex(const std::vector<int64_t>& index) const;
    virtual int64_t getLinIndex(int64_t x, int64_t y, int64_t z, int64_t t) const;

    virtual int64_t tlen() const {
        if(D >= 3)
            return _m_stride[2];
        else
            return 1;
    };

    T* _m_data;
    size_t _m_stride[D]; // steps between pixels
    size_t _m_dim[D];   // overall image dimension

    protected:

    void updateStrides();

    virtual int writeNifti1Image(gzFile file) const;
    virtual int writeNifti2Image(gzFile file) const;
    virtual int writeNifti1Header(gzFile file) const;
    virtual int writeNifti2Header(gzFile file) const;
    virtual int writePixels(gzFile file) const;
    virtual int writeJSON(gzFile file) const;
    virtual int writeCSV(gzFile file) const;
};


#undef VIRTGETSET
#undef GETSET

} //npl

#endif