void IO_UncertSimResults::ReadTable(DC_TableData& tableData)
{
    ReadString(tableData.tableID, DC_TableData::tableIDLen);
    ReadStringArray(tableData.columnDesc);
    ReadStringArray(tableData.rowDesc);
    ReadDoubleMatrix(tableData.dataTable);
}
Exemple #2
0
LDARec::LDARec(int class_num,vector<string>& IDs)
{

	cnum = class_num;
	for(int i=0;i<cnum;++i)
		this->StIDs.push_back(IDs[i]);

	char str[100];

	int width,height;

	FILE *fin;

	std::printf("read LDAWcross\n");

	sprintf(str,"%s/LDAWcross",settingpath);
    fin = fopen(str,"r");
	ReadDoubleMatrix(fin,w,width,height);
	fclose(fin);

	this->Ws = cvMat(height,width,CV_64FC1,(void*)(&(w[0])) );
	printf("Ws %d,%d,%f,%f\n",width,height,cvmGet(&Ws, 0, 0),cvmGet(&Ws, 0, 1));

	std::printf("read LDAMeancross\n");

	sprintf(str,"%s/LDAMEANcross",settingpath);
	fin = fopen(str,"r");
	ReadDoubleMatrix(fin,m1,width,height);
	fclose(fin);

	this->mean1d = cvMat(height,width,CV_64FC1,(void*)(&(m1[0])) );
	printf("mean1d %d,%d,%f,%f\n",width,height,cvmGet(&mean1d, 0, 0),cvmGet(&mean1d, 0, 1));

	ydata = new double[Ws.rows];
	y = cvMat(1,Ws.rows,CV_64FC1,ydata);
}
void IO_ProfileSimResults::ReadOneCase(ProfileSimCaseResults& caseRes)
{
    ReadString(caseRes.caseID, ProfileSimCaseResults::caseIDLen);
    ReadDouble(caseRes.staticPressure);

    if (readVersion < 1)
        caseRes.caseDataIsExtended = false;
    else
        ReadBool(caseRes.caseDataIsExtended);

    caseRes.caseValues.AllocAndSetSize(ReadInt());
    for (int i = 0; i < caseRes.caseValues.Size(); i++)
        ReadDouble(caseRes.caseValues[i]);

    if (!caseRes.caseDataIsExtended)
    {
        DC_GridData& currGrid = caseRes.caseData;
        ReadString(currGrid.gridID, DC_GridData::gridIDLen);
        ReadString(currGrid.xData.dataID, DC_DataCoord::dataIDLen);
        ReadString(currGrid.yData.dataID, DC_DataCoord::dataIDLen);
        ReadBool(currGrid.xData.dataIsLog);
        ReadBool(currGrid.yData.dataIsLog);

        int nX = ReadInt();
        int nY = ReadInt();
        if (!currGrid.Alloc(nX, nY))
            BufferError("couldn't alloc Grid");

        ReadDoubleArray(currGrid.xData);
        ReadDoubleArray(currGrid.yData);
        for (int i = 0; i < currGrid.Size(); i++)
            ReadDouble(currGrid[i]);
    }
    else
    {
        ExtendedProfile& currPro = caseRes.extendedCaseData;
        ReadInt(currPro.ntotalVert);
        ReadInt(currPro.nradial);
        ReadInt(currPro.nconstantVert);
        ReadInt(currPro.nvariableVert);

        if (readVersion < 2)
        {
            double constVert;
            ReadDouble(constVert);
            currPro.constantVertZPos.Alloc(currPro.nconstantVert + 1);
            currPro.constantVertZPos += 0.0;
            if (currPro.nconstantVert > 0)
            {
                double dVert = constVert / double(currPro.nconstantVert);
                double currY = dVert;
                for (int i = 0; i < currPro.nconstantVert; i++)
                {
                    currPro.constantVertZPos += currY;
                    currY += dVert;
                }
            }
            currPro.nconstantVert++;
            currPro.nvariableVert--;
        }
        else
        {
            ReadDoubleArray(currPro.constantVertZPos);
        }

        ReadDoubleArray(currPro.nodeRadii);
        int nextended = ReadInt();
        currPro.AllocAndSetSize(nextended);
        for (int i = 0; i < nextended; i++)
        {
            ExtendedProfileTimeData& currSing = currPro[i];
            ReadDouble(currSing.profileTime);
            if (currPro.nvariableVert > 0)
                ReadDoubleArray(currSing.waterTablePos);
            ReadDoubleMatrix(currSing.nodalPressures);
        }
    }
}