How can we alternate between DQ_SerialManipulatorDH and DQ_SerialManipulatorMDH?

[marcos-pereira]

Hello everyone,

I would like to know how can we alternate between DQ_SerialManipulatorDH and DQ_SerialManipulatorMDH across different functions in the code.

For example, consider the code below:

#include <iostream>
#include <dqrobotics/DQ.h>
#include <dqrobotics/robot_modeling/DQ_SerialManipulatorDH.h>
#include <dqrobotics/robot_modeling/DQ_SerialManipulatorMDH.h>
#include <dqrobotics/robots/KukaLw4Robot.h>
#include <dqrobotics/robots/FrankaEmikaPandaRobot.h>

#include <memory>

using namespace DQ_robotics;

void function1(std::shared_ptr<DQ_SerialManipulatorDH> robot);
void function2(std::shared_ptr<DQ_SerialManipulatorDH> robot);

void function1(std::shared_ptr<DQ_SerialManipulatorDH> robot)
{
    function2(robot);
}

void function2(std::shared_ptr<DQ_SerialManipulatorDH> robot)
{
    // do stuff
}

int main(int argc, char **argv)
{   
    std::shared_ptr<DQ_SerialManipulatorDH> robot(nullptr);
    robot = std::make_shared<DQ_SerialManipulatorDH>(KukaLw4Robot::kinematics());

    return 0;
}

In the code above I am using a DQ_SerialManipulatorDH object. If I would like to test the same code for a DQ_SerialManipulatorMDH, I would need to change all the object types to DQ_SerialManipulatorMDH everywhere in the code.

The code above is short and simple, but when the code has several functions and the DQ_SerialManipulator object is passed across all of them, it is no so easy to adapt the code to use DQ_SerialManipulatorDH or DQ_SerialManipulatorMDH in a simple way.

Maybe I am missing some simple way of doing that, but at the moment I have not found a solution yet.

How would you recommend me to use the same code for both types of objects?

Kind regards,
Marcos

[bvadorno]

Hi @marcos-pereira,

It suffices to use DQ_SerialManipulator, the superclass, as the argument for your methods. When passing an object of DQ_SerialManipulatorDH or DQ_SerialManipulatorMDH, the compiler (or interpreter, in the case of MATLAB) is clever enough to recognize that the object belongs to one subclass or another and use the appropriate method implementation.

Kind regards,
Bruno

[marcos-pereira]

Hi @bvadorno ,

Many thanks for the quick response. I tried the solution in my short example above and it worked well. For anyone who comes here, I will leave the solution below:

#include <iostream>
#include <dqrobotics/DQ.h>
#include <dqrobotics/robot_modeling/DQ_SerialManipulatorDH.h>
#include <dqrobotics/robot_modeling/DQ_SerialManipulatorMDH.h>
#include <dqrobotics/robots/KukaLw4Robot.h>
#include <dqrobotics/robots/FrankaEmikaPandaRobot.h>

#include <memory>

using namespace DQ_robotics;

void function1(std::shared_ptr<DQ_SerialManipulator> robot);
void function2(std::shared_ptr<DQ_SerialManipulator> robot);

void function1(std::shared_ptr<DQ_SerialManipulator> robot)
{
    function2(robot);
}

void function2(std::shared_ptr<DQ_SerialManipulator> robot)
{
    // do stuff
}

int main(int argc, char **argv)
{   
    std::shared_ptr<DQ_SerialManipulatorDH> robot(nullptr);
    robot = std::make_shared<DQ_SerialManipulatorDH>(KukaLw4Robot::kinematics());
    function1(robot);

    return 0;
}

Thanks,
Marcos

[mmmarinho]

@marcos-pereira In case we're trying to make a suggestion for future users, this would be my initial suggestion instead. I haven't tried to compile this so if you find a typo let me know.

PS: I'd like to add there's no dqrobotics magic here, it's simply how subclass polymorphism is used in modern C++ with smart pointers.

#include <memory>

#include <dqrobotics/DQ.h>
#include <dqrobotics/robot_modeling/DQ_SerialManipulatorDH.h>
#include <dqrobotics/robot_modeling/DQ_SerialManipulatorMDH.h>
#include <dqrobotics/robots/KukaLw4Robot.h>
#include <dqrobotics/robots/FrankaEmikaPandaRobot.h>

using namespace DQ_robotics;

void do_something(const std::shared_ptr<DQ_SerialManipulator>& robot);

int main(int, char**)
{   
    auto robot1 = std::make_shared<DQ_SerialManipulatorDH>(KukaLw4Robot::kinematics());
    auto robot2 = std::make_shared<DQ_SerialManipulatorMDH>(FrankaEmikaPandaRobot::kinematics());

    do_something(robot1);
    do_something(robot2);

    return 0;
}

void do_something(const std::shared_ptr<DQ_SerialManipulator>& robot)
{
    //Do something
}

[marcos-pereira]

Hi @mmmarinho ,

I adapted my code to follow the same standard as yours. It compiled without errors.

Here follows the code:

#include <memory>

#include <dqrobotics/DQ.h>
#include <dqrobotics/robot_modeling/DQ_SerialManipulatorDH.h>
#include <dqrobotics/robot_modeling/DQ_SerialManipulatorMDH.h>
#include <dqrobotics/robots/KukaLw4Robot.h>
#include <dqrobotics/robots/FrankaEmikaPandaRobot.h>

using namespace DQ_robotics;

void function1(const std::shared_ptr<DQ_SerialManipulator>& robot);
void function2(const std::shared_ptr<DQ_SerialManipulator>& robot);

int main(int, char **)
{   
    auto robot1 = std::make_shared<DQ_SerialManipulatorDH>(KukaLw4Robot::kinematics());
    auto robot2 = std::make_shared<DQ_SerialManipulatorMDH>(FrankaEmikaPandaRobot::kinematics());

    function1(robot1);
    function1(robot2);

    return 0;
}

void function1(const std::shared_ptr<DQ_SerialManipulator>& robot)
{
    function2(robot);
}

void function2(const std::shared_ptr<DQ_SerialManipulator>& robot)
{
    // do stuff
}

I think the specific details here are related to C++ syntax:

1. When you pass variables by reference, you need to make them const (I am not the best person to explain it clearly why). People can read the explanation here.
2. To declare variables using auto is okay as long as you can infer the variable type. The way it was done is ok because it is initialized explicitly as a shared_ptr.

@bvadorno the reason for coding it the way @mmmarinho did is probably because of the reason mentioned here. I believe it is more related to C++ best practices.

Kind regards,
Marcos

[mmmarinho]

@marcos-pereira

1. Passing a copy of a std::shared_ptr when you don't need one unnecessarily increases the reference count just to have it decreased when the copy is destroyed. Hence the reference. The const is simply to enforce in compilation time that the method will not modify the shared pointer, in this case where the shared pointer points to. It will give out a compilation error if you try to do so.
2. auto reduces verbosity, with massive usability in many parts of modern C++. In this particular case, if you already wrote DQ_SerialManipulatorDH in the assignment of the smart pointer, it is a waste of time and space to repeat the same thing instead of just using auto. It also makes it easier to maintain, as someone will only need to change one mention to the class.

---

Additional tips:

---

1. When you're posting on github, please add the cpp modifier to the code snippets so that they have syntax highlighting.

int main(void)

is not easy to read, whereas

int main(void)

is much easier.

---

2. Don't name variables you don't use, otherwise you'll get warnings. For good programers, most warnings should also be taken as errors.
   There is no point doing

int main(int argc, char **argv)
{   
    return 0;
}

If you don't use argc and argv.
Do, instead,

int main(int, char **)
{   
    return 0;
}

[marcos-pereira]

Hi @mmmarinho ,

Many thanks for the clear explanations and tips. I edited my answers above to add the cpp modifier. Also, I removed the unused variables from my last code above.

Kind regards,
Marcos

[mmmarinho]

Closed discussions don't show up in the list anymore so maybe we can leave this open?

[bvadorno]

Hi @mmmarinho,

Let's go ahead and leave it open. Could you add some comments to your reply to highlight the advantages of your implementation over what Marcos did? It will be very educational for people using smart pointers, and then we can incorporate your solution into a section on tips for best practices.

Thanks,
Bruno