bool IO_UncertSimResults::ReadUncertResults(DC_UncertSimResults& results)
{
try
{
ReadFileHeader(results, true);
ReadNextRecord();
ReadInt(); // skip next rec
SC_IntArray runStartRecs;
ReadIntArray(runStartRecs);
results.AllocAndSetSize(runStartRecs.Size());
for (int i = 0; i < results.Size(); i++)
{
ReadAbsolute(runStartRecs[i]);
ReadOneRun(results[i]);
}
CloseFile();
return true;
}
catch (BufFileC::BufferFileError& err) {
GenAppErrorMsg("ReadUncertResults", err.errMsg);
CloseFile();
}
return false;
}
void ReadIndexMSSpec(DSC_IndexMSSpec& inSpec)
{
inSpec.indexIsMaster = ReadBool();
ReadFuncObjRef(inSpec.indexMasterObjRef);
inSpec.enteredIndexValue = ReadInt();
if (inSpec.MultipleOK())
{
if (inSpec.SingleOK())
inSpec.enteredIndexIsSingle = ReadBool();
ReadIntArray(inSpec.enteredIndexArray);
}
}
bool DPO_STEPWISE::ReadFromFile()
{
ReadObjectHeader();
ReadFuncObjRef(indepVarObjRef);
ReadFuncObjRef(depVarObjRef);
ReadText(title, titleLen);
optBACKWARD = ReadBool();
optRANK = ReadBool();
optPRESS = ReadBool();
optSTAND01 = ReadBool();
optSTEPWISE = ReadBool();
optFORCE = ReadBool();
optWEIGHT = ReadBool();
optDROP = ReadBool();
outMEAN = ReadBool();
outCORR = ReadBool();
outSSCP = ReadBool();
outINVERSE = ReadBool();
outSTEPS = ReadBool();
outRESIDUALS= ReadBool();
outOTHER = ReadBool();
optSigin = ReadDouble();
optSigout = ReadDouble();
weightIndex = ReadInt();
if (currentObjReadMajorVersion > 0)
{
decForm.digitsPrecision = ReadInt();
sciForm.digitsPrecision = ReadInt();
}
ReadIntArray(forceIndexes);
ReadIntArray(dropIndexes);
CheckForInputFailure("Reading DPO_STEPWISE");
return true;
}
void IO_ProfileSimResults::ReadOneRun(ProfileSimRunResults& runRes)
{
ReadString(runRes.runID, ProfileSimRunResults::runIDLen);
ReadStringArray(runRes.caseValDesc);
ReadStringArray(runRes.caseValShortDesc);
ReadStringArray(runRes.caseSeqData.sequenceIDs);
ReadDoubleArray(runRes.caseSeqData.sequenceStartTimes);
// next record contains case start records
ReadNextRecord();
SC_IntArray caseStartRecs;
ReadIntArray(caseStartRecs);
runRes.AllocAndSetSize(caseStartRecs.Size());
// individual case results
for (int i = 0; i < runRes.Size(); i++)
{
ReadAbsolute(caseStartRecs[i]);
ReadOneCase(runRes[i]);
}
}
static meshBone * CreateBones(JsonNode& json_obj,
const std::string& key)
{
meshBone * root_bone = NULL;
JsonNode * base_obj = GetJSONLevelNodeFromKey(json_obj, key);
std::map<int, std::pair<meshBone *, std::vector<int> > > bone_data;
std::set<int> child_set;
// layout bones
for (JsonIterator it = JsonBegin(base_obj->value);
it != JsonEnd(base_obj->value);
++it)
{
JsonNode * cur_node = *it;
std::string cur_name(cur_node->key);
int cur_id = (int)GetJSONNodeFromKey(*cur_node, "id")->value.toNumber();
glm::mat4 cur_parent_mat = ReadJSONMat4(*cur_node, "restParentMat");
glm::vec4 cur_local_rest_start_pt = ReadJSONVec4_2(*cur_node, "localRestStartPt");
glm::vec4 cur_local_rest_end_pt = ReadJSONVec4_2(*cur_node, "localRestEndPt");
std::vector<int> cur_children_ids = ReadIntArray(*cur_node, "children");
meshBone * new_bone = new meshBone(cur_name,
glm::vec4(0),
glm::vec4(0),
cur_parent_mat);
new_bone->getLocalRestStartPt() = cur_local_rest_start_pt;
new_bone->getLocalRestEndPt() = cur_local_rest_end_pt;
new_bone->calcRestData();
new_bone->setTagId(cur_id);
bone_data[cur_id] = std::make_pair(new_bone, cur_children_ids);
for(auto& cur_child_id : cur_children_ids) {
child_set.insert(cur_child_id);
}
}
// Find root
for(auto& cur_data : bone_data)
{
int cur_id = cur_data.first;
if(child_set.count(cur_id) <= 0) {
// not a child, so is root
root_bone = cur_data.second.first;
break;
}
}
// construct hierarchy
for(auto& cur_data : bone_data)
{
meshBone * cur_bone = cur_data.second.first;
const std::vector<int>& children_ids = cur_data.second.second;
for(auto& cur_child_id : children_ids)
{
meshBone * child_bone = bone_data[cur_child_id].first;
cur_bone->addChild(child_bone);
}
}
return root_bone;
}
bool IO_UncertSimResults::AddUncertRun(const DC_UncertSimResults& resultHeader,
const UncertRunResults& results,
bool addExisting)
{
GenAppClearMsgs();
bool openExisting = addExisting && ConvFileC::CFfileExists(fileName);
DC_UncertSimResults currHeader;
if (openExisting)
{
if (!ReadFileHeader(currHeader, false))
{
GenAppErrorMsg("UncertSimResults", "File contents incompatible");
return false;
}
if ((currHeader.IsMultiple() && (!resultHeader.IsMultiple())) ||
((!currHeader.IsMultiple()) && resultHeader.IsMultiple()))
{
GenAppErrorMsg("UncertSimResults", "Cannot combine multiple & not multiple");
return false;
}
if (currHeader.IsMultiple())
{
if (currHeader.multipleRunVariableIDs.Size() != resultHeader.multipleRunVariableIDs.Size())
GenAppErrorMsg("UncertSimResults", "Multiple run results different size??");
}
}
try
{
SC_IntArray runStartRecs;
runStartRecs.SetResizable();
int nextRec, runIndexRecord;
if (openExisting)
{
ReadFileHeader(currHeader, true);
ReadNextRecord();
runIndexRecord = GetCurrentRec();
nextRec = ReadInt();
ReadIntArray(runStartRecs);
}
else
{
OpenFile(fileName, false);
// set up initial header info
nRuns = 0;
WriteFileHeader(resultHeader);
FlushBuffer(nextRec);
runIndexRecord = nextRec;
// initial header
BufferReset(nextRec);
WriteInt(0);
FlushBuffer(nextRec);
// backup and set nextRec
BufferReset(runIndexRecord);
WriteInt(nextRec);
// reflush
FlushBuffer();
}
int runStart = nextRec;
// set to next avail
BufferReset(nextRec);
// add the run to the end
WriteOneRun(results, nextRec);
nRuns++;
// update header
BufferReset(0);
WriteFileHeader(resultHeader);
FlushBuffer();
// update next avail record
BufferReset(runIndexRecord);
WriteInt(nextRec);
// update run start records
runStartRecs += runStart;
WriteIntArray(runStartRecs);
FlushBuffer();
CloseFile();
return true;
}
catch (BufFileC::BufferFileError& err) {
GenAppErrorMsg("WriteUncertResults", err.errMsg);
}
CloseFile();
return false;
}
bool IO_ProfileSimResults::AddSimRun(const ProfileSimRunResults& results,
bool addExisting)
{
GenAppClearMsgs();
bool fileOK = addExisting && ReadFileHeader(false);
try
{
SC_IntArray runStartRecs;
runStartRecs.SetResizable();
int nextRec, runIndexRecord;
if (fileOK)
{
ReadFileHeader(true);
ReadNextRecord();
runIndexRecord = GetCurrentRec();
nextRec = ReadInt();
ReadIntArray(runStartRecs);
}
else
{
OpenFile(fileName, false);
WriteStdFileHeader(fileHeader, StringLength(fileHeader) + 1, writeVersion, 0);
WriteInt(0); // 0 runs
FlushBuffer(nextRec);
runIndexRecord = nextRec;
// initial header
BufferReset(nextRec);
WriteInt(0);
WriteInt(0);
WriteInt(0);
FlushBuffer(nextRec);
// backup and set nextRec
BufferReset(runIndexRecord);
WriteInt(nextRec);
WriteInt(0);
WriteInt(0);
// reflush
FlushBuffer();
}
int runStart = nextRec;
// set to next avail
BufferReset(nextRec);
// add the run to the end
WriteOneRun(results, nextRec);
nRuns++;
// update header
BufferReset(0);
WriteStdFileHeader(fileHeader, StringLength(fileHeader) + 1, writeVersion, 0);
WriteInt(nRuns);
FlushBuffer();
// update next avail record
BufferReset(runIndexRecord);
WriteInt(nextRec);
// update run start records
runStartRecs += runStart;
WriteIntArray(runStartRecs);
FlushBuffer();
CloseFile();
return true;
}
catch (BufFileC::BufferFileError& err) {
GenAppErrorMsg("WriteSimResults", err.errMsg);
}
CloseFile();
return false;
}
