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

comment out serialization

release/4.3a0
Varun Agrawal 2024-10-09 11:41:31 -04:00
parent 8a650b6a4e
commit e87d1fb1de
1 changed files with 89 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -39,112 +39,112 @@ 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(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() {