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.

Sign up for GitHub

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

Jump to bottom

Light: update calls to use sdf::Errors parameters #1154

Merged
merged 6 commits into from
Mar 28, 2023
Merged

Light: update calls to use sdf::Errors parameters #1154

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
6cc7e7e
updating Element calls to use Errors
Sep 15, 2022
f33e935
Light: adding error parameter to function calls
Sep 19, 2022
4300b9d
Merge branch 'sdf13' into marcoag/sdf_error_light
Mar 23, 2023
d677714
Adding ToElement errors test
Mar 27, 2023
5dea672
Merge branch 'sdf13' into marcoag/sdf_error_light
Mar 28, 2023
ce487dd
Merge branch 'sdf13' into marcoag/sdf_error_light
Mar 28, 2023
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
8 changes: 8 additions & 0 deletions include/sdf/Light.hh
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -291,6 +291,14 @@ namespace sdf
/// \return SDF element pointer with updated light values.
public: sdf::ElementPtr ToElement() const;

/// \brief Create and return an SDF element filled with data from this
/// light object.
/// Note that parameter passing functionality is not captured with this
/// function.
/// \param[out] _errors Vector of errors.
/// \return SDF element pointer with updated light values.
public: sdf::ElementPtr ToElement(sdf::Errors &_errors) const;

/// \brief Allow Link::SetPoseRelativeToGraph or World::Load to call
/// SetXmlParentName and SetPoseRelativeToGraph,
/// but Link::SetPoseRelativeToGraph is a private function, so we need
Expand Down
109 changes: 62 additions & 47 deletions src/Light.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -115,7 +115,7 @@ Errors Light::Load(ElementPtr _sdf)
return errors;
}

std::string typeString = _sdf->Get<std::string>("type",
std::string typeString = _sdf->Get<std::string>(errors, "type",
std::string("point")).first;
if (typeString == "point")
this->dataPtr->type = LightType::POINT;
Expand Down Expand Up @@ -148,52 +148,52 @@ Errors Light::Load(ElementPtr _sdf)
// Load the pose. Ignore the return value since the light pose is optional.
loadPose(_sdf, this->dataPtr->pose, this->dataPtr->poseRelativeTo);

this->dataPtr->isLightOn = _sdf->Get<bool>("light_on",
this->dataPtr->isLightOn = _sdf->Get<bool>(errors, "light_on",
this->dataPtr->isLightOn).first;

this->dataPtr->visualize = _sdf->Get<bool>("visualize",
this->dataPtr->visualize = _sdf->Get<bool>(errors, "visualize",
this->dataPtr->visualize).first;

this->dataPtr->castShadows = _sdf->Get<bool>("cast_shadows",
this->dataPtr->castShadows = _sdf->Get<bool>(errors, "cast_shadows",
this->dataPtr->castShadows).first;

this->dataPtr->intensity = _sdf->Get<double>("intensity",
this->dataPtr->intensity = _sdf->Get<double>(errors, "intensity",
this->dataPtr->intensity).first;

this->dataPtr->diffuse = _sdf->Get<gz::math::Color>("diffuse",
this->dataPtr->diffuse = _sdf->Get<gz::math::Color>(errors, "diffuse",
this->dataPtr->diffuse).first;

this->dataPtr->specular = _sdf->Get<gz::math::Color>("specular",
this->dataPtr->specular = _sdf->Get<gz::math::Color>(errors, "specular",
this->dataPtr->specular).first;

sdf::ElementPtr attenuationElem = _sdf->GetElement("attenuation");
sdf::ElementPtr attenuationElem = _sdf->GetElement("attenuation", errors);
if (attenuationElem)
{
std::pair<double, bool> doubleValue = attenuationElem->Get<double>(
"range", this->dataPtr->attenuationRange);
errors, "range", this->dataPtr->attenuationRange);
if (!doubleValue.second)
{
errors.push_back({ErrorCode::ELEMENT_MISSING,
"An <attenuation> requires a <range>."});
}
this->SetAttenuationRange(doubleValue.first);

this->SetLinearAttenuationFactor(attenuationElem->Get<double>("linear",
this->dataPtr->linearAttenuation).first);
this->SetLinearAttenuationFactor(attenuationElem->Get<double>(
errors, "linear", this->dataPtr->linearAttenuation).first);

this->SetConstantAttenuationFactor(attenuationElem->Get<double>("constant",
this->dataPtr->constantAttenuation).first);
this->SetConstantAttenuationFactor(attenuationElem->Get<double>(
errors, "constant", this->dataPtr->constantAttenuation).first);

this->SetQuadraticAttenuationFactor(attenuationElem->Get<double>(
"quadratic", this->dataPtr->quadraticAttenuation).first);
errors, "quadratic", this->dataPtr->quadraticAttenuation).first);
}

// Read the direction
if (this->dataPtr->type == LightType::SPOT ||
this->dataPtr->type == LightType::DIRECTIONAL)
{
std::pair<gz::math::Vector3d, bool> dirPair =
_sdf->Get<>("direction", this->dataPtr->direction);
_sdf->Get<>(errors, "direction", this->dataPtr->direction);

if (!dirPair.second)
{
Expand All @@ -204,12 +204,12 @@ Errors Light::Load(ElementPtr _sdf)
this->dataPtr->direction = dirPair.first;
}

sdf::ElementPtr spotElem = _sdf->GetElement("spot");
sdf::ElementPtr spotElem = _sdf->GetElement("spot", errors);
if (this->dataPtr->type == LightType::SPOT && spotElem)
{
// Check for and set inner_angle
std::pair<double, bool> doubleValue = spotElem->Get<double>(
"inner_angle", this->dataPtr->spotInnerAngle.Radian());
errors, "inner_angle", this->dataPtr->spotInnerAngle.Radian());
if (!doubleValue.second)
{
errors.push_back({ErrorCode::ELEMENT_MISSING,
Expand All @@ -219,7 +219,7 @@ Errors Light::Load(ElementPtr _sdf)

// Check for and set outer_angle
doubleValue = spotElem->Get<double>(
"outer_angle", this->dataPtr->spotOuterAngle.Radian());
errors, "outer_angle", this->dataPtr->spotOuterAngle.Radian());
if (!doubleValue.second)
{
errors.push_back({ErrorCode::ELEMENT_MISSING,
Expand All @@ -228,7 +228,8 @@ Errors Light::Load(ElementPtr _sdf)
this->SetSpotOuterAngle(doubleValue.first);

// Check for and set falloff
doubleValue = spotElem->Get<double>("falloff", this->dataPtr->spotFalloff);
doubleValue = spotElem->Get<double>(
errors, "falloff", this->dataPtr->spotFalloff);
if (!doubleValue.second)
{
errors.push_back({ErrorCode::ELEMENT_MISSING,
Expand Down Expand Up @@ -488,6 +489,15 @@ void Light::SetType(const LightType _type)

/////////////////////////////////////////////////
sdf::ElementPtr Light::ToElement() const
{
sdf::Errors errors;
auto result = this->ToElement(errors);
sdf::throwOrPrintErrors(errors);
return result;
}

/////////////////////////////////////////////////
sdf::ElementPtr Light::ToElement(sdf::Errors &_errors) const
{
sdf::ElementPtr elem(new sdf::Element);
sdf::initFile("light.sdf", elem);
Expand All @@ -507,37 +517,42 @@ sdf::ElementPtr Light::ToElement() const
default:
break;
}
elem->GetAttribute("type")->Set<std::string>(lightTypeStr);
elem->GetAttribute("name")->Set<std::string>(this->Name());
sdf::ElementPtr poseElem = elem->GetElement("pose");
elem->GetAttribute("type")->Set<std::string>(lightTypeStr, _errors);
elem->GetAttribute("name")->Set<std::string>(this->Name(), _errors);
sdf::ElementPtr poseElem = elem->GetElement("pose", _errors);
if (!this->dataPtr->poseRelativeTo.empty())
{
poseElem->GetAttribute("relative_to")->Set<std::string>(
this->dataPtr->poseRelativeTo);
this->dataPtr->poseRelativeTo, _errors);
}
poseElem->Set<gz::math::Pose3d>(this->RawPose());

elem->GetElement("cast_shadows")->Set<bool>(this->CastShadows());
elem->GetElement("intensity")->Set<double>(this->Intensity());
elem->GetElement("direction")->Set<gz::math::Vector3d>(
this->Direction());
elem->GetElement("diffuse")->Set<gz::math::Color>(this->Diffuse());
elem->GetElement("specular")->Set<gz::math::Color>(this->Specular());
sdf::ElementPtr attenuationElem = elem->GetElement("attenuation");
attenuationElem->GetElement("linear")->Set<double>(
this->LinearAttenuationFactor());
attenuationElem->GetElement("constant")->Set<double>(
this->ConstantAttenuationFactor());
attenuationElem->GetElement("quadratic")->Set<double>(
this->QuadraticAttenuationFactor());
attenuationElem->GetElement("range")->Set<double>(
this->AttenuationRange());

sdf::ElementPtr spotElem = elem->GetElement("spot");
spotElem->GetElement("inner_angle")->Set<double>(
this->SpotInnerAngle().Radian());
spotElem->GetElement("outer_angle")->Set<double>(
this->SpotOuterAngle().Radian());
spotElem->GetElement("falloff")->Set<double>(this->SpotFalloff());
poseElem->Set<gz::math::Pose3d>(_errors, this->RawPose());

elem->GetElement("cast_shadows", _errors)->Set<bool>(
_errors, this->CastShadows());
elem->GetElement("intensity", _errors)->Set<double>(
_errors, this->Intensity());
elem->GetElement("direction", _errors)->Set<gz::math::Vector3d>(
_errors, this->Direction());
elem->GetElement("diffuse", _errors)->Set<gz::math::Color>(
_errors, this->Diffuse());
elem->GetElement("specular", _errors)->Set<gz::math::Color>(
_errors, this->Specular());
sdf::ElementPtr attenuationElem = elem->GetElement("attenuation", _errors);
attenuationElem->GetElement("linear", _errors)->Set<double>(
_errors, this->LinearAttenuationFactor());
attenuationElem->GetElement("constant", _errors)->Set<double>(
_errors, this->ConstantAttenuationFactor());
attenuationElem->GetElement("quadratic", _errors)->Set<double>(
_errors, this->QuadraticAttenuationFactor());
attenuationElem->GetElement("range", _errors)->Set<double>(
_errors, this->AttenuationRange());

sdf::ElementPtr spotElem = elem->GetElement("spot", _errors);
spotElem->GetElement("inner_angle", _errors)->Set<double>(
_errors, this->SpotInnerAngle().Radian());
spotElem->GetElement("outer_angle", _errors)->Set<double>(
_errors, this->SpotOuterAngle().Radian());
spotElem->GetElement("falloff", _errors)->Set<double>(
_errors, this->SpotFalloff());
return elem;
}
69 changes: 69 additions & 0 deletions src/Light_TEST.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,6 +18,7 @@
#include <gtest/gtest.h>
#include <gz/math/Pose3.hh>
#include "sdf/Light.hh"
#include "test_utils.hh"

/////////////////////////////////////////////////
TEST(DOMLight, DefaultConstruction)
Expand Down Expand Up @@ -400,3 +401,71 @@ TEST(DOMLight, ToElement)
light3.Load(light2Elem);
EXPECT_FALSE(light3.CastShadows());
}

/////////////////////////////////////////////////
TEST(DOMLight, ToElementErrorOutput)
{
std::stringstream buffer;
sdf::testing::RedirectConsoleStream redir(
sdf::Console::Instance()->GetMsgStream(), &buffer);

#ifdef _WIN32
sdf::Console::Instance()->SetQuiet(false);
sdf::testing::ScopeExit revertSetQuiet(
[]
{
sdf::Console::Instance()->SetQuiet(true);
});
#endif

// test calling ToElement on a DOM object constructed without calling Load
sdf::Light light;
light.SetName("test_light_assignment");
light.SetType(sdf::LightType::SPOT);
light.SetRawPose({3, 2, 1, 0, GZ_PI, 0});
light.SetPoseRelativeTo("ground_plane");
light.SetCastShadows(true);
light.SetDiffuse(gz::math::Color(0.4f, 0.5f, 0.6f, 1.0));
light.SetSpecular(gz::math::Color(0.8f, 0.9f, 0.1f, 1.0));
light.SetAttenuationRange(3.2);
light.SetLinearAttenuationFactor(0.1);
light.SetConstantAttenuationFactor(0.5);
light.SetQuadraticAttenuationFactor(0.01);
light.SetDirection({0.1, 0.2, 1});
light.SetSpotInnerAngle(1.9);
light.SetSpotOuterAngle(3.3);
light.SetSpotFalloff(0.9);
light.SetIntensity(1.7);

sdf::Errors errors;
sdf::ElementPtr lightElem = light.ToElement(errors);
EXPECT_TRUE(errors.empty());
EXPECT_NE(nullptr, lightElem);
EXPECT_EQ(nullptr, light.Element());

// verify values after loading the element back
sdf::Light light2;
errors = light2.Load(lightElem);
EXPECT_TRUE(errors.empty());

EXPECT_NE(nullptr, light2.Element());
EXPECT_EQ("test_light_assignment", light2.Name());
EXPECT_EQ(sdf::LightType::SPOT, light2.Type());
EXPECT_EQ(gz::math::Pose3d(3, 2, 1, 0, GZ_PI, 0), light2.RawPose());
EXPECT_EQ("ground_plane", light2.PoseRelativeTo());
EXPECT_TRUE(light2.CastShadows());
EXPECT_EQ(gz::math::Color(0.4f, 0.5f, 0.6f, 1), light2.Diffuse());
EXPECT_EQ(gz::math::Color(0.8f, 0.9f, 0.1f, 1), light2.Specular());
EXPECT_DOUBLE_EQ(3.2, light2.AttenuationRange());
EXPECT_DOUBLE_EQ(0.1, light2.LinearAttenuationFactor());
EXPECT_DOUBLE_EQ(0.5, light2.ConstantAttenuationFactor());
EXPECT_DOUBLE_EQ(0.01, light2.QuadraticAttenuationFactor());
EXPECT_EQ(gz::math::Vector3d(0.1, 0.2, 1), light2.Direction());
EXPECT_EQ(gz::math::Angle(1.9), light2.SpotInnerAngle());
EXPECT_EQ(gz::math::Angle(3.3), light2.SpotOuterAngle());
EXPECT_DOUBLE_EQ(0.9, light2.SpotFalloff());
EXPECT_DOUBLE_EQ(1.7, light2.Intensity());

// Check nothing has been printed
EXPECT_TRUE(buffer.str().empty()) << buffer.str();
}