Function LoadArrayFromNumpy

src/Misc/numpy.hpp:240–323

template<typename Scalar>
void LoadArrayFromNumpy(
    const std::string& filename, std::vector<int>& shape,
    std::vector<Scalar>& data)
{
    std::ifstream stream(filename.c_str(), std::ios::in|std::ios::binary);
    if(!stream) {
        throw std::runtime_error("io error: failed to open a file.");
    }
    // check if this file is the valid .npy file
    std::string valid_preamble = "\x93NUMPY";
    valid_preamble.push_back(char(1));
    valid_preamble.push_back(char(0));
    std::string preamble(8, ' ');
    stream.read(&preamble[0], 8);
    if(valid_preamble != preamble) {
        throw std::runtime_error(
            "io error: this file do not have a valid npy format.");
    }
    // load header
    uint16_t header_length;
    stream.read(reinterpret_cast<char*>(&header_length), sizeof(uint16_t));
    header_length = detail::ReorderInteger(header_length);
    if((header_length + preamble.size() + sizeof(uint16_t)) % 16 != 0) {
        throw std::runtime_error(
            "formatting error: metadata length is not divisible by 16.");
    }
    std::string header(header_length, ' ');
    stream.read(reinterpret_cast<char*>(&header[0]), header_length);

    // load fortran order
    typedef std::string::size_type size_type;
    const size_type header_loc = header.find("fortran_order") + 16;
    const bool fortran_order = (header.substr(header_loc, 4) == "True");

    // load shape
    const size_type shape_loc1 = header.find("(");
    const size_type shape_loc2 = header.find(")");
    std::string shape_str = header.substr(
        shape_loc1 + 1, shape_loc2 - shape_loc1 - 1);
    if(shape_str[shape_str.size() - 1] == ',') shape.resize(1);
    else shape.resize(std::count(shape_str.begin(), shape_str.end(), ',') + 1);
    for(size_t i=0; i<shape.size(); ++i) {
        std::stringstream ss;
        const size_type loc = shape_str.find(",");
        ss << shape_str.substr(0, loc);
        ss >> shape[i];
        shape_str = shape_str.substr(loc + 1);
    }
    if(fortran_order) {
        std::reverse(shape.begin(), shape.end());
    }

    // load descriptor
    const size_type descr_loc = header.find("descr") + 9;
    const char endian_str = header[descr_loc];
    const bool little_endian = (endian_str == '<' || endian_str == '|');
#ifdef AOBA_NUMPY_BIG_ENDIAN
    const bool is_same_endian = !little_endian;