25#define treesMatchingVector \
26 std::vector<std::vector<std::tuple<ftm::idNode, ftm::idNode, double>>>
27#define matchingVectorType std::vector<treesMatchingVector>
46 template <
class dataType2>
50 bool parallelizeUpdate_ =
true;
52 unsigned int noCentroids_ = 2;
55 int noIterationC_ = 0;
56 double addDeletedNodesTime_ = 0;
59 bool acceleratedInitialized_ =
false;
60 std::vector<std::vector<double>> lowerBound_;
61 std::vector<double> upperBound_;
62 std::vector<int> bestCentroid_, oldBestCentroid_;
63 std::vector<double> bestDistance_;
64 std::vector<bool> recompute_;
65 std::vector<ftm::MergeTree<dataType2>> oldCentroids_, oldCentroids2_;
68 std::vector<std::vector<int>> trees2NodeCorr_;
73 "MergeTreeClustering");
79 noCentroids_ = noCentroidsT;
87 return trees2NodeCorr_;
98 template <
class dataType>
100 std::vector<ftm::FTMTree_MT *> &trees,
101 std::vector<ftm::FTMTree_MT *> &trees2,
105 std::vector<dataType> distances(
106 trees.size(), std::numeric_limits<dataType>::max());
110 std::vector<ftm::MergeTree<dataType>> mTreesLimited, mTrees2Limited;
114 getSizeLimitedTrees<dataType>(
116 if(trees2.size() != 0)
118 limitPercent, mTrees2Limited);
122 for(
unsigned int i = 0; i < noCentroids_; ++i) {
125 bestIndex = getBestInitTreeIndex<dataType>(
126 trees, trees2, limitPercent,
false);
130 for(
auto val : distances)
132 double bestValue = std::numeric_limits<double>::lowest();
133 std::vector<double> probabilities(trees.size());
134 for(
unsigned int j = 0; j < distances.size(); ++j) {
136 = (sum != 0 ? distances[j] / sum : 1.0 / distances.size());
137 if(probabilities[j] > bestValue) {
138 bestValue = probabilities[j];
143 std::random_device rd;
144 std::default_random_engine generator(rd());
145 std::discrete_distribution<int> distribution(
146 probabilities.begin(), probabilities.end());
147 bestIndex = distribution(generator);
154 = ftm::copyMergeTree<dataType>(trees[bestIndex],
true);
156 ftm::cleanMergeTree<dataType>(allCentroids[0][i]);
157 if(trees2.size() != 0) {
159 = ftm::copyMergeTree<dataType>(trees2[bestIndex],
true);
161 ftm::cleanMergeTree<dataType>(allCentroids[1][i]);
164 if(i == noCentroids_ - 1)
166#ifdef TTK_ENABLE_OPENMP
167#pragma omp parallel for schedule(dynamic) shared(allCentroids) \
168 num_threads(this->threadNumber_) if(parallelize_)
170 for(
unsigned int j = 0; j < trees.size(); ++j) {
171 std::vector<std::tuple<ftm::idNode, ftm::idNode, double>> matching,
173 dataType distanceT, distanceT2;
175 = (doSizeLimit ? &(mTreesLimited[j].tree) : trees[j]);
176 computeOneDistance<dataType>(treeToUse, allCentroids[0][i], matching,
178 if(trees2.size() != 0) {
180 = (doSizeLimit ? &(mTrees2Limited[j].tree) : trees2[j]);
181 computeOneDistance<dataType>(tree2ToUse, allCentroids[1][i],
184 distanceT = mixDistances<dataType>(distanceT, distanceT2);
186 distances[j] = std::min(distances[j], distanceT);
191 template <
class dataType>
195 std::vector<std::tuple<double, int>> distancesAndIndexes(
196 bestDistance_.size());
197 for(
unsigned int i = 0; i < bestDistance_.size(); ++i)
198 distancesAndIndexes[i] = std::make_tuple(-bestDistance_[i], i);
199 std::sort(distancesAndIndexes.begin(), distancesAndIndexes.end());
200 int bestIndex = std::get<1>(distancesAndIndexes[noNewCentroid]);
201 centroid = ftm::copyMergeTree<dataType>(trees[bestIndex],
true);
203 ftm::cleanMergeTree<dataType>(centroid);
206 template <
class dataType>
208 std::vector<ftm::FTMTree_MT *> &trees,
210 std::vector<ftm::FTMTree_MT *> &
ttkNotUsed(trees2)) {
213 trees.size(), std::vector<double>(centroids.size(), 0));
215 upperBound_.resize(trees.size(), std::numeric_limits<double>::max());
216 bestCentroid_.clear();
217 bestCentroid_.resize(trees.size(), -1);
218 oldBestCentroid_.clear();
219 oldBestCentroid_.resize(trees.size(), -1);
220 bestDistance_.clear();
221 bestDistance_.resize(trees.size(), std::numeric_limits<double>::max());
223 recompute_.resize(trees.size(),
true);
226 template <
class dataType>
230 std::vector<ftm::FTMTree_MT *> &trees2,
232 acceleratedInitialized_ =
true;
233 std::vector<std::tuple<int, int>> assignmentC;
234 std::vector<dataType> bestDistanceT(
235 trees.size(), std::numeric_limits<dataType>::max());
236 assignmentCentroidsNaive<dataType>(
237 trees, centroids, assignmentC, bestDistanceT, trees2, centroids2);
238 for(
unsigned int i = 0; i < bestDistanceT.size(); ++i)
239 bestDistance_[i] = bestDistanceT[i];
240 for(
auto asgn : assignmentC)
241 bestCentroid_[std::get<1>(asgn)] = std::get<0>(asgn);
242 for(
unsigned int i = 0; i < bestDistance_.size(); ++i)
243 upperBound_[i] = bestDistance_[i];
246 template <
class dataType>
249 oldCentroids.clear();
250 for(
unsigned int i = 0; i < centroids.size(); ++i)
251 oldCentroids.push_back(ftm::copyMergeTree<dataType>(centroids[i]));
257 template <
class dataType>
259 std::vector<ftm::FTMTree_MT *> &trees,
261 std::vector<std::tuple<int, int>> &assignmentC,
262 std::vector<dataType> &bestDistanceT,
263 std::vector<ftm::FTMTree_MT *> &trees2,
265 if(not acceleratedInitialized_) {
266 initAcceleratedKMeans<dataType>(trees, centroids, trees2, centroids2);
269 std::vector<dataType> distanceShift(centroids.size()),
270 distanceShift2(centroids2.size());
271#ifdef TTK_ENABLE_OPENMP
272#pragma omp parallel for schedule(dynamic) \
273 shared(centroids, centroids2, oldCentroids_, oldCentroids2_) \
274 num_threads(this->threadNumber_) if(parallelize_)
276 for(
unsigned int i = 0; i < centroids.size(); ++i) {
277 std::vector<std::tuple<ftm::idNode, ftm::idNode, double>> matching,
279 computeOneDistance<dataType>(centroids[i], oldCentroids_[i], matching,
281 if(trees2.size() != 0) {
282 computeOneDistance<dataType>(centroids2[i], oldCentroids2_[i],
283 matching2, distanceShift2[i],
286 = mixDistances<dataType>(distanceShift[i], distanceShift2[i]);
291 for(
unsigned int i = 0; i < trees.size(); ++i)
292 for(
unsigned int c = 0; c < centroids.size(); ++c)
294 = std::max(lowerBound_[i][c] - distanceShift[c], 0.0);
297 for(
unsigned int i = 0; i < trees.size(); ++i) {
298 upperBound_[i] = upperBound_[i] + distanceShift[bestCentroid_[i]];
299 recompute_[i] =
true;
304 std::vector<std::vector<double>> centroidsDistance, centroidsDistance2;
305 getCentroidsDistanceMatrix<dataType>(
307 if(trees2.size() != 0) {
308 getCentroidsDistanceMatrix<dataType>(
312 std::vector<double> centroidScore(
313 centroids.size(), std::numeric_limits<double>::max());
314 for(
unsigned int i = 0; i < centroids.size(); ++i)
315 for(
unsigned int j = i + 1; j < centroids.size(); ++j) {
316 if(0.5 * centroidsDistance[i][j] < centroidScore[i])
317 centroidScore[i] = 0.5 * centroidsDistance[i][j];
318 if(0.5 * centroidsDistance[i][j] < centroidScore[j])
319 centroidScore[j] = 0.5 * centroidsDistance[i][j];
323 std::vector<bool> identified(trees.size());
324 for(
unsigned int i = 0; i < trees.size(); ++i)
325 identified[i] = (upperBound_[i] <= centroidScore[bestCentroid_[i]]);
328#ifdef TTK_ENABLE_OPENMP
329#pragma omp parallel for schedule(dynamic) shared(centroids, centroids2) \
330 num_threads(this->threadNumber_) if(parallelize_)
332 for(
unsigned int i = 0; i < trees.size(); ++i)
333 for(
unsigned int c = 0; c < centroids.size(); ++c) {
334 if(not identified[i] and (
int) c != bestCentroid_[i]
335 and upperBound_[i] > lowerBound_[i][c]
337 > 0.5 * centroidsDistance[bestCentroid_[i]][c]) {
340 std::vector<std::tuple<ftm::idNode, ftm::idNode, double>>
342 dataType distance, distance2;
343 computeOneDistance<dataType>(trees[i],
344 centroids[bestCentroid_[i]],
346 if(trees2.size() != 0) {
347 computeOneDistance<dataType>(
348 trees2[i], centroids2[bestCentroid_[i]], matching2, distance2,
350 distance = mixDistances<dataType>(distance, distance2);
352 recompute_[i] =
false;
353 lowerBound_[i][bestCentroid_[i]] = distance;
354 upperBound_[i] = distance;
355 bestDistance_[i] = distance;
357 bestDistance_[i] = upperBound_[i];
360 if(bestDistance_[i] > lowerBound_[i][c]
362 > 0.5 * centroidsDistance[bestCentroid_[i]][c]) {
363 std::vector<std::tuple<ftm::idNode, ftm::idNode, double>>
365 dataType distance, distance2;
366 computeOneDistance<dataType>(
368 if(trees2.size() != 0) {
369 computeOneDistance<dataType>(trees2[i], centroids2[c],
370 matching2, distance2,
372 distance = mixDistances<dataType>(distance, distance2);
374 lowerBound_[i][c] = distance;
375 if(distance < bestDistance_[i]) {
376 bestCentroid_[i] = c;
377 upperBound_[i] = distance;
378 bestDistance_[i] = distance;
385 copyCentroids<dataType>(centroids, oldCentroids_);
386 if(trees2.size() != 0)
387 copyCentroids<dataType>(centroids2, oldCentroids2_);
390 for(
unsigned int i = 0; i < bestDistance_.size(); ++i)
391 bestDistanceT[i] = bestDistance_[i];
392 for(
unsigned int i = 0; i < bestCentroid_.size(); ++i)
393 assignmentC.emplace_back(bestCentroid_[i], i);
396 template <
class dataType>
400 std::vector<std::tuple<int, int>> &assignmentC,
401 std::vector<dataType> &bestDistanceT,
402 std::vector<ftm::FTMTree_MT *> &trees2,
404 oldBestCentroid_ = bestCentroid_;
405 assignmentCentroidsAccelerated<dataType>(
406 trees, centroids, assignmentC, bestDistanceT, trees2, centroids2);
409 template <
class dataType>
411 std::vector<ftm::FTMTree_MT *> &trees,
414 std::vector<std::tuple<int, int>> &assignmentC,
415 std::vector<dataType> &bestDistanceT,
416 std::vector<ftm::FTMTree_MT *> &trees2,
419 int noC = centroids.size();
420 std::vector<std::vector<ftm::FTMTree_MT *>> assignedTrees(noC),
422 std::vector<std::vector<int>> assignedTreesIndex(noC);
424 for(
auto asgn : assignmentC) {
425 assignedTreesIndex[std::get<0>(asgn)].push_back(std::get<1>(asgn));
426 assignedTrees[std::get<0>(asgn)].push_back(trees[std::get<1>(asgn)]);
427 if(trees2.size() != 0)
428 assignedTrees2[std::get<0>(asgn)].push_back(
429 trees2[std::get<1>(asgn)]);
432#ifdef TTK_ENABLE_OPENMP
433#pragma omp parallel for schedule(dynamic) shared(centroids, centroids2) \
434 num_threads(this->threadNumber_) if(parallelize_)
436 for(
unsigned int i = 0; i < centroids.size(); ++i) {
437 std::vector<dataType> distances(assignedTrees[i].size(), 0);
438 std::vector<dataType> distances2(assignedTrees[i].size(), 0);
440 assignment<dataType>(
442 matchingsC[i] = matching;
443 if(trees2.size() != 0) {
444 assignment<dataType>(assignedTrees2[i], centroids2[i], matching2,
446 matchingsC2[i] = matching2;
447 for(
unsigned int j = 0; j < assignedTreesIndex[i].size(); ++j)
448 distances[j] = mixDistances<dataType>(distances[j], distances2[j]);
450 for(
unsigned int j = 0; j < assignedTreesIndex[i].size(); ++j) {
451 int index = assignedTreesIndex[i][j];
452 bestDistanceT[index] = distances[j];
457 template <
class dataType>
459 std::vector<ftm::FTMTree_MT *> &trees,
461 std::vector<std::tuple<int, int>> &assignmentC,
462 std::vector<dataType> &bestDistanceT,
463 std::vector<ftm::FTMTree_MT *> &trees2,
465 std::vector<int> bestCentroidT(trees.size(), -1);
467#ifdef TTK_ENABLE_OPENMP
468#pragma omp parallel for schedule(dynamic) shared(centroids, centroids2) \
469 num_threads(this->threadNumber_) if(parallelize_)
471 for(
unsigned int i = 0; i < trees.size(); ++i) {
472 for(
unsigned int j = 0; j < centroids.size(); ++j) {
473 std::vector<std::tuple<ftm::idNode, ftm::idNode, double>> matching;
474 std::vector<std::tuple<ftm::idNode, ftm::idNode, double>> matching2;
475 dataType distance, distance2;
476 computeOneDistance<dataType>(
478 if(trees2.size() != 0) {
479 computeOneDistance<dataType>(trees2[i], centroids2[j], matching2,
481 distance = mixDistances<dataType>(distance, distance2);
483 if(distance < bestDistanceT[i]) {
484 bestDistanceT[i] = distance;
485 bestDistance_[i] = distance;
486 bestCentroidT[i] = j;
487 bestCentroid_[i] = j;
492 for(
unsigned int i = 0; i < bestCentroidT.size(); ++i)
493 assignmentC.emplace_back(bestCentroidT[i], i);
496 template <
class dataType>
499 std::vector<std::vector<double>> &distanceMatrix,
500 bool useDoubleInput =
false,
501 bool isFirstInput =
true) {
502 std::vector<ftm::FTMTree_MT *> trees(centroids.size());
503 for(
size_t i = 0; i < centroids.size(); ++i) {
504 trees[i] = &(centroids[i].tree);
506 getDistanceMatrix<dataType>(
507 trees, distanceMatrix, useDoubleInput, isFirstInput);
511 std::vector<int> &nodeCorr,
512 std::vector<int> &assignedTreesIndex) {
513 for(
int i : assignedTreesIndex) {
514 std::vector<std::tuple<ftm::idNode, ftm::idNode, double>> newMatching;
515 for(
auto tup : matchingT[i])
516 newMatching.emplace_back(
517 nodeCorr[std::get<0>(tup)], std::get<1>(tup), std::get<2>(tup));
518 matchingT[i] = newMatching;
526 for(
unsigned int i = 0; i < bestCentroid_.size(); ++i)
527 if(bestCentroid_[i] == clusterId
528 and bestCentroid_[i] != oldBestCentroid_[i])
533 template <
class dataType>
536 std::vector<double> &alphas,
537 std::vector<std::tuple<int, int>> &assignmentC) {
538 bool oneCentroidUpdated =
false;
539 int noC = centroids.size();
540 std::vector<std::vector<ftm::FTMTree_MT *>> assignedTrees(noC);
541 std::vector<std::vector<int>> assignedTreesIndex(noC);
542 std::vector<std::vector<double>> assignedAlphas(noC);
544 for(
auto asgn : assignmentC) {
545 assignedTrees[std::get<0>(asgn)].push_back(trees[std::get<1>(asgn)]);
546 assignedTreesIndex[std::get<0>(asgn)].push_back(std::get<1>(asgn));
547 assignedAlphas[std::get<0>(asgn)].push_back(alphas[std::get<1>(asgn)]);
551 std::vector<int> noNewCentroid(centroids.size(), -1);
552 for(
unsigned int i = 0; i < centroids.size(); ++i)
553 if(assignedTrees[i].size() == 0) {
554 noNewCentroid[i] = cpt;
558#ifdef TTK_ENABLE_OPENMP
559#pragma omp parallel num_threads(this->threadNumber_) \
560 shared(centroids) if(parallelize_ and parallelizeUpdate_)
562#pragma omp single nowait
565 for(
unsigned int i = 0; i < centroids.size(); ++i) {
566#ifdef TTK_ENABLE_OPENMP
567#pragma omp task firstprivate(i) shared(centroids)
570 if(assignedTrees[i].size() == 0) {
572 initNewCentroid<dataType>(
573 trees, centroids[i], noNewCentroid[i]);
574 for(
unsigned int t = 0; t < trees.size(); ++t)
575 lowerBound_[t][i] = 0;
576 }
else if(assignedTrees[i].size() == 1) {
578 = ftm::copyMergeTree<dataType>(assignedTrees[i][0],
true);
580 ftm::cleanMergeTree<dataType>(centroids[i]);
584 oneCentroidUpdated =
true;
585 double alphasSum = 0;
586 for(
unsigned int j = 0; j < assignedAlphas[i].size(); ++j)
587 alphasSum += assignedAlphas[i][j];
588 for(
unsigned int j = 0; j < assignedAlphas[i].size(); ++j)
589 assignedAlphas[i][j] /= alphasSum;
591 computeOneBarycenter<dataType>(
592 assignedTrees[i], centroids[i], assignedAlphas[i], matching);
593 std::vector<ftm::idNode> deletedNodesT;
594 persistenceThresholding<dataType>(
595 &(centroids[i].tree), 0, deletedNodesT);
596 ftm::cleanMergeTree<dataType>(centroids[i]);
598#ifdef TTK_ENABLE_OPENMP
602#ifdef TTK_ENABLE_OPENMP
607 return oneCentroidUpdated;
610 template <
class dataType>
612 std::vector<ftm::FTMTree_MT *> &trees,
614 std::vector<double> &alphas,
615 std::vector<std::vector<std::tuple<ftm::idNode, ftm::idNode, double>>>
634 trees, baryMergeTree, alphas, finalMatchings);
642 template <
class dataType>
646 std::vector<double> &alphas,
647 std::vector<int> &clusteringAssignment,
648 std::vector<ftm::FTMTree_MT *> &trees2,
656 int noCentroidsT = centroids.size();
657 bool converged =
false;
658 dataType inertia = -1;
659 dataType minInertia = std::numeric_limits<dataType>::max();
662 std::vector<std::tuple<int, int>> assignmentC;
663 std::vector<dataType> bestDistanceT(
664 trees.size(), std::numeric_limits<dataType>::max());
665 while(not converged) {
669 std::stringstream ssIter;
670 ssIter <<
"Iteration " << noIterationC_;
675 assignmentCentroids<dataType>(
676 trees, centroids, assignmentC, bestDistanceT, trees2, centroids2);
682 bool trees1Updated =
true, trees2Updated =
true;
684 = updateCentroids<dataType>(trees, centroids, alphas, assignmentC);
685 if(trees2.size() != 0)
686 trees2Updated = updateCentroids<dataType>(
687 trees2, centroids2, alphas, assignmentC);
693 dataType currentInertia = 0;
694 for(
auto distance : bestDistanceT)
695 currentInertia += distance * distance;
696 converged = std::abs((
double)(inertia - currentInertia)) < 0.01;
697 inertia = currentInertia;
698 std::stringstream ss3;
699 ss3 <<
"Inertia : " << inertia;
702 minInertia = std::min(minInertia, inertia);
704 cptBlocked += (minInertia < inertia) ? 1 : 0;
705 converged = (cptBlocked >= 10);
710 converged = converged or (not trees1Updated and not trees2Updated);
715 bestDistanceT.clear();
716 bestDistanceT.resize(
717 trees.size(), std::numeric_limits<dataType>::max());
726 finalAssignmentCentroids<dataType>(trees, centroids, matchingsC,
727 assignmentC, bestDistanceT, trees2,
728 centroids2, matchingsC2);
729 for(
auto dist : bestDistanceT)
731 dataType currentInertia = 0;
732 for(
auto distance : bestDistanceT)
733 currentInertia += distance * distance;
734 std::stringstream ss;
735 ss <<
"Inertia : " << currentInertia;
739 std::vector<int> cptCentroid(centroids.size(), 0);
740 for(
auto asgn : assignmentC) {
741 int centroid = std::get<0>(asgn);
742 int tree = std::get<1>(asgn);
744 clusteringAssignment[tree] = centroid;
745 outputMatching[centroid][tree]
746 = matchingsC[centroid][cptCentroid[centroid]];
747 if(trees2.size() != 0)
748 outputMatching2[centroid][tree]
749 = matchingsC2[centroid][cptCentroid[centroid]];
750 ++cptCentroid[centroid];
753 auto clusteringTime = t_clust.
getElapsedTime() - addDeletedNodesTime_;
757 template <
class dataType>
760 std::vector<double> &alphas,
761 std::vector<int> &clusteringAssignment,
770 if(trees2.size() != 0) {
771 trees2NodeCorr_.resize(trees2.size());
772 preprocessingClustering<dataType>(trees2, trees2NodeCorr_,
false);
774 std::vector<ftm::FTMTree_MT *> treesT;
775 ftm::mergeTreeToFTMTree<dataType>(trees, treesT);
776 std::vector<ftm::FTMTree_MT *> treesT2;
777 ftm::mergeTreeToFTMTree<dataType>(trees2, treesT2);
781 std::vector<std::vector<ftm::MergeTree<dataType>>> allCentroids;
782 initCentroids<dataType>(treesT, treesT2, allCentroids);
783 centroids = allCentroids[0];
784 if(trees2.size() != 0)
785 centroids2 = allCentroids[1];
793 initAcceleratedKMeansVectors<dataType>(treesT, centroids, treesT2);
796 computeCentroids<dataType>(treesT, centroids, outputMatching, alphas,
797 clusteringAssignment, treesT2, centroids2,
803 postprocessingClustering<dataType>(
804 trees, centroids, outputMatching, clusteringAssignment);
813 template <
class dataType>
816 std::vector<int> &clusteringAssignment,
821 if(trees2.size() != 0)
822 printMsg(
"Use join and split trees");
824 std::vector<double> alphas;
825 for(
unsigned int i = 0; i < trees.size(); ++i)
826 alphas.push_back(1.0 / trees.size());
828 execute<dataType>(trees, outputMatching, alphas, clusteringAssignment,
829 trees2, outputMatching2, centroids, centroids2);
832 template <
class dataType>
835 std::vector<int> &clusteringAssignment,
837 std::vector<ftm::MergeTree<dataType>> trees2, centroids2;
839 execute<dataType>(trees, outputMatching, clusteringAssignment, trees2,
840 outputMatching2, centroids, centroids2);
846 template <
class dataType>
848 std::vector<std::vector<int>> &nodeCorr,
849 bool useMinMaxPairT =
true) {
850 for(
unsigned int i = 0; i < trees.size(); ++i) {
851 preprocessingPipeline<dataType>(
854 if(trees.size() < 40)
855 printTreeStats(trees[i]);
863 template <
class dataType>
866 for(
unsigned int i = 0; i < centroids.size(); ++i)
867 fixMergedRootOriginBarycenter<dataType>(centroids[i]);
870 template <
class dataType>
873 for(
unsigned int i = 0; i < centroids2.size(); ++i)
877 template <
class dataType>
882 std::vector<int> &clusteringAssignment) {
883 for(
unsigned int i = 0; i < trees.size(); ++i)
884 postprocessingPipeline<dataType>(&(trees[i].tree));
885 for(
unsigned int i = 0; i < centroids.size(); ++i)
886 postprocessingPipeline<dataType>(&(centroids[i].tree));
887 for(
unsigned int c = 0; c < centroids.size(); ++c)
888 for(
unsigned int i = 0; i < trees.size(); ++i)
889 if(clusteringAssignment[i] == (
int)c)
890 convertBranchDecompositionMatching<dataType>(
891 &(centroids[c].tree), &(trees[i].tree), outputMatching[c][i]);
897 template <
class dataType>
901 for(
auto ¢roid : centroids)
903 for(
auto ¢roid : centroids2)
#define ttkNotUsed(x)
Mark function/method parameters that are not used in the function body at all.
#define matchingVectorType
#define treesMatchingVector
virtual int setThreadNumber(const int threadNumber)
Minimalist debugging class.
void setDebugMsgPrefix(const std::string &prefix)
virtual int setDebugLevel(const int &debugLevel)
int printMsg(const std::string &msg, const debug::Priority &priority=debug::Priority::INFO, const debug::LineMode &lineMode=debug::LineMode::NEW, std::ostream &stream=std::cout) const
void limitSizeBarycenter(ftm::MergeTree< dataType > &bary, std::vector< ftm::FTMTree_MT * > &trees, unsigned int barycenterMaximumNumberOfPairs, double percent, bool useBD=true)
double getAddDeletedNodesTime()
void setIsCalled(bool ic)
double barycenterSizeLimitPercent_
void computeBarycenter(std::vector< ftm::FTMTree_MT * > &trees, ftm::MergeTree< dataType > &baryMergeTree, std::vector< double > &alphas, std::vector< std::vector< std::tuple< ftm::idNode, ftm::idNode, double > > > &finalMatchings, bool finalAsgnDoubleInput=false, bool finalAsgnFirstInput=true)
unsigned int barycenterMaximumNumberOfPairs_
void setDeterministic(bool deterministicT)
std::vector< double > finalDistances_
bool progressiveBarycenter_
void printBaryStats(ftm::FTMTree_MT *baryTree, const debug::Priority &priority=debug::Priority::INFO)
void setProgressiveBarycenter(bool progressive)
void setBarycenterMaximumNumberOfPairs(unsigned int maxi)
void setBarycenterSizeLimitPercent(double percent)
void setBranchDecomposition(bool useBD)
void setNormalizedWasserstein(bool normalizedWasserstein)
void setDistanceSquaredRoot(bool distanceSquaredRoot)
double mixtureCoefficient_
void setAssignmentSolver(int assignmentSolver)
bool normalizedWasserstein_
void printTreesStats(std::vector< ftm::FTMTree_MT * > &trees)
void copyMinMaxPair(ftm::MergeTree< dataType > &mTree1, ftm::MergeTree< dataType > &mTree2, bool setOrigins=false)
std::vector< std::vector< int > > treesNodeCorr_
void setKeepSubtree(bool keepSubtree)
bool branchDecomposition_
void mixDistancesMatrix(std::vector< std::vector< dataType > > &distanceMatrix, std::vector< std::vector< dataType > > &distanceMatrix2)
void computeCentroids(std::vector< ftm::FTMTree_MT * > &trees, std::vector< ftm::MergeTree< dataType > > ¢roids, matchingVectorType &outputMatching, std::vector< double > &alphas, std::vector< int > &clusteringAssignment, std::vector< ftm::FTMTree_MT * > &trees2, std::vector< ftm::MergeTree< dataType > > ¢roids2, matchingVectorType &outputMatching2)
void assignmentCentroidsNaive(std::vector< ftm::FTMTree_MT * > &trees, std::vector< ftm::MergeTree< dataType > > ¢roids, std::vector< std::tuple< int, int > > &assignmentC, std::vector< dataType > &bestDistanceT, std::vector< ftm::FTMTree_MT * > &trees2, std::vector< ftm::MergeTree< dataType > > ¢roids2)
void copyCentroids(std::vector< ftm::MergeTree< dataType > > ¢roids, std::vector< ftm::MergeTree< dataType > > &oldCentroids)
void setMixtureCoefficient(double coef)
void postprocessingClustering(std::vector< ftm::MergeTree< dataType > > &trees, std::vector< ftm::MergeTree< dataType > > ¢roids, matchingVectorType &outputMatching, std::vector< int > &clusteringAssignment)
void initAcceleratedKMeans(std::vector< ftm::FTMTree_MT * > &trees, std::vector< ftm::MergeTree< dataType > > ¢roids, std::vector< ftm::FTMTree_MT * > &trees2, std::vector< ftm::MergeTree< dataType > > ¢roids2)
void fixMergedRootOriginClustering(std::vector< ftm::MergeTree< dataType > > ¢roids)
void getCentroidsDistanceMatrix(std::vector< ftm::MergeTree< dataType > > ¢roids, std::vector< std::vector< double > > &distanceMatrix, bool useDoubleInput=false, bool isFirstInput=true)
void initAcceleratedKMeansVectors(std::vector< ftm::FTMTree_MT * > &trees, std::vector< ftm::MergeTree< dataType > > ¢roids, std::vector< ftm::FTMTree_MT * > &ttkNotUsed(trees2))
void printCentroidsStats(std::vector< ftm::MergeTree< dataType > > ¢roids, std::vector< ftm::MergeTree< dataType > > ¢roids2)
void computeOneBarycenter(std::vector< ftm::FTMTree_MT * > &trees, ftm::MergeTree< dataType > &baryMergeTree, std::vector< double > &alphas, std::vector< std::vector< std::tuple< ftm::idNode, ftm::idNode, double > > > &finalMatchings)
void setNoCentroids(unsigned int noCentroidsT)
void preprocessingClustering(std::vector< ftm::MergeTree< dataType > > &trees, std::vector< std::vector< int > > &nodeCorr, bool useMinMaxPairT=true)
void finalAssignmentCentroids(std::vector< ftm::FTMTree_MT * > &trees, std::vector< ftm::MergeTree< dataType > > ¢roids, matchingVectorType &matchingsC, std::vector< std::tuple< int, int > > &assignmentC, std::vector< dataType > &bestDistanceT, std::vector< ftm::FTMTree_MT * > &trees2, std::vector< ftm::MergeTree< dataType > > ¢roids2, matchingVectorType &matchingsC2)
void execute(std::vector< ftm::MergeTree< dataType > > &trees, matchingVectorType &outputMatching, std::vector< double > &alphas, std::vector< int > &clusteringAssignment, std::vector< ftm::MergeTree< dataType > > &trees2, matchingVectorType &outputMatching2, std::vector< ftm::MergeTree< dataType > > ¢roids, std::vector< ftm::MergeTree< dataType > > ¢roids2)
std::vector< std::vector< int > > getTrees2NodeCorr()
void assignmentCentroidsAccelerated(std::vector< ftm::FTMTree_MT * > &trees, std::vector< ftm::MergeTree< dataType > > ¢roids, std::vector< std::tuple< int, int > > &assignmentC, std::vector< dataType > &bestDistanceT, std::vector< ftm::FTMTree_MT * > &trees2, std::vector< ftm::MergeTree< dataType > > ¢roids2)
void execute(std::vector< ftm::MergeTree< dataType > > &trees, matchingVectorType &outputMatching, std::vector< int > &clusteringAssignment, std::vector< ftm::MergeTree< dataType > > ¢roids)
void putBackMinMaxPair(std::vector< ftm::MergeTree< dataType > > ¢roids, std::vector< ftm::MergeTree< dataType > > ¢roids2)
bool samePreviousAssignment(int clusterId)
bool updateCentroids(std::vector< ftm::FTMTree_MT * > &trees, std::vector< ftm::MergeTree< dataType > > ¢roids, std::vector< double > &alphas, std::vector< std::tuple< int, int > > &assignmentC)
void initCentroids(std::vector< ftm::FTMTree_MT * > &trees, std::vector< ftm::FTMTree_MT * > &trees2, std::vector< std::vector< ftm::MergeTree< dataType > > > &allCentroids)
void execute(std::vector< ftm::MergeTree< dataType > > &trees, matchingVectorType &outputMatching, std::vector< int > &clusteringAssignment, std::vector< ftm::MergeTree< dataType > > &trees2, matchingVectorType &outputMatching2, std::vector< ftm::MergeTree< dataType > > ¢roids, std::vector< ftm::MergeTree< dataType > > ¢roids2)
~MergeTreeClustering() override=default
void matchingCorrespondence(treesMatchingVector &matchingT, std::vector< int > &nodeCorr, std::vector< int > &assignedTreesIndex)
void initNewCentroid(std::vector< ftm::FTMTree_MT * > &trees, ftm::MergeTree< dataType > ¢roid, int noNewCentroid)
void assignmentCentroids(std::vector< ftm::FTMTree_MT * > &trees, std::vector< ftm::MergeTree< dataType > > ¢roids, std::vector< std::tuple< int, int > > &assignmentC, std::vector< dataType > &bestDistanceT, std::vector< ftm::FTMTree_MT * > &trees2, std::vector< ftm::MergeTree< dataType > > ¢roids2)