html renderers in discrete

examples/UGM_small.cpp

@@ -50,7 +50,8 @@ int main(int argc, char** argv) {
 
   // Print the UGM distribution
   cout << "\nUGM distribution:" << endl;
-  auto allPosbValues = cartesianProduct(Cathy & Heather & Mark & Allison);
+  auto allPosbValues =
+      DiscreteValues::CartesianProduct(Cathy & Heather & Mark & Allison);
   for (size_t i = 0; i < allPosbValues.size(); ++i) {
     DiscreteFactor::Values values = allPosbValues[i];
     double prodPot = graph(values);

gtsam/discrete/Assignment.h

@@ -19,32 +19,30 @@
 #pragma once
 
 #include <iostream>
-#include <vector>
 #include <map>
-
+#include <utility>
+#include <vector>
 
 namespace gtsam {
 
-  /**
-   * An assignment from labels to value index (size_t).
-   * Assigns to each label a value. Implemented as a simple map.
-   * A discrete factor takes an Assignment and returns a value.
-   */
-  template<class L>
-  class Assignment: public std::map<L, size_t> {
-  public:
-    void print(const std::string& s = "Assignment: ") const {
-      std::cout << s << ": ";
-      for(const typename Assignment::value_type& keyValue: *this)
-        std::cout << "(" << keyValue.first << ", " << keyValue.second << ")";
-      std::cout << std::endl;
-    }
-
-    bool equals(const Assignment& other, double tol = 1e-9) const {
-      return (*this == other);
-    }
-  };  //Assignment
+/**
+ * An assignment from labels to value index (size_t).
+ * Assigns to each label a value. Implemented as a simple map.
+ * A discrete factor takes an Assignment and returns a value.
+ */
+template <class L>
+class Assignment : public std::map<L, size_t> {
+ public:
+  void print(const std::string& s = "Assignment: ") const {
+    std::cout << s << ": ";
+    for (const typename Assignment::value_type& keyValue : *this)
+      std::cout << "(" << keyValue.first << ", " << keyValue.second << ")";
+    std::cout << std::endl;
+  }
 
+  bool equals(const Assignment& other, double tol = 1e-9) const {
+    return (*this == other);
+  }
 
   /**
    * @brief Get Cartesian product consisting all possible configurations
@@ -58,29 +56,28 @@ namespace gtsam {
    * variables with each having cardinalities 4, we get 4096 possible
    * configurations!!
    */
-  template<typename L>
-  std::vector<Assignment<L> > cartesianProduct(
-      const std::vector<std::pair<L, size_t> >& keys) {
-    std::vector<Assignment<L> > allPossValues;
-    Assignment<L> values;
+  template <typename Derived = Assignment<L>>
+  static std::vector<Derived> CartesianProduct(
+      const std::vector<std::pair<L, size_t>>& keys) {
+    std::vector<Derived> allPossValues;
+    Derived values;
     typedef std::pair<L, size_t> DiscreteKey;
-    for(const DiscreteKey& key: keys)
-      values[key.first] = 0;  //Initialize from 0
+    for (const DiscreteKey& key : keys)
+      values[key.first] = 0;  // Initialize from 0
     while (1) {
       allPossValues.push_back(values);
       size_t j = 0;
       for (j = 0; j < keys.size(); j++) {
         L idx = keys[j].first;
         values[idx]++;
-        if (values[idx] < keys[j].second)
-          break;
-        //Wrap condition
+        if (values[idx] < keys[j].second) break;
+        // Wrap condition
         values[idx] = 0;
       }
-      if (j == keys.size())
-        break;
+      if (j == keys.size()) break;
     }
     return allPossValues;
   }
+};  // Assignment
 
-} // namespace gtsam
+}  // namespace gtsam

gtsam/discrete/DecisionTreeFactor.cpp

@@ -22,6 +22,7 @@
 #include <gtsam/base/FastSet.h>
 
 #include <boost/make_shared.hpp>
+#include <utility>
 
 using namespace std;
 
@@ -150,9 +151,9 @@ namespace gtsam {
     for (auto& key : keys()) {
       pairs.emplace_back(key, cardinalities_.at(key));
     }
-    // Reverse to make cartesianProduct output a more natural ordering.
+    // Reverse to make cartesian product output a more natural ordering.
     std::vector<std::pair<Key, size_t>> rpairs(pairs.rbegin(), pairs.rend());
-    const auto assignments = cartesianProduct(rpairs);
+    const auto assignments = DiscreteValues::CartesianProduct(rpairs);
 
     // Construct unordered_map with values
     std::vector<std::pair<DiscreteValues, double>> result;
@@ -187,12 +188,13 @@ namespace gtsam {
     return ADT::dot(keyFormatter, valueFormatter, showZero);
   }
 
+    // Print out header.
   /* ************************************************************************* */
   string DecisionTreeFactor::markdown(const KeyFormatter& keyFormatter,
                                       const Names& names) const {
     stringstream ss;
 
-    // Print out header and construct argument for `cartesianProduct`.
+    // Print out header.
     ss << "|";
     for (auto& key : keys()) {
       ss << keyFormatter(key) << "|";
@@ -211,18 +213,54 @@ namespace gtsam {
       auto assignment = kv.first;
       for (auto& key : keys()) {
         size_t index = assignment.at(key);
-        ss << Translate(names, key, index) << "|";
+        ss << DiscreteValues::Translate(names, key, index) << "|";
       }
       ss << kv.second << "|\n";
     }
     return ss.str();
   }
 
+  /* ************************************************************************ */
+  string DecisionTreeFactor::html(const KeyFormatter& keyFormatter,
+                                  const Names& names) const {
+    stringstream ss;
+
+    // Print out preamble.
+    ss << "<div>\n<table class='DecisionTreeFactor'>\n  <thead>\n";
+
+    // Print out header row.
+    ss << "    <tr>";
+    for (auto& key : keys()) {
+      ss << "<th>" << keyFormatter(key) << "</th>";
+    }
+    ss << "<th>value</th></tr>\n";
+
+    // Finish header and start body.
+    ss << "  </thead>\n  <tbody>\n";
+
+    // Print out all rows.
+    auto rows = enumerate();
+    for (const auto& kv : rows) {
+      ss << "    <tr>";
+      auto assignment = kv.first;
+      for (auto& key : keys()) {
+        size_t index = assignment.at(key);
+        ss << "<th>" << DiscreteValues::Translate(names, key, index) << "</th>";
+      }
+      ss << "<td>" << kv.second << "</td>";  // value
+      ss << "</tr>\n";
+    }
+    ss << "  </tbody>\n</table>\n</div>";
+    return ss.str();
+  }
+
+  /* ************************************************************************* */
   DecisionTreeFactor::DecisionTreeFactor(const DiscreteKeys &keys, const vector<double> &table) :
           DiscreteFactor(keys.indices()), AlgebraicDecisionTree<Key>(keys, table),
           cardinalities_(keys.cardinalities()) {
   }
 
+  /* ************************************************************************* */
   DecisionTreeFactor::DecisionTreeFactor(const DiscreteKeys &keys, const string &table) :
           DiscreteFactor(keys.indices()), AlgebraicDecisionTree<Key>(keys, table),
           cardinalities_(keys.cardinalities()) {

gtsam/discrete/DecisionTreeFactor.h

@@ -211,6 +211,16 @@ namespace gtsam {
     std::string markdown(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
                          const Names& names = {}) const override;
 
+    /**
+     * @brief Render as html table
+     *
+     * @param keyFormatter GTSAM-style Key formatter.
+     * @param names optional, category names corresponding to choices.
+     * @return std::string a html string.
+     */
+    std::string html(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
+                     const Names& names = {}) const override;
+
     /// @}
 
 };

gtsam/discrete/DiscreteBayesNet.cpp

@@ -61,16 +61,29 @@ namespace gtsam {
     return result;
   }
 
-  /* ************************************************************************* */
+  /* *********************************************************************** */
   std::string DiscreteBayesNet::markdown(
       const KeyFormatter& keyFormatter,
       const DiscreteFactor::Names& names) const {
     using std::endl;
     std::stringstream ss;
     ss << "`DiscreteBayesNet` of size " << size() << endl << endl;
-    for(const DiscreteConditional::shared_ptr& conditional: *this)
+    for (const DiscreteConditional::shared_ptr& conditional : *this)
       ss << conditional->markdown(keyFormatter, names) << endl;
     return ss.str();
   }
+
+  /* *********************************************************************** */
+  std::string DiscreteBayesNet::html(
+      const KeyFormatter& keyFormatter,
+      const DiscreteFactor::Names& names) const {
+    using std::endl;
+    std::stringstream ss;
+    ss << "<div><p><tt>DiscreteBayesNet</tt> of size " << size() << "</p>";
+    for (const DiscreteConditional::shared_ptr& conditional : *this)
+      ss << conditional->html(keyFormatter, names) << endl;
+    return ss.str();
+  }
+
 /* ************************************************************************* */
 } // namespace

gtsam/discrete/DiscreteBayesNet.h

@@ -18,13 +18,16 @@
 
 #pragma once
 
-#include <vector>
-#include <map>
-#include <boost/shared_ptr.hpp>
+#include <gtsam/discrete/DiscreteConditional.h>
+#include <gtsam/discrete/DiscretePrior.h>
 #include <gtsam/inference/BayesNet.h>
 #include <gtsam/inference/FactorGraph.h>
-#include <gtsam/discrete/DiscretePrior.h>
-#include <gtsam/discrete/DiscreteConditional.h>
+
+#include <boost/shared_ptr.hpp>
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
 
 namespace gtsam {
 
@@ -107,13 +110,17 @@ namespace gtsam {
     /// @name Wrapper support
     /// @{
 
-    /// Render as markdown table.
+    /// Render as markdown tables.
     std::string markdown(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
                          const DiscreteFactor::Names& names = {}) const;
 
+    /// Render as html tables.
+    std::string html(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
+                     const DiscreteFactor::Names& names = {}) const;
+
     /// @}
 
-  private:
+ private:
     /** Serialization function */
     friend class boost::serialization::access;
     template<class ARCHIVE>

gtsam/discrete/DiscreteBayesTree.cpp

@@ -72,5 +72,23 @@ namespace gtsam {
     return ss.str();
   }
 
+  /* **************************************************************************/
+  std::string DiscreteBayesTree::html(
+      const KeyFormatter& keyFormatter,
+      const DiscreteFactor::Names& names) const {
+    using std::endl;
+    std::stringstream ss;
+    ss << "<div><p><tt>DiscreteBayesTree</tt> of size " << nodes_.size()
+       << "</p>";
+    auto visitor = [&](const DiscreteBayesTreeClique::shared_ptr& clique,
+                       size_t& indent) {
+      ss << clique->conditional()->html(keyFormatter, names);
+      return indent + 1;
+    };
+    size_t indent;
+    treeTraversal::DepthFirstForest(*this, indent, visitor);
+    return ss.str();
+  }
+
   /* **************************************************************************/
   }  // namespace gtsam

gtsam/discrete/DiscreteBayesTree.h

@@ -92,10 +92,14 @@ class GTSAM_EXPORT DiscreteBayesTree
   /// @name Wrapper support
   /// @{
 
-  /// Render as markdown table.
+  /// Render as markdown tables.
   std::string markdown(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
                        const DiscreteFactor::Names& names = {}) const;
 
+  /// Render as html tables.
+  std::string html(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
+                   const DiscreteFactor::Names& names = {}) const;
+
   /// @}
 };