how can i load 4d medical image of type nifti?

edit

The following code reads the .nii header and then the .nii body. It writes PNG images. Make sure that you mark this answer as correct if you find that it works for you. It handles input files of dimensions up to 7.

#include <fstream>
#include <iostream>
#include <vector>
#include <string>
#include <strstream>
using namespace std;

#include <opencv2/opencv.hpp>
using namespace cv;
#pragma comment(lib, "opencv_world331.lib")

int main(void)
{
    // https://brainder.org/2012/09/23/the-nifti-file-format/
    ifstream infile("example_func.nii", std::ios::binary);

    if (infile.fail())
    {
        cout << "Could not read file example_func.nii" << endl;
        return 0;
    }

    size_t bytes_read = 0;

    cout << "Reading header" << endl;

    int sizeof_header;
    infile.read(reinterpret_cast<char*>(&sizeof_header), sizeof(sizeof_header));
    bytes_read += infile.gcount();

    if (sizeof_header != 348)
    {
        cout << "Invalid header size: should be 348 bytes" << endl;
        return -1;
    }

    char data_type[10];
    infile.read(reinterpret_cast<char*>(&data_type), sizeof(data_type));
    bytes_read += infile.gcount();

    char db_name[18];
    infile.read(reinterpret_cast<char*>(&db_name), sizeof(db_name));
    bytes_read += infile.gcount();

    int extents;
    infile.read(reinterpret_cast<char*>(&extents), sizeof(extents));
    bytes_read += infile.gcount();

    short session_error;
    infile.read(reinterpret_cast<char*>(&session_error), sizeof(session_error));
    bytes_read += infile.gcount();

    char regular;
    infile.read(reinterpret_cast<char*>(&regular), sizeof(regular));
    bytes_read += infile.gcount();

    char dim_info;
    infile.read(reinterpret_cast<char*>(&dim_info), sizeof(dim_info));
    bytes_read += infile.gcount();

    short dim[8];
    infile.read(reinterpret_cast<char*>(&dim), sizeof(dim));
    bytes_read += infile.gcount();

    cout << dim[0] << " dimensions" << endl;
    cout << "Dim 1: " << dim[1] << endl;
    cout << "Dim 2: " << dim[2] << endl;
    cout << "Dim 3: " << dim[3] << endl;
    cout << "Dim 4: " << dim[4] << endl;
    cout << "Dim 5: " << dim[5] << endl;
    cout << "Dim 6: " << dim[6] << endl;
    cout << "Dim 7: " << dim[7] << endl;

    float intent_p1;
    infile.read(reinterpret_cast<char*>(&intent_p1), sizeof(intent_p1));
    bytes_read += infile.gcount();

    float intent_p2;
    infile.read(reinterpret_cast<char*>(&intent_p2), sizeof(intent_p2));
    bytes_read += infile.gcount();

    float intent_p3;
    infile.read(reinterpret_cast<char*>(&intent_p3), sizeof(intent_p3));
    bytes_read += infile.gcount();

    short intent_code;
    infile.read(reinterpret_cast<char*>(&intent_code), sizeof(intent_code));
    bytes_read += infile.gcount();

    short datatype;
    infile.read(reinterpret_cast<char*>(&datatype), sizeof(datatype));
    bytes_read += infile.gcount();

    if (datatype != 16)
    {
        cout << "Data type must be float" << endl;
        return -1;
    }
    else
    {
        cout << "Data type: float" << endl;
    }

    short bitpix;
    infile.read(reinterpret_cast<char*>(&bitpix), sizeof(bitpix));
    bytes_read += infile.gcount();

    if (bitpix != 32)
    {
        cout << "Bits per pixel must be 32-bit" << endl;
        return -1;
    }
    else
    {
        cout << "Bits per pixel: " << bitpix << endl;
    }

    short slice_start;
    infile.read(reinterpret_cast<char*>(&slice_start), sizeof(slice_start));
    bytes_read += infile.gcount();

    float pixdim[8];
    infile.read(reinterpret_cast<char*>(&pixdim), sizeof(pixdim));
    bytes_read += infile.gcount();

    float vox_offset;
    infile.read(reinterpret_cast<char*>(&vox_offset), sizeof(vox_offset));
    bytes_read += infile.gcount();

    float scl_slope;
    infile.read(reinterpret_cast<char*>(&scl_slope), sizeof(scl_slope));
    bytes_read += infile.gcount();

    float scl_inter;
    infile.read(reinterpret_cast<char*>(&scl_inter), sizeof(scl_inter));
    bytes_read += infile.gcount();

    short slice_end;
    infile.read(reinterpret_cast<char*>(&slice_end), sizeof(slice_end));
    bytes_read += infile.gcount();

    char slice_code;
    infile.read(reinterpret_cast<char*>(&slice_code), sizeof(slice_code));
    bytes_read += infile.gcount();

    char xyzt_units ...