Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Backport mesh optimization feature #1395

Merged
merged 3 commits into from
Apr 10, 2024
Merged
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
72 changes: 72 additions & 0 deletions include/sdf/Mesh.hh
Original file line number Diff line number Diff line change
@@ -37,6 +37,47 @@ namespace sdf
// Forward declarations.
class ParserConfig;

/// \brief Mesh optimization method
enum class MeshOptimization
{
/// \brief No mesh optimization
NONE,
/// \brief Convex hull
CONVEX_HULL,
/// \brief Convex decomposition
CONVEX_DECOMPOSITION
};

/// \brief Convex decomposition
class SDFORMAT_VISIBLE ConvexDecomposition
{
/// \brief Default constructor
public: ConvexDecomposition();

/// \brief Load the contact based on a element pointer. This is *not* the
/// usual entry point. Typical usage of the SDF DOM is through the Root
/// object.
/// \param[in] _sdf The SDF Element pointer
/// \return Errors, which is a vector of Error objects. Each Error includes
/// an error code and message. An empty vector indicates no error.
public: Errors Load(ElementPtr _sdf);

/// \brief Get a pointer to the SDF element that was used during
/// load.
/// \return SDF element pointer. The value will be nullptr if Load has
/// not been called.
public: sdf::ElementPtr Element() const;

/// \brief Get the maximum number of convex hulls that can be generated.
public: unsigned int MaxConvexHulls() const;

/// \brief Set the maximum number of convex hulls that can be generated.
public: void SetMaxConvexHulls(unsigned int _maxConvexHulls);

/// \brief Private data pointer.
GZ_UTILS_IMPL_PTR(dataPtr)
};

/// \brief Mesh represents a mesh shape, and is usually accessed through a
/// Geometry.
class SDFORMAT_VISIBLE Mesh
@@ -61,6 +102,37 @@ namespace sdf
/// an error code and message. An empty vector indicates no error.
public: Errors Load(sdf::ElementPtr _sdf, const ParserConfig &_config);

/// \brief Get the mesh's optimization method
/// \return The mesh optimization method.
/// MeshOptimization::NONE if no mesh simplificaton is done.
public: MeshOptimization Optimization() const;

/// \brief Get the mesh's optimization method
/// \return The mesh optimization method.
/// Empty string if no mesh simplificaton is done.
public: std::string OptimizationStr() const;

/// \brief Set the mesh optimization method.
/// \param[in] _optimization The mesh optimization method.
public: void SetOptimization(MeshOptimization _optimization);

/// \brief Set the mesh optimization method.
/// \param[in] _optimization The mesh optimization method.
/// \return True if the _optimizationStr parameter matched a known
/// mesh optimization method. False if the mesh optimization method
/// could not be set.
public: bool SetOptimization(const std::string &_optimizationStr);

/// \brief Get the associated ConvexDecomposition object
/// \returns Pointer to the associated ConvexDecomposition object,
/// nullptr if the Mesh doesn't contain a ConvexDecomposition element.
public: const sdf::ConvexDecomposition *ConvexDecomposition() const;

/// \brief Set the associated ConvexDecomposition object.
/// \param[in] _convexDecomposition The ConvexDecomposition object.
public: void SetConvexDecomposition(
const sdf::ConvexDecomposition &_convexDecomposition);

/// \brief Get the mesh's URI.
/// \return The URI of the mesh data.
public: std::string Uri() const;
1 change: 1 addition & 0 deletions python/CMakeLists.txt
Original file line number Diff line number Diff line change
@@ -52,6 +52,7 @@ pybind11_add_module(${BINDINGS_MODULE_NAME} MODULE
src/sdf/pyCamera.cc
src/sdf/pyCapsule.cc
src/sdf/pyCollision.cc
src/sdf/pyConvexDecomposition.cc
src/sdf/pyCylinder.cc
src/sdf/pyElement.cc
src/sdf/pyEllipsoid.cc
2 changes: 2 additions & 0 deletions python/src/sdf/_gz_sdformat_pybind11.cc
Original file line number Diff line number Diff line change
@@ -26,6 +26,7 @@
#include "pyCamera.hh"
#include "pyCapsule.hh"
#include "pyCollision.hh"
#include "pyConvexDecomposition.hh"
#include "pyCylinder.hh"
#include "pyElement.hh"
#include "pyEllipsoid.hh"
@@ -85,6 +86,7 @@ PYBIND11_MODULE(BINDINGS_MODULE_NAME, m) {
sdf::python::defineCamera(m);
sdf::python::defineCapsule(m);
sdf::python::defineCollision(m);
sdf::python::defineConvexDecomposition(m);
sdf::python::defineContact(m);
sdf::python::defineCylinder(m);
// PrintConfig has to be defined before Param and Element because it's used as
50 changes: 50 additions & 0 deletions python/src/sdf/pyConvexDecomposition.cc
Original file line number Diff line number Diff line change
@@ -0,0 +1,50 @@
/*
* Copyright (C) 2024 Open Source Robotics Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#include "pyMesh.hh"

#include <pybind11/pybind11.h>

#include "sdf/ParserConfig.hh"
#include "sdf/Mesh.hh"

using namespace pybind11::literals;

namespace sdf
{
// Inline bracket to help doxygen filtering.
inline namespace SDF_VERSION_NAMESPACE {
namespace python
{
/////////////////////////////////////////////////
void defineConvexDecomposition(pybind11::object module)
{
pybind11::class_<sdf::ConvexDecomposition>(module, "ConvexDecomposition")
.def(pybind11::init<>())
.def("max_convex_hulls", &sdf::ConvexDecomposition::MaxConvexHulls,
"Get the maximum number of convex hulls that can be generated.")
.def("set_max_convex_hulls", &sdf::ConvexDecomposition::SetMaxConvexHulls,
"Set the maximum number of convex hulls that can be generated.")
.def("__copy__", [](const sdf::ConvexDecomposition &self) {
return sdf::ConvexDecomposition(self);
})
.def("__deepcopy__", [](const sdf::ConvexDecomposition &self, pybind11::dict) {
return sdf::ConvexDecomposition(self);
}, "memo"_a);
}
} // namespace python
} // namespace SDF_VERSION_NAMESPACE
} // namespace sdf
41 changes: 41 additions & 0 deletions python/src/sdf/pyConvexDecomposition.hh
Original file line number Diff line number Diff line change
@@ -0,0 +1,41 @@
/*
* Copyright (C) 2024 Open Source Robotics Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#ifndef SDFORMAT_PYTHON_CONVEX_DECOMPOSITION_HH_
#define SDFORMAT_PYTHON_CONVEX_DECOMPOSITION_HH_

#include <pybind11/pybind11.h>

#include "sdf/Mesh.hh"

#include "sdf/config.hh"

namespace sdf
{
// Inline bracket to help doxygen filtering.
inline namespace SDF_VERSION_NAMESPACE {
namespace python
{
/// Define a pybind11 wrapper for an sdf::ConvexDecomposition
/**
* \param[in] module a pybind11 module to add the definition to
*/
void defineConvexDecomposition(pybind11::object module);
} // namespace python
} // namespace SDF_VERSION_NAMESPACE
} // namespace sdf

#endif // SDFORMAT_PYTHON_CONVEX_DECOMPOSITION_HH_
22 changes: 22 additions & 0 deletions python/src/sdf/pyMesh.cc
Original file line number Diff line number Diff line change
@@ -35,6 +35,23 @@ void defineMesh(pybind11::object module)
pybind11::class_<sdf::Mesh>(module, "Mesh")
.def(pybind11::init<>())
.def(pybind11::init<sdf::Mesh>())
.def("optimization", &sdf::Mesh::Optimization,
"Get the mesh's optimization method.")
.def("optimization_str", &sdf::Mesh::OptimizationStr,
"Get the mesh's optimization method")
.def("set_optimization",
pybind11::overload_cast<sdf::MeshOptimization>(
&sdf::Mesh::SetOptimization),
"Set the mesh optimization method.")
.def("set_optimization",
pybind11::overload_cast<const std::string &>(
&sdf::Mesh::SetOptimization),
"Set the mesh optimization method.")
.def("convex_decomposition", &sdf::Mesh::ConvexDecomposition,
pybind11::return_value_policy::reference_internal,
"Get the associated ConvexDecomposition object")
.def("set_convex_decomposition", &sdf::Mesh::SetConvexDecomposition,
"Set the associated ConvexDecomposition object.")
.def("uri", &sdf::Mesh::Uri,
"Get the mesh's URI.")
.def("set_uri", &sdf::Mesh::SetUri,
@@ -67,6 +84,11 @@ void defineMesh(pybind11::object module)
.def("__deepcopy__", [](const sdf::Mesh &self, pybind11::dict) {
return sdf::Mesh(self);
}, "memo"_a);

pybind11::enum_<sdf::MeshOptimization>(module, "MeshOptimization")
.value("NONE", sdf::MeshOptimization::NONE)
.value("CONVEX_HULL", sdf::MeshOptimization::CONVEX_HULL)
.value("CONVEX_DECOMPOSITION", sdf::MeshOptimization::CONVEX_DECOMPOSITION);
}
} // namespace python
} // namespace SDF_VERSION_NAMESPACE
44 changes: 43 additions & 1 deletion python/test/pyMesh_TEST.py
Original file line number Diff line number Diff line change
@@ -13,8 +13,9 @@
# limitations under the License.

import copy
from gz_test_deps.sdformat import Mesh
from gz_test_deps.sdformat import Mesh, ConvexDecomposition
from gz_test_deps.math import Vector3d
import gz_test_deps.sdformat as sdf
import unittest


@@ -23,6 +24,9 @@ class MeshTEST(unittest.TestCase):
def test_default_construction(self):
mesh = Mesh()

self.assertEqual("", mesh.optimization_str())
self.assertEqual(sdf.MeshOptimization.NONE, mesh.optimization())
self.assertEqual(None, mesh.convex_decomposition())
self.assertEqual("", mesh.file_path())
self.assertEqual("", mesh.uri())
self.assertEqual("", mesh.submesh())
@@ -32,19 +36,29 @@ def test_default_construction(self):

def test_assigment(self):
mesh = Mesh()
self.assertTrue(mesh.set_optimization("convex_decomposition"))
mesh.set_uri("banana")
mesh.set_submesh("watermelon")
mesh.set_center_submesh(True)
mesh.set_scale(Vector3d(0.5, 0.6, 0.7))
mesh.set_file_path("/pear")

convexDecomp = ConvexDecomposition()
convexDecomp.set_max_convex_hulls(10)
mesh.set_convex_decomposition(convexDecomp)

mesh2 = mesh
self.assertEqual("convex_decomposition", mesh2.optimization_str())
self.assertEqual(sdf.MeshOptimization.CONVEX_DECOMPOSITION, mesh2.optimization())
self.assertEqual("banana", mesh2.uri())
self.assertEqual("watermelon", mesh2.submesh())
self.assertEqual(Vector3d(0.5, 0.6, 0.7), mesh2.scale())
self.assertTrue(mesh2.center_submesh())
self.assertEqual("/pear", mesh2.file_path())

convexDecomp2 = mesh2.convex_decomposition()
self.assertEqual(10, convexDecomp2.max_convex_hulls())

mesh.set_file_path("/apple")
self.assertEqual("/apple", mesh2.file_path())

@@ -63,19 +77,29 @@ def test_assigment(self):

def test_deepcopy_construction(self):
mesh = Mesh()
self.assertTrue(mesh.set_optimization("convex_decomposition"))
mesh.set_uri("banana")
mesh.set_submesh("watermelon")
mesh.set_center_submesh(True)
mesh.set_scale(Vector3d(0.5, 0.6, 0.7))
mesh.set_file_path("/pear")

convexDecomp = ConvexDecomposition()
convexDecomp.set_max_convex_hulls(10)
mesh.set_convex_decomposition(convexDecomp)

mesh2 = copy.deepcopy(mesh)
self.assertEqual("convex_decomposition", mesh2.optimization_str())
self.assertEqual(sdf.MeshOptimization.CONVEX_DECOMPOSITION, mesh2.optimization())
self.assertEqual("banana", mesh2.uri())
self.assertEqual("watermelon", mesh2.submesh())
self.assertEqual(Vector3d(0.5, 0.6, 0.7), mesh2.scale())
self.assertTrue(mesh2.center_submesh())
self.assertEqual("/pear", mesh2.file_path())

convexDecomp2 = mesh2.convex_decomposition()
self.assertEqual(10, convexDecomp2.max_convex_hulls())

mesh.set_file_path("/apple")
mesh.set_scale(Vector3d(0.3, 0.2, 0.4))
mesh.set_center_submesh(False)
@@ -92,6 +116,24 @@ def test_deepcopy_construction(self):
def test_set(self):
mesh = Mesh()

self.assertEqual("", mesh.optimization_str())
self.assertTrue(mesh.set_optimization("convex_hull"))
self.assertEqual("convex_hull", mesh.optimization_str())
self.assertEqual(sdf.MeshOptimization.CONVEX_HULL, mesh.optimization())
mesh.set_optimization(sdf.MeshOptimization.CONVEX_DECOMPOSITION)
self.assertEqual("convex_decomposition", mesh.optimization_str())
self.assertEqual(sdf.MeshOptimization.CONVEX_DECOMPOSITION, mesh.optimization())

self.assertFalse(mesh.set_optimization("invalid"))
mesh.set_optimization(sdf.MeshOptimization(99))
self.assertEqual(sdf.MeshOptimization(99), mesh.optimization())
self.assertEqual("", mesh.optimization_str())

convexDecomp = ConvexDecomposition()
convexDecomp.set_max_convex_hulls(10)
mesh.set_convex_decomposition(convexDecomp)
self.assertEqual(10, mesh.convex_decomposition().max_convex_hulls())

self.assertEqual("", mesh.uri())
mesh.set_uri("http://myuri.com")
self.assertEqual("http://myuri.com", mesh.uri())
14 changes: 14 additions & 0 deletions sdf/1.11/mesh_shape.sdf
Original file line number Diff line number Diff line change
@@ -1,5 +1,19 @@
<element name="mesh" required="0">
<description>Mesh shape</description>

<attribute name="optimization" type="string" default="" required="0">
<description>
Set whether to optimize the mesh using one of the specified methods. Values include: "convex_hull" - a single convex hull that encapsulates the mesh, "convex_decomposition" - decompose the mesh into multiple convex hull meshes. Default value is an empty string which means no mesh optimization.
</description>
</attribute>

<element name="convex_decomposition" required="0">
<description>Convex decomposition parameters. Applicable if the mesh optimization attribute is set to convex_decomposition</description>
<element name="max_convex_hulls" type="unsigned int" default="16" required="0">
<description>Maximum number of convex hulls to decompose into. This sets the maximum number of submeshes that the final decomposed mesh will contain.</description>
</element>
</element>

<element name="uri" type="string" default="__default__" required="1">
<description>Mesh uri</description>
</element>
163 changes: 162 additions & 1 deletion src/Mesh.cc
Original file line number Diff line number Diff line change
@@ -14,8 +14,10 @@
* limitations under the License.
*
*/
#include <array>
#include <filesystem>
#include <optional>
#include <string_view>

#include <gz/math/Inertial.hh>
#include "sdf/CustomInertiaCalcProperties.hh"
@@ -27,9 +29,35 @@

using namespace sdf;

// Private data class
/// Mesh Optimization method strings. These should match the data in
/// `enum class MeshOptimization` located in Mesh.hh, and the size
/// template parameter should match the number of elements as well.
constexpr std::array<const std::string_view, 3> kMeshOptimizationStrs =
{
"",
"convex_hull",
"convex_decomposition"
};

// Private data class for ConvexDecomposition
class sdf::ConvexDecomposition::Implementation
{
/// \brief Maximum number of convex hulls to generate.
public: unsigned int maxConvexHulls{16u};

/// \brief The SDF element pointer used during load.
public: sdf::ElementPtr sdf = nullptr;
};

// Private data class for Mesh
class sdf::Mesh::Implementation
{
/// \brief Mesh optimization method
public: MeshOptimization optimization = MeshOptimization::NONE;

/// \brief Optional convex decomposition.
public: std::optional<sdf::ConvexDecomposition> convexDecomposition;

/// \brief The mesh's URI.
public: std::string uri = "";

@@ -49,6 +77,62 @@ class sdf::Mesh::Implementation
public: sdf::ElementPtr sdf = nullptr;
};

/////////////////////////////////////////////////
ConvexDecomposition::ConvexDecomposition()
: dataPtr(gz::utils::MakeImpl<Implementation>())
{
}

/////////////////////////////////////////////////
Errors ConvexDecomposition::Load(ElementPtr _sdf)
{
Errors errors;

this->dataPtr->sdf = _sdf;

// Check that sdf is a valid pointer
if (!_sdf)
{
errors.push_back({ErrorCode::ELEMENT_MISSING,
"Attempting to load convex decomposition, "
"but the provided SDF element is null."});
return errors;
}

// We need a convex_decomposition element
if (_sdf->GetName() != "convex_decomposition")
{
errors.push_back({ErrorCode::ELEMENT_INCORRECT_TYPE,
"Attempting to load convex decomposition, but the provided SDF "
"element is not <convex_decomposition>."});
return errors;
}

this->dataPtr->maxConvexHulls = _sdf->Get<unsigned int>(
errors, "max_convex_hulls",
this->dataPtr->maxConvexHulls).first;

return errors;
}

/////////////////////////////////////////////////
sdf::ElementPtr ConvexDecomposition::Element() const
{
return this->dataPtr->sdf;
}

/////////////////////////////////////////////////
unsigned int ConvexDecomposition::MaxConvexHulls() const
{
return this->dataPtr->maxConvexHulls;
}

/////////////////////////////////////////////////
void ConvexDecomposition::SetMaxConvexHulls(unsigned int _maxConvexHulls)
{
this->dataPtr->maxConvexHulls = _maxConvexHulls;
}

/////////////////////////////////////////////////
Mesh::Mesh()
: dataPtr(gz::utils::MakeImpl<Implementation>())
@@ -61,6 +145,7 @@ Errors Mesh::Load(ElementPtr _sdf)
return this->Load(_sdf, ParserConfig::GlobalConfig());
}


/////////////////////////////////////////////////
Errors Mesh::Load(ElementPtr _sdf, const ParserConfig &_config)
{
@@ -87,6 +172,20 @@ Errors Mesh::Load(ElementPtr _sdf, const ParserConfig &_config)
return errors;
}

// Optimization
if (_sdf->HasAttribute("optimization"))
{
this->SetOptimization(_sdf->Get<std::string>("optimization", "").first);
}

if (_sdf->HasElement("convex_decomposition"))
{
this->dataPtr->convexDecomposition.emplace();
Errors err = this->dataPtr->convexDecomposition->Load(
_sdf->GetElement("convex_decomposition", errors));
errors.insert(errors.end(), err.begin(), err.end());
}

if (_sdf->HasElement("uri"))
{
std::unordered_set<std::string> paths;
@@ -140,6 +239,56 @@ sdf::ElementPtr Mesh::Element() const
return this->dataPtr->sdf;
}

//////////////////////////////////////////////////
MeshOptimization Mesh::Optimization() const
{
return this->dataPtr->optimization;
}

//////////////////////////////////////////////////
std::string Mesh::OptimizationStr() const
{
size_t index = static_cast<int>(this->dataPtr->optimization);
if (index < kMeshOptimizationStrs.size())
return std::string(kMeshOptimizationStrs[index]);
return "";
}

//////////////////////////////////////////////////
bool Mesh::SetOptimization(const std::string &_optimizationStr)
{
for (size_t i = 0; i < kMeshOptimizationStrs.size(); ++i)
{
if (_optimizationStr == kMeshOptimizationStrs[i])
{
this->dataPtr->optimization = static_cast<MeshOptimization>(i);
return true;
}
}
return false;
}

//////////////////////////////////////////////////
void Mesh::SetOptimization(MeshOptimization _optimization)
{
this->dataPtr->optimization = _optimization;
}

//////////////////////////////////////////////////
const sdf::ConvexDecomposition *Mesh::ConvexDecomposition() const
{
if (this->dataPtr->convexDecomposition.has_value())
return &this->dataPtr->convexDecomposition.value();
return nullptr;
}

//////////////////////////////////////////////////
void Mesh::SetConvexDecomposition(
const sdf::ConvexDecomposition &_convexDecomposition)
{
this->dataPtr->convexDecomposition = _convexDecomposition;
}

//////////////////////////////////////////////////
std::string Mesh::Uri() const
{
@@ -244,6 +393,18 @@ sdf::ElementPtr Mesh::ToElement(sdf::Errors &_errors) const
sdf::ElementPtr elem(new sdf::Element);
sdf::initFile("mesh_shape.sdf", elem);

// Optimization
elem->GetAttribute("optimization")->Set<std::string>(
this->OptimizationStr());

if (this->dataPtr->convexDecomposition.has_value())
{
sdf::ElementPtr convexDecomp = elem->GetElement("convex_decomposition",
_errors);
convexDecomp->GetElement("max_convex_hulls")->Set(
this->dataPtr->convexDecomposition->MaxConvexHulls());
}

// Uri
sdf::ElementPtr uriElem = elem->GetElement("uri", _errors);
uriElem->Set(_errors, this->Uri());
74 changes: 74 additions & 0 deletions src/Mesh_TEST.cc
Original file line number Diff line number Diff line change
@@ -34,6 +34,9 @@ TEST(DOMMesh, Construction)
sdf::Mesh mesh;
EXPECT_EQ(nullptr, mesh.Element());

EXPECT_EQ(std::string(), mesh.OptimizationStr());
EXPECT_EQ(sdf::MeshOptimization::NONE, mesh.Optimization());
EXPECT_EQ(nullptr, mesh.ConvexDecomposition());
EXPECT_EQ(std::string(), mesh.FilePath());
EXPECT_EQ(std::string(), mesh.Uri());
EXPECT_EQ(std::string(), mesh.Submesh());
@@ -45,31 +48,47 @@ TEST(DOMMesh, Construction)
TEST(DOMMesh, MoveConstructor)
{
sdf::Mesh mesh;
EXPECT_TRUE(mesh.SetOptimization("convex_decomposition"));
mesh.SetUri("banana");
mesh.SetSubmesh("watermelon");
mesh.SetCenterSubmesh(true);
mesh.SetScale({0.5, 0.6, 0.7});
mesh.SetFilePath("/pear");

sdf::ConvexDecomposition convexDecomp;
EXPECT_EQ(nullptr, convexDecomp.Element());
convexDecomp.SetMaxConvexHulls(10u);
mesh.SetConvexDecomposition(convexDecomp);

sdf::Mesh mesh2(std::move(mesh));
EXPECT_EQ("convex_decomposition", mesh2.OptimizationStr());
EXPECT_EQ(sdf::MeshOptimization::CONVEX_DECOMPOSITION, mesh2.Optimization());
EXPECT_EQ("banana", mesh2.Uri());
EXPECT_EQ("watermelon", mesh2.Submesh());
EXPECT_EQ(gz::math::Vector3d(0.5, 0.6, 0.7), mesh2.Scale());
EXPECT_TRUE(mesh2.CenterSubmesh());
EXPECT_EQ("/pear", mesh2.FilePath());

auto convexDecomp2 = mesh2.ConvexDecomposition();
ASSERT_NE(nullptr, convexDecomp2);
EXPECT_EQ(10u, convexDecomp2->MaxConvexHulls());
}

/////////////////////////////////////////////////
TEST(DOMMesh, CopyConstructor)
{
sdf::Mesh mesh;
EXPECT_TRUE(mesh.SetOptimization("convex_hull"));
mesh.SetUri("banana");
mesh.SetSubmesh("watermelon");
mesh.SetCenterSubmesh(true);
mesh.SetScale({0.5, 0.6, 0.7});
mesh.SetFilePath("/pear");

sdf::Mesh mesh2(mesh);
EXPECT_EQ("convex_hull", mesh2.OptimizationStr());
EXPECT_EQ(sdf::MeshOptimization::CONVEX_HULL, mesh2.Optimization());
EXPECT_EQ(nullptr, mesh2.ConvexDecomposition());
EXPECT_EQ("banana", mesh2.Uri());
EXPECT_EQ("watermelon", mesh2.Submesh());
EXPECT_EQ(gz::math::Vector3d(0.5, 0.6, 0.7), mesh2.Scale());
@@ -81,6 +100,7 @@ TEST(DOMMesh, CopyConstructor)
TEST(DOMMesh, CopyAssignmentOperator)
{
sdf::Mesh mesh;
EXPECT_TRUE(mesh.SetOptimization("convex_hull"));
mesh.SetUri("banana");
mesh.SetSubmesh("watermelon");
mesh.SetCenterSubmesh(true);
@@ -89,6 +109,9 @@ TEST(DOMMesh, CopyAssignmentOperator)

sdf::Mesh mesh2;
mesh2 = mesh;
EXPECT_EQ("convex_hull", mesh2.OptimizationStr());
EXPECT_EQ(sdf::MeshOptimization::CONVEX_HULL, mesh2.Optimization());
EXPECT_EQ(nullptr, mesh2.ConvexDecomposition());
EXPECT_EQ("banana", mesh2.Uri());
EXPECT_EQ("watermelon", mesh2.Submesh());
EXPECT_EQ(gz::math::Vector3d(0.5, 0.6, 0.7), mesh2.Scale());
@@ -100,6 +123,7 @@ TEST(DOMMesh, CopyAssignmentOperator)
TEST(DOMMesh, MoveAssignmentOperator)
{
sdf::Mesh mesh;
EXPECT_TRUE(mesh.SetOptimization("convex_hull"));
mesh.SetUri("banana");
mesh.SetSubmesh("watermelon");
mesh.SetCenterSubmesh(true);
@@ -108,6 +132,9 @@ TEST(DOMMesh, MoveAssignmentOperator)

sdf::Mesh mesh2;
mesh2 = std::move(mesh);
EXPECT_EQ("convex_hull", mesh2.OptimizationStr());
EXPECT_EQ(sdf::MeshOptimization::CONVEX_HULL, mesh2.Optimization());
EXPECT_EQ(nullptr, mesh2.ConvexDecomposition());
EXPECT_EQ("banana", mesh2.Uri());
EXPECT_EQ("watermelon", mesh2.Submesh());
EXPECT_EQ(gz::math::Vector3d(0.5, 0.6, 0.7), mesh2.Scale());
@@ -140,6 +167,29 @@ TEST(DOMMesh, Set)
sdf::Mesh mesh;
EXPECT_EQ(nullptr, mesh.Element());

EXPECT_EQ(std::string(), mesh.OptimizationStr());
EXPECT_TRUE(mesh.SetOptimization("convex_hull"));
EXPECT_EQ("convex_hull", mesh.OptimizationStr());
EXPECT_EQ(sdf::MeshOptimization::CONVEX_HULL, mesh.Optimization());
mesh.SetOptimization(sdf::MeshOptimization::CONVEX_DECOMPOSITION);
EXPECT_EQ("convex_decomposition", mesh.OptimizationStr());
EXPECT_EQ(sdf::MeshOptimization::CONVEX_DECOMPOSITION,
mesh.Optimization());
// check invalid inputs
EXPECT_FALSE(mesh.SetOptimization("invalid"));
{
auto invalidMeshOpt = static_cast<sdf::MeshOptimization>(99);
mesh.SetOptimization(invalidMeshOpt);
EXPECT_EQ(invalidMeshOpt, mesh.Optimization());
EXPECT_EQ("", mesh.OptimizationStr());
}

sdf::ConvexDecomposition convexDecomp;
convexDecomp.SetMaxConvexHulls(10u);
mesh.SetConvexDecomposition(convexDecomp);
ASSERT_NE(nullptr, mesh.ConvexDecomposition());
EXPECT_EQ(10u, mesh.ConvexDecomposition()->MaxConvexHulls());

EXPECT_EQ(std::string(), mesh.Uri());
mesh.SetUri("http://myuri.com");
EXPECT_EQ("http://myuri.com", mesh.Uri());
@@ -165,6 +215,7 @@ TEST(DOMMesh, Set)
TEST(DOMMesh, Load)
{
sdf::Mesh mesh;
sdf::ConvexDecomposition convexDecomp;
sdf::Errors errors;

// Null element name
@@ -173,6 +224,11 @@ TEST(DOMMesh, Load)
EXPECT_EQ(sdf::ErrorCode::ELEMENT_MISSING, errors[0].Code());
EXPECT_EQ(nullptr, mesh.Element());

errors = convexDecomp.Load(nullptr);
ASSERT_EQ(1u, errors.size());
EXPECT_EQ(sdf::ErrorCode::ELEMENT_MISSING, errors[0].Code());
EXPECT_EQ(nullptr, convexDecomp.Element());

// Bad element name
sdf::ElementPtr sdf(new sdf::Element());
sdf->SetName("bad");
@@ -181,6 +237,11 @@ TEST(DOMMesh, Load)
EXPECT_EQ(sdf::ErrorCode::ELEMENT_INCORRECT_TYPE, errors[0].Code());
EXPECT_NE(nullptr, mesh.Element());

errors = convexDecomp.Load(sdf);
ASSERT_EQ(1u, errors.size());
EXPECT_EQ(sdf::ErrorCode::ELEMENT_INCORRECT_TYPE, errors[0].Code());
EXPECT_NE(nullptr, convexDecomp.Element());

// Missing <uri> element
sdf->SetName("mesh");
errors = mesh.Load(sdf);
@@ -296,21 +357,30 @@ TEST(DOMMesh, ToElement)
{
sdf::Mesh mesh;

EXPECT_TRUE(mesh.SetOptimization("convex_decomposition"));
mesh.SetUri("mesh-uri");
mesh.SetScale(gz::math::Vector3d(1, 2, 3));
mesh.SetSubmesh("submesh");
mesh.SetCenterSubmesh(false);

sdf::ConvexDecomposition convexDecomp;
convexDecomp.SetMaxConvexHulls(10u);
mesh.SetConvexDecomposition(convexDecomp);

sdf::ElementPtr elem = mesh.ToElement();
ASSERT_NE(nullptr, elem);

sdf::Mesh mesh2;
mesh2.Load(elem);

EXPECT_EQ(mesh.OptimizationStr(), mesh2.OptimizationStr());
EXPECT_EQ(mesh.Optimization(), mesh2.Optimization());
EXPECT_EQ(mesh.Uri(), mesh2.Uri());
EXPECT_EQ(mesh.Scale(), mesh2.Scale());
EXPECT_EQ(mesh.Submesh(), mesh2.Submesh());
EXPECT_EQ(mesh.CenterSubmesh(), mesh2.CenterSubmesh());
ASSERT_NE(nullptr, mesh2.ConvexDecomposition());
EXPECT_EQ(10u, mesh2.ConvexDecomposition()->MaxConvexHulls());
}

/////////////////////////////////////////////////
@@ -332,6 +402,7 @@ TEST(DOMMesh, ToElementErrorOutput)
sdf::Mesh mesh;
sdf::Errors errors;

EXPECT_TRUE(mesh.SetOptimization("convex_hull"));
mesh.SetUri("mesh-uri");
mesh.SetScale(gz::math::Vector3d(1, 2, 3));
mesh.SetSubmesh("submesh");
@@ -345,6 +416,9 @@ TEST(DOMMesh, ToElementErrorOutput)
errors = mesh2.Load(elem);
EXPECT_TRUE(errors.empty());

EXPECT_EQ(mesh.OptimizationStr(), mesh2.OptimizationStr());
EXPECT_EQ(mesh.Optimization(), mesh2.Optimization());
EXPECT_EQ(nullptr, mesh2.ConvexDecomposition());
EXPECT_EQ(mesh.Uri(), mesh2.Uri());
EXPECT_EQ(mesh.Scale(), mesh2.Scale());
EXPECT_EQ(mesh.Submesh(), mesh2.Submesh());
6 changes: 6 additions & 0 deletions test/integration/geometry_dom.cc
Original file line number Diff line number Diff line change
@@ -179,6 +179,12 @@ TEST(DOMGeometry, Shapes)
EXPECT_EQ(sdf::GeometryType::MESH, meshCol->Geom()->Type());
const sdf::Mesh *meshColGeom = meshCol->Geom()->MeshShape();
ASSERT_NE(nullptr, meshColGeom);
EXPECT_EQ("convex_decomposition", meshColGeom->OptimizationStr());
EXPECT_EQ(sdf::MeshOptimization::CONVEX_DECOMPOSITION,
meshColGeom->Optimization());
ASSERT_NE(nullptr, meshColGeom->ConvexDecomposition());
EXPECT_EQ(4u, meshColGeom->ConvexDecomposition()->MaxConvexHulls());

EXPECT_EQ("https://fuel.gazebosim.org/1.0/an_org/models/a_model/mesh/"
"mesh.dae", meshColGeom->Uri());
EXPECT_TRUE(gz::math::Vector3d(0.1, 0.2, 0.3) ==
5 changes: 4 additions & 1 deletion test/sdf/shapes.sdf
Original file line number Diff line number Diff line change
@@ -120,7 +120,10 @@

<collision name="mesh_col">
<geometry>
<mesh>
<mesh optimization="convex_decomposition">
<convex_decomposition>
<max_convex_hulls>4</max_convex_hulls>
</convex_decomposition>
<uri>https://fuel.gazebosim.org/1.0/an_org/models/a_model/mesh/mesh.dae</uri>
<submesh>
<name>my_submesh</name>