12345qiupeng
/
gtsam
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

undo test change

release/4.3a0
Varun Agrawal 2024-10-09 12:04:04 -04:00
parent e87d1fb1de
commit 99a39e6568
1 changed files with 91 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

180
gtsam/hybrid/tests/testSerializationHybrid.cpp
View File

@ -39,112 +39,114 @@ using symbol_shorthand::Z;
using namespace serializationTestHelpers; using namespace serializationTestHelpers;
// BOOST_CLASS_EXPORT_GUID(Factor, "gtsam_Factor"); BOOST_CLASS_EXPORT_GUID(Factor, "gtsam_Factor");
// BOOST_CLASS_EXPORT_GUID(HybridFactor, "gtsam_HybridFactor"); BOOST_CLASS_EXPORT_GUID(HybridFactor, "gtsam_HybridFactor");
// BOOST_CLASS_EXPORT_GUID(JacobianFactor, "gtsam_JacobianFactor"); BOOST_CLASS_EXPORT_GUID(JacobianFactor, "gtsam_JacobianFactor");
// BOOST_CLASS_EXPORT_GUID(GaussianConditional, "gtsam_GaussianConditional"); BOOST_CLASS_EXPORT_GUID(GaussianConditional, "gtsam_GaussianConditional");
// BOOST_CLASS_EXPORT_GUID(DiscreteConditional, "gtsam_DiscreteConditional"); BOOST_CLASS_EXPORT_GUID(DiscreteConditional, "gtsam_DiscreteConditional");
// BOOST_CLASS_EXPORT_GUID(DecisionTreeFactor, "gtsam_DecisionTreeFactor"); BOOST_CLASS_EXPORT_GUID(DecisionTreeFactor, "gtsam_DecisionTreeFactor");
// using ADT = AlgebraicDecisionTree<Key>; using ADT = AlgebraicDecisionTree<Key>;
// BOOST_CLASS_EXPORT_GUID(ADT, "gtsam_AlgebraicDecisionTree"); BOOST_CLASS_EXPORT_GUID(ADT, "gtsam_AlgebraicDecisionTree");
// BOOST_CLASS_EXPORT_GUID(ADT::Leaf, "gtsam_AlgebraicDecisionTree_Leaf"); BOOST_CLASS_EXPORT_GUID(ADT::Leaf, "gtsam_AlgebraicDecisionTree_Leaf");
// BOOST_CLASS_EXPORT_GUID(ADT::Choice, "gtsam_AlgebraicDecisionTree_Choice") BOOST_CLASS_EXPORT_GUID(ADT::Choice, "gtsam_AlgebraicDecisionTree_Choice")
// BOOST_CLASS_EXPORT_GUID(HybridGaussianFactor, "gtsam_HybridGaussianFactor"); BOOST_CLASS_EXPORT_GUID(HybridGaussianFactor, "gtsam_HybridGaussianFactor");
// BOOST_CLASS_EXPORT_GUID(HybridGaussianFactor::FactorValuePairs, BOOST_CLASS_EXPORT_GUID(HybridGaussianFactor::FactorValuePairs,
// "gtsam_HybridGaussianFactor_Factors"); "gtsam_HybridGaussianFactor_Factors");
// BOOST_CLASS_EXPORT_GUID(HybridGaussianFactor::FactorValuePairs::Leaf, BOOST_CLASS_EXPORT_GUID(HybridGaussianFactor::FactorValuePairs::Leaf,
// "gtsam_HybridGaussianFactor_Factors_Leaf"); "gtsam_HybridGaussianFactor_Factors_Leaf");
// BOOST_CLASS_EXPORT_GUID(HybridGaussianFactor::FactorValuePairs::Choice, BOOST_CLASS_EXPORT_GUID(HybridGaussianFactor::FactorValuePairs::Choice,
// "gtsam_HybridGaussianFactor_Factors_Choice"); "gtsam_HybridGaussianFactor_Factors_Choice");
// BOOST_CLASS_EXPORT_GUID(GaussianFactorGraphValuePair, BOOST_CLASS_EXPORT_GUID(GaussianFactorGraphValuePair,
// "gtsam_GaussianFactorGraphValuePair"); "gtsam_GaussianFactorGraphValuePair");
BOOST_CLASS_EXPORT_GUID(HybridGaussianProductFactor,
"gtsam_HybridGaussianProductFactor");
// BOOST_CLASS_EXPORT_GUID(HybridGaussianConditional, BOOST_CLASS_EXPORT_GUID(HybridGaussianConditional,
// "gtsam_HybridGaussianConditional"); "gtsam_HybridGaussianConditional");
// BOOST_CLASS_EXPORT_GUID(HybridGaussianConditional::Conditionals, BOOST_CLASS_EXPORT_GUID(HybridGaussianConditional::Conditionals,
// "gtsam_HybridGaussianConditional_Conditionals"); "gtsam_HybridGaussianConditional_Conditionals");
// BOOST_CLASS_EXPORT_GUID(HybridGaussianConditional::Conditionals::Leaf, BOOST_CLASS_EXPORT_GUID(HybridGaussianConditional::Conditionals::Leaf,
// "gtsam_HybridGaussianConditional_Conditionals_Leaf"); "gtsam_HybridGaussianConditional_Conditionals_Leaf");
// BOOST_CLASS_EXPORT_GUID(HybridGaussianConditional::Conditionals::Choice, BOOST_CLASS_EXPORT_GUID(HybridGaussianConditional::Conditionals::Choice,
// "gtsam_HybridGaussianConditional_Conditionals_Choice"); "gtsam_HybridGaussianConditional_Conditionals_Choice");
// // Needed since GaussianConditional::FromMeanAndStddev uses it // Needed since GaussianConditional::FromMeanAndStddev uses it
// BOOST_CLASS_EXPORT_GUID(noiseModel::Isotropic, "gtsam_noiseModel_Isotropic"); BOOST_CLASS_EXPORT_GUID(noiseModel::Isotropic, "gtsam_noiseModel_Isotropic");
// BOOST_CLASS_EXPORT_GUID(HybridBayesNet, "gtsam_HybridBayesNet"); BOOST_CLASS_EXPORT_GUID(HybridBayesNet, "gtsam_HybridBayesNet");
// /* ****************************************************************************/ /* ****************************************************************************/
// // Test HybridGaussianFactor serialization. // Test HybridGaussianFactor serialization.
// TEST(HybridSerialization, HybridGaussianFactor) { TEST(HybridSerialization, HybridGaussianFactor) {
// DiscreteKey discreteKey{M(0), 2}; DiscreteKey discreteKey{M(0), 2};
// auto A = Matrix::Zero(2, 1); auto A = Matrix::Zero(2, 1);
// auto b0 = Matrix::Zero(2, 1); auto b0 = Matrix::Zero(2, 1);
// auto b1 = Matrix::Ones(2, 1); auto b1 = Matrix::Ones(2, 1);
// auto f0 = std::make_shared<JacobianFactor>(X(0), A, b0); auto f0 = std::make_shared<JacobianFactor>(X(0), A, b0);
// auto f1 = std::make_shared<JacobianFactor>(X(0), A, b1); auto f1 = std::make_shared<JacobianFactor>(X(0), A, b1);
// std::vector<GaussianFactor::shared_ptr> factors{f0, f1}; std::vector<GaussianFactor::shared_ptr> factors{f0, f1};
// const HybridGaussianFactor factor(discreteKey, factors); const HybridGaussianFactor factor(discreteKey, factors);
// EXPECT(equalsObj<HybridGaussianFactor>(factor)); EXPECT(equalsObj<HybridGaussianFactor>(factor));
// EXPECT(equalsXML<HybridGaussianFactor>(factor)); EXPECT(equalsXML<HybridGaussianFactor>(factor));
// EXPECT(equalsBinary<HybridGaussianFactor>(factor)); EXPECT(equalsBinary<HybridGaussianFactor>(factor));
// } }
// /* ****************************************************************************/ /* ****************************************************************************/
// // Test HybridConditional serialization. // Test HybridConditional serialization.
// TEST(HybridSerialization, HybridConditional) { TEST(HybridSerialization, HybridConditional) {
// const DiscreteKey mode(M(0), 2); const DiscreteKey mode(M(0), 2);
// Matrix1 I = Matrix1::Identity(); Matrix1 I = Matrix1::Identity();
// const auto conditional = std::make_shared<GaussianConditional>( const auto conditional = std::make_shared<GaussianConditional>(
// GaussianConditional::FromMeanAndStddev(Z(0), I, X(0), Vector1(0), 0.5)); GaussianConditional::FromMeanAndStddev(Z(0), I, X(0), Vector1(0), 0.5));
// const HybridConditional hc(conditional); const HybridConditional hc(conditional);
// EXPECT(equalsObj<HybridConditional>(hc)); EXPECT(equalsObj<HybridConditional>(hc));
// EXPECT(equalsXML<HybridConditional>(hc)); EXPECT(equalsXML<HybridConditional>(hc));
// EXPECT(equalsBinary<HybridConditional>(hc)); EXPECT(equalsBinary<HybridConditional>(hc));
// } }
// /* ****************************************************************************/ /* ****************************************************************************/
// // Test HybridGaussianConditional serialization. // Test HybridGaussianConditional serialization.
// TEST(HybridSerialization, HybridGaussianConditional) { TEST(HybridSerialization, HybridGaussianConditional) {
// const DiscreteKey mode(M(0), 2); const DiscreteKey mode(M(0), 2);
// Matrix1 I = Matrix1::Identity(); Matrix1 I = Matrix1::Identity();
// const auto conditional0 = std::make_shared<GaussianConditional>( const auto conditional0 = std::make_shared<GaussianConditional>(
// GaussianConditional::FromMeanAndStddev(Z(0), I, X(0), Vector1(0), 0.5)); GaussianConditional::FromMeanAndStddev(Z(0), I, X(0), Vector1(0), 0.5));
// const auto conditional1 = std::make_shared<GaussianConditional>( const auto conditional1 = std::make_shared<GaussianConditional>(
// GaussianConditional::FromMeanAndStddev(Z(0), I, X(0), Vector1(0), 3)); GaussianConditional::FromMeanAndStddev(Z(0), I, X(0), Vector1(0), 3));
// const HybridGaussianConditional gm(mode, {conditional0, conditional1}); const HybridGaussianConditional gm(mode, {conditional0, conditional1});
// EXPECT(equalsObj<HybridGaussianConditional>(gm)); EXPECT(equalsObj<HybridGaussianConditional>(gm));
// EXPECT(equalsXML<HybridGaussianConditional>(gm)); EXPECT(equalsXML<HybridGaussianConditional>(gm));
// EXPECT(equalsBinary<HybridGaussianConditional>(gm)); EXPECT(equalsBinary<HybridGaussianConditional>(gm));
// } }
// /* ****************************************************************************/ /* ****************************************************************************/
// // Test HybridBayesNet serialization. // Test HybridBayesNet serialization.
// TEST(HybridSerialization, HybridBayesNet) { TEST(HybridSerialization, HybridBayesNet) {
// Switching s(2); Switching s(2);
// HybridBayesNet hbn = *(s.linearizedFactorGraph.eliminateSequential()); HybridBayesNet hbn = *(s.linearizedFactorGraph.eliminateSequential());
// EXPECT(equalsObj<HybridBayesNet>(hbn)); EXPECT(equalsObj<HybridBayesNet>(hbn));
// EXPECT(equalsXML<HybridBayesNet>(hbn)); EXPECT(equalsXML<HybridBayesNet>(hbn));
// EXPECT(equalsBinary<HybridBayesNet>(hbn)); EXPECT(equalsBinary<HybridBayesNet>(hbn));
// } }
// /* ****************************************************************************/ /* ****************************************************************************/
// // Test HybridBayesTree serialization. // Test HybridBayesTree serialization.
// TEST(HybridSerialization, HybridBayesTree) { TEST(HybridSerialization, HybridBayesTree) {
// Switching s(2); Switching s(2);
// HybridBayesTree hbt = *(s.linearizedFactorGraph.eliminateMultifrontal()); HybridBayesTree hbt = *(s.linearizedFactorGraph.eliminateMultifrontal());
// EXPECT(equalsObj<HybridBayesTree>(hbt)); EXPECT(equalsObj<HybridBayesTree>(hbt));
// EXPECT(equalsXML<HybridBayesTree>(hbt)); EXPECT(equalsXML<HybridBayesTree>(hbt));
// EXPECT(equalsBinary<HybridBayesTree>(hbt)); EXPECT(equalsBinary<HybridBayesTree>(hbt));
// } }
/* ************************************************************************* */ /* ************************************************************************* */
int main() { int main() {