vctDynamicMatrixRef.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */

/*
  Author(s):  Ofri Sadowsky, Anton Deguet
  Created on: 2004-07-01

  (C) Copyright 2004-2015 Johns Hopkins University (JHU), All Rights Reserved.

--- begin cisst license - do not edit ---

This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.

--- end cisst license ---
*/

#pragma once
#ifndef _vctDynamicMatrixRef_h
#define _vctDynamicMatrixRef_h

#include<cisstVector/vctDynamicMatrixBase.h>
#include<cisstVector/vctDynamicConstMatrixRef.h>

template <class _elementType>
class vctDynamicMatrixRef: public vctDynamicMatrixBase<vctDynamicMatrixRefOwner<_elementType>, _elementType>
{
public:
    /* documented in base class */
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);
    enum {DIMENSION = 2};
    VCT_NARRAY_TRAITS_TYPEDEFS(DIMENSION);

    typedef vctDynamicMatrixRef<_elementType> ThisType;
    typedef vctDynamicMatrixRefOwner<_elementType> MatrixOwnerType;
    typedef vctDynamicMatrixBase<vctDynamicMatrixRefOwner<_elementType>, _elementType> BaseType;
    typedef typename MatrixOwnerType::iterator iterator;
    typedef typename MatrixOwnerType::const_iterator const_iterator;
    typedef typename MatrixOwnerType::reverse_iterator reverse_iterator;
    typedef typename MatrixOwnerType::const_reverse_iterator const_reverse_iterator;

    vctDynamicMatrixRef() {
        SetRef(0, 0, 1, 1, 0);
    }

    vctDynamicMatrixRef(const ThisType & other):
        BaseType()
    {
        SetRef(other.sizes(), other.strides(), const_cast<pointer>(other.Pointer()));
    }

    vctDynamicMatrixRef(size_type rows, size_type cols, stride_type rowStride, stride_type colStride,
                        pointer dataPointer)
    {
        SetRef(rows, cols, rowStride, colStride, dataPointer);
    }

    vctDynamicMatrixRef(const nsize_type & matrixSize, stride_type rowStride, stride_type colStride,
                        pointer dataPointer)
    {
        SetRef(matrixSize, rowStride, colStride, dataPointer);
    }

    vctDynamicMatrixRef(const nsize_type & matrixSize, const nstride_type & matrixStride,
                        pointer dataPointer)
    {
        SetRef(matrixSize, matrixStride, dataPointer);
    }


    vctDynamicMatrixRef(size_type rows, size_type cols, pointer dataPointer, bool storageOrder = VCT_DEFAULT_STORAGE)
    {
        SetRef(rows, cols, dataPointer, storageOrder);
    }

    vctDynamicMatrixRef(const nsize_type & matrixSize, pointer dataPointer, bool storageOrder = VCT_DEFAULT_STORAGE)
    {
        SetRef(matrixSize, dataPointer, storageOrder);
    }


    template <size_type __rows, size_type __cols, stride_type __rowStride, stride_type __colStride, typename __dataPtrType>
    inline vctDynamicMatrixRef(vctFixedSizeMatrixBase<__rows, __cols, __rowStride, __colStride, _elementType, __dataPtrType> & otherMatrix)
    {
        SetRef(otherMatrix);
    }

    template <size_type __rows, size_type __cols, stride_type __rowStride, stride_type __colStride, typename __dataPtrType>
    inline vctDynamicMatrixRef(vctFixedSizeMatrixBase<__rows, __cols, __rowStride, __colStride, _elementType, __dataPtrType> & otherMatrix,
                               size_type startRow, size_type startCol, size_type rows, size_type cols)
    {
        SetRef(otherMatrix, startRow, startCol, rows, cols);
    }

    template <class __ownerType>
    inline vctDynamicMatrixRef(vctDynamicMatrixBase<__ownerType, _elementType> & otherMatrix)
    {
        SetRef(otherMatrix);
    }

    //@
    template <class __ownerType>
    inline vctDynamicMatrixRef(vctDynamicMatrixBase<__ownerType, _elementType> & otherMatrix,
                               size_type startRow, size_type startCol, size_type rows, size_type cols)
    {
        SetRef(otherMatrix, startRow, startCol, rows, cols);
    }

    template <class __ownerType>
    inline vctDynamicMatrixRef(vctDynamicMatrixBase<__ownerType, _elementType> & otherMatrix,
                               const nsize_type & start, const nsize_type & matrixSize)
    {
        SetRef(otherMatrix, start, matrixSize);
    }

    void SetRef(size_type rows, size_type cols,
                stride_type rowStride, stride_type colStride,
                pointer dataPointer) {
        this->Matrix.SetRef(rows, cols, rowStride, colStride, dataPointer);
    }

    void SetRef(const nsize_type & matrixSize,
                stride_type rowStride, stride_type colStride,
                pointer dataPointer) {
        this->Matrix.SetRef(matrixSize, rowStride, colStride, dataPointer);
    }

    void SetRef(const nsize_type & matrixSize,
                const nstride_type & matrixStride,
                pointer dataPointer) {
        this->Matrix.SetRef(matrixSize, matrixStride, dataPointer);
    }


    void SetRef(size_type rows, size_type cols, pointer dataPointer, bool storageOrder = VCT_DEFAULT_STORAGE)
    {
        this->Matrix.SetRef(rows, cols, dataPointer, storageOrder);
    }

    void SetRef(const nsize_type & sizes, pointer dataPointer, bool storageOrder = VCT_DEFAULT_STORAGE)
    {
        this->Matrix.SetRef(sizes, dataPointer, storageOrder);
    }


    template <size_type __rows, size_type __cols, stride_type __rowStride, stride_type __colStride, typename __dataPtrType>
    inline void SetRef(vctFixedSizeMatrixBase<__rows, __cols, __rowStride, __colStride, _elementType, __dataPtrType> & otherMatrix)
    {
        SetRef(otherMatrix.rows(), otherMatrix.cols(), otherMatrix.row_stride(), otherMatrix.col_stride(),
               otherMatrix.Pointer());
    }

    template <size_type __rows, size_type __cols, stride_type __rowStride, stride_type __colStride, typename __dataPtrType>
    inline void SetRef(vctFixedSizeMatrixBase<__rows, __cols, __rowStride, __colStride, _elementType, __dataPtrType> & otherMatrix,
                       size_type startRow, size_type startCol, size_type rows, size_type cols)
    {
        if ( (startRow + rows > otherMatrix.rows()) || (startCol + cols > otherMatrix.cols()) ) {
            cmnThrow(std::out_of_range("vctDynamicMatrixRef SetRef out of range"));
        }
        SetRef(rows, cols, otherMatrix.row_stride(), otherMatrix.col_stride(), otherMatrix.Pointer(startRow, startCol));
    }

    template <class __ownerType>
    inline void SetRef(vctDynamicMatrixBase<__ownerType, _elementType> & otherMatrix)
    {
        SetRef(otherMatrix.rows(), otherMatrix.cols(), otherMatrix.row_stride(), otherMatrix.col_stride(),
               otherMatrix.Pointer());
    }

    template <class __ownerType>
    inline void SetRef(vctDynamicMatrixBase<__ownerType, _elementType> & otherMatrix,
                       size_type startRow, size_type startCol, size_type rows, size_type cols)
    {
        if ( (startRow + rows > otherMatrix.rows()) || (startCol + cols > otherMatrix.cols()) ) {
            cmnThrow(std::out_of_range("vctDynamicMatrixRef SetRef out of range"));
        }
        SetRef(rows, cols, otherMatrix.row_stride(), otherMatrix.col_stride(),
               otherMatrix.Pointer(startRow, startCol));
    }

    template <class __ownerType>
    inline void SetRef(vctDynamicMatrixBase<__ownerType, _elementType> & otherMatrix,
                       const nsize_type & start, const nsize_type & matrixSize)
    {
        SetRef(otherMatrix,
               start.Element(0), start.Element(1), matrixSize.Element(0), matrixSize.Element(1));
    }

    inline ThisType & operator = (const ThisType & other) {
        return reinterpret_cast<ThisType &>(this->Assign(other));
    }

    inline ThisType & operator = (const vctDynamicConstMatrixRef<_elementType> & other) {
        return reinterpret_cast<ThisType &>(this->Assign(other));
    }

    template <class __matrixOwnerType, typename __elementType>
    inline ThisType & operator = (const vctDynamicConstMatrixBase<__matrixOwnerType, __elementType> & other) {
        return reinterpret_cast<ThisType &>(this->Assign(other));
    }

    template <size_type __rows, size_type __cols, stride_type __rowStride, stride_type __colStride, typename __dataPtrType>
    inline ThisType & operator = (const vctFixedSizeConstMatrixBase<__rows, __cols, __rowStride, __colStride, _elementType, __dataPtrType> & other) {
        return reinterpret_cast<ThisType &>(this->Assign(other));
    }

    inline ThisType & operator = (const value_type & value) {
        this->SetAll(value);
        return *this;
    }

    void DeSerializeRaw(std::istream & inputStream) throw(std::runtime_error)
    {
        // get and set size
        size_type myRows;
        size_type myCols;
        cmnDeSerializeRaw(inputStream, myRows);
        cmnDeSerializeRaw(inputStream, myCols);

        if ((myRows != this->rows()) || (myCols != this->cols())) {
            cmnThrow(std::runtime_error("vctDynamicMatrixRef::DeSerializeRaw: Sizes of matrices don't match"));
        }

        // get data
        size_type indexRow, indexCol;
        for (indexRow = 0; indexRow < myRows; ++indexRow) {
            for (indexCol = 0; indexCol < myCols; ++indexCol) {
                cmnDeSerializeRaw(inputStream, this->Element(indexRow, indexCol));
            }
        }
    }

};


/*
  Methods declared and use for vctDynamicVectorBase.  Implemented here
  since these need the const-matrix base.
*/
#ifndef DOXYGEN
template <class _resultVectorOwnerType, class _matrixOwnerType, class _vectorOwnerType, class _elementType>
inline
void vctMultiplyMatrixVector(vctDynamicVectorBase<_resultVectorOwnerType, _elementType> & result,
                             const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & matrix,
                             const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & vector) {
    const vctDynamicConstMatrixRef<_elementType> inputVectorRef(vector.size(), 1,
                                                                vector.stride(), 1,
                                                                vector.Pointer());
    vctDynamicMatrixRef<_elementType> resultRef(result.size(), 1,
                                                result.stride(), 1,
                                                result.Pointer());
    resultRef.ProductOf(matrix, inputVectorRef);
}


template <class _resultVectorOwnerType, class _vectorOwnerType, class _matrixOwnerType, class _elementType>
inline
void vctMultiplyVectorMatrix(vctDynamicVectorBase<_resultVectorOwnerType, _elementType> & result,
                             const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & vector,
                             const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & matrix) {
    const vctDynamicConstMatrixRef<_elementType> inputVectorRef(1, vector.size() * vector.stride(),
                                                                1, vector.stride(),
                                                                vector.Pointer());
    vctDynamicMatrixRef<_elementType> resultRef(1, result.size() * result.stride(),
                                                1, result.stride(),
                                                result.Pointer());
    resultRef.ProductOf(inputVectorRef, matrix);
}
#endif // DOXYGEN

#endif // _vctDynamicMatrixRef_h