unpackbits.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <type_traits>
 
#include "NumCpp/Core/Internal/Error.hpp"
#include "NumCpp/NdArray.hpp"
 
namespace nc
{
    //============================================================================
    // Method Description:
    inline NdArray<uint8> unpackbitsLittleEndian(const NdArray<uint8>& a, Axis axis = Axis::NONE)
    {
        switch (axis)
        {
            case Axis::NONE:
            {
                NdArray<uint8> result(1, a.size() * 8);
 
                for (NdArray<uint8>::size_type byte = 0; byte < a.size(); ++byte)
                {
                    const auto startIdx  = byte * 8;
                    const auto byteValue = a[byte];
 
                    for (uint8 bit = 0; bit < 8; ++bit)
                    {
                        result[startIdx + bit] = static_cast<uint8>((byteValue & (uint8{ 1 } << bit)) >> bit);
                    }
                }
 
                return result;
            }
            case Axis::COL:
            {
                const auto     aShape = a.shape();
                NdArray<uint8> result(aShape.rows, aShape.cols * 8);
                const auto     resultCSlice = result.cSlice();
                const auto     aCSlice      = a.cSlice();
 
                for (NdArray<uint8>::size_type row = 0; row < aShape.rows; ++row)
                {
                    result.put(row, resultCSlice, unpackbitsLittleEndian(a(row, aCSlice)));
                }
 
                return result;
            }
            case Axis::ROW:
            {
                return unpackbitsLittleEndian(a.transpose(), Axis::COL).transpose();
            }
            default:
            {
                THROW_INVALID_ARGUMENT_ERROR("Unimplemented axis type.");
                return {}; // get rid of compiler warning
            }
        }
    }
 
    //============================================================================
    // Method Description:
    inline NdArray<uint8> unpackbitsBigEndian(const NdArray<uint8>& a, Axis axis = Axis::NONE)
    {
        switch (axis)
        {
            case Axis::NONE:
            {
                NdArray<uint8> result(1, a.size() * 8);
 
                for (NdArray<uint8>::size_type byte = 0; byte < a.size(); ++byte)
                {
                    const auto startIdx  = byte * 8;
                    const auto byteValue = a[byte];
 
                    for (uint8 bit = 0; bit < 8; ++bit)
                    {
                        const auto bitToMask = static_cast<uint8>(7 - bit);
                        result[startIdx + bit] =
                            static_cast<uint8>((byteValue & (uint8{ 1 } << bitToMask)) >> bitToMask);
                    }
                }
 
                return result;
            }
            case Axis::COL:
            {
                const auto     aShape = a.shape();
                NdArray<uint8> result(aShape.rows, aShape.cols * 8);
                const auto     resultCSlice = result.cSlice();
                const auto     aCSlice      = a.cSlice();
 
                for (NdArray<uint8>::size_type row = 0; row < aShape.rows; ++row)
                {
                    result.put(row, resultCSlice, unpackbitsBigEndian(a(row, aCSlice)));
                }
 
                return result;
            }
            case Axis::ROW:
            {
                return unpackbitsBigEndian(a.transpose(), Axis::COL).transpose();
            }
            default:
            {
                THROW_INVALID_ARGUMENT_ERROR("Unimplemented axis type.");
                return {}; // get rid of compiler warning
            }
        }
    }
 
} // namespace nc