Reading double values and int values from binary file

Question

I have a binary file which has the following format :

# vtk DataFile Version 4.0
vtk output
BINARY
DATASET POLYDATA
POINTS 10000 double
?�T�����?����h�?�T�����?���� <-- 10000 double values (in binary format) follow separated by space and new line after every 9 values.

I want to read this file byte by byte so that I can store these double values in my array. I have the following code which loads this file into a char *buffer array. Now I want to know how to proceed further?

#include<iostream>     
#include<fstream> 
#include<sstream>
#include<stdlib.h>     
#include<string>
using namespace std;

int main () {

  ifstream is ("Data_binary.vtk", ifstream::binary);
  if (is) {
    // get length of file:
    is.seekg (0, is.end);
    unsigned long length = is.tellg();
    is.seekg (0, is.beg);

    char * buffer = new char [length+1];
    buffer[length] = '\0';

    cout << "Reading " << length << " characters... ";
    // read data as a block:
    is.seekg(0, is.beg);
    is.read (buffer,length);

    if (is)
      cout << "all characters read successfully." << endl;
    else
      cout << "error: only " << is.gcount() << " could be read";
    is.close();
   }

  return 0;
}

In ASCII format, an example file would look like the following :

# vtk DataFile Version 4.0
vtk output
ASCII
DATASET POLYDATA
POINTS 18 double
.1 .2 .3 1.4 11.55 1 0 8e-03 5.6
1.02 2.2 3.3 .1 .5 0.001 4e-07 4.2 1.55

For binary file, the double values are present in binary. I want to get double values from binary format.

Answer 1

Use this function.


/*
* read a double from a stream in ieee754 format regardless of host
*  encoding.
*  fp - the stream
*  bigendian - set to if big bytes first, clear for little bytes
*              first
*
*/
double freadieee754(FILE *fp, int bigendian)
{
    unsigned char buff[8];
    int i;
    double fnorm = 0.0;
    unsigned char temp;
    int sign;
    int exponent;
    double bitval;
    int maski, mask;
    int expbits = 11;
    int significandbits = 52;
    int shift;
    double answer;

    /* read the data */
    for (i = 0; i < 8; i++)
        buff[i] = fgetc(fp);
    /* just reverse if not big-endian*/
    if (!bigendian)
    {
        for (i = 0; i < 4; i++)
        {
            temp = buff[i];
            buff[i] = buff[8 - i - 1];
            buff[8 - i - 1] = temp;
        }
    }
    sign = buff[0] & 0x80 ? -1 : 1;
    /* exponet in raw format*/
    exponent = ((buff[0] & 0x7F) << 4) | ((buff[1] & 0xF0) >> 4);

    /* read inthe mantissa. Top bit is 0.5, the successive bits half*/
    bitval = 0.5;
    maski = 1;
    mask = 0x08;
    for (i = 0; i < significandbits; i++)
    {
        if (buff[maski] & mask)
            fnorm += bitval;

        bitval /= 2.0;
        mask >>= 1;
        if (mask == 0)
        {
            mask = 0x80;
            maski++;
        }
    }
    /* handle zero specially */
    if (exponent == 0 && fnorm == 0)
        return 0.0;

    shift = exponent - ((1 << (expbits - 1)) - 1); /* exponent = shift + bias */
    /* nans have exp 1024 and non-zero mantissa */
    if (shift == 1024 && fnorm != 0)
        return sqrt(-1.0);
    /*infinity*/
    if (shift == 1024 && fnorm == 0)
    {

#ifdef INFINITY
        return sign == 1 ? INFINITY : -INFINITY;
#endif
        return  (sign * 1.0) / 0.0;
    }
    if (shift > -1023)
    {
        answer = ldexp(fnorm + 1.0, shift);
        return answer * sign;
    }
    else
    {
        /* denormalised numbers */
        if (fnorm == 0.0)
            return 0.0;
        shift = -1022;
        while (fnorm < 1.0)
        {
            fnorm *= 2;
            shift--;
        }
        answer = ldexp(fnorm, shift);
        return answer * sign;
    }
}

it's a lot, but it's just a snippet to cut and paste, and you never need to worry about binary floating point formats again. It simply reads an IEEE 754 double, regardless of host floating point format. There's a twin which writes

Answer 2

Instead of reading into a char * buffer, read into a double * buffer. Casting to/from char * is allowed just for this purpose.

vector<double> buffer;
buffer.resize(n);
is.read(reinterpret_cast<char *>(&buffer[0]), n * sizeof(buffer[0]));

You'll need to read the non-binary data first so that the file pointer is located at the start of the binary data. This is defined as coming immediately after the newline character of the last field in the header.

The spec doesn't appear to mandate little-endian or big-endian format, it expects you to know based on the source of the file. If you're lucky the format will match the machine you're using to read the file and no conversion will be necessary. Otherwise you'll need to do a byte swap:

void ByteSwap(double * p)
{
    char * pc = reinterpret_cast<char *>(p);
    std::swap(pc[0], pc[7]);
    std::swap(pc[1], pc[6]);
    std::swap(pc[2], pc[5]);
    std::swap(pc[3], pc[4]);
}