const bool allAtOnce = 0;
bool writeNodes(
int blockId,
cee::vtfx::Database* database,
const std::vector<float> nodes,
const std::vector<int> nodeIds)
{
if (allAtOnce)
{
if (!nodeBlock->
setNodes(nodes, nodeIds))
{
return false;
}
}
else
{
{
return false;
}
for (size_t i = 0; i < nodes.size() / 3; i++)
{
if (!nodeIds.empty())
{
nodeBlock->
addNode(nodes[i * 3], nodes[i * 3 + 1], nodes[i * 3 + 2], nodeIds[i]);
}
else
{
nodeBlock->
addNode(nodes[i * 3], nodes[i * 3 + 1], nodes[i * 3 + 2]);
}
}
}
{
return false;
}
return true;
}
{
if (allAtOnce)
{
if (!elementBlock->
addElements(elementType, elementNodes, elementIds))
{
return false;
}
}
else
{
int numElements = static_cast<int>(elementNodes.size()) / numElementNodes;
for (int i = 0; i < numElements; i++)
{
std::vector<int> currentElementNodes;
currentElementNodes.assign(elementNodes.begin() + (i*numElementNodes), elementNodes.begin() + ((i + 1)*numElementNodes));
if (!elementBlock->
addElement(elementType, currentElementNodes, elementIds.empty() ? -1 : elementIds[i]))
{
return false;
}
}
}
{
return false;
}
return true;
}
{
size_t geoIndex = 0;
{
return false;
}
{
return false;
}
for (size_t i = 0; i < elementParts.size(); i++)
{
}
{
return false;
}
return true;
}
{
if (allAtOnce)
{
{
return false;
}
}
else
{
{
{
return false;
}
for (size_t i = 0; i < resultValues.size(); i++)
{
}
}
else
{
{
return false;
}
for (size_t i = 0; i < resultValues.size() / 3; i++)
{
resultValuesBlock->
addResultValue3d(resultValues[3 * i], resultValues[3 * i + 1], resultValues[3 * i + 2]);
}
}
}
{
return false;
}
return true;
}
{
partSettings->
setValue(
"context_geometry_index", static_cast<unsigned int>(0));
partSettings->
setValue(
"context_part_id", 1);
partSettings->
setValue(
"draw_style",
"line");
scalarSelection->
setValue(
"fringes_result_id", 1);
colorMapper->
setValue(
"context_result_id", 1);
colorMapper->
setValue(
"range_min", 1.0);
colorMapper->
setValue(
"range_max", 5.0);
std::vector<cee::Variant> vectorIds;
vectorIds.push_back(1);
vectorSelection->
setValue(
"vector_result_ids", vectorIds);
vectorSettings->
setValue(
"context_result_id", 1);
vectorSettings->
setValue(
"color_mode",
"color_by_fringes");
{
return false;
}
return true;
}
int main()
{
unsigned int licenseKeyA = 0x00;
unsigned int licenseKeyB = 0x00;
const cee::Str fileName =
"Example1.vtfx";
if (!file->
create(fileName, fileSettings))
{
return EXIT_FAILURE;
}
std::vector<float> nodesPart1(NODES_PART_1, NODES_PART_1 + sizeof(NODES_PART_1) / sizeof(float));
std::vector<int> nodesPart1Ids(NODES_PART_1_IDS, NODES_PART_1_IDS + sizeof(NODES_PART_1_IDS) / sizeof(int));
if (!writeNodes(1, singleDatabase.
get(), nodesPart1, nodesPart1Ids))
{
return EXIT_FAILURE;
}
std::vector<int> connectsPart1(CONNECTS_PART_1, CONNECTS_PART_1 + sizeof(CONNECTS_PART_1) / sizeof(int));
std::vector<int> elementPart1(ELEMENTS_PART_1_IDS, ELEMENTS_PART_1_IDS + sizeof(ELEMENTS_PART_1_IDS) / sizeof(int));
if (!writeElements(1, singleDatabase.
get(), connectsPart1, elementTypePart1, 1, elementPart1))
{
return EXIT_FAILURE;
}
std::vector<float> nodesPart2(NODES_PART_2, NODES_PART_2 + sizeof(NODES_PART_2) / sizeof(float));
std::vector<int> nodesPart2Ids(NODES_PART_2_IDS, NODES_PART_2_IDS + sizeof(NODES_PART_2_IDS) / sizeof(int));
if (!writeNodes(2, singleDatabase.
get(), nodesPart2, nodesPart2Ids))
{
return EXIT_FAILURE;
}
std::vector<int> connectsPart2(CONNECTS_PART_2, CONNECTS_PART_2 + sizeof(CONNECTS_PART_2) / sizeof(int));
std::vector<int> elementPart2(ELEMENTS_PART_2_IDS, ELEMENTS_PART_2_IDS + sizeof(ELEMENTS_PART_2_IDS) / sizeof(int));
if (!writeElements(2, singleDatabase.
get(), connectsPart2, elementTypePart2, 2, elementPart2))
{
return EXIT_FAILURE;
}
std::vector<int> elementParts(ELEMENT_PARTS, ELEMENT_PARTS + sizeof(ELEMENT_PARTS) / sizeof(int));
if (!writeGeometry(singleDatabase.
get(), elementParts))
{
return EXIT_FAILURE;
}
std::vector<float> result1P1S1(RESULT1_P1_S1, RESULT1_P1_S1 + sizeof(RESULT1_P1_S1) / sizeof(int));
{
return EXIT_FAILURE;
}
std::vector<float> result1P1S2(RESULT1_P1_S2, RESULT1_P1_S2 + sizeof(RESULT1_P1_S2) / sizeof(int));
{
return EXIT_FAILURE;
}
std::vector<float> result1P2S1(RESULT1_P2_S1, RESULT1_P2_S1 + sizeof(RESULT1_P2_S1) / sizeof(int));
{
return EXIT_FAILURE;
}
std::vector<float> result1P2S2(RESULT1_P2_S2, RESULT1_P2_S2 + sizeof(RESULT1_P2_S2) / sizeof(int));
{
return EXIT_FAILURE;
}
{
return EXIT_FAILURE;
}
scalarResult->
setName(
"My scalar result");
{
return EXIT_FAILURE;
}
std::vector<float> result2P1S1(RESULT2_P1_S1, RESULT2_P1_S1 + sizeof(RESULT2_P1_S1) / sizeof(float));
{
return EXIT_FAILURE;
}
std::vector<float> result2P1S2(RESULT2_P1_S2, RESULT2_P1_S2 + sizeof(RESULT2_P1_S2) / sizeof(float));
{
return EXIT_FAILURE;
}
std::vector<float> result2P2S1(RESULT2_P2_S1, RESULT2_P2_S1 + sizeof(RESULT2_P2_S1) / sizeof(float));
{
return EXIT_FAILURE;
}
std::vector<float> result2P2S2(RESULT2_P2_S2, RESULT2_P2_S2 + sizeof(RESULT2_P2_S2) / sizeof(float));
{
return EXIT_FAILURE;
}
{
return EXIT_FAILURE;
}
vectorResult->
setName(
"My vector result");
{
return EXIT_FAILURE;
}
std::vector<float> result3P1S1(RESULT3_P1_S1, RESULT3_P1_S1 + sizeof(RESULT3_P1_S1) / sizeof(float));
{
return EXIT_FAILURE;
}
std::vector<float> result3P1S2(RESULT3_P1_S2, RESULT3_P1_S2 + sizeof(RESULT3_P1_S2) / sizeof(float));
{
return EXIT_FAILURE;
}
std::vector<float> result3P2S1(RESULT3_P2_S1, RESULT3_P2_S1 + sizeof(RESULT3_P2_S1) / sizeof(float));
{
return EXIT_FAILURE;
}
std::vector<float> result3P2S2(RESULT3_P2_S2, RESULT3_P2_S2 + sizeof(RESULT3_P2_S2) / sizeof(float));
{
return EXIT_FAILURE;
}
{
return EXIT_FAILURE;
}
displacementResult->
setName(
"My displacement result");
{
return EXIT_FAILURE;
}
{
return EXIT_FAILURE;
}
{
return EXIT_FAILURE;
}
if (!createProperties(singleCase.get()))
{
return EXIT_FAILURE;
}
{
return EXIT_FAILURE;
}
std::cout <<
"Exported successfully to file: " << fileName.
toStdString() << std::endl;
std::cout << std::endl << "Press enter to exit..." << std::endl;
std::cin.ignore();
return EXIT_SUCCESS;
}