Russian Qt Forum

C#
        unsafe void ReadSingleBuffer(float[] s_buffer)
        {
            int count = s_buffer.Length * 4;
            byte[] m_buffer = new byte[count];
            br.Read(m_buffer, 0, count);
 
            //convert byte -> single
            for (int i = 0; i < s_buffer.Length; ++i)
            {
                uint num = (uint)(((m_buffer[0 + i * 4] | (m_buffer[1 + i * 4] << 8)) | (m_buffer[2 + i * 4] << 0x10)) | (m_buffer[3 + i * 4] << 0x18));
                s_buffer[i] = *(((float*)&num));
            }
        }
 

C#
                br = new BinaryReader(fs, System.Text.Encoding.GetEncoding(1251))
...
                br.ReadBytes(54);
 
                this.progHeader1 = ReadString(75);
                this.progHeader2 = ReadString(75);
 
                br.ReadBytes(12);
 
                ReadInt32Buffer(numb);
 
                nx = numb[43];
                ny = numb[44];
                nz = numb[45];
 
                br.ReadBytes(12);
 

C++ (Qt)
void DataLoader::readFloatbuffer(QFile &f, float*  f_buffer, int len)
{
	char m_buffer[len * 4];
	f.read(m_buffer, len * 4);
	for (int i = 0; i < len; ++i)
		f_buffer[i] = *(float*)(&m_buffer[i * 4]);
}
 

C++ (Qt)
	QFile file(fname);
	file.open(QIODevice::ReadOnly);
...
	file.read(54);
	progHeader1 = readString(file, 75);
	progHeader2 = readString(file, 75);
 
	file.read(12);
	readInt32buffer(file, numb, 100);
 
	nx = numb[43];
	ny = numb[44];
	nz = numb[45];
 
	file.read(12);
 

C++ (Qt)
void DataLoader::readFloatbuffer(QFile &f, float*  f_buffer, int len)
{
	f.read( (char*)f_buffer, len * sizeof( *f_buffer ) );
}
 

C++ (Qt)
float GLView::readFloat(QFile &f)
{
	char m_buffer[4];
	f.read(m_buffer, 4);
	return *((float*)m_buffer);
}
 

C++ (Qt)
float GLView::readFloat(QFile &f)
{
	char m_buffer[4];
	f.read(m_buffer, 4);
	return *((float*)m_buffer);
}
 

C++ (Qt)
float GLView::readFloat(QFile &f)
{
	float val;
	f.read((char*)&val, sizeof(val));
	return val;
}

C++ (Qt)
float GLView::readFloat(QFile &f)
{
	char m_buffer[4];
	f.read(m_buffer, 4);
	return *((float*)m_buffer);
}
 

C++ (Qt)
void GLView::readFloat(QFile &f,float& x)
{
	f.read(&x, 4);
}
 

C++ (Qt)
glBufferData(GL_ARRAY_BUFFER, 3 * vertexCount * sizeof(GLfloat), NULL, GL_STATIC_DRAW);
 

C++ (Qt)
QString readString(QFile& f, int count)
{
	char* c = new char[count + 1];
	f.read(c, count);
	c[count] = 0;       // Null terminated
	return QString(c).trimmed();
}
 
void readFloatbuffer(QFile &f, float*  f_buffer, int len)
{
	f.read((char*)f_buffer, len * sizeof(*f_buffer));
}
 
void readInt32buffer(QFile &f, int*  i_buffer, int len)
{
	f.read((char*)i_buffer, len * sizeof(*i_buffer));
}
 
int readInt32(QFile &f)
{
	int val;
	f.read((char*)&val, sizeof(val));
	return val;
}
 
float readFloat(QFile &f)
{
	float val;
	f.read((char*)&val, sizeof(val));
	return val;
}
 
//Implementation
TempestDataLoader::TempestDataLoader(SharedData* data)
{
	m_data = data;
}
 
TempestDataLoader::~TempestDataLoader()
{
}
 
void TempestDataLoader::loadDataFromFile(QString fName)
{
	QTime timer;
	timer.start();
 
	m_data->fileName = fName;
	int numb[100];
 
	// Prepare for read file
	QFileInfo fileInfo(fName);
	QString baseName = fileInfo.baseName();
	QString pathName = fileInfo.absolutePath();
	QString fname(pathName + "/" + baseName + ".mis");
 
	// Read mis-file
	QFile file(fname);
	file.open(QIODevice::ReadOnly);
 
	file.read(16);
	int d = readInt32(file);
	int m = readInt32(file);
	int y = readInt32(file);
 
	m_data->initDate.setDate(y, m, d);
	file.read(54);
 
	m_data->progHeader1 = readString(file, 75);
	m_data->progHeader2 = readString(file, 75);
	file.read(12);
 
	readInt32buffer(file, numb, 100);
 
	m_data->wellCount = numb[2];
	m_data->groupCount = numb[11];
	m_data->aquaCount = numb[32];
	m_data->quantCount = numb[37];
	m_data->nx = numb[43];
	m_data->ny = numb[44];
	m_data->nz = numb[45];
 
	file.read(12);
	int nc = readInt32(file);
	int nl = readInt32(file);
	readInt32(file);
	int ms = readInt32(file);
	int mp = readInt32(file);
	file.read(mp * 16 + nc * 16 + mp * 4 + nc * mp * 4 + mp * 4 + 3 * nc * 4 + nl * 16 + nc * nl * 4 + ms * 16 + nc * ms * 4);
	m_data->oilden = readFloat(file);
	m_data->gasden = readFloat(file);
	m_data->waterden = readFloat(file);
 
	file.close();
 
	// Read ctl-file
	m_data->daysList.clear();
	m_data->datesList.clear();
	m_data->arrayList.clear();
	m_data->yearsIndex.clear();
 
	fname = pathName + "/" + baseName + ".ctl";
 
	file.setFileName(fname);
	file.open(QIODevice::ReadOnly);
 
	file.read(12);
 
	while (file.pos() != file.size())
	{
		readInt32(file);
		int isArray = readInt32(file);
		int isRate = readInt32(file);
		float value = readFloat(file);
 
		if (isArray == 1) m_data->arrayList.append(m_data->initDate.addDays((int)value));
		if (isRate == 1)
		{
			m_data->daysList.append(value);
			m_data->datesList.append(m_data->initDate.addDays((int)value));
			if (m_data->datesList.last().month() == 01)
			{
				m_data->yearsIndex.append(m_data->datesList.count() - 1);
			}
		}
 
		file.read(8);
	}
	file.close();
 
	m_data->daysCount = m_data->daysList.count();
	m_data->yearsCount = m_data->yearsIndex.count();
 
	// Read rat-file
	fname = pathName + "/" + baseName + ".rat";
 
	file.setFileName(fname);
        file.open(QIODevice::ReadOnly);
 
	m_data->wellNames.clear();
	m_data->groupNames.clear();
	m_data->aquiferNames.clear();
        m_data->quantMnemonic.clear();
        m_data->quantUnits.clear();
        m_data->quantAssociated.clear();
        m_data->quantDescription.clear();
 
	for (int i = 0; i < m_data->wellCount; ++i) m_data->wellNames.append(readString(file, 16));
	for (int i = 0; i < m_data->groupCount; ++i) m_data->groupNames.append(readString(file, 16));
        for (int i = 0; i < m_data->aquaCount; ++i) m_data->aquiferNames.append(readString(file, 16));
        for (int i = 0; i < m_data->quantCount; ++i)
        {
            m_data->quantMnemonic.append(readString(file, 16));
            m_data->quantUnits.append(readString(file, 16));
            m_data->quantAssociated.append(readString(file, 16));
            m_data->quantDescription.append(readString(file, 48));
            file.read(numb[39] * 4 + numb[40] * 4);
        }
 
	int leng = (numb[20] + numb[1] + 1) * (numb[15] + 2) + 2 * numb[20] + 4 * numb[1] + 2 * numb[1] * numb[4];
 
	// Found  max-array of float
	int fbufflen = numb[48];
	if (fbufflen < 15) fbufflen = 15;
	if (fbufflen < leng) fbufflen = leng;
	float* fbuff = new float[fbufflen];
	int* ibuff = new int[numb[46]];
 
	// Initialization
	m_data->init();
 
	int _status = 0;
	for (int istep = 0; istep < m_data->daysCount; ++istep)
	{
		for (int iw = 0; iw < m_data->wellCount; ++iw)
		{
			readInt32buffer(file, ibuff, numb[46]);
			_status = ibuff[3];
 
			//IRPTR + IRLIM
			file.read(numb[4] * numb[47] * 4 + numb[6] * 2 * 4);
 
			//WRATE
			readFloatbuffer(file, fbuff, numb[48]);
 
			m_data->xloc[iw] = fbuff[0];
			m_data->yloc[iw] = fbuff[1];
 
			//WRVOL
			readFloatbuffer(file, fbuff, 15);
 
			m_data->opr[istep * m_data->wellCount + iw] = 0;
			m_data->gpr[istep * m_data->wellCount + iw] = 0;
			m_data->wpr[istep * m_data->wellCount + iw] = 0;
			m_data->wir[istep *  m_data->wellCount + iw] = 0;
 
			if (_status == 1)
			{
				m_data->opr[istep * m_data->wellCount + iw] = fbuff[0];
				m_data->gpr[istep * m_data->wellCount + iw] = fbuff[1];
				m_data->wpr[istep * m_data->wellCount + iw] = fbuff[2];
			}
 
			if (_status == 2)
			{
				m_data->wir[istep * m_data->wellCount + iw] = fbuff[1];
			}
 
			m_data->opt[istep * m_data->wellCount + iw] = fbuff[5];
			m_data->gpt[istep * m_data->wellCount + iw] = fbuff[6];
			m_data->wpt[istep * m_data->wellCount + iw] = fbuff[7];
			m_data->wit[istep * m_data->wellCount + iw] = fbuff[11];
 
			//WRMS + WMCMP + WRCMP
			file.read(numb[1] * 3 * 4 + numb[4] * 2 * 4 + numb[4] * numb[1] * 4);
 
			//WVCMP
			if (numb[54] == 1)
				file.read(numb[4] * 15 * 4);
 
			//WVLAY
			if (numb[55] == 1)
				file.read(numb[4] * numb[51] * 4);
		}
 
		//Group data
		for (int ig = 0; ig < m_data->groupCount; ig++)
		{
			file.read(4);
			readFloatbuffer(file, fbuff, leng);
 
			file.read(numb[20] * numb[52] * 4);
 
			for (int iw = 0; iw < m_data->wellCount; iw++)
			{
				m_data->gwfr[ig *  m_data->wellCount  + iw] =readFloat(file);
			}
 
			file.read(numb[4] * numb[53] * 4);
		}
 
		//Aquifer data
		file.read(numb[32] * numb[33] * 4);
 
		// Quantities
                    for (int iq = 0; iq < m_data->quantCount; ++iq)
                    {
                        m_data->qdata[istep * m_data->quantCount + iq] = readFloat(file);
                    }
 
	}
	file.close();
 
	delete[] ibuff;
	delete[] fbuff;
 
	m_data->elapsedTime = timer.elapsed();
}
 

C++ (Qt)
#include <iostream>
 
void func( int sz )
{
        char arr[ sz ];
 
        for( int i = 0; i < sz; ++i )
                arr[ i ] = (char)i;
 
        for( int i = 0; i < sz; ++i )
                std::cout << (int)arr[ i ] << std::endl;
}
 
int main( int argc, char *argv[] )
{
        func( 10 );
        func( 20 );
}
 

C++ (Qt)
static inline QString readString(QIODevice *f, int count, uchar* buff)
{
	int len = f->read(buff, count);
	return QString(buff, len).trimmed();
}
 

C++ (Qt)
QString readString(QFile& f, int count) {
	return QString(f.read(count)).trimmed();
}
 

C++ (Qt)
int readInt32(QFile &f) {
	return f.read(sizeof(int)).toInt();
}
 

C++ (Qt)
QString readString(QFile& f, int count) {
  return QString::fromAscii(f.read(count).constData(), count).trimmed();
}

C++ (Qt)
int readInt32(QFile &f) {
  return f.read(sizeof(int)).toInt();
}