TTK
Loading...
Searching...
No Matches
ttkMergeTreeNeuralNetworkUtils.cpp
Go to the documentation of this file.
1#include <MergeTreeAxesAlgorithmUtils.h>
2#include <ttkMergeTreeNeuralNetworkUtils.h>
3
4#include <vtkInformation.h>
5#include <vtkTable.h>
6
7#ifdef TTK_ENABLE_TORCH
8namespace ttk {
9 namespace wnn {
10
11 void makeMatchingVectors(
12 std::vector<std::vector<std::tuple<ftm::idNode, ftm::idNode, double>>>
13 &originsMatchings,
14 std::vector<mtu::TorchMergeTree<float>> &originsCopy,
15 std::vector<mtu::TorchMergeTree<float>> &originsPrimeCopy,
16 std::vector<std::vector<ttk::ftm::idNode>> &originsMatchingVectorT,
17 std::vector<std::vector<ttk::ftm::idNode>> &invOriginsMatchingVectorT,
18 std::vector<
19 std::vector<std::vector<std::tuple<ftm::idNode, ftm::idNode, double>>>>
20 &dataMatchings,
21 std::vector<std::vector<mtu::TorchMergeTree<float>>> &recs,
22 std::vector<std::vector<std::vector<ttk::ftm::idNode>>>
23 &invDataMatchingVectorT,
24 std::vector<std::vector<std::tuple<ftm::idNode, ftm::idNode, double>>>
25 &reconstMatchings,
26 std::vector<std::vector<ttk::ftm::idNode>> &invReconstMatchingVectorT) {
27 originsMatchingVectorT.resize(originsMatchings.size());
28 invOriginsMatchingVectorT = originsMatchingVectorT;
29 for(unsigned int l = 0; l < originsMatchingVectorT.size(); ++l) {
30 auto &tree1 = (l == 0 ? originsCopy[0] : originsPrimeCopy[l - 1]);
31 auto &tree2 = (l == 0 ? originsPrimeCopy[0] : originsPrimeCopy[l]);
32 ttk::axa::getMatchingVector(tree1.mTree, tree2.mTree,
33 originsMatchings[l],
34 originsMatchingVectorT[l]);
35 ttk::axa::getInverseMatchingVector(tree1.mTree, tree2.mTree,
36 originsMatchings[l],
37 invOriginsMatchingVectorT[l]);
38 }
39
40 invDataMatchingVectorT.resize(dataMatchings.size());
41 for(unsigned int l = 0; l < invDataMatchingVectorT.size(); ++l) {
42 invDataMatchingVectorT[l].resize(dataMatchings[l].size());
43 for(unsigned int i = 0; i < invDataMatchingVectorT[l].size(); ++i)
44 ttk::axa::getInverseMatchingVector(
45 originsCopy[l].mTree, recs[i][l].mTree, dataMatchings[l][i],
46 invDataMatchingVectorT[l][i]);
47 }
48 invReconstMatchingVectorT.resize(reconstMatchings.size());
49 for(unsigned int i = 0; i < invReconstMatchingVectorT.size(); ++i) {
50 auto l = recs[i].size() - 1;
51 ttk::axa::getInverseMatchingVector(recs[i][0].mTree, recs[i][l].mTree,
52 reconstMatchings[i],
53 invReconstMatchingVectorT[i]);
54 }
55 }
56
57 void makeDataOutput(
58 vtkMultiBlockDataSet *output_data,
59 std::vector<std::vector<mtu::TorchMergeTree<float>>> &recs,
60 unsigned int recSize,
61 std::vector<vtkDataSet *> &treesSegmentation,
62 std::vector<std::vector<double>> &persCorrelationMatrix,
63 std::vector<std::vector<std::vector<ttk::ftm::idNode>>>
64 &invDataMatchingVectorT,
65 std::vector<std::vector<ttk::ftm::idNode>> &invReconstMatchingVectorT,
66 std::vector<std::vector<ttk::ftm::idNode>> &originsMatchingVectorT,
67 std::vector<std::vector<ttk::ftm::idNode>> &originsMatchingVector,
68 std::vector<std::vector<double>> &originsPersPercent,
69 std::vector<std::vector<double>> &originsPersDiff,
70 std::vector<int> &originPersistenceOrder,
71 std::vector<vtkUnstructuredGrid *> &treesNodes,
72 std::vector<std::vector<int>> &treesNodeCorr,
73 std::vector<unsigned int> classId,
74 float bestLoss,
75 double mixtureCoefficient,
76 bool isPersistenceDiagram,
77 bool convertToDiagram,
78 int debugLevel) {
79 output_data->SetNumberOfBlocks(1);
80 vtkSmartPointer<vtkMultiBlockDataSet> data
81 = vtkSmartPointer<vtkMultiBlockDataSet>::New();
82 data->SetNumberOfBlocks(1);
83 vtkSmartPointer<vtkMultiBlockDataSet> dataSeg
84 = vtkSmartPointer<vtkMultiBlockDataSet>::New();
85 dataSeg->SetNumberOfBlocks(recs.size());
86 bool outputSegmentation
87 = !treesSegmentation.empty() and treesSegmentation[0];
88 for(unsigned int l = 0; l < recSize; ++l) {
89 vtkSmartPointer<vtkMultiBlockDataSet> out_layer_i
90 = vtkSmartPointer<vtkMultiBlockDataSet>::New();
91 out_layer_i->SetNumberOfBlocks(recs.size());
92 std::vector<ttk::ftm::MergeTree<float> *> trees(recs.size());
93 for(unsigned int i = 0; i < recs.size(); ++i)
94 trees[i] = &(recs[i][l].mTree);
95
96 // Custom arrays
97 std::vector<std::vector<std::tuple<std::string, std::vector<int>>>>
98 customIntArrays(recs.size());
99 std::vector<std::vector<std::tuple<std::string, std::vector<double>>>>
100 customDoubleArrays(recs.size());
101 unsigned int lShift = 0;
102 ttk::wnn::computeCustomArrays(
103 recs, persCorrelationMatrix, invDataMatchingVectorT,
104 invReconstMatchingVectorT, originsMatchingVector,
105 originsMatchingVectorT, originsPersPercent, originsPersDiff,
106 originPersistenceOrder, l, lShift, customIntArrays,
107 customDoubleArrays);
108 if(!classId.empty()) {
109 for(unsigned int i = 0; i < recs.size(); ++i)
110 customIntArrays[i].emplace_back(std::make_tuple(
111 "ClassID",
112 std::vector<int>(
113 recs[i][l].mTree.tree.getNumberOfNodes(), classId[i])));
114 }
115
116 // Create output
117 if(l == 0)
118 ttk::wnn::makeManyOutput(
119 trees, treesNodes, treesNodeCorr, out_layer_i, customIntArrays,
120 customDoubleArrays, mixtureCoefficient, isPersistenceDiagram,
121 convertToDiagram, debugLevel);
122 else
123 ttk::wnn::makeManyOutput(trees, out_layer_i, customIntArrays,
124 customDoubleArrays, mixtureCoefficient,
125 isPersistenceDiagram, convertToDiagram,
126 debugLevel);
127 if(outputSegmentation and l == 0) {
128 ttk::wnn::makeManyOutput(
129 trees, treesNodes, treesNodeCorr, treesSegmentation, dataSeg,
130 customIntArrays, customDoubleArrays, mixtureCoefficient,
131 isPersistenceDiagram, convertToDiagram, debugLevel);
132 }
133 data->SetBlock(l, out_layer_i);
134 std::stringstream ss;
135 ss << (l == 0 ? "Input" : "Layer") << l;
136 data->GetMetaData(l)->Set(vtkCompositeDataSet::NAME(), ss.str());
137 }
138 output_data->SetBlock(0, data);
139 unsigned int num = 0;
140 output_data->GetMetaData(num)->Set(
141 vtkCompositeDataSet::NAME(), "layersTrees");
142 if(outputSegmentation)
143 output_data->SetBlock(1, dataSeg);
144 vtkNew<vtkFloatArray> lossArray{};
145 lossArray->SetName("Loss");
146 lossArray->InsertNextTuple1(bestLoss);
147 output_data->GetFieldData()->AddArray(lossArray);
148 }
149
150 void makeDataOutput(
151 vtkMultiBlockDataSet *output_data,
152 std::vector<std::vector<mtu::TorchMergeTree<float>>> &recs,
153 unsigned int recSize,
154 std::vector<vtkDataSet *> &treesSegmentation,
155 std::vector<std::vector<double>> &persCorrelationMatrix,
156 std::vector<std::vector<std::vector<ttk::ftm::idNode>>>
157 &invDataMatchingVectorT,
158 std::vector<std::vector<ttk::ftm::idNode>> &invReconstMatchingVectorT,
159 std::vector<std::vector<ttk::ftm::idNode>> &originsMatchingVectorT,
160 std::vector<std::vector<ttk::ftm::idNode>> &originsMatchingVector,
161 std::vector<std::vector<double>> &originsPersPercent,
162 std::vector<std::vector<double>> &originsPersDiff,
163 std::vector<int> &originPersistenceOrder,
164 std::vector<vtkUnstructuredGrid *> &treesNodes,
165 std::vector<std::vector<int>> &treesNodeCorr,
166 float bestLoss,
167 double mixtureCoefficient,
168 bool isPersistenceDiagram,
169 bool convertToDiagram,
170 int debugLevel) {
171 std::vector<unsigned int> classId;
172 makeDataOutput(output_data, recs, recSize, treesSegmentation,
173 persCorrelationMatrix, invDataMatchingVectorT,
174 invReconstMatchingVectorT, originsMatchingVectorT,
175 originsMatchingVector, originsPersPercent, originsPersDiff,
176 originPersistenceOrder, treesNodes, treesNodeCorr, classId,
177 bestLoss, mixtureCoefficient, isPersistenceDiagram,
178 convertToDiagram, debugLevel);
179 }
180
181 void makeOriginsOutput(
182 vtkMultiBlockDataSet *output_origins,
183 std::vector<mtu::TorchMergeTree<float>> &originsCopy,
184 std::vector<mtu::TorchMergeTree<float>> &originsPrimeCopy,
185 std::vector<double> &originPersPercent,
186 std::vector<double> &originPersDiff,
187 std::vector<int> &originPersistenceOrder,
188 std::vector<std::vector<ttk::ftm::idNode>> &originsMatchingVector,
189 std::vector<std::vector<double>> &originsPersPercent,
190 std::vector<std::vector<double>> &originsPersDiff,
191 double mixtureCoefficient,
192 bool isPersistenceDiagram,
193 bool convertToDiagram,
194 int debugLevel) {
195 unsigned int noLayers = originsCopy.size();
196
197 output_origins->SetNumberOfBlocks(2);
198 // Origins
199 vtkSmartPointer<vtkMultiBlockDataSet> origins
200 = vtkSmartPointer<vtkMultiBlockDataSet>::New();
201 vtkSmartPointer<vtkMultiBlockDataSet> originsP
202 = vtkSmartPointer<vtkMultiBlockDataSet>::New();
203 origins->SetNumberOfBlocks(noLayers);
204 originsP->SetNumberOfBlocks(noLayers);
205 std::vector<ttk::ftm::MergeTree<float> *> trees(noLayers);
206 std::vector<std::vector<std::tuple<std::string, std::vector<int>>>>
207 customIntArrays(noLayers);
208 std::vector<std::vector<std::tuple<std::string, std::vector<double>>>>
209 customDoubleArrays(noLayers);
210 for(unsigned int l = 0; l < noLayers; ++l) {
211 trees[l] = &(originsCopy[l].mTree);
212 if(l == 0) {
213 std::string name2{"OriginPersPercent"};
214 customDoubleArrays[l].emplace_back(
215 std::make_tuple(name2, originPersPercent));
216 std::string name3{"OriginPersDiff"};
217 customDoubleArrays[l].emplace_back(
218 std::make_tuple(name3, originPersDiff));
219 std::string nameOrder{"OriginPersOrder"};
220 customIntArrays[l].emplace_back(
221 std::make_tuple(nameOrder, originPersistenceOrder));
222 }
223 }
224 ttk::wnn::makeManyOutput(
225 trees, origins, customIntArrays, customDoubleArrays, mixtureCoefficient,
226 isPersistenceDiagram, convertToDiagram, debugLevel);
227
228 customIntArrays.clear();
229 customIntArrays.resize(noLayers);
230 customDoubleArrays.clear();
231 customDoubleArrays.resize(noLayers);
232 for(unsigned int l = 0; l < noLayers; ++l) {
233 trees[l] = &(originsPrimeCopy[l].mTree);
234 if(l < originsMatchingVector.size()) {
235 std::vector<int> customArrayMatching,
236 originPersOrder(trees[l]->tree.getNumberOfNodes(), -1);
237 for(unsigned int i = 0; i < originsMatchingVector[l].size(); ++i) {
238 customArrayMatching.emplace_back(originsMatchingVector[l][i]);
239 if(originsMatchingVector[l][i] < originPersistenceOrder.size())
240 originPersOrder[i]
241 = originPersistenceOrder[originsMatchingVector[l][i]];
242 }
243 std::string name{"OriginTrueNodeId"};
244 customIntArrays[l].emplace_back(
245 std::make_tuple(name, customArrayMatching));
246 std::string nameOrder{"OriginPersOrder"};
247 customIntArrays[l].emplace_back(
248 std::make_tuple(nameOrder, originPersOrder));
249 std::string name2{"OriginPersPercent"};
250 customDoubleArrays[l].emplace_back(
251 std::make_tuple(name2, originsPersPercent[l]));
252 std::string name3{"OriginPersDiff"};
253 customDoubleArrays[l].emplace_back(
254 std::make_tuple(name3, originsPersDiff[l]));
255 }
256 }
257 ttk::wnn::makeManyOutput(
258 trees, originsP, customIntArrays, customDoubleArrays,
259 mixtureCoefficient, isPersistenceDiagram, convertToDiagram, debugLevel);
260 output_origins->SetBlock(0, origins);
261 output_origins->SetBlock(1, originsP);
262 // for(unsigned int l = 0; l < 2; ++l) {
263 for(unsigned int l = 0; l < noLayers; ++l) {
264 if(l >= 2)
265 break;
266 std::stringstream ss;
267 ss << (l == 0 ? "InputOrigin" : "LayerOrigin") << l;
268 auto originsMetaData = origins->GetMetaData(l);
269 if(originsMetaData)
270 originsMetaData->Set(vtkCompositeDataSet::NAME(), ss.str());
271 ss.str("");
272 ss << (l == 0 ? "InputOriginPrime" : "LayerOriginPrime") << l;
273 auto originsPMetaData = originsP->GetMetaData(l);
274 if(originsPMetaData)
275 originsPMetaData->Set(vtkCompositeDataSet::NAME(), ss.str());
276 }
277 unsigned int num = 0;
278 output_origins->GetMetaData(num)->Set(
279 vtkCompositeDataSet::NAME(), "layersOrigins");
280 num = 1;
281 output_origins->GetMetaData(num)->Set(
282 vtkCompositeDataSet::NAME(), "layersOriginsPrime");
283 }
284
285 void makeCoefficientsOutput(
286 vtkMultiBlockDataSet *output_coef,
287 std::vector<std::vector<torch::Tensor>> &allAlphas,
288 std::vector<std::vector<torch::Tensor>> &allScaledAlphas,
289 std::vector<std::vector<torch::Tensor>> &allActAlphas,
290 std::vector<std::vector<torch::Tensor>> &allActScaledAlphas,
291 std::vector<unsigned int> &clusterAsgn,
292 std::vector<std::vector<mtu::TorchMergeTree<float>>> &recs,
293 std::vector<vtkSmartPointer<vtkMultiBlockDataSet>> &inputTrees) {
294 output_coef->SetNumberOfBlocks(allAlphas[0].size());
295 for(unsigned int l = 0; l < allAlphas[0].size(); ++l) {
296 vtkSmartPointer<vtkTable> coef_table = vtkSmartPointer<vtkTable>::New();
297 vtkNew<vtkIntArray> treeIDArray{};
298 treeIDArray->SetName("TreeID");
299 treeIDArray->SetNumberOfTuples(inputTrees.size());
300 for(unsigned int i = 0; i < inputTrees.size(); ++i)
301 treeIDArray->SetTuple1(i, i);
302 coef_table->AddColumn(treeIDArray);
303 auto noVec = allAlphas[0][l].sizes()[0];
304 for(unsigned int v = 0; v < noVec; ++v) {
305 // Alphas
306 vtkNew<vtkFloatArray> tArray{};
307 std::string name = ttk::axa::getTableCoefficientName(noVec, v);
308 tArray->SetName(name.c_str());
309 tArray->SetNumberOfTuples(allAlphas.size());
310 // Act Alphas
311 vtkNew<vtkFloatArray> actArray{};
312 std::string actName = "Act" + name;
313 actArray->SetName(actName.c_str());
314 actArray->SetNumberOfTuples(allAlphas.size());
315 // Scaled Alphas
316 vtkNew<vtkFloatArray> tArrayNorm{};
317 std::string nameNorm
318 = ttk::axa::getTableCoefficientNormName(noVec, v);
319 tArrayNorm->SetName(nameNorm.c_str());
320 tArrayNorm->SetNumberOfTuples(allAlphas.size());
321 // Act Scaled Alphas
322 vtkNew<vtkFloatArray> actArrayNorm{};
323 std::string actNameNorm = "Act" + nameNorm;
324 actArrayNorm->SetName(actNameNorm.c_str());
325 actArrayNorm->SetNumberOfTuples(allAlphas.size());
326 // Fill Arrays
327 for(unsigned int i = 0; i < allAlphas.size(); ++i) {
328 tArray->SetTuple1(i, allAlphas[i][l][v].item<float>());
329 actArray->SetTuple1(i, allActAlphas[i][l][v].item<float>());
330 tArrayNorm->SetTuple1(i, allScaledAlphas[i][l][v].item<float>());
331 actArrayNorm->SetTuple1(
332 i, allActScaledAlphas[i][l][v].item<float>());
333 }
334 coef_table->AddColumn(tArray);
335 coef_table->AddColumn(actArray);
336 coef_table->AddColumn(tArrayNorm);
337 coef_table->AddColumn(actArrayNorm);
338 }
339 if(!clusterAsgn.empty()) {
340 vtkNew<vtkIntArray> clusterArray{};
341 clusterArray->SetName("ClusterAssignment");
342 clusterArray->SetNumberOfTuples(inputTrees.size());
343 for(unsigned int i = 0; i < clusterAsgn.size(); ++i)
344 clusterArray->SetTuple1(i, clusterAsgn[i]);
345 coef_table->AddColumn(clusterArray);
346 }
347 if(l == 0) {
348 vtkNew<vtkIntArray> treesNoNodesArray{};
349 treesNoNodesArray->SetNumberOfTuples(recs.size());
350 treesNoNodesArray->SetName("treeNoNodes");
351 for(unsigned int i = 0; i < recs.size(); ++i)
352 treesNoNodesArray->SetTuple1(
353 i, recs[i][0].mTree.tree.getNumberOfNodes());
354 coef_table->AddColumn(treesNoNodesArray);
355 }
356 output_coef->SetBlock(l, coef_table);
357 std::stringstream ss;
358 ss << "Coef" << l;
359 output_coef->GetMetaData(l)->Set(vtkCompositeDataSet::NAME(), ss.str());
360 }
361
362 // Copy Field Data
363 // - aggregate input field data
364 for(unsigned int b = 0; b < inputTrees[0]->GetNumberOfBlocks(); ++b) {
365 vtkNew<vtkFieldData> fd{};
366 fd->CopyStructure(inputTrees[0]->GetBlock(b)->GetFieldData());
367 fd->SetNumberOfTuples(inputTrees.size());
368 for(size_t i = 0; i < inputTrees.size(); ++i) {
369 fd->SetTuple(i, 0, inputTrees[i]->GetBlock(b)->GetFieldData());
370 }
371
372 // - copy input field data to output row data
373 for(int i = 0; i < fd->GetNumberOfArrays(); ++i) {
374 auto array = fd->GetAbstractArray(i);
375 array->SetName(array->GetName());
376 vtkTable::SafeDownCast(output_coef->GetBlock(0))->AddColumn(array);
377 }
378 }
379 }
380
381 void makeOneOutput(
382 ttk::ftm::MergeTree<float> &tree,
383 vtkUnstructuredGrid *treeNodes,
384 std::vector<int> &treeNodeCorr,
385 vtkDataSet *treeSegmentation,
386 vtkSmartPointer<vtkUnstructuredGrid> &vtkOutputNode,
387 vtkSmartPointer<vtkUnstructuredGrid> &vtkOutputArc,
388 vtkSmartPointer<vtkDataSet> &vtkOutputSegmentation,
389 unsigned int treeID,
390 std::vector<std::tuple<std::string, std::vector<int>>> &customIntArrays,
391 std::vector<std::tuple<std::string, std::vector<double>>>
392 &customDoubleArrays,
393 bool outputSegmentation,
394 double mixtureCoefficient,
395 bool isPersistenceDiagram,
396 bool convertToDiagram,
397 int debugLevel) {
398 vtkOutputNode = vtkSmartPointer<vtkUnstructuredGrid>::New();
399 vtkOutputArc = vtkSmartPointer<vtkUnstructuredGrid>::New();
400
401 ttkMergeTreeVisualization visuMakerBary;
402 visuMakerBary.setShiftMode(-1); // Line
403 visuMakerBary.setVtkOutputNode(vtkOutputNode);
404 if(not isPersistenceDiagram)
405 visuMakerBary.setVtkOutputArc(vtkOutputArc);
406 else {
407 visuMakerBary.setVtkOutputArc(vtkOutputNode);
408 visuMakerBary.setIsPDSadMax(mixtureCoefficient == 0);
409 }
410 visuMakerBary.copyPointData(treeNodes, treeNodeCorr);
411 for(auto &tup : customIntArrays)
412 visuMakerBary.addCustomIntArray(std::get<0>(tup), std::get<1>(tup));
413 for(auto &tup : customDoubleArrays)
414 visuMakerBary.addCustomArray(std::get<0>(tup), std::get<1>(tup));
415 visuMakerBary.setDebugLevel(debugLevel);
416 visuMakerBary.setIsPersistenceDiagram(isPersistenceDiagram);
417 visuMakerBary.setConvertedToDiagram(convertToDiagram);
418 if(treeNodes) {
419 visuMakerBary.setTreesNodes(treeNodes);
420 visuMakerBary.setTreesNodeCorrMesh(treeNodeCorr);
421 }
422 if(outputSegmentation) {
423 vtkOutputSegmentation = vtkSmartPointer<vtkUnstructuredGrid>::New();
424 visuMakerBary.setTreesSegmentation(treeSegmentation);
425 visuMakerBary.setPlanarLayout(false);
426 visuMakerBary.setOutputSegmentation(true);
427 visuMakerBary.setVtkOutputSegmentation(vtkOutputSegmentation);
428 } else {
429 visuMakerBary.setPlanarLayout(true);
430 }
431 visuMakerBary.setISampleOffset(treeID);
432 visuMakerBary.setOutputTreeNodeId(true);
433 visuMakerBary.makeTreesOutput<float>(&(tree.tree));
434 }
435
436 void makeManyOutput(
437 std::vector<ttk::ftm::MergeTree<float> *> &trees,
438 std::vector<vtkUnstructuredGrid *> &treesNodesT,
439 std::vector<std::vector<int>> &treesNodeCorr,
440 std::vector<vtkDataSet *> &treesSegmentationT,
441 vtkSmartPointer<vtkMultiBlockDataSet> &output,
442 std::vector<std::vector<std::tuple<std::string, std::vector<int>>>>
443 &customIntArrays,
444 std::vector<std::vector<std::tuple<std::string, std::vector<double>>>>
445 &customDoubleArrays,
446 double mixtureCoefficient,
447 bool isPersistenceDiagram,
448 bool convertToDiagram,
449 int debugLevel) {
450 vtkSmartPointer<vtkMultiBlockDataSet> allNodes
451 = vtkSmartPointer<vtkMultiBlockDataSet>::New();
452 vtkSmartPointer<vtkMultiBlockDataSet> allArcs;
453 if(not isPersistenceDiagram) {
454 allArcs = vtkSmartPointer<vtkMultiBlockDataSet>::New();
455 }
456 bool outputSegmentation
457 = !treesSegmentationT.empty() and treesSegmentationT[0];
458 vtkSmartPointer<vtkMultiBlockDataSet> allSegs;
459 if(outputSegmentation) {
460 allSegs = vtkSmartPointer<vtkMultiBlockDataSet>::New();
461 }
462 int shift = 0;
463 for(unsigned int i = 0; i < trees.size(); ++i) {
464 if(trees[i]->tree.template getMaximumPersistence<float>() == 0) {
465 ++shift;
466 continue;
467 }
468 vtkUnstructuredGrid *treeNodes = nullptr;
469 vtkDataSet *treeSegmentation = nullptr;
470 std::vector<int> treeNodeCorr;
471 if(outputSegmentation) {
472 treeSegmentation = treesSegmentationT[i];
473 }
474 if(i < treesNodesT.size()) {
475 treeNodes = treesNodesT[i];
476 treeNodeCorr = treesNodeCorr[i];
477 }
478 vtkSmartPointer<vtkUnstructuredGrid> vtkOutputNode, vtkOutputArc;
479 vtkSmartPointer<vtkDataSet> vtkOutputSegmentation;
480 makeOneOutput(*(trees[i]), treeNodes, treeNodeCorr, treeSegmentation,
481 vtkOutputNode, vtkOutputArc, vtkOutputSegmentation, i,
482 customIntArrays[i], customDoubleArrays[i],
483 outputSegmentation, mixtureCoefficient,
484 isPersistenceDiagram, convertToDiagram, debugLevel);
485 allNodes->SetBlock(i - shift, vtkOutputNode);
486 if(not isPersistenceDiagram)
487 allArcs->SetBlock(i - shift, vtkOutputArc);
488 if(outputSegmentation)
489 allSegs->SetBlock(i - shift, vtkOutputSegmentation);
490 }
491 if(not isPersistenceDiagram) {
492 output->SetNumberOfBlocks(2);
493 output->SetBlock(0, allNodes);
494 output->SetBlock(1, allArcs);
495 if(outputSegmentation)
496 output->SetBlock(2, allSegs);
497 } else {
498 if(not outputSegmentation) {
499 output->ShallowCopy(allNodes);
500 } else {
501 output->SetNumberOfBlocks(2);
502 output->SetBlock(0, allNodes);
503 output->SetBlock(1, allSegs);
504 }
505 }
506 }
507
508 void makeManyOutput(
509 std::vector<ttk::ftm::MergeTree<float> *> &trees,
510 std::vector<vtkUnstructuredGrid *> &treesNodesT,
511 std::vector<std::vector<int>> &treesNodeCorr,
512 vtkSmartPointer<vtkMultiBlockDataSet> &output,
513 std::vector<std::vector<std::tuple<std::string, std::vector<int>>>>
514 &customIntArrays,
515 std::vector<std::vector<std::tuple<std::string, std::vector<double>>>>
516 &customDoubleArrays,
517 double mixtureCoefficient,
518 bool isPersistenceDiagram,
519 bool convertToDiagram,
520 int debugLevel) {
521 std::vector<vtkDataSet *> treesSegmentationT;
522 makeManyOutput(trees, treesNodesT, treesNodeCorr, treesSegmentationT,
523 output, customIntArrays, customDoubleArrays,
524 mixtureCoefficient, isPersistenceDiagram, convertToDiagram,
525 debugLevel);
526 }
527
528 void makeManyOutput(
529 std::vector<ttk::ftm::MergeTree<float> *> &trees,
530 vtkSmartPointer<vtkMultiBlockDataSet> &output,
531 std::vector<std::vector<std::tuple<std::string, std::vector<int>>>>
532 &customIntArrays,
533 std::vector<std::vector<std::tuple<std::string, std::vector<double>>>>
534 &customDoubleArrays,
535 double mixtureCoefficient,
536 bool isPersistenceDiagram,
537 bool convertToDiagram,
538 int debugLevel) {
539 std::vector<vtkUnstructuredGrid *> treesNodesT;
540 std::vector<std::vector<int>> treesNodeCorr;
541 makeManyOutput(trees, treesNodesT, treesNodeCorr, output, customIntArrays,
542 customDoubleArrays, mixtureCoefficient,
543 isPersistenceDiagram, convertToDiagram, debugLevel);
544 }
545
546 void makeManyOutput(std::vector<ttk::ftm::MergeTree<float> *> &trees,
547 vtkSmartPointer<vtkMultiBlockDataSet> &output,
548 double mixtureCoefficient,
549 bool isPersistenceDiagram,
550 bool convertToDiagram,
551 int debugLevel) {
552 std::vector<std::vector<std::tuple<std::string, std::vector<int>>>>
553 customIntArrays(trees.size());
554 std::vector<std::vector<std::tuple<std::string, std::vector<double>>>>
555 customDoubleArrays(trees.size());
556 makeManyOutput(trees, output, customIntArrays, customDoubleArrays,
557 mixtureCoefficient, isPersistenceDiagram, convertToDiagram,
558 debugLevel);
559 }
560
561 void computeTrackingInformation(
562 std::vector<mtu::TorchMergeTree<float>> &origins,
563 std::vector<mtu::TorchMergeTree<float>> &originsPrime,
564 std::vector<std::vector<ttk::ftm::idNode>> &originsMatchingVectorT,
565 std::vector<std::vector<ttk::ftm::idNode>> &invOriginsMatchingVectorT,
566 bool isPersistenceDiagram,
567 std::vector<std::vector<ttk::ftm::idNode>> &originsMatchingVector,
568 std::vector<std::vector<double>> &originsPersPercent,
569 std::vector<std::vector<double>> &originsPersDiff,
570 std::vector<double> &originPersPercent,
571 std::vector<double> &originPersDiff,
572 std::vector<int> &originPersistenceOrder) {
573 unsigned int originsMatchingSize = originsMatchingVectorT.size();
574 originsMatchingVector.resize(originsMatchingSize);
575 originsPersPercent.resize(originsMatchingSize);
576 originsPersDiff.resize(originsMatchingSize);
577 for(unsigned int l = 0; l < originsMatchingSize; ++l) {
578 auto &tree2 = (l == 0 ? originsPrime[0] : originsPrime[l]);
579 originsMatchingVector[l] = invOriginsMatchingVectorT[l];
580 if(l != 0) {
581 for(unsigned int i = 0; i < originsMatchingVector[l].size(); ++i)
582 if(originsMatchingVector[l][i]
583 < originsMatchingVector[l - 1].size())
584 originsMatchingVector[l][i]
585 = originsMatchingVector[l - 1][originsMatchingVector[l][i]];
586 }
587 originsPersPercent[l].resize(tree2.mTree.tree.getNumberOfNodes());
588 originsPersDiff[l].resize(tree2.mTree.tree.getNumberOfNodes());
589 for(unsigned int i = 0; i < originsMatchingVector[l].size(); ++i) {
590 if(originsMatchingVector[l][i]
591 >= origins[0].mTree.tree.getNumberOfNodes())
592 continue;
593 auto pers = origins[0].mTree.tree.template getNodePersistence<float>(
594 originsMatchingVector[l][i]);
595 auto treePers
596 = tree2.mTree.tree.template getNodePersistence<float>(i);
597 originsPersPercent[l][i] = treePers * 100 / pers;
598 originsPersDiff[l][i] = treePers - pers;
599 }
600 }
601
602 originPersPercent.resize(origins[0].mTree.tree.getNumberOfNodes());
603 originPersDiff.resize(origins[0].mTree.tree.getNumberOfNodes());
604 std::vector<ttk::ftm::idNode> originMatchingVector;
605 for(unsigned int l = 0; l < originsMatchingSize; ++l) {
606 std::vector<ttk::ftm::idNode> &originMatchingVectorT
607 = originsMatchingVectorT[l];
608 if(l == 0) {
609 originMatchingVector = originMatchingVectorT;
610 } else {
611 for(unsigned int i = 0; i < originMatchingVector.size(); ++i)
612 if(originMatchingVector[i] < originMatchingVectorT.size())
613 originMatchingVector[i]
614 = originMatchingVectorT[originMatchingVector[i]];
615 }
616 }
617 unsigned int l2 = originsMatchingSize - 1;
618 for(unsigned int i = 0; i < originMatchingVector.size(); ++i) {
619 if(originMatchingVector[i] < originsPersDiff[l2].size()) {
620 originPersPercent[i]
621 = originsPersPercent[l2][originMatchingVector[i]];
622 originPersDiff[i] = originsPersDiff[l2][originMatchingVector[i]];
623 }
624 }
625
626 originPersistenceOrder.resize(
627 origins[0].mTree.tree.getNumberOfNodes(), -1);
628 std::vector<std::tuple<ttk::ftm::idNode, ttk::ftm::idNode, float>>
629 pairsBary;
630 bool useBD = isPersistenceDiagram;
631 origins[0].mTree.tree.template getPersistencePairsFromTree<float>(
632 pairsBary, useBD);
633 for(unsigned int j = 0; j < pairsBary.size(); ++j) {
634 int index = pairsBary.size() - 1 - j;
635 originPersistenceOrder[std::get<0>(pairsBary[j])] = index;
636 originPersistenceOrder[std::get<1>(pairsBary[j])] = index;
637 }
638 }
639
640 void computeCustomArrays(
641 std::vector<std::vector<mtu::TorchMergeTree<float>>> &recs,
642 std::vector<std::vector<double>> &persCorrelationMatrix,
643 std::vector<std::vector<std::vector<ttk::ftm::idNode>>>
644 &invDataMatchingVectorT,
645 std::vector<std::vector<ttk::ftm::idNode>> &invReconstMatchingVectorT,
646 std::vector<std::vector<ttk::ftm::idNode>> &originsMatchingVector,
647 std::vector<std::vector<ttk::ftm::idNode>> &originsMatchingVectorT,
648 std::vector<std::vector<double>> &originsPersPercent,
649 std::vector<std::vector<double>> &originsPersDiff,
650 std::vector<int> &originPersistenceOrder,
651 unsigned int l,
652 unsigned int lShift,
653 std::vector<std::vector<std::tuple<std::string, std::vector<int>>>>
654 &customIntArrays,
655 std::vector<std::vector<std::tuple<std::string, std::vector<double>>>>
656 &customDoubleArrays) {
657 unsigned int originsMatchingSize = originsMatchingVectorT.size();
658 unsigned int dataMatchingSize = invDataMatchingVectorT.size();
659 unsigned int lShifted = l + lShift;
660 std::vector<std::vector<ttk::ftm::idNode>> matchingVectors(recs.size());
661 std::vector<std::vector<double>> dataPersPercent, dataPersDiff;
662 std::vector<std::vector<int>> dataOriginPersOrder;
663 std::vector<std::vector<std::vector<double>>> dataCorrelation;
664 if(lShifted < dataMatchingSize) {
665 for(unsigned int i = 0; i < recs.size(); ++i) {
666 matchingVectors[i] = invDataMatchingVectorT[lShifted][i];
667 if(lShifted != 0) {
668 for(unsigned int j = 0; j < matchingVectors[i].size(); ++j)
669 if(matchingVectors[i][j]
670 < originsMatchingVector[lShifted - 1].size())
671 matchingVectors[i][j]
672 = originsMatchingVector[lShifted - 1][matchingVectors[i][j]];
673 }
674 }
675 }
676 if(lShifted == 0 or lShifted == dataMatchingSize - 1) {
677 dataPersPercent.resize(recs.size());
678 dataPersDiff.resize(recs.size());
679 for(unsigned int i = 0; i < recs.size(); ++i) {
680 dataPersPercent[i].resize(recs[i][l].mTree.tree.getNumberOfNodes());
681 dataPersDiff[i].resize(recs[i][l].mTree.tree.getNumberOfNodes());
682 std::vector<ttk::ftm::idNode> matchingVector;
683 if(lShifted == 0) {
684 matchingVector = matchingVectors[i];
685 for(unsigned int l2 = 0; l2 < originsMatchingSize; ++l2) {
686 std::vector<ttk::ftm::idNode> &originMatchingVector
687 = originsMatchingVectorT[l2];
688 for(unsigned int j = 0; j < matchingVector.size(); ++j)
689 if(matchingVector[j] < originMatchingVector.size())
690 matchingVector[j] = originMatchingVector[matchingVector[j]];
691 }
692 } else {
693 matchingVector = invDataMatchingVectorT[lShifted][i];
694 }
695 unsigned int l2 = originsMatchingSize - 1;
696 for(unsigned int j = 0; j < matchingVector.size(); ++j) {
697 if(matchingVector[j] < originsPersDiff[l2].size()) {
698 dataPersDiff[i][j] = originsPersDiff[l2][matchingVector[j]];
699 dataPersPercent[i][j] = originsPersPercent[l2][matchingVector[j]];
700 }
701 }
702 }
703
704 if(lShifted == 0) {
705 dataCorrelation.resize(recs.size());
706 for(unsigned int i = 0; i < recs.size(); ++i) {
707 dataCorrelation[i].resize(persCorrelationMatrix[0].size());
708 for(unsigned int j = 0; j < persCorrelationMatrix[0].size(); ++j) {
709 dataCorrelation[i][j].resize(
710 recs[i][l].mTree.tree.getNumberOfNodes());
711 for(unsigned int k = 0; k < matchingVectors[i].size(); ++k) {
712 if(matchingVectors[i][k] < persCorrelationMatrix.size())
713 dataCorrelation[i][j][k]
714 = persCorrelationMatrix[matchingVectors[i][k]][j];
715 }
716 }
717 }
718 }
719 }
720
721 if(lShifted == 0 or lShifted == dataMatchingSize - 1
722 or l == recs[0].size() - 1) {
723 dataOriginPersOrder.resize(recs.size());
724 for(unsigned int i = 0; i < recs.size(); ++i) {
725 std::vector<ttk::ftm::idNode> &matchingVector = matchingVectors[i];
726 if(l == recs[0].size() - 1) {
727 matchingVector = invReconstMatchingVectorT[i];
728 std::vector<ttk::ftm::idNode> &matchingVectorT
729 = invDataMatchingVectorT[0][i];
730 for(unsigned int j = 0; j < matchingVector.size(); ++j)
731 if(matchingVector[j] < matchingVectorT.size())
732 matchingVector[j] = matchingVectorT[matchingVector[j]];
733 }
734 dataOriginPersOrder[i].resize(
735 recs[i][l].mTree.tree.getNumberOfNodes());
736 for(unsigned int j = 0; j < matchingVector.size(); ++j) {
737 if(matchingVector[j] < originPersistenceOrder.size())
738 dataOriginPersOrder[i][j]
739 = originPersistenceOrder[matchingVector[j]];
740 else
741 dataOriginPersOrder[i][j] = -1;
742 }
743 }
744 }
745
746 for(unsigned int i = 0; i < recs.size(); ++i) {
747 if(lShifted < dataMatchingSize) {
748 std::vector<int> customArrayMatching;
749 for(auto &e : matchingVectors[i])
750 customArrayMatching.emplace_back(e);
751 std::string name{"OriginTrueNodeId"};
752 customIntArrays[i].emplace_back(
753 std::make_tuple(name, customArrayMatching));
754 if(lShifted == 0 or lShifted == dataMatchingSize - 1) {
755 std::string name2{"OriginPersPercent"};
756 customDoubleArrays[i].emplace_back(
757 std::make_tuple(name2, dataPersPercent[i]));
758 std::string name3{"OriginPersDiff"};
759 customDoubleArrays[i].emplace_back(
760 std::make_tuple(name3, dataPersDiff[i]));
761 }
762 if(lShifted == 0) {
763 for(unsigned int j = 0; j < dataCorrelation[i].size(); ++j) {
764 std::string name2 = ttk::axa::getTableCorrelationPersName(
765 dataCorrelation[i].size(), j);
766 customDoubleArrays[i].emplace_back(
767 std::make_tuple(name2, dataCorrelation[i][j]));
768 }
769 }
770 }
771 if(lShifted == 0 or lShifted == dataMatchingSize - 1
772 or l == recs[0].size() - 1) {
773 std::string name4{"OriginPersOrder"};
774 customIntArrays[i].emplace_back(
775 std::make_tuple(name4, dataOriginPersOrder[i]));
776 }
777 }
778 }
779
780 } // namespace wnn
781} // namespace ttk
782#endif
ttkMergeTreeVisualization::setTreesSegmentation
void setTreesSegmentation(std::vector< vtkDataSet * > &segmentation)
Definition ttkMergeTreeVisualization.h:193
ttkMergeTreeVisualization::copyPointData
void copyPointData(vtkUnstructuredGrid *treeNodes, std::vector< int > &nodeCorrT)
Definition ttkMergeTreeVisualization.h:337
ttkMergeTreeVisualization::setVtkOutputSegmentation
void setVtkOutputSegmentation(vtkDataSet *vtkSegmentation)
Definition ttkMergeTreeVisualization.h:232
ttkMergeTreeVisualization::setTreesNodeCorrMesh
void setTreesNodeCorrMesh(std::vector< std::vector< int > > &nodeCorrMesh)
Definition ttkMergeTreeVisualization.h:180
ttkMergeTreeVisualization::addCustomIntArray
void addCustomIntArray(std::string &name, std::vector< int > &vec)
Definition ttkMergeTreeVisualization.h:263
ttkMergeTreeVisualization::makeTreesOutput
void makeTreesOutput(FTMTree_MT *tree1)
Definition ttkMergeTreeVisualization.h:555
ttkMergeTreeVisualization::setConvertedToDiagram
void setConvertedToDiagram(bool converted)
Definition ttkMergeTreeVisualization.h:142
ttkMergeTreeVisualization::setVtkOutputArc
void setVtkOutputArc(vtkUnstructuredGrid *vtkArc)
Definition ttkMergeTreeVisualization.h:229
ttkMergeTreeVisualization::setVtkOutputNode
void setVtkOutputNode(vtkUnstructuredGrid *vtkNode)
Definition ttkMergeTreeVisualization.h:226
ttkMergeTreeVisualization::addCustomArray
void addCustomArray(std::string &name, std::vector< double > &vec)
Definition ttkMergeTreeVisualization.h:260
ttkMergeTreeVisualization::setTreesNodes
void setTreesNodes(std::vector< vtkUnstructuredGrid * > &nodes)
Definition ttkMergeTreeVisualization.h:177
ttk::Debug::setDebugLevel
virtual int setDebugLevel(const int &debugLevel)
Definition Debug.cpp:147
ttk::axa::getTableCoefficientNormName
std::string getTableCoefficientNormName(int noAxes, int axeNum)
Definition MergeTreeAxesAlgorithmUtils.cpp:37
ttk::axa::getTableCorrelationPersName
std::string getTableCorrelationPersName(int noAxes, int axeNum)
Definition MergeTreeAxesAlgorithmUtils.cpp:59
ttk::axa::getMatchingVector
void getMatchingVector(const ftm::MergeTree< dataType > &barycenter, const ftm::MergeTree< dataType > &tree, std::vector< std::tuple< ftm::idNode, ftm::idNode, double > > &matchings, std::vector< ftm::idNode > &matchingVector)
Definition MergeTreeAxesAlgorithmUtils.h:13
ttk::axa::getInverseMatchingVector
void getInverseMatchingVector(const ftm::MergeTree< dataType > &barycenter, const ftm::MergeTree< dataType > &tree, std::vector< std::tuple< ftm::idNode, ftm::idNode, double > > &matchings, std::vector< ftm::idNode > &matchingVector)
Definition MergeTreeAxesAlgorithmUtils.h:32
ttk::axa::getTableCoefficientName
std::string getTableCoefficientName(int noAxes, int axeNum)
Definition MergeTreeAxesAlgorithmUtils.cpp:31
ttk
TTK base package defining the standard types.
Definition AbstractTriangulation.h:51
ttk::ftm::MergeTree::tree
ftm::FTMTree_MT tree
Definition FTMTree_MT.h:906
Generated on Fri Apr 10 2026 10:02:09 for TTK by doxygen 1.13.2