Closes #52 | fix stacked dialogs and cancel wiring in KK layout and matrix functions [ci]

- graphMatrixDistanceGeodesicCreate: remove progressUpdate from matrix-fill
  phase — DistanceEngine dialog is already destroyed on return from
  graphDistancesGeodesic(); matrix fill is O(N²) and needs no dialog
- layoutForceDirectedKamadaKawai: guard graphMatrixDistanceGeodesicCreate
  return value; use graphDiameterCached() instead of re-triggering
  graphDiameter(); guard D==0 to prevent division by zero
- writeMatrix: add MATRIX_DISTANCES_CHEBYSHEV to compute-phase switch;
  add progressFinish() before return true; fix default cases to return false
- writeClusteringHierarchical: remove spurious progressFinish() from
  graphClusteringHierarchical failure path; fix default switch case

Author: oxy86

src/graph.h

@@ -971,9 +971,9 @@ public slots:
     void addToDistanceSum(qreal delta);
     void incGeodesicsCount();
     void setAverageDistanceCached(qreal v);
-
-    void graphMatrixDistanceGeodesicCreate(const bool &considerWeights = false,
-                                           const bool &inverseWeights = true,
+    
+    bool graphMatrixDistanceGeodesicCreate(const bool &considerWeights = false,
+                                           const bool &inverseWeights = false,
                                            const bool &dropIsolates = false);
 
     void graphMatrixShortestPathsCreate(const bool &considerWeights = false,

src/graph/distances/graph_distance_cache.cpp

@@ -124,28 +124,40 @@ void Graph::graphMatrixShortestPathsCreate(const bool &considerWeights,
 }
 
 /**
- * @brief Creates the matrix DM of geodesic distances between vertices
- * @param considerWeights
- * @param inverseWeights
- * @param dropIsolates
+ * @brief Creates the matrix DM of geodesic distances between vertices.
+ *
+ * Phase 1: calls graphDistancesGeodesic() which runs the DistanceEngine.
+ * The engine owns its own progress dialog — it creates it, updates it,
+ * and destroys it before returning. The dialog stack is empty on return.
+ *
+ * Phase 2: fills the DM matrix from the cached per-vertex distances.
+ * This is an O(N²) memory-write pass — fast enough to need no progress
+ * dialog of its own. No progressUpdate or progressFinish is called here;
+ * the caller owns the dialog lifecycle for any subsequent phase.
+ *
+ * @param considerWeights If true, edge weights are used in distance computations.
+ * @param inverseWeights  If true, edge weights are inverted before use.
+ * @param dropIsolates    If true, isolate nodes are excluded from the analysis.
+ * @return true on success, false if the computation was cancelled.
  */
-void Graph::graphMatrixDistanceGeodesicCreate(const bool &considerWeights,
+bool Graph::graphMatrixDistanceGeodesicCreate(const bool &considerWeights,
                                               const bool &inverseWeights,
                                               const bool &dropIsolates)
 {
     qDebug() << "Graph::graphMatrixDistanceGeodesicCreate()";
 
+    // Phase 1: compute all geodesic distances via DistanceEngine.
+    // The engine owns its own progress dialog for this phase.
     graphDistancesGeodesic(false, considerWeights, inverseWeights, dropIsolates);
 
     if (progressCanceled())
     {
         calculatedDistances = false;
-        return;
+        return false;
     }
 
     VList::const_iterator it, jt;
     int N = vertices(dropIsolates, false, true);
-    int progressCounter = 0;
     int source = 0, target = 0;
     int i = 0, j = 0;
 
@@ -155,76 +167,49 @@ void Graph::graphMatrixDistanceGeodesicCreate(const bool &considerWeights,
 
     DM.resize(N, N);
 
-    QString pMsg = tr("Creating geodesic distances matrix. \nPlease wait ");
-    progressStatus(pMsg);
-    progressCreate(N, pMsg);
-
-    qDebug() << "Graph: graphMatrixDistanceGeodesicCreate() - Writing distances matrix...";
+    // Phase 2: fill DM from cached per-vertex distances.
+    // No progressUpdate here — the DistanceEngine dialog is already destroyed
+    // by this point. The matrix-fill is O(N²) memory writes and needs no
+    // progress reporting of its own.
+    progressStatus(tr("Creating geodesic distances matrix. \nPlease wait "));
 
     for (it = m_graph.cbegin(); it != m_graph.cend(); ++it)
     {
 
-        progressUpdate(++progressCounter);
-        if (progressCanceled())
-        {
-            calculatedDistances = false;
-            progressFinish();
-            return;
-        }
-
         source = (*it)->number();
 
-        if ((*it)->isIsolated() && dropIsolates)
-        {
-            qDebug() << "Graph: graphMatrixDistanceGeodesicCreate() - "
-                     << source << "isolated. SKIP";
-
+        if ((*it)->isIsolated() && dropIsolates) {
             continue;
         }
-
-        if (!(*it)->isEnabled())
-        {
-            qDebug() << "Graph: graphMatrixDistanceGeodesicCreate() - "
-                     << source << "disabled. SKIP";
+        if (!(*it)->isEnabled()) {
             continue;
         }
 
-        qDebug() << "Graph: graphMatrixDistanceGeodesicCreate() - source"
-                 << source << "i" << i;
-
         for (jt = m_graph.cbegin(); jt != m_graph.cend(); ++jt)
         {
-
             target = (*jt)->number();
 
-            if ((*jt)->isIsolated() && dropIsolates)
-            {
-                qDebug() << "Graph: graphMatrixDistanceGeodesicCreate() - "
-                         << target << "isolated. SKIP";
+            if ((*jt)->isIsolated() && dropIsolates) {
                 continue;
             }
-
-            if (!(*jt)->isEnabled())
-            {
-                qDebug() << "Graph: graphMatrixDistanceGeodesicCreate() - "
-                         << target << "disabled. SKIP";
+            if (!(*jt)->isEnabled()) {
                 continue;
             }
 
-            qDebug() << "Graph: graphMatrixDistanceGeodesicCreate() - "
-                     << "target" << target << "j" << j;
+            // qDebug() << "Graph: graphMatrixDistanceGeodesicCreate() - "
+            //          << "target" << target << "j" << j;
+            // qDebug() << "Graph: graphMatrixDistanceGeodesicCreate() - setting DM ("
+            //          << i << "," << j << ") =" << (*it)->distance(target);
 
-            qDebug() << "Graph: graphMatrixDistanceGeodesicCreate() -  setting DM ("
-                     << i << "," << j << ") =" << (*it)->distance(target);
             DM.setItem(i, j, (*it)->distance(target));
-
             j++;
         }
         j = 0;
         i++;
     }
 
-    progressFinish();
+    // No progressFinish() here — the caller owns the outer dialog lifecycle.
+    return true;
 }
 
 /**

src/graph/layouts/graph_layouts_force.cpp

@@ -322,7 +322,6 @@ void Graph::layoutForceDirectedFruchtermanReingold(const int maxIterations)
  * distances and real ones for all pairs of particles
  * Initially, the particles/actors are placed on the vertices of a regular n-polygon
  */
-
 void Graph::layoutForceDirectedKamadaKawai(const int maxIterations,
                                            const bool considerWeights,
                                            const bool inverseWeights,
@@ -378,31 +377,42 @@ void Graph::layoutForceDirectedKamadaKawai(const int maxIterations,
 
     qDebug() << "Compute dij, where (i,j) in E";
 
-    graphMatrixDistanceGeodesicCreate(considerWeights, inverseWeights, dropIsolates);
+    if (!graphMatrixDistanceGeodesicCreate(considerWeights, inverseWeights, dropIsolates))
+    {
+        return;
+    }
 
     if (progressCanceled())
     {
         return;
     }
+
     // processEvents() ensures the geodesic progress dialog updates are
     // flushed before we start the KK iteration phase.
     QApplication::processEvents();
 
-    // Compute original spring length
-    // lij for 1 <= i!=j <= n using the formula:
-    // lij = L x dij
-    // where L the desirable length of a single edge in the display pane
-    // Since we are on a restricted display (a canvas), L depends on the
-    // diameter D of the graph and the length L of a side of the display square:
-    // L = L0 / D
+    // Use the cached diameter — graphMatrixDistanceGeodesicCreate() already
+    // ran the DistanceEngine so re-calling graphDiameter() would redundantly
+    // re-trigger it if the cache were ever invalidated.
+    D = graphDiameterCached();
+    L0 = canvasMinDimension() - 100;
 
-    qDebug() << "Compute lij = L x dij. lij will be symmmetric.";
+    // Guard against degenerate graphs (no edges, all isolates, single node)
+    // where D == 0, which would cause division by zero.
+    if (D <= 0)
+    {
+        qDebug() << "KK layout: graph diameter is 0 (degenerate graph). Aborting.";
+        progressFinish();
+        setModStatus(ModStatus::VertexPositions);
+        return;
+    }
 
-    D = graphDiameter(considerWeights, inverseWeights);
-    L0 = canvasMinDimension() - 100;
+    // L = L0 / D: the desirable length of a single edge in the display pane
+    // scales with the graph diameter so the layout fills the canvas.
     L = L0 / D;
 
-    qDebug() << "L=" << L0 << "/" << D << "=" << L;
+    qDebug() << "Compute lij = L x dij. lij will be symmetric."
+             << "L0=" << L0 << "D=" << D << "L=" << L;
 
     l.zeroMatrix(DM.rows(), DM.cols());
     l = DM;

src/graph/reporting/graph_reports.cpp

@@ -4450,14 +4450,24 @@ bool Graph::writeCliqueCensus(const QString &fileName,
 }
 
 /**
- * @brief Writes Hierarchical Clustering Analysis to a given file
- * @param fileName
- * @param matrix
- * @param similarityMeasure
- * @param method
- * @param considerWeights
- * @param inverseWeights
- * @param dropIsolates
+ * @brief Performs Hierarchical Cluster Analysis (HCA) and writes the results to an HTML report file.
+ *
+ * The analysis proceeds in three phases:
+ * 1. Build the structural equivalence matrix (adjacency or geodesic distances).
+ * 2. Run the hierarchical clustering algorithm on the equivalence matrix.
+ * 3. Write the HTML report including the equivalence matrix and dendrogram.
+ *
+ * @param fileName        Path to the output HTML report file.
+ * @param varLocation     Whether variables are in rows or columns ("rows"/"cols").
+ * @param matrix          Input matrix type: "adjacency" or "distances".
+ * @param metric          Distance/dissimilarity metric (e.g., "euclidean", "manhattan").
+ * @param method          Clustering linkage method (e.g., "single", "complete", "average").
+ * @param diagonal        If true, include the diagonal of the matrix in computations.
+ * @param dendrogram      If true, include dendrogram output in the report.
+ * @param considerWeights If true, edge weights are used in distance computations.
+ * @param inverseWeights  If true, edge weights are inverted before use.
+ * @param dropIsolates    If true, isolate nodes are excluded from the analysis.
+ * @return true on success, false if the computation was cancelled or an error occurred.
  */
 bool Graph::writeClusteringHierarchical(const QString &fileName,
                                         const QString &varLocation,
@@ -4510,8 +4520,7 @@ bool Graph::writeClusteringHierarchical(const QString &fileName,
         STR_EQUIV = AM;
         break;
     case MATRIX_DISTANCES:
-        graphMatrixDistanceGeodesicCreate(considerWeights, inverseWeights, dropIsolates);
-        if (progressCanceled())
+        if (!graphMatrixDistanceGeodesicCreate(considerWeights, inverseWeights, dropIsolates))
         {
             file.close();
             progressStatus(tr("Computation canceled."));
@@ -4520,7 +4529,9 @@ bool Graph::writeClusteringHierarchical(const QString &fileName,
         STR_EQUIV = DM;
         break;
     default:
-        break;
+        file.close();
+        progressStatus(tr("Error: unsupported matrix type."));
+        return false;
     }
 
     if (!graphClusteringHierarchical(STR_EQUIV,
@@ -4534,8 +4545,8 @@ bool Graph::writeClusteringHierarchical(const QString &fileName,
                                      dropIsolates))
     {
         qDebug() << "Graph::writeClusteringHierarchical() - HCA failed. Returning...";
+        file.close();
         progressStatus("Error completing HCA analysis");
-        progressFinish();
         return false;
     }
 
@@ -5691,9 +5702,25 @@ void Graph::writeDataSetToFile(const QString dir, const QString fileName)
     }
 }
 
+
 /**
-    Writes the specified matrix of social network to file fn
-*/
+ * @brief Computes and writes the specified matrix of the social network to an HTML report file.
+ *
+ * Supported matrix types: adjacency, laplacian, degree, geodesic distances,
+ * shortest paths (geodesics), inverse adjacency, reachability, transpose,
+ * cocitation, and tie-profile distance matrices (Euclidean, Hamming, Jaccard,
+ * Manhattan, Chebyshev).
+ *
+ * @param fn              Path to the output HTML report file.
+ * @param matrix          Matrix type constant (e.g., MATRIX_ADJACENCY, MATRIX_DISTANCES).
+ * @param considerWeights If true, edge weights are used in distance computations.
+ * @param inverseWeights  If true, edge weights are inverted before use.
+ * @param dropIsolates    If true, isolate nodes are excluded from the analysis.
+ * @param varLocation     Whether variables are in rows or columns ("rows"/"cols"),
+ *                        used for tie-profile distance matrices.
+ * @param simpler         Reserved for future use.
+ * @return true on success, false if the computation was cancelled or an error occurred.
+ */
 bool Graph::writeMatrix(const QString &fn,
                         const int &matrix,
                         const bool &considerWeights,
@@ -5756,8 +5783,7 @@ bool Graph::writeMatrix(const QString &fn,
         progressStatus(tr("Adjacency recomputed. Writing Degree Matrix..."));
         break;
     case MATRIX_DISTANCES:
-        graphMatrixDistanceGeodesicCreate(considerWeights, inverseWeights, dropIsolates);
-        if (progressCanceled())
+        if (!graphMatrixDistanceGeodesicCreate(considerWeights, inverseWeights, dropIsolates))
         {
             file.close();
             progressStatus(tr("Computation canceled."));
@@ -5823,6 +5849,7 @@ bool Graph::writeMatrix(const QString &fn,
     case MATRIX_DISTANCES_JACCARD:
     case MATRIX_DISTANCES_MANHATTAN:
     case MATRIX_DISTANCES_EUCLIDEAN:
+    case MATRIX_DISTANCES_CHEBYSHEV:
         progressStatus(tr("Need to recompute tie profile distances. Please wait..."));
         createMatrixAdjacency();
         if (progressCanceled())
@@ -5835,7 +5862,9 @@ bool Graph::writeMatrix(const QString &fn,
         break;
 
     default:
-        break;
+        file.close();
+        progressStatus(tr("Error: unsupported matrix type."));
+        return false;
     }
 
     QTextStream outText(&file);
@@ -6090,6 +6119,7 @@ bool Graph::writeMatrix(const QString &fn,
     outText << htmlEnd;
 
     file.close();
+    progressFinish();
     return true;
 }