From f12409f011cdb710727cf5349f436a61846815bb Mon Sep 17 00:00:00 2001 From: Stefano Date: Fri, 11 Jun 2021 19:31:23 +0200 Subject: [PATCH 01/15] Added Label interface to visualizer. --- src/visualization/CMakeLists.txt | 2 + .../include/iDynTree/Visualizer.h | 75 ++++++++++ src/visualization/src/Label.cpp | 129 ++++++++++++++++++ src/visualization/src/Label.h | 55 ++++++++ src/visualization/src/Visualizer.cpp | 4 + 5 files changed, 265 insertions(+) create mode 100644 src/visualization/src/Label.cpp create mode 100644 src/visualization/src/Label.h diff --git a/src/visualization/CMakeLists.txt b/src/visualization/CMakeLists.txt index b8461ad507a..0f0ae63170b 100644 --- a/src/visualization/CMakeLists.txt +++ b/src/visualization/CMakeLists.txt @@ -21,6 +21,7 @@ if(IDYNTREE_USES_IRRLICHT) src/Texture.h src/TexturesHandler.h src/Light.h + src/Label.h src/FloorGridSceneNode.h) set(iDynTree_visualization_private_source src/Camera.cpp src/CameraAnimator.cpp @@ -32,6 +33,7 @@ if(IDYNTREE_USES_IRRLICHT) src/Texture.cpp src/TexturesHandler.cpp src/Light.cpp + src/Label.cpp src/FloorGridSceneNode.cpp) endif() diff --git a/src/visualization/include/iDynTree/Visualizer.h b/src/visualization/include/iDynTree/Visualizer.h index cc971eed30c..2f269480f07 100644 --- a/src/visualization/include/iDynTree/Visualizer.h +++ b/src/visualization/include/iDynTree/Visualizer.h @@ -619,6 +619,81 @@ class IModelVisualization virtual Transform getWorldFrameTransform(const std::string& frameName) = 0; }; +/** + * The interface to add a label in the visualizer. + */ + +class ILabel +{ +public: + + /** + * Destructor + */ + virtual ~ILabel() = 0; + + /** + * @brief Set the text of the label + * @param text The text to be displayed + */ + virtual void setText(const std::string& text) = 0; + + /** + * @brief Get the label text + * @return The text shown in the label. + */ + virtual std::string getText() const = 0; + + /** + * @brief Set the height of the label. The width is computed automatically + * @param height The height to be set + */ + virtual void setSize(float height) = 0; + + /** + * @brief Set the width and the height of the label + * @param width The width of the label + * @param height The height of the label + */ + virtual void setSize(float width, float height) = 0; + + /** + * @brief Get the width of the label + * @return The width of the label + */ + virtual float width() const = 0; + + /** + * @brief Get the height of the label + * @return The height of the label + */ + virtual float height() const = 0; + + /** + * @brief Set the position of the label + * @param position The position of the label + */ + virtual void setPosition(const iDynTree::Position& position) = 0; + + /** + * @brief Get the position of the label + * @return The position of the label + */ + virtual iDynTree::Position getPosition() const = 0; + + /** + * @brief Set the color of the label + * @param color The color of the label + */ + virtual void setColor(const iDynTree::ColorViz& color) = 0; + + /** + * @brief Set the visibility of the label + * @param visible The visibility of the label + */ + virtual void setVisible(bool visible = true) = 0; +}; + /** * The interface for an object that can be used as an additional target for the renderer. * This allows rendering the scene using dimensions and environment that are different from diff --git a/src/visualization/src/Label.cpp b/src/visualization/src/Label.cpp new file mode 100644 index 00000000000..da58cd72219 --- /dev/null +++ b/src/visualization/src/Label.cpp @@ -0,0 +1,129 @@ +/* + * Copyright (C) 2021 Fondazione Istituto Italiano di Tecnologia + * + * Licensed under either the GNU Lesser General Public License v3.0 : + * https://www.gnu.org/licenses/lgpl-3.0.html + * or the GNU Lesser General Public License v2.1 : + * https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html + * at your option. + */ + +#include "Label.h" +#include +#include +#include +#include +#include "IrrlichtUtils.h" + + +Label::~Label() +{ + if (m_font) + { + m_font->drop(); + m_font = nullptr; + } + + if (m_label) + { + m_label->drop(); + m_label = nullptr; + } +} + +void Label::init(irr::scene::ISceneManager *smgr, irr::scene::ISceneNode *parent) +{ + assert(smgr); + m_font = smgr->getGUIEnvironment()->getBuiltInFont(); + m_font->grab(); + + m_label = smgr->addBillboardTextSceneNode(m_font, L"", parent); + m_label->grab(); +} + +void Label::setText(const std::string &text) +{ + assert(m_font); + assert(m_label); + using convert_typeX = std::codecvt_utf8; + std::wstring_convert converterX; + m_wtext = converterX.from_bytes(text).c_str(); //See https://stackoverflow.com/a/18374698 + m_label->setText(m_wtext.c_str()); + m_text = text; + if (m_ratio >= 0) + { + auto dims = m_font->getDimension(m_wtext.c_str()); + if (dims.Height) + { + m_ratio = dims.Width / (float) dims.Height; + m_width = m_ratio * m_height; + m_label->setSize({m_width, m_height}); + } + } + setColor(m_color); +} + +std::string Label::getText() const +{ + return m_text; +} + +void Label::setSize(float height) +{ + assert(m_font); + assert(m_label); + + m_height = -height; + auto dims = m_font->getDimension(m_wtext.c_str()); + if (dims.Height) + { + m_ratio = dims.Width / (float) dims.Height; + m_width = m_ratio * m_height; + m_label->setSize({m_width, m_height}); + } + +} + +void Label::setSize(float width, float height) +{ + m_height = -height; + m_width = -width; + m_ratio = -1.0; + m_label->setSize({m_width, m_height}); +} + +float Label::width() const +{ + return m_width; +} + +float Label::height() const +{ + return m_height; +} + +void Label::setPosition(const iDynTree::Position &position) +{ + assert(m_label); + m_label->setPosition(iDynTree::idyntree2irr_pos(position)); +} + +iDynTree::Position Label::getPosition() const +{ + assert(m_label); + return iDynTree::irr2idyntree_pos(m_label->getPosition()); +} + +void Label::setColor(const iDynTree::ColorViz &color) +{ + assert(m_label); + m_color = color; + m_label->setTextColor(iDynTree::idyntree2irrlicht(color).toSColor()); + m_label->setColor(iDynTree::idyntree2irrlicht(color).toSColor()); +} + +void Label::setVisible(bool visible) +{ + assert(m_label); + m_label->setVisible(visible); +} diff --git a/src/visualization/src/Label.h b/src/visualization/src/Label.h new file mode 100644 index 00000000000..8a9e1f7c2cb --- /dev/null +++ b/src/visualization/src/Label.h @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2021 Fondazione Istituto Italiano di Tecnologia + * + * Licensed under either the GNU Lesser General Public License v3.0 : + * https://www.gnu.org/licenses/lgpl-3.0.html + * or the GNU Lesser General Public License v2.1 : + * https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html + * at your option. + */ + +#ifndef IDYNTREE_LABEL_H +#define IDYNTREE_LABEL_H + +#include +#include + +class Label : public iDynTree::ILabel +{ + irr::gui::IGUIFont* m_font{nullptr}; + irr::scene::IBillboardTextSceneNode* m_label{nullptr}; + float m_ratio{1.0}; + float m_width{0.0}; + float m_height{-0.1}; + std::string m_text; + std::wstring m_wtext; + iDynTree::ColorViz m_color{0.0, 0.0, 0.0, 1.0}; + +public: + + virtual ~Label(); + + void init(irr::scene::ISceneManager* smgr, irr::scene::ISceneNode* parent = nullptr); + + virtual void setText(const std::string& text) final; + + virtual std::string getText() const final; + + virtual void setSize(float height) final; + + virtual void setSize(float width, float height) final; + + virtual float width() const final; + + virtual float height() const final; + + virtual void setPosition(const iDynTree::Position& position) final; + + virtual iDynTree::Position getPosition() const final; + + virtual void setColor(const iDynTree::ColorViz& color) final; + + virtual void setVisible(bool visible = true) final; +}; + +#endif // LABEL_H diff --git a/src/visualization/src/Visualizer.cpp b/src/visualization/src/Visualizer.cpp index 24bea9fca6a..7783543e39f 100644 --- a/src/visualization/src/Visualizer.cpp +++ b/src/visualization/src/Visualizer.cpp @@ -56,6 +56,10 @@ IModelVisualization::~IModelVisualization() { } +ILabel::~ILabel() +{ +} + ILight::~ILight() { } From 8db6e8037e8e3eac823f9cb4d504125f1b25354c Mon Sep 17 00:00:00 2001 From: Stefano Date: Mon, 14 Jun 2021 09:50:47 +0200 Subject: [PATCH 02/15] Added use of Label interface in the Visualizer main class and in vectors visualization. --- .../include/iDynTree/Visualizer.h | 162 ++++++++++-------- src/visualization/src/DummyImplementations.h | 17 ++ src/visualization/src/Label.cpp | 47 +++++ src/visualization/src/Label.h | 14 +- .../src/VectorsVisualization.cpp | 27 ++- src/visualization/src/VectorsVisualization.h | 6 +- src/visualization/src/Visualizer.cpp | 26 +++ .../tests/VisualizerUnitTest.cpp | 2 +- 8 files changed, 215 insertions(+), 86 deletions(-) diff --git a/src/visualization/include/iDynTree/Visualizer.h b/src/visualization/include/iDynTree/Visualizer.h index 2f269480f07..b3dab98d554 100644 --- a/src/visualization/include/iDynTree/Visualizer.h +++ b/src/visualization/include/iDynTree/Visualizer.h @@ -382,6 +382,81 @@ class IJetsVisualization virtual bool setJetsIntensity(const VectorDynSize & jetsIntensity) = 0; }; +/** + * The interface to add a label in the visualizer. + */ + +class ILabel +{ +public: + + /** + * Destructor + */ + virtual ~ILabel() = 0; + + /** + * @brief Set the text of the label + * @param text The text to be displayed + */ + virtual void setText(const std::string& text) = 0; + + /** + * @brief Get the label text + * @return The text shown in the label. + */ + virtual std::string getText() const = 0; + + /** + * @brief Set the height of the label. The width is computed automatically + * @param height The height to be set + */ + virtual void setSize(float height) = 0; + + /** + * @brief Set the width and the height of the label + * @param width The width of the label + * @param height The height of the label + */ + virtual void setSize(float width, float height) = 0; + + /** + * @brief Get the width of the label + * @return The width of the label + */ + virtual float width() const = 0; + + /** + * @brief Get the height of the label + * @return The height of the label + */ + virtual float height() const = 0; + + /** + * @brief Set the position of the label + * @param position The position of the label + */ + virtual void setPosition(const iDynTree::Position& position) = 0; + + /** + * @brief Get the position of the label + * @return The position of the label + */ + virtual iDynTree::Position getPosition() const = 0; + + /** + * @brief Set the color of the label + * @param color The color of the label + */ + virtual void setColor(const iDynTree::ColorViz& color) = 0; + + /** + * @brief Set the visibility of the label + * @param visible The visibility of the label + */ + virtual void setVisible(bool visible = true) = 0; +}; + /** * Interface to the visualization of vectors. */ @@ -454,6 +529,13 @@ class IVectorsVisualization * @return true if successfull, false in case of negative numbers. */ virtual bool setVectorsAspect(double zeroModulusRadius, double modulusMultiplier, double heightScale) = 0; + + /** + * @brief Get the label associated to a vector + * @param vectorIndex The index of the vector to get the label + * @return The label associated to the vector. nullptr if the vectorIndex is out of bounds. + */ + virtual ILabel* getVectorLabel(size_t vectorIndex) = 0; }; /** @@ -619,81 +701,6 @@ class IModelVisualization virtual Transform getWorldFrameTransform(const std::string& frameName) = 0; }; -/** - * The interface to add a label in the visualizer. - */ - -class ILabel -{ -public: - - /** - * Destructor - */ - virtual ~ILabel() = 0; - - /** - * @brief Set the text of the label - * @param text The text to be displayed - */ - virtual void setText(const std::string& text) = 0; - - /** - * @brief Get the label text - * @return The text shown in the label. - */ - virtual std::string getText() const = 0; - - /** - * @brief Set the height of the label. The width is computed automatically - * @param height The height to be set - */ - virtual void setSize(float height) = 0; - - /** - * @brief Set the width and the height of the label - * @param width The width of the label - * @param height The height of the label - */ - virtual void setSize(float width, float height) = 0; - - /** - * @brief Get the width of the label - * @return The width of the label - */ - virtual float width() const = 0; - - /** - * @brief Get the height of the label - * @return The height of the label - */ - virtual float height() const = 0; - - /** - * @brief Set the position of the label - * @param position The position of the label - */ - virtual void setPosition(const iDynTree::Position& position) = 0; - - /** - * @brief Get the position of the label - * @return The position of the label - */ - virtual iDynTree::Position getPosition() const = 0; - - /** - * @brief Set the color of the label - * @param color The color of the label - */ - virtual void setColor(const iDynTree::ColorViz& color) = 0; - - /** - * @brief Set the visibility of the label - * @param visible The visibility of the label - */ - virtual void setVisible(bool visible = true) = 0; -}; - /** * The interface for an object that can be used as an additional target for the renderer. * This allows rendering the scene using dimensions and environment that are different from @@ -890,6 +897,11 @@ friend class ModelVisualization; */ ITexturesHandler& textures(); + /** + * Get a label given a name. Note: this does not set the text in the label. + */ + ILabel& getLabel(const std::string& labelName); + /** * Wrap the run method of the Irrlicht device. */ diff --git a/src/visualization/src/DummyImplementations.h b/src/visualization/src/DummyImplementations.h index 905d28a2fa1..67dbe1fc372 100644 --- a/src/visualization/src/DummyImplementations.h +++ b/src/visualization/src/DummyImplementations.h @@ -93,6 +93,22 @@ class DummyJetsVisualization : public IJetsVisualization virtual bool setJetsIntensity(const VectorDynSize & ) { return false; }; }; +class DummyLabel : public iDynTree::ILabel +{ +public: + virtual ~DummyLabel() override {}; + virtual void setText(const std::string& ) override {}; + virtual std::string getText() const override {return "";}; + virtual void setSize(float ) override {}; + virtual void setSize(float , float ) override {}; + virtual float width() const override {return 0.0;}; + virtual float height() const override {return 0.0;}; + virtual void setPosition(const iDynTree::Position& ) override {}; + virtual iDynTree::Position getPosition() const override {return iDynTree::Position::Zero();}; + virtual void setColor(const iDynTree::ColorViz& ) override {}; + virtual void setVisible(bool ) override {}; +}; + class DummyVectorsVisualization : public IVectorsVisualization { public: virtual ~DummyVectorsVisualization() override { } @@ -107,6 +123,7 @@ class DummyVectorsVisualization : public IVectorsVisualization { virtual bool setVectorsAspect(double, double, double) override { return false; } virtual void setVectorsColor(const ColorViz &) override { return; } virtual void setVectorsDefaultColor(const ColorViz &) override { return; } + virtual ILabel* getVectorLabel(size_t ) override {return nullptr;} }; class DummyFrameVisualization : public IFrameVisualization diff --git a/src/visualization/src/Label.cpp b/src/visualization/src/Label.cpp index da58cd72219..6e5bdd9a1fe 100644 --- a/src/visualization/src/Label.cpp +++ b/src/visualization/src/Label.cpp @@ -16,6 +16,48 @@ #include "IrrlichtUtils.h" +Label::Label() +{ + +} + +Label::Label(const Label &other) +{ + operator=(other); +} + +Label::Label(Label &&other) +{ + operator=(other); +} + +Label &Label::operator=(const Label &other) +{ + m_font = other.m_font; + if (m_font) + { + m_font->grab(); + } + + m_label = other.m_label; + if (m_label) + { + m_label->grab(); + } + return *this; +} + +Label &Label::operator=(Label &&other) +{ + m_font = other.m_font; + other.m_font = nullptr; + + m_label = other.m_label; + other.m_label = nullptr; + + return *this; +} + Label::~Label() { if (m_font) @@ -41,6 +83,11 @@ void Label::init(irr::scene::ISceneManager *smgr, irr::scene::ISceneNode *parent m_label->grab(); } +bool Label::initialized() const +{ + return m_font && m_label; +} + void Label::setText(const std::string &text) { assert(m_font); diff --git a/src/visualization/src/Label.h b/src/visualization/src/Label.h index 8a9e1f7c2cb..172a5eb7633 100644 --- a/src/visualization/src/Label.h +++ b/src/visualization/src/Label.h @@ -27,10 +27,22 @@ class Label : public iDynTree::ILabel public: + Label(); + + Label(const Label& other); + + Label(Label&& other); + + Label& operator=(const Label& other); + + Label& operator=(Label&& other); + virtual ~Label(); void init(irr::scene::ISceneManager* smgr, irr::scene::ISceneNode* parent = nullptr); + bool initialized() const; + virtual void setText(const std::string& text) final; virtual std::string getText() const final; @@ -49,7 +61,7 @@ class Label : public iDynTree::ILabel virtual void setColor(const iDynTree::ColorViz& color) final; - virtual void setVisible(bool visible = true) final; + virtual void setVisible(bool visible) final; }; #endif // LABEL_H diff --git a/src/visualization/src/VectorsVisualization.cpp b/src/visualization/src/VectorsVisualization.cpp index 86e1049e199..ae11eba5b59 100644 --- a/src/visualization/src/VectorsVisualization.cpp +++ b/src/visualization/src/VectorsVisualization.cpp @@ -22,13 +22,6 @@ using namespace iDynTree; void VectorsVisualization::drawVector(size_t vectorIndex) { - // Delete existing node - if (m_vectors[vectorIndex].visualizationNode) - { - m_vectors[vectorIndex].visualizationNode->remove(); - m_vectors[vectorIndex].visualizationNode = nullptr; - } - float arrowHeight = static_cast(std::abs(m_vectors[vectorIndex].modulus) * m_heightScale); float arrowWidth = static_cast(m_radiusOffset + m_radiusMultiplier * std::abs(m_vectors[vectorIndex].modulus) * m_heightScale); @@ -58,7 +51,14 @@ void VectorsVisualization::drawVector(size_t vectorIndex) irr::scene::IMesh* arrowMesh = m_smgr->getGeometryCreator()->createArrowMesh(4, 8, arrowHeight, 0.9f * arrowHeight, arrowWidth, 2.0f * arrowWidth); - m_vectors[vectorIndex].visualizationNode = m_smgr->addMeshSceneNode(arrowMesh,frameNode); + if (m_vectors[vectorIndex].visualizationNode) + { + m_vectors[vectorIndex].visualizationNode->setMesh(arrowMesh); + } + else + { + m_vectors[vectorIndex].visualizationNode = m_smgr->addMeshSceneNode(arrowMesh,frameNode); + } m_vectors[vectorIndex].visualizationNode->setPosition(arrowPosition); m_vectors[vectorIndex].visualizationNode->setRotation(arrowRotation); irr::video::SMaterial arrowColor; @@ -128,6 +128,7 @@ size_t VectorsVisualization::addVector(const Position &origin, const Direction & m_vectors.push_back(newVector); drawVector(m_vectors.size()-1); + m_vectors.back().label.init(m_smgr, m_vectors.back().visualizationNode); return m_vectors.size() - 1; } @@ -243,3 +244,13 @@ bool VectorsVisualization::setVectorsAspect(double zeroModulusRadius, double mod return true; } + +ILabel *VectorsVisualization::getVectorLabel(size_t vectorIndex) +{ + if (vectorIndex >= m_vectors.size()) { + reportError("VectorsVisualization","getVectorLabel","vectorIndex out of bounds."); + return nullptr; + } + + return &m_vectors[vectorIndex].label; +} diff --git a/src/visualization/src/VectorsVisualization.h b/src/visualization/src/VectorsVisualization.h index 006a2a923a3..8ae9b40404e 100644 --- a/src/visualization/src/VectorsVisualization.h +++ b/src/visualization/src/VectorsVisualization.h @@ -11,6 +11,7 @@ #define IDYNTREE_VECTORS_VISUALIZATION_H #include +#include "Label.h" #include #include @@ -24,7 +25,8 @@ namespace iDynTree { Direction direction; double modulus; ColorViz color = ColorViz(1.0, 0.0, 0.0, 1.0); - irr::scene::ISceneNode * visualizationNode = nullptr; + Label label; + irr::scene::IMeshSceneNode * visualizationNode = nullptr; } VectorsProperties; ColorViz m_vectorsDefaultColor{ColorViz(1.0, 0.0, 0.0, 1.0)}; @@ -76,6 +78,8 @@ namespace iDynTree { virtual bool setVectorsAspect(double zeroModulusRadius, double modulusMultiplier, double heightScale) override; + virtual ILabel* getVectorLabel(size_t vectorIndex) override; + }; } diff --git a/src/visualization/src/Visualizer.cpp b/src/visualization/src/Visualizer.cpp index 7783543e39f..b45689af216 100644 --- a/src/visualization/src/Visualizer.cpp +++ b/src/visualization/src/Visualizer.cpp @@ -22,10 +22,12 @@ #include "FrameVisualization.h" #include "TexturesHandler.h" #include "CameraAnimator.h" +#include "Label.h" #endif #include "DummyImplementations.h" +#include #include namespace iDynTree @@ -152,7 +154,16 @@ struct Visualizer::VisualizerPimpl */ TexturesHandler m_textures; + /** + * Dimension of the root frame arrows + */ double rootFrameArrowsDimension; + + /** + * Set of labels + */ + std::unordered_map m_labels; + struct ColorPalette { irr::video::SColorf background = irr::video::SColorf(0.0,0.4,0.4,1.0); @@ -190,6 +201,7 @@ struct Visualizer::VisualizerPimpl DummyVectorsVisualization m_invalidVectors; DummyFrameVisualization m_invalidFrames; DummyTexturesHandler m_invalidTextures; + DummyLabel m_invalidLabel; #endif VisualizerPimpl() @@ -536,6 +548,20 @@ ITexturesHandler &Visualizer::textures() #endif } +ILabel &Visualizer::getLabel(const std::string &labelName) +{ +#ifdef IDYNTREE_USES_IRRLICHT + Label& requestedLabel = this->pimpl->m_labels[labelName]; + if (!requestedLabel.initialized()) + { + requestedLabel.init(this->pimpl->m_irrSmgr); + } + return requestedLabel; +#else + return this->pimpl->m_invalidLabel; +#endif +} + bool Visualizer::run() { #ifdef IDYNTREE_USES_IRRLICHT diff --git a/src/visualization/tests/VisualizerUnitTest.cpp b/src/visualization/tests/VisualizerUnitTest.cpp index 82dee9f5d4a..a20c6cf8640 100644 --- a/src/visualization/tests/VisualizerUnitTest.cpp +++ b/src/visualization/tests/VisualizerUnitTest.cpp @@ -76,7 +76,7 @@ void checkArrowsVisualization() { ok = vectors.updateVector(index, iDynTree::Position(0.2, 0.1, 0.1), components); ASSERT_IS_TRUE(ok); - + vectors.getVectorLabel(0)->setText("Vector0"); for(int i=0; i < 5; i++) { From 9c07f69ae8aebd25ef317c3695bf81981226d474 Mon Sep 17 00:00:00 2001 From: Stefano Date: Mon, 14 Jun 2021 10:00:04 +0200 Subject: [PATCH 03/15] Added possibility to change the visibility of a vector. --- src/visualization/include/iDynTree/Visualizer.h | 8 ++++++++ src/visualization/src/DummyImplementations.h | 1 + src/visualization/src/VectorsVisualization.cpp | 12 ++++++++++++ src/visualization/src/VectorsVisualization.h | 2 ++ src/visualization/tests/VisualizerUnitTest.cpp | 8 ++++++++ 5 files changed, 31 insertions(+) diff --git a/src/visualization/include/iDynTree/Visualizer.h b/src/visualization/include/iDynTree/Visualizer.h index b3dab98d554..961874b229c 100644 --- a/src/visualization/include/iDynTree/Visualizer.h +++ b/src/visualization/include/iDynTree/Visualizer.h @@ -530,6 +530,14 @@ class IVectorsVisualization */ virtual bool setVectorsAspect(double zeroModulusRadius, double modulusMultiplier, double heightScale) = 0; + /** + * @brief Set the visibility of a given vector + * @param The index of the vector to change the visibility + * @param visible The visibility of the vector + * @return true if successfull, false if the index is out of bounds + */ + virtual bool setVisible(size_t vectorIndex, bool visible = true) = 0; + /** * @brief Get the label associated to a vector * @param vectorIndex The index of the vector to get the label diff --git a/src/visualization/src/DummyImplementations.h b/src/visualization/src/DummyImplementations.h index 67dbe1fc372..c32ba6dc485 100644 --- a/src/visualization/src/DummyImplementations.h +++ b/src/visualization/src/DummyImplementations.h @@ -123,6 +123,7 @@ class DummyVectorsVisualization : public IVectorsVisualization { virtual bool setVectorsAspect(double, double, double) override { return false; } virtual void setVectorsColor(const ColorViz &) override { return; } virtual void setVectorsDefaultColor(const ColorViz &) override { return; } + virtual bool setVisible(size_t , bool ) override { return false; } virtual ILabel* getVectorLabel(size_t ) override {return nullptr;} }; diff --git a/src/visualization/src/VectorsVisualization.cpp b/src/visualization/src/VectorsVisualization.cpp index ae11eba5b59..dcb28b08468 100644 --- a/src/visualization/src/VectorsVisualization.cpp +++ b/src/visualization/src/VectorsVisualization.cpp @@ -245,6 +245,18 @@ bool VectorsVisualization::setVectorsAspect(double zeroModulusRadius, double mod return true; } +bool VectorsVisualization::setVisible(size_t vectorIndex, bool visible) +{ + if (vectorIndex >= m_vectors.size()) { + reportError("VectorsVisualization","setVisible","vectorIndex out of bounds."); + return false; + } + + m_vectors[vectorIndex].visualizationNode->setVisible(visible); + + return true; +} + ILabel *VectorsVisualization::getVectorLabel(size_t vectorIndex) { if (vectorIndex >= m_vectors.size()) { diff --git a/src/visualization/src/VectorsVisualization.h b/src/visualization/src/VectorsVisualization.h index 8ae9b40404e..fbbc6d99ba9 100644 --- a/src/visualization/src/VectorsVisualization.h +++ b/src/visualization/src/VectorsVisualization.h @@ -78,6 +78,8 @@ namespace iDynTree { virtual bool setVectorsAspect(double zeroModulusRadius, double modulusMultiplier, double heightScale) override; + virtual bool setVisible(size_t vectorIndex, bool visible) override; + virtual ILabel* getVectorLabel(size_t vectorIndex) override; }; diff --git a/src/visualization/tests/VisualizerUnitTest.cpp b/src/visualization/tests/VisualizerUnitTest.cpp index a20c6cf8640..9754cd8cbf0 100644 --- a/src/visualization/tests/VisualizerUnitTest.cpp +++ b/src/visualization/tests/VisualizerUnitTest.cpp @@ -83,6 +83,14 @@ void checkArrowsVisualization() { viz.draw(); } + ok = vectors.setVisible(0, false); + ASSERT_IS_TRUE(ok); + + for(int i=0; i < 5; i++) + { + viz.draw(); + } + viz.close(); } From 7564d2ff18093a0f80173575116a53e009c8eaea Mon Sep 17 00:00:00 2001 From: Stefano Date: Mon, 14 Jun 2021 10:54:21 +0200 Subject: [PATCH 04/15] Added interface to set frame labels. --- src/visualization/include/iDynTree/Visualizer.h | 7 +++++++ src/visualization/src/DummyImplementations.h | 1 + src/visualization/src/FrameVisualization.cpp | 11 +++++++++++ src/visualization/src/FrameVisualization.h | 4 ++++ src/visualization/tests/VisualizerUnitTest.cpp | 2 ++ 5 files changed, 25 insertions(+) diff --git a/src/visualization/include/iDynTree/Visualizer.h b/src/visualization/include/iDynTree/Visualizer.h index 961874b229c..fd086317374 100644 --- a/src/visualization/include/iDynTree/Visualizer.h +++ b/src/visualization/include/iDynTree/Visualizer.h @@ -585,6 +585,13 @@ class IFrameVisualization * Update Frame */ virtual bool updateFrame(size_t frameIndex, const Transform& transformation) = 0; + + /** + * Get the label of a frame. + * + * Returns nullptr of the frame index is out of bounds. + */ + virtual ILabel* getFrameLabel(size_t frameIndex) = 0; }; diff --git a/src/visualization/src/DummyImplementations.h b/src/visualization/src/DummyImplementations.h index c32ba6dc485..254e19b420d 100644 --- a/src/visualization/src/DummyImplementations.h +++ b/src/visualization/src/DummyImplementations.h @@ -137,6 +137,7 @@ class DummyFrameVisualization : public IFrameVisualization virtual size_t getNrOfFrames() const override {return 0; }; virtual bool getFrameTransform(size_t , Transform& ) const override {return false;}; virtual bool updateFrame(size_t, const Transform&) override {return false;}; + virtual ILabel* getFrameLabel(size_t) override {return nullptr;}; }; /** diff --git a/src/visualization/src/FrameVisualization.cpp b/src/visualization/src/FrameVisualization.cpp index 6e3d0be2bcc..caeaf5d733d 100644 --- a/src/visualization/src/FrameVisualization.cpp +++ b/src/visualization/src/FrameVisualization.cpp @@ -31,6 +31,7 @@ size_t iDynTree::FrameVisualization::addFrame(const iDynTree::Transform &transfo m_frames.back().visualizationNode = addFrameAxes(m_smgr, 0, arrowLength); setFrameTransform(m_frames.size() - 1, transformation); + m_frames.back().label.init(m_smgr, m_frames.back().visualizationNode); return m_frames.size() - 1; } @@ -76,6 +77,16 @@ bool iDynTree::FrameVisualization::updateFrame(size_t frameIndex, const iDynTree return true; } +iDynTree::ILabel *iDynTree::FrameVisualization::getFrameLabel(size_t frameIndex) +{ + if (frameIndex >= m_frames.size()) { + reportError("FrameVisualization","getFrameLabel","frameIndex out of bounds."); + return nullptr; + } + + return &m_frames[frameIndex].label; +} + iDynTree::FrameVisualization::~FrameVisualization() { close(); diff --git a/src/visualization/src/FrameVisualization.h b/src/visualization/src/FrameVisualization.h index 331d4a02906..f04bb4f4452 100644 --- a/src/visualization/src/FrameVisualization.h +++ b/src/visualization/src/FrameVisualization.h @@ -11,6 +11,7 @@ #define IDYNTREE_FRAMEVISUALIZATION_H #include +#include "Label.h" #include #include @@ -22,6 +23,7 @@ namespace iDynTree struct Frame { irr::scene::ISceneNode * visualizationNode = nullptr; + Label label; }; std::vector m_frames; @@ -53,6 +55,8 @@ namespace iDynTree virtual bool updateFrame(size_t frameIndex, const Transform& transformation) final; + virtual ILabel* getFrameLabel(size_t frameIndex) final; + }; } diff --git a/src/visualization/tests/VisualizerUnitTest.cpp b/src/visualization/tests/VisualizerUnitTest.cpp index 9754cd8cbf0..5071f1271ea 100644 --- a/src/visualization/tests/VisualizerUnitTest.cpp +++ b/src/visualization/tests/VisualizerUnitTest.cpp @@ -141,6 +141,7 @@ void checkFrameVisualization() { size_t index = frames.addFrame(firstTransform); ASSERT_IS_TRUE(index == 0); + frames.getFrameLabel(0)->setText("First"); iDynTree::Transform secondTransform; secondTransform.setRotation(iDynTree::Rotation::RPY(-1.57, 0,0)); @@ -148,6 +149,7 @@ void checkFrameVisualization() { index = frames.addFrame(secondTransform); ASSERT_IS_TRUE(index == 1); + frames.getFrameLabel(1)->setText("Second"); for(int i=0; i < 5; i++) { From 8dcc172b0e05e43f5041f26be182b1538cebac67 Mon Sep 17 00:00:00 2001 From: Stefano Date: Mon, 14 Jun 2021 11:03:52 +0200 Subject: [PATCH 05/15] Added label test. --- src/visualization/src/Visualizer.cpp | 4 ++++ src/visualization/tests/VisualizerUnitTest.cpp | 17 +++++++++++++++++ 2 files changed, 21 insertions(+) diff --git a/src/visualization/src/Visualizer.cpp b/src/visualization/src/Visualizer.cpp index b45689af216..383e32db344 100644 --- a/src/visualization/src/Visualizer.cpp +++ b/src/visualization/src/Visualizer.cpp @@ -551,6 +551,10 @@ ITexturesHandler &Visualizer::textures() ILabel &Visualizer::getLabel(const std::string &labelName) { #ifdef IDYNTREE_USES_IRRLICHT + if( !this->pimpl->m_isInitialized ) + { + init(); + } Label& requestedLabel = this->pimpl->m_labels[labelName]; if (!requestedLabel.initialized()) { diff --git a/src/visualization/tests/VisualizerUnitTest.cpp b/src/visualization/tests/VisualizerUnitTest.cpp index 5071f1271ea..c0058456aef 100644 --- a/src/visualization/tests/VisualizerUnitTest.cpp +++ b/src/visualization/tests/VisualizerUnitTest.cpp @@ -186,12 +186,29 @@ void checkFrameVisualization() { } +void checkLabelVisualization() +{ + iDynTree::Visualizer viz; + + iDynTree::ILabel& label = viz.getLabel("dummy"); + label.setText("Label test"); + label.setSize(1.0); + label.setPosition(iDynTree::Position(-1.0, -1.0, 0.1)); + label.setColor(iDynTree::ColorViz(1.0, 0.0, 0.0, 0.0)); + + for(int i=0; i < 5; i++) + { + viz.draw(); + } +} + int main() { threeLinksReducedTest(); checkArrowsVisualization(); checkAdditionalTexture(); checkFrameVisualization(); + checkLabelVisualization(); return EXIT_SUCCESS; } From 7b02547625bbd5f152c49941ecc4eb077f3b3a55 Mon Sep 17 00:00:00 2001 From: Stefano Date: Mon, 14 Jun 2021 12:46:25 +0200 Subject: [PATCH 06/15] Added labels to model visualization. --- .../include/iDynTree/Visualizer.h | 5 +++++ src/visualization/src/DummyImplementations.h | 2 ++ src/visualization/src/ModelVisualization.cpp | 18 ++++++++++++++++++ src/visualization/src/ModelVisualization.h | 3 ++- src/visualization/tests/VisualizerUnitTest.cpp | 5 +++++ 5 files changed, 32 insertions(+), 1 deletion(-) diff --git a/src/visualization/include/iDynTree/Visualizer.h b/src/visualization/include/iDynTree/Visualizer.h index fd086317374..dad921f660c 100644 --- a/src/visualization/include/iDynTree/Visualizer.h +++ b/src/visualization/include/iDynTree/Visualizer.h @@ -714,6 +714,11 @@ class IModelVisualization * Get the transformation of given frame with respect to visualizer world \f$ w_H_{frame}\f$ */ virtual Transform getWorldFrameTransform(const std::string& frameName) = 0; + + /** + * Get the label for the model. + */ + virtual ILabel& label() = 0; }; /** diff --git a/src/visualization/src/DummyImplementations.h b/src/visualization/src/DummyImplementations.h index 254e19b420d..c6f80a82390 100644 --- a/src/visualization/src/DummyImplementations.h +++ b/src/visualization/src/DummyImplementations.h @@ -147,6 +147,7 @@ class DummyModelVisualization : public IModelVisualization { Model m_dummyModel; DummyJetsVisualization m_dummyJets; + DummyLabel m_dummyLabel; public: virtual ~DummyModelVisualization() {}; virtual bool init(const Model& , const std::string , Visualizer &) { return false; } @@ -170,6 +171,7 @@ class DummyModelVisualization : public IModelVisualization virtual Transform getWorldFrameTransform(const FrameIndex &) { return iDynTree::Transform::Identity(); } virtual Transform getWorldLinkTransform(const std::string &) { return iDynTree::Transform::Identity(); } virtual Transform getWorldFrameTransform(const std::string &) { return iDynTree::Transform::Identity(); } + virtual ILabel& label() { return m_dummyLabel; }; }; class DummyTexturesHandler : public ITexturesHandler diff --git a/src/visualization/src/ModelVisualization.cpp b/src/visualization/src/ModelVisualization.cpp index f58e39db8af..358b9748cc1 100644 --- a/src/visualization/src/ModelVisualization.cpp +++ b/src/visualization/src/ModelVisualization.cpp @@ -11,6 +11,7 @@ #include "ModelVisualization.h" #include "JetsVisualization.h" #include "IrrlichtUtils.h" +#include "Label.h" #include #include @@ -72,6 +73,11 @@ struct ModelVisualization::ModelVisualizationPimpl */ JetsVisualization m_jets; + /** + * The label of the model + */ + Label m_label; + ModelVisualizationPimpl() { @@ -202,6 +208,13 @@ bool ModelVisualization::init(const Model& model, // Initialize the jets visualizer this->pimpl->m_jets.init(this->pimpl->m_irrSmgr,this,&(this->pimpl->frameNodes)); + irr::scene::ISceneNode* labelParent = this->pimpl->modelNode; + if (this->pimpl->linkNodes.size() > 0) + { + labelParent = this->pimpl->linkNodes.front(); + } + this->pimpl->m_label.init(this->pimpl->m_irrSmgr, labelParent); + pimpl->m_isValid = true; return true; @@ -274,6 +287,11 @@ Transform ModelVisualization::getWorldFrameTransform(const std::string& frameNam return getWorldFrameTransform(frameIndex); } +ILabel &ModelVisualization::label() +{ + return pimpl->m_label; +} + bool ModelVisualization::setPositions(const Transform& world_H_base, const VectorDynSize& jointPos) { diff --git a/src/visualization/src/ModelVisualization.h b/src/visualization/src/ModelVisualization.h index 7b251b095b9..7f69e58b26a 100644 --- a/src/visualization/src/ModelVisualization.h +++ b/src/visualization/src/ModelVisualization.h @@ -41,7 +41,7 @@ class ModelVisualization: public IModelVisualization virtual void setModelColor(const ColorViz & modelColor); virtual void resetModelColor(); virtual bool setLinkColor(const LinkIndex& linkIndex, const ColorViz& linkColor); - virtual bool resetLinkColor(const LinkIndex& linkIndex); + virtual bool resetLinkColor(const LinkIndex& linkIndex); virtual std::vector< std::string > getLinkNames(); virtual bool setLinkVisibility(const std::string & linkName, bool isVisible); virtual std::vector getFeatures(); @@ -54,6 +54,7 @@ class ModelVisualization: public IModelVisualization virtual Transform getWorldFrameTransform(const FrameIndex& frameIndex); virtual Transform getWorldLinkTransform(const std::string& linkName); virtual Transform getWorldFrameTransform(const std::string& frameName); + virtual ILabel& label(); }; } diff --git a/src/visualization/tests/VisualizerUnitTest.cpp b/src/visualization/tests/VisualizerUnitTest.cpp index c0058456aef..873b8dcc9b0 100644 --- a/src/visualization/tests/VisualizerUnitTest.cpp +++ b/src/visualization/tests/VisualizerUnitTest.cpp @@ -23,6 +23,11 @@ void checkVizLoading(const iDynTree::Model & model) bool ok = viz.addModel(model,"model"); ASSERT_IS_TRUE(ok); + iDynTree::ILabel& label = viz.modelViz("model").label(); + label.setText("TEST MODEL"); + label.setSize(1.0); + label.setPosition(iDynTree::Position(-1.0, -1.0, 0.3)); + for(int i=0; i < 5; i++) { viz.draw(); From b5fc73bbac5861aa72c4f7c095f5a3c1b18c1ac0 Mon Sep 17 00:00:00 2001 From: Stefano Date: Mon, 14 Jun 2021 12:46:59 +0200 Subject: [PATCH 07/15] Bumped version. --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 3d4ad25bb2d..2afd2a10eee 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,7 +8,7 @@ cmake_minimum_required(VERSION 3.16) -project(iDynTree VERSION 3.2.1 +project(iDynTree VERSION 3.3.0 LANGUAGES C CXX) # Disable in source build, unless Eclipse is used From a60de01a9cfadbdf13a6aa45c00bd040ad9662c5 Mon Sep 17 00:00:00 2001 From: Stefano Date: Mon, 14 Jun 2021 19:22:35 +0200 Subject: [PATCH 08/15] Updated CHANGELOG. --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index f1e36862431..3b605c806c5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Unreleased] +### Added +- Add the visualization of labels in the visualizer (https://github.com/robotology/idyntree/pull/879) ## [3.2.1] - 2021-06-07 From 1f4400f214a9cfcae3680a5fcbed296334c89d61 Mon Sep 17 00:00:00 2001 From: Stefano Date: Mon, 14 Jun 2021 19:27:13 +0200 Subject: [PATCH 09/15] Inverting label width and height before returning them. --- src/visualization/src/Label.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/visualization/src/Label.cpp b/src/visualization/src/Label.cpp index 6e5bdd9a1fe..84b4e7d9844 100644 --- a/src/visualization/src/Label.cpp +++ b/src/visualization/src/Label.cpp @@ -141,12 +141,12 @@ void Label::setSize(float width, float height) float Label::width() const { - return m_width; + return -m_width; } float Label::height() const { - return m_height; + return -m_height; } void Label::setPosition(const iDynTree::Position &position) From d24617e625c12638504ea01ee44e11c16de0696e Mon Sep 17 00:00:00 2001 From: Stefano Date: Tue, 15 Jun 2021 09:52:12 +0200 Subject: [PATCH 10/15] Bumped version to 4.0 --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 2afd2a10eee..2eab0935d4a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,7 +8,7 @@ cmake_minimum_required(VERSION 3.16) -project(iDynTree VERSION 3.3.0 +project(iDynTree VERSION 4.0.0 LANGUAGES C CXX) # Disable in source build, unless Eclipse is used From 9506a9d5c28f961046d7d3f3783c274ca60f613e Mon Sep 17 00:00:00 2001 From: Silvio Traversaro Date: Wed, 7 Jul 2021 18:31:56 +0200 Subject: [PATCH 11/15] Remove unused par2urdf.cpp --- src/tools/par2urdf.cpp | 54 ------------------------------------------ 1 file changed, 54 deletions(-) delete mode 100644 src/tools/par2urdf.cpp diff --git a/src/tools/par2urdf.cpp b/src/tools/par2urdf.cpp deleted file mode 100644 index 9f08e59466f..00000000000 --- a/src/tools/par2urdf.cpp +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright (C) 2013 Fondazione Istituto Italiano di Tecnologia - * - * Licensed under either the GNU Lesser General Public License v3.0 : - * https://www.gnu.org/licenses/lgpl-3.0.html - * or the GNU Lesser General Public License v2.1 : - * https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html - * at your option. - */ - -/* Author: Silvio Traversaro */ - - -#include -#include - -#include -#include - -#include - -#include - - -using namespace KDL; -using namespace std; -using namespace iDynTree; - -int main(int argc, char** argv) -{ - if (argc != 3){ - std::cerr << "Usage: par2urdf robot.par robot.urdf" << std::endl; - return -1; - } - - symoro_par_model mdl; - - if( !parModelFromFile(argv[1],mdl) ) {cerr << "Could not parse SYMORO par robot model" << endl; return EXIT_FAILURE;} - - std::cout << "Extracted par file" << std::endl; - std::cout << mdl.toString() << std::endl; - - - Tree my_tree; - if (!treeFromSymoroParFile(argv[1],my_tree,true)) - {cerr << "Could not generate robot model and extract kdl tree" << endl; return EXIT_FAILURE;} - - if( !treeToUrdfFile(argv[2],my_tree,"par_file_robot") ) - {cerr << "Could not export KDL::Tree to URDF file" << endl; return EXIT_FAILURE;} - - return EXIT_SUCCESS; -} - - From b8e26ba266954381cfa1099bc6e7e02c85279c5a Mon Sep 17 00:00:00 2001 From: Silvio Traversaro Date: Wed, 7 Jul 2021 23:55:30 +0200 Subject: [PATCH 12/15] Remove deprecated headers (#885) * Update CMakeLists.txt * Delete AngularForceVector3.h * Delete AngularMotionVector3.h * Delete ForceVector3.h * Delete LinearForceVector3.h * Delete LinearMotionVector3.h * Delete MotionVector3.h * Update CHANGELOG.md * Update CHANGELOG.md --- CHANGELOG.md | 3 +++ src/core/CMakeLists.txt | 9 +-------- .../iDynTree/Core/AngularForceVector3.h | 18 ------------------ .../iDynTree/Core/AngularMotionVector3.h | 18 ------------------ src/core/include/iDynTree/Core/ForceVector3.h | 18 ------------------ .../include/iDynTree/Core/LinearForceVector3.h | 18 ------------------ .../iDynTree/Core/LinearMotionVector3.h | 18 ------------------ src/core/include/iDynTree/Core/MotionVector3.h | 18 ------------------ 8 files changed, 4 insertions(+), 116 deletions(-) delete mode 100644 src/core/include/iDynTree/Core/AngularForceVector3.h delete mode 100644 src/core/include/iDynTree/Core/AngularMotionVector3.h delete mode 100644 src/core/include/iDynTree/Core/ForceVector3.h delete mode 100644 src/core/include/iDynTree/Core/LinearForceVector3.h delete mode 100644 src/core/include/iDynTree/Core/LinearMotionVector3.h delete mode 100644 src/core/include/iDynTree/Core/MotionVector3.h diff --git a/CHANGELOG.md b/CHANGELOG.md index 3fe51832d60..b1e194bbd26 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added - Add the visualization of labels in the visualizer (https://github.com/robotology/idyntree/pull/879) +### Removed +- Remove headers `iDynTree/Core/AngularForceVector3.h`, `iDynTree/Core/AngularMotionVector3.h`, `include/iDynTree/Core/ForceVector3.h`, `iDynTree/Core/LinearForceVector3.h`, `include/iDynTree/Core/LinearMotionVector3.h`, `include/iDynTree/Core/MotionVector3.h`. They were deprecated in iDynTree 2.0 (https://github.com/robotology/idyntree/pull/708, https://github.com/robotology/idyntree/pull/885). + ## [Unreleased] ### Added diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index ee69859d3c1..fbe4f27d209 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -44,14 +44,7 @@ set(IDYNTREE_CORE_EXP_HEADERS include/iDynTree/Core/Axis.h include/iDynTree/Core/CubicSpline.h include/iDynTree/Core/Span.h include/iDynTree/Core/SO3Utils.h - include/iDynTree/Core/MatrixView.h - # Deprecated headers - include/iDynTree/Core/AngularForceVector3.h - include/iDynTree/Core/AngularMotionVector3.h - include/iDynTree/Core/ForceVector3.h - include/iDynTree/Core/LinearForceVector3.h - include/iDynTree/Core/LinearMotionVector3.h - include/iDynTree/Core/MotionVector3.h) + include/iDynTree/Core/MatrixView.h) set(IDYNTREE_CORE_EXP_SOURCES src/Axis.cpp diff --git a/src/core/include/iDynTree/Core/AngularForceVector3.h b/src/core/include/iDynTree/Core/AngularForceVector3.h deleted file mode 100644 index 6b3b7ba393a..00000000000 --- a/src/core/include/iDynTree/Core/AngularForceVector3.h +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (C) Fondazione Istituto Italiano di Tecnologia - * - * Licensed under either the GNU Lesser General Public License v3.0 : - * https://www.gnu.org/licenses/lgpl-3.0.html - * or the GNU Lesser General Public License v2.1 : - * https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html - * at your option. - */ - -#ifndef IDYNTREE_ANGULAR_FORCE_VECTOR_3_H -#define IDYNTREE_ANGULAR_FORCE_VECTOR_3_H - -#warning is deprecated. Please use GeomVector3 and . - -#include - -#endif /* IDYNTREE_ANGULAR_FORCE_VECTOR_3_H */ diff --git a/src/core/include/iDynTree/Core/AngularMotionVector3.h b/src/core/include/iDynTree/Core/AngularMotionVector3.h deleted file mode 100644 index abe8ed12a79..00000000000 --- a/src/core/include/iDynTree/Core/AngularMotionVector3.h +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (C) Fondazione Istituto Italiano di Tecnologia - * - * Licensed under either the GNU Lesser General Public License v3.0 : - * https://www.gnu.org/licenses/lgpl-3.0.html - * or the GNU Lesser General Public License v2.1 : - * https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html - * at your option. - */ - -#ifndef IDYNTREE_ANGULAR_MOTION_VECTOR_3_H -#define IDYNTREE_ANGULAR_MOTION_VECTOR_3_H - -#warning is deprecated. Please use GeomVector3 and . - -#include - -#endif /* IDYNTREE_ANGULAR_MOTION_VECTOR_3_H */ diff --git a/src/core/include/iDynTree/Core/ForceVector3.h b/src/core/include/iDynTree/Core/ForceVector3.h deleted file mode 100644 index b07fb2c1877..00000000000 --- a/src/core/include/iDynTree/Core/ForceVector3.h +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (C) Fondazione Istituto Italiano di Tecnologia - * - * Licensed under either the GNU Lesser General Public License v3.0 : - * https://www.gnu.org/licenses/lgpl-3.0.html - * or the GNU Lesser General Public License v2.1 : - * https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html - * at your option. - */ - -#ifndef IDYNTREE_FORCE_VECTOR_3_H -#define IDYNTREE_FORCE_VECTOR_3_H - -#warning is deprecated. Please use GeomVector3 and . - -#include - -#endif /* IDYNTREE_FORCE_VECTOR_3_H */ diff --git a/src/core/include/iDynTree/Core/LinearForceVector3.h b/src/core/include/iDynTree/Core/LinearForceVector3.h deleted file mode 100644 index 82a81f245b6..00000000000 --- a/src/core/include/iDynTree/Core/LinearForceVector3.h +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (C) Fondazione Istituto Italiano di Tecnologia - * - * Licensed under either the GNU Lesser General Public License v3.0 : - * https://www.gnu.org/licenses/lgpl-3.0.html - * or the GNU Lesser General Public License v2.1 : - * https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html - * at your option. - */ - -#ifndef IDYNTREE_LINEAR_FORCE_VECTOR_3_H -#define IDYNTREE_LINEAR_FORCE_VECTOR_3_H - -#warning is deprecated. Please use GeomVector3 and . - -#include - -#endif /* IDYNTREE_LINEAR_FORCE_VECTOR_3_H */ diff --git a/src/core/include/iDynTree/Core/LinearMotionVector3.h b/src/core/include/iDynTree/Core/LinearMotionVector3.h deleted file mode 100644 index 9527fff2acb..00000000000 --- a/src/core/include/iDynTree/Core/LinearMotionVector3.h +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (C) Fondazione Istituto Italiano di Tecnologia - * - * Licensed under either the GNU Lesser General Public License v3.0 : - * https://www.gnu.org/licenses/lgpl-3.0.html - * or the GNU Lesser General Public License v2.1 : - * https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html - * at your option. - */ - -#ifndef IDYNTREE_LINEAR_MOTION_VECTOR_3_H -#define IDYNTREE_LINEAR_MOTION_VECTOR_3_H - -#warning is deprecated. Please use GeomVector3 and . - -#include - -#endif /* IDYNTREE_LINEAR_MOTION_VECTOR_3_H */ diff --git a/src/core/include/iDynTree/Core/MotionVector3.h b/src/core/include/iDynTree/Core/MotionVector3.h deleted file mode 100644 index eabdcdd3444..00000000000 --- a/src/core/include/iDynTree/Core/MotionVector3.h +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (C) Fondazione Istituto Italiano di Tecnologia - * - * Licensed under either the GNU Lesser General Public License v3.0 : - * https://www.gnu.org/licenses/lgpl-3.0.html - * or the GNU Lesser General Public License v2.1 : - * https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html - * at your option. - */ - -#ifndef IDYNTREE_MOTION_VECTOR_3_H -#define IDYNTREE_MOTION_VECTOR_3_H - -#warning is deprecated. Please use GeomVector3 and . - -#include - -#endif /* IDYNTREE_MOTION_VECTOR_3_H */ From 8203507c25bd02e1c2d71484239d69e02cbe6c3b Mon Sep 17 00:00:00 2001 From: Silvio Traversaro Date: Fri, 9 Jul 2021 14:52:08 +0200 Subject: [PATCH 13/15] Change methods to const in InverseKinematics class (#883) Co-authored-by: Giulio Romualdi --- bindings/matlab/autogenerated/iDynTreeMATLAB_wrap.cxx | 4 ++-- .../include/iDynTree/ConvexHullHelpers.h | 4 ++-- .../include/iDynTree/InverseKinematics.h | 6 +++--- src/inverse-kinematics/src/ConvexHullHelpers.cpp | 4 ++-- src/inverse-kinematics/src/InverseKinematics.cpp | 11 ++++------- 5 files changed, 13 insertions(+), 16 deletions(-) diff --git a/bindings/matlab/autogenerated/iDynTreeMATLAB_wrap.cxx b/bindings/matlab/autogenerated/iDynTreeMATLAB_wrap.cxx index 93bc6b45fdb..89017018851 100644 --- a/bindings/matlab/autogenerated/iDynTreeMATLAB_wrap.cxx +++ b/bindings/matlab/autogenerated/iDynTreeMATLAB_wrap.cxx @@ -105312,7 +105312,7 @@ int _wrap_InverseKinematics_setCOMTarget__SWIG_1(int resc, mxArray *resv[], int int _wrap_InverseKinematics_setCOMTarget__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) { iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ; - SwigValueWrapper< iDynTree::Span< double,-1 > > arg2 ; + SwigValueWrapper< iDynTree::Span< const double,-1 > > arg2 ; double arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -105358,7 +105358,7 @@ int _wrap_InverseKinematics_setCOMTarget__SWIG_2(int resc, mxArray *resv[], int int _wrap_InverseKinematics_setCOMTarget__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) { iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ; - SwigValueWrapper< iDynTree::Span< double,-1 > > arg2 ; + SwigValueWrapper< iDynTree::Span< const double,-1 > > arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; diff --git a/src/inverse-kinematics/include/iDynTree/ConvexHullHelpers.h b/src/inverse-kinematics/include/iDynTree/ConvexHullHelpers.h index a824aa990bd..a140872922f 100644 --- a/src/inverse-kinematics/include/iDynTree/ConvexHullHelpers.h +++ b/src/inverse-kinematics/include/iDynTree/ConvexHullHelpers.h @@ -238,7 +238,7 @@ namespace iDynTree * * @param direction vector along which we want to project a point */ - void setProjectionAlongDirection(Vector3 direction); + void setProjectionAlongDirection(const iDynTree::Vector3& direction); /*! * Project a point along a direction defined by the projection matrix 'Pdirection' @@ -247,7 +247,7 @@ namespace iDynTree * * @param posIn3dInAbsoluteFrame a point we want to project */ - Vector2 projectAlongDirection(iDynTree::Position& posIn3dInAbsoluteFrame); + Vector2 projectAlongDirection(const iDynTree::Position& posIn3dInAbsoluteFrame); }; } diff --git a/src/inverse-kinematics/include/iDynTree/InverseKinematics.h b/src/inverse-kinematics/include/iDynTree/InverseKinematics.h index 3c66fa8c341..f4e2348e266 100644 --- a/src/inverse-kinematics/include/iDynTree/InverseKinematics.h +++ b/src/inverse-kinematics/include/iDynTree/InverseKinematics.h @@ -1069,9 +1069,9 @@ class iDynTree::InverseKinematics const Model & reducedModel() const; - void setCOMTarget(iDynTree::Position& desiredPosition, double weight = 1.0); + void setCOMTarget(const iDynTree::Position& desiredPosition, double weight = 1.0); - bool setCOMTarget(iDynTree::Span desiredPosition, double weight = 1.0); + bool setCOMTarget(iDynTree::Span desiredPosition, double weight = 1.0); void setCOMAsConstraint(bool asConstraint = true); @@ -1090,7 +1090,7 @@ class iDynTree::InverseKinematics * * @param direction vector along which we want to project a point */ - void setCOMConstraintProjectionDirection(iDynTree::Vector3 direction); + void setCOMConstraintProjectionDirection(const iDynTree::Vector3& direction); bool setCOMConstraintProjectionDirection(iDynTree::Span direction); diff --git a/src/inverse-kinematics/src/ConvexHullHelpers.cpp b/src/inverse-kinematics/src/ConvexHullHelpers.cpp index d3d01c9cfde..5f7451d4b79 100644 --- a/src/inverse-kinematics/src/ConvexHullHelpers.cpp +++ b/src/inverse-kinematics/src/ConvexHullHelpers.cpp @@ -351,7 +351,7 @@ namespace iDynTree return margin; } - void ConvexHullProjectionConstraint::setProjectionAlongDirection(Vector3 direction) + void ConvexHullProjectionConstraint::setProjectionAlongDirection(const Vector3& direction) { Vector3 xProjection, yProjection; @@ -371,7 +371,7 @@ namespace iDynTree } - Vector2 ConvexHullProjectionConstraint::projectAlongDirection(iDynTree::Position& posIn3dInAbsoluteFrame) + Vector2 ConvexHullProjectionConstraint::projectAlongDirection(const iDynTree::Position& posIn3dInAbsoluteFrame) { iDynTree::Vector2 projected; toEigen(projected) = toEigen(Pdirection) * toEigen(posIn3dInAbsoluteFrame - o); diff --git a/src/inverse-kinematics/src/InverseKinematics.cpp b/src/inverse-kinematics/src/InverseKinematics.cpp index 1cab8b1031e..85fb513603a 100644 --- a/src/inverse-kinematics/src/InverseKinematics.cpp +++ b/src/inverse-kinematics/src/InverseKinematics.cpp @@ -1353,7 +1353,7 @@ namespace iDynTree { } // this should be const reference but we keep it like this to avoid breaking the API. Please change me in iDynTree 4.0 - void InverseKinematics::setCOMTarget(Position& desiredPosition, double weight) + void InverseKinematics::setCOMTarget(const Position& desiredPosition, double weight) { #ifdef IDYNTREE_USES_IPOPT IK_PIMPL(m_pimpl)->setCoMTarget(desiredPosition, weight); @@ -1362,7 +1362,7 @@ namespace iDynTree { #endif } - bool InverseKinematics::setCOMTarget(iDynTree::Span desiredPosition, double weight) + bool InverseKinematics::setCOMTarget(iDynTree::Span desiredPosition, double weight) { constexpr int expected_pos_size = 3; bool ok = (desiredPosition.size() == expected_pos_size); @@ -1372,9 +1372,7 @@ namespace iDynTree { return false; } - // TODO please remove me in iDynTree 4.0 - Position tmp(desiredPosition); - this->setCOMTarget(tmp, weight); + this->setCOMTarget(Position(desiredPosition), weight); return true; } @@ -1398,8 +1396,7 @@ namespace iDynTree { #endif } - // this should be const reference but we keep it like this to avoid breaking the API. Please change me in iDynTree 4.0 - void InverseKinematics::setCOMConstraintProjectionDirection(iDynTree::Vector3 direction) + void InverseKinematics::setCOMConstraintProjectionDirection(const iDynTree::Vector3& direction) { this->setCOMConstraintProjectionDirection(make_span(direction)); } From 7f17e19d20a6024b44f2b3cdb939ae9034254ae5 Mon Sep 17 00:00:00 2001 From: Silvio Traversaro Date: Sat, 10 Jul 2021 00:13:43 +0200 Subject: [PATCH 14/15] Remove deprecated methods (#884) --- CHANGELOG.md | 2 +- .../autogenerated/iDynTreeMATLAB_wrap.cxx | 23 ++----------------- .../include/iDynTree/Sensors/Sensors.h | 9 -------- src/sensors/src/Sensors.cpp | 12 ---------- .../include/iDynTree/Visualizer.h | 8 ------- src/visualization/src/DummyImplementations.h | 1 - src/visualization/src/ModelVisualization.cpp | 8 ------- src/visualization/src/ModelVisualization.h | 1 - 8 files changed, 3 insertions(+), 61 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b1e194bbd26..4e125824be6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,12 +11,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Removed - Remove headers `iDynTree/Core/AngularForceVector3.h`, `iDynTree/Core/AngularMotionVector3.h`, `include/iDynTree/Core/ForceVector3.h`, `iDynTree/Core/LinearForceVector3.h`, `include/iDynTree/Core/LinearMotionVector3.h`, `include/iDynTree/Core/MotionVector3.h`. They were deprecated in iDynTree 2.0 (https://github.com/robotology/idyntree/pull/708, https://github.com/robotology/idyntree/pull/885). +- The method `ModelVisualization::getWorldModelTransform()` was removed, it was deprecated in iDynTree 3.0.1 . ## [Unreleased] ### Added - Add the `is/asPrismaticJoint` methods in the bindings (https://github.com/robotology/idyntree/issues/881, https://github.com/robotology/idyntree/pull/882) ->>>>>>> master ## [3.2.1] - 2021-06-07 diff --git a/bindings/matlab/autogenerated/iDynTreeMATLAB_wrap.cxx b/bindings/matlab/autogenerated/iDynTreeMATLAB_wrap.cxx index 89017018851..1960f4e323b 100644 --- a/bindings/matlab/autogenerated/iDynTreeMATLAB_wrap.cxx +++ b/bindings/matlab/autogenerated/iDynTreeMATLAB_wrap.cxx @@ -63614,7 +63614,7 @@ int _wrap_SensorsList_getSensorIndex__SWIG_1(int resc, mxArray *resv[], int argc iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ; iDynTree::SensorType *arg2 = 0 ; std::string *arg3 = 0 ; - unsigned int *arg4 = 0 ; + ptrdiff_t *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; @@ -63659,7 +63659,7 @@ int _wrap_SensorsList_getSensorIndex__SWIG_1(int resc, mxArray *resv[], int argc if (!argp4) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsList_getSensorIndex" "', argument " "4"" of type '" "unsigned int &""'"); } - arg4 = reinterpret_cast< unsigned int * >(argp4); + arg4 = reinterpret_cast< ptrdiff_t * >(argp4); result = (bool)((iDynTree::SensorsList const *)arg1)->getSensorIndex((iDynTree::SensorType const &)*arg2,(std::string const &)*arg3,*arg4); _out = SWIG_From_bool(static_cast< bool >(result)); if (_out) --resc, *resv++ = _out; @@ -95146,25 +95146,6 @@ int _wrap_IModelVisualization_jets(int resc, mxArray *resv[], int argc, mxArray int _wrap_IModelVisualization_getWorldModelTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) { - iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mxArray * _out; - iDynTree::Transform result; - - if (!SWIG_check_num_args("IModelVisualization_getWorldModelTransform",argc,1,1,0)) { - SWIG_fail; - } - res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IModelVisualization_getWorldModelTransform" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); - } - arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1); - result = (arg1)->getWorldModelTransform(); - _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN | 0 ); - if (_out) --resc, *resv++ = _out; - return 0; -fail: return 1; } diff --git a/src/sensors/include/iDynTree/Sensors/Sensors.h b/src/sensors/include/iDynTree/Sensors/Sensors.h index 55bf9f75970..15fcedc2440 100644 --- a/src/sensors/include/iDynTree/Sensors/Sensors.h +++ b/src/sensors/include/iDynTree/Sensors/Sensors.h @@ -330,15 +330,6 @@ namespace iDynTree { */ bool getSensorIndex(const SensorType & sensor_type, const std::string & _sensor_name, std::ptrdiff_t & sensor_index) const; - /** - * Get the index of a sensor of type sensor_type in this SensorList - * - * @return true if the sensor name is found, false otherwise. - * - * @deprecated Use the version that takes in input a std::ptrdiff_t sensor_index - */ - IDYNTREE_DEPRECATED_WITH_MSG("Use std::ptrdiff_t for representing the SensorIndex.") bool getSensorIndex(const SensorType & sensor_type, const std::string & _sensor_name, unsigned int & sensor_index) const; - /** * Get the index of a sensor of type sensor_type and with name sensor_name * diff --git a/src/sensors/src/Sensors.cpp b/src/sensors/src/Sensors.cpp index 0b82858d3ac..a5fc18ba0a2 100644 --- a/src/sensors/src/Sensors.cpp +++ b/src/sensors/src/Sensors.cpp @@ -202,18 +202,6 @@ bool SensorsList::getSensorIndex(const SensorType & sensor_type, const std::stri } } -bool SensorsList::getSensorIndex(const SensorType & sensor_type, const std::string & _sensor_name, unsigned int & sensor_index) const -{ - std::ptrdiff_t sensor_index_full ; - bool ret = this->getSensorIndex(sensor_type, _sensor_name, sensor_index_full); - if (ret) - { - sensor_index = static_cast(sensor_index_full); - } - return ret; -} - - std::ptrdiff_t SensorsList::getSensorIndex(const SensorType& sensor_type, const std::string& _sensor_name) const { std::ptrdiff_t retVal; diff --git a/src/visualization/include/iDynTree/Visualizer.h b/src/visualization/include/iDynTree/Visualizer.h index dad921f660c..1383d488f7a 100644 --- a/src/visualization/include/iDynTree/Visualizer.h +++ b/src/visualization/include/iDynTree/Visualizer.h @@ -687,14 +687,6 @@ class IModelVisualization */ virtual IJetsVisualization& jets() = 0; - /** - * Get the transformation of the model (root link) with respect to visualizer world \f$ w_H_{root}\f$ - * The obtained transformation matrix can be used to map any homogeneous vector from the - * model's root link frame to the visualizer world frame. - */ - IDYNTREE_DEPRECATED_WITH_MSG("This method is simply returning the identity. If you need the root link transformation matrix, please use the getWorldLinkTransform() method.") - virtual Transform getWorldModelTransform() = 0; - /** * Get the transformation of given link with respect to visualizer world \f$ w_H_{link}\f$ */ diff --git a/src/visualization/src/DummyImplementations.h b/src/visualization/src/DummyImplementations.h index c6f80a82390..e4b2e89d6d0 100644 --- a/src/visualization/src/DummyImplementations.h +++ b/src/visualization/src/DummyImplementations.h @@ -166,7 +166,6 @@ class DummyModelVisualization : public IModelVisualization virtual std::vector getFeatures() { return std::vector(); } virtual bool setFeatureVisibility(const std::string& , bool) { return false; } virtual IJetsVisualization& jets() { return m_dummyJets; } - virtual Transform getWorldModelTransform() { return iDynTree::Transform::Identity(); } virtual Transform getWorldLinkTransform(const LinkIndex &) { return iDynTree::Transform::Identity(); } virtual Transform getWorldFrameTransform(const FrameIndex &) { return iDynTree::Transform::Identity(); } virtual Transform getWorldLinkTransform(const std::string &) { return iDynTree::Transform::Identity(); } diff --git a/src/visualization/src/ModelVisualization.cpp b/src/visualization/src/ModelVisualization.cpp index 358b9748cc1..4642ab7cb80 100644 --- a/src/visualization/src/ModelVisualization.cpp +++ b/src/visualization/src/ModelVisualization.cpp @@ -225,14 +225,6 @@ Model& ModelVisualization::model() return this->pimpl->m_model; } -Transform ModelVisualization::getWorldModelTransform() -{ - Transform w_H_b; - irr::core::matrix4 relativeTransform(this->pimpl->modelNode->getRelativeTransformation()); - w_H_b = irr2idyntree_trans(relativeTransform); - return w_H_b; -} - Transform ModelVisualization::getWorldLinkTransform(const LinkIndex& linkIndex) { if (linkIndex < 0 || linkIndex >= pimpl->geomNodes.size()) diff --git a/src/visualization/src/ModelVisualization.h b/src/visualization/src/ModelVisualization.h index 7f69e58b26a..aa19ae2d440 100644 --- a/src/visualization/src/ModelVisualization.h +++ b/src/visualization/src/ModelVisualization.h @@ -49,7 +49,6 @@ class ModelVisualization: public IModelVisualization void setWireframeVisibility(bool isVisible); void setTransparent(bool isTransparent); virtual IJetsVisualization& jets(); - virtual Transform getWorldModelTransform(); virtual Transform getWorldLinkTransform(const LinkIndex& linkIndex); virtual Transform getWorldFrameTransform(const FrameIndex& frameIndex); virtual Transform getWorldLinkTransform(const std::string& linkName); From bf4be57c2d114973894429a285fa72d6022bdc75 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 11 Jul 2021 10:51:53 +0200 Subject: [PATCH 15/15] update matlab bindings (#895) Co-authored-by: traversaro --- .../ConvexHullProjectionConstraint.m | 56 +- .../+iDynTree/IFrameVisualization.m | 15 +- .../matlab/autogenerated/+iDynTree/ILabel.m | 51 + .../+iDynTree/IModelVisualization.m | 40 +- .../matlab/autogenerated/+iDynTree/ITexture.m | 8 +- .../+iDynTree/ITexturesHandler.m | 6 +- .../+iDynTree/IVectorsVisualization.m | 24 +- .../+iDynTree/InverseKinematics.m | 118 +- .../matlab/autogenerated/+iDynTree/Polygon.m | 20 +- .../autogenerated/+iDynTree/Polygon2D.m | 16 +- .../autogenerated/+iDynTree/Visualizer.m | 41 +- .../+iDynTree/VisualizerOptions.m | 20 +- .../+iDynTree/sizeOfRotationParametrization.m | 2 +- .../autogenerated/iDynTreeMATLAB_wrap.cxx | 1895 +++++++++++------ 14 files changed, 1492 insertions(+), 820 deletions(-) create mode 100644 bindings/matlab/autogenerated/+iDynTree/ILabel.m diff --git a/bindings/matlab/autogenerated/+iDynTree/ConvexHullProjectionConstraint.m b/bindings/matlab/autogenerated/+iDynTree/ConvexHullProjectionConstraint.m index 4261345b3e3..39076beef35 100644 --- a/bindings/matlab/autogenerated/+iDynTree/ConvexHullProjectionConstraint.m +++ b/bindings/matlab/autogenerated/+iDynTree/ConvexHullProjectionConstraint.m @@ -4,118 +4,118 @@ this = iDynTreeMEX(3, self); end function varargout = setActive(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1946, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1960, self, varargin{:}); end function varargout = isActive(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1947, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1961, self, varargin{:}); end function varargout = getNrOfConstraints(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1948, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1962, self, varargin{:}); end function varargout = projectedConvexHull(self, varargin) narginchk(1, 2) if nargin==1 nargoutchk(0, 1) - varargout{1} = iDynTreeMEX(1949, self); + varargout{1} = iDynTreeMEX(1963, self); else nargoutchk(0, 0) - iDynTreeMEX(1950, self, varargin{1}); + iDynTreeMEX(1964, self, varargin{1}); end end function varargout = A(self, varargin) narginchk(1, 2) if nargin==1 nargoutchk(0, 1) - varargout{1} = iDynTreeMEX(1951, self); + varargout{1} = iDynTreeMEX(1965, self); else nargoutchk(0, 0) - iDynTreeMEX(1952, self, varargin{1}); + iDynTreeMEX(1966, self, varargin{1}); end end function varargout = b(self, varargin) narginchk(1, 2) if nargin==1 nargoutchk(0, 1) - varargout{1} = iDynTreeMEX(1953, self); + varargout{1} = iDynTreeMEX(1967, self); else nargoutchk(0, 0) - iDynTreeMEX(1954, self, varargin{1}); + iDynTreeMEX(1968, self, varargin{1}); end end function varargout = P(self, varargin) narginchk(1, 2) if nargin==1 nargoutchk(0, 1) - varargout{1} = iDynTreeMEX(1955, self); + varargout{1} = iDynTreeMEX(1969, self); else nargoutchk(0, 0) - iDynTreeMEX(1956, self, varargin{1}); + iDynTreeMEX(1970, self, varargin{1}); end end function varargout = Pdirection(self, varargin) narginchk(1, 2) if nargin==1 nargoutchk(0, 1) - varargout{1} = iDynTreeMEX(1957, self); + varargout{1} = iDynTreeMEX(1971, self); else nargoutchk(0, 0) - iDynTreeMEX(1958, self, varargin{1}); + iDynTreeMEX(1972, self, varargin{1}); end end function varargout = AtimesP(self, varargin) narginchk(1, 2) if nargin==1 nargoutchk(0, 1) - varargout{1} = iDynTreeMEX(1959, self); + varargout{1} = iDynTreeMEX(1973, self); else nargoutchk(0, 0) - iDynTreeMEX(1960, self, varargin{1}); + iDynTreeMEX(1974, self, varargin{1}); end end function varargout = o(self, varargin) narginchk(1, 2) if nargin==1 nargoutchk(0, 1) - varargout{1} = iDynTreeMEX(1961, self); + varargout{1} = iDynTreeMEX(1975, self); else nargoutchk(0, 0) - iDynTreeMEX(1962, self, varargin{1}); + iDynTreeMEX(1976, self, varargin{1}); end end function varargout = buildConvexHull(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1963, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1977, self, varargin{:}); end function varargout = supportFrameIndices(self, varargin) narginchk(1, 2) if nargin==1 nargoutchk(0, 1) - varargout{1} = iDynTreeMEX(1964, self); + varargout{1} = iDynTreeMEX(1978, self); else nargoutchk(0, 0) - iDynTreeMEX(1965, self, varargin{1}); + iDynTreeMEX(1979, self, varargin{1}); end end function varargout = absoluteFrame_X_supportFrame(self, varargin) narginchk(1, 2) if nargin==1 nargoutchk(0, 1) - varargout{1} = iDynTreeMEX(1966, self); + varargout{1} = iDynTreeMEX(1980, self); else nargoutchk(0, 0) - iDynTreeMEX(1967, self, varargin{1}); + iDynTreeMEX(1981, self, varargin{1}); end end function varargout = project(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1968, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1982, self, varargin{:}); end function varargout = computeMargin(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1969, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1983, self, varargin{:}); end function varargout = setProjectionAlongDirection(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1970, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1984, self, varargin{:}); end function varargout = projectAlongDirection(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1971, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1985, self, varargin{:}); end function self = ConvexHullProjectionConstraint(varargin) if nargin==1 && strcmp(class(varargin{1}),'iDynTreeSwigRef') @@ -123,14 +123,14 @@ self.swigPtr = varargin{1}.swigPtr; end else - tmp = iDynTreeMEX(1972, varargin{:}); + tmp = iDynTreeMEX(1986, varargin{:}); self.swigPtr = tmp.swigPtr; tmp.SwigClear(); end end function delete(self) if self.swigPtr - iDynTreeMEX(1973, self); + iDynTreeMEX(1987, self); self.SwigClear(); end end diff --git a/bindings/matlab/autogenerated/+iDynTree/IFrameVisualization.m b/bindings/matlab/autogenerated/+iDynTree/IFrameVisualization.m index 4e088444a8c..1d63c62923e 100644 --- a/bindings/matlab/autogenerated/+iDynTree/IFrameVisualization.m +++ b/bindings/matlab/autogenerated/+iDynTree/IFrameVisualization.m @@ -5,24 +5,27 @@ end function delete(self) if self.swigPtr - iDynTreeMEX(1868, self); + iDynTreeMEX(1880, self); self.SwigClear(); end end function varargout = addFrame(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1869, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1881, self, varargin{:}); end function varargout = setVisible(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1870, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1882, self, varargin{:}); end function varargout = getNrOfFrames(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1871, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1883, self, varargin{:}); end function varargout = getFrameTransform(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1872, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1884, self, varargin{:}); end function varargout = updateFrame(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1873, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1885, self, varargin{:}); + end + function varargout = getFrameLabel(self,varargin) + [varargout{1:nargout}] = iDynTreeMEX(1886, self, varargin{:}); end function self = IFrameVisualization(varargin) if nargin==1 && strcmp(class(varargin{1}),'iDynTreeSwigRef') diff --git a/bindings/matlab/autogenerated/+iDynTree/ILabel.m b/bindings/matlab/autogenerated/+iDynTree/ILabel.m new file mode 100644 index 00000000000..44a600802d5 --- /dev/null +++ b/bindings/matlab/autogenerated/+iDynTree/ILabel.m @@ -0,0 +1,51 @@ +classdef ILabel < iDynTreeSwigRef + methods + function this = swig_this(self) + this = iDynTreeMEX(3, self); + end + function delete(self) + if self.swigPtr + iDynTreeMEX(1859, self); + self.SwigClear(); + end + end + function varargout = setText(self,varargin) + [varargout{1:nargout}] = iDynTreeMEX(1860, self, varargin{:}); + end + function varargout = getText(self,varargin) + [varargout{1:nargout}] = iDynTreeMEX(1861, self, varargin{:}); + end + function varargout = setSize(self,varargin) + [varargout{1:nargout}] = iDynTreeMEX(1862, self, varargin{:}); + end + function varargout = width(self,varargin) + [varargout{1:nargout}] = iDynTreeMEX(1863, self, varargin{:}); + end + function varargout = height(self,varargin) + [varargout{1:nargout}] = iDynTreeMEX(1864, self, varargin{:}); + end + function varargout = setPosition(self,varargin) + [varargout{1:nargout}] = iDynTreeMEX(1865, self, varargin{:}); + end + function varargout = getPosition(self,varargin) + [varargout{1:nargout}] = iDynTreeMEX(1866, self, varargin{:}); + end + function varargout = setColor(self,varargin) + [varargout{1:nargout}] = iDynTreeMEX(1867, self, varargin{:}); + end + function varargout = setVisible(self,varargin) + [varargout{1:nargout}] = iDynTreeMEX(1868, self, varargin{:}); + end + function self = ILabel(varargin) + if nargin==1 && strcmp(class(varargin{1}),'iDynTreeSwigRef') + if ~isnull(varargin{1}) + self.swigPtr = varargin{1}.swigPtr; + end + else + error('No matching constructor'); + end + end + end + methods(Static) + end +end diff --git a/bindings/matlab/autogenerated/+iDynTree/IModelVisualization.m b/bindings/matlab/autogenerated/+iDynTree/IModelVisualization.m index 29119dcd5b6..2289d9734ee 100644 --- a/bindings/matlab/autogenerated/+iDynTree/IModelVisualization.m +++ b/bindings/matlab/autogenerated/+iDynTree/IModelVisualization.m @@ -5,60 +5,60 @@ end function delete(self) if self.swigPtr - iDynTreeMEX(1874, self); + iDynTreeMEX(1887, self); self.SwigClear(); end end function varargout = setPositions(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1875, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1888, self, varargin{:}); end function varargout = setLinkPositions(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1876, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1889, self, varargin{:}); end function varargout = model(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1877, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1890, self, varargin{:}); end function varargout = getInstanceName(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1878, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1891, self, varargin{:}); end function varargout = setModelVisibility(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1879, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1892, self, varargin{:}); end function varargout = setModelColor(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1880, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1893, self, varargin{:}); end function varargout = resetModelColor(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1881, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1894, self, varargin{:}); end function varargout = setLinkColor(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1882, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1895, self, varargin{:}); end function varargout = resetLinkColor(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1883, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1896, self, varargin{:}); end function varargout = getLinkNames(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1884, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1897, self, varargin{:}); end function varargout = setLinkVisibility(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1885, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1898, self, varargin{:}); end function varargout = getFeatures(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1886, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1899, self, varargin{:}); end function varargout = setFeatureVisibility(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1887, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1900, self, varargin{:}); end function varargout = jets(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1888, self, varargin{:}); - end - function varargout = getWorldModelTransform(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1889, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1901, self, varargin{:}); end function varargout = getWorldLinkTransform(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1890, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1902, self, varargin{:}); end function varargout = getWorldFrameTransform(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1891, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1903, self, varargin{:}); + end + function varargout = label(self,varargin) + [varargout{1:nargout}] = iDynTreeMEX(1904, self, varargin{:}); end function self = IModelVisualization(varargin) if nargin==1 && strcmp(class(varargin{1}),'iDynTreeSwigRef') diff --git a/bindings/matlab/autogenerated/+iDynTree/ITexture.m b/bindings/matlab/autogenerated/+iDynTree/ITexture.m index 22e2d0def21..6f4dc87dc9c 100644 --- a/bindings/matlab/autogenerated/+iDynTree/ITexture.m +++ b/bindings/matlab/autogenerated/+iDynTree/ITexture.m @@ -5,18 +5,18 @@ end function delete(self) if self.swigPtr - iDynTreeMEX(1892, self); + iDynTreeMEX(1905, self); self.SwigClear(); end end function varargout = environment(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1893, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1906, self, varargin{:}); end function varargout = getPixelColor(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1894, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1907, self, varargin{:}); end function varargout = getPixels(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1895, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1908, self, varargin{:}); end function self = ITexture(varargin) if nargin==1 && strcmp(class(varargin{1}),'iDynTreeSwigRef') diff --git a/bindings/matlab/autogenerated/+iDynTree/ITexturesHandler.m b/bindings/matlab/autogenerated/+iDynTree/ITexturesHandler.m index cb12411402c..dd09cbed6f9 100644 --- a/bindings/matlab/autogenerated/+iDynTree/ITexturesHandler.m +++ b/bindings/matlab/autogenerated/+iDynTree/ITexturesHandler.m @@ -5,15 +5,15 @@ end function delete(self) if self.swigPtr - iDynTreeMEX(1906, self); + iDynTreeMEX(1919, self); self.SwigClear(); end end function varargout = add(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1907, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1920, self, varargin{:}); end function varargout = get(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1908, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1921, self, varargin{:}); end function self = ITexturesHandler(varargin) if nargin==1 && strcmp(class(varargin{1}),'iDynTreeSwigRef') diff --git a/bindings/matlab/autogenerated/+iDynTree/IVectorsVisualization.m b/bindings/matlab/autogenerated/+iDynTree/IVectorsVisualization.m index e8484db6d9b..01509fdc562 100644 --- a/bindings/matlab/autogenerated/+iDynTree/IVectorsVisualization.m +++ b/bindings/matlab/autogenerated/+iDynTree/IVectorsVisualization.m @@ -5,33 +5,39 @@ end function delete(self) if self.swigPtr - iDynTreeMEX(1859, self); + iDynTreeMEX(1869, self); self.SwigClear(); end end function varargout = addVector(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1860, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1870, self, varargin{:}); end function varargout = getNrOfVectors(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1861, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1871, self, varargin{:}); end function varargout = getVector(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1862, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1872, self, varargin{:}); end function varargout = updateVector(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1863, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1873, self, varargin{:}); end function varargout = setVectorColor(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1864, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1874, self, varargin{:}); end function varargout = setVectorsDefaultColor(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1865, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1875, self, varargin{:}); end function varargout = setVectorsColor(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1866, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1876, self, varargin{:}); end function varargout = setVectorsAspect(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1867, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1877, self, varargin{:}); + end + function varargout = setVisible(self,varargin) + [varargout{1:nargout}] = iDynTreeMEX(1878, self, varargin{:}); + end + function varargout = getVectorLabel(self,varargin) + [varargout{1:nargout}] = iDynTreeMEX(1879, self, varargin{:}); end function self = IVectorsVisualization(varargin) if nargin==1 && strcmp(class(varargin{1}),'iDynTreeSwigRef') diff --git a/bindings/matlab/autogenerated/+iDynTree/InverseKinematics.m b/bindings/matlab/autogenerated/+iDynTree/InverseKinematics.m index 1cbb5dbaa4e..ab8d563dff3 100644 --- a/bindings/matlab/autogenerated/+iDynTree/InverseKinematics.m +++ b/bindings/matlab/autogenerated/+iDynTree/InverseKinematics.m @@ -9,187 +9,187 @@ self.swigPtr = varargin{1}.swigPtr; end else - tmp = iDynTreeMEX(1975, varargin{:}); + tmp = iDynTreeMEX(1989, varargin{:}); self.swigPtr = tmp.swigPtr; tmp.SwigClear(); end end function delete(self) if self.swigPtr - iDynTreeMEX(1976, self); + iDynTreeMEX(1990, self); self.SwigClear(); end end function varargout = loadModelFromFile(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1977, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1991, self, varargin{:}); end function varargout = setModel(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1978, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1992, self, varargin{:}); end function varargout = setJointLimits(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1979, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1993, self, varargin{:}); end function varargout = getJointLimits(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1980, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1994, self, varargin{:}); end function varargout = clearProblem(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1981, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1995, self, varargin{:}); end function varargout = setFloatingBaseOnFrameNamed(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1982, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1996, self, varargin{:}); end function varargout = setCurrentRobotConfiguration(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1983, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1997, self, varargin{:}); end function varargout = setJointConfiguration(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1984, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1998, self, varargin{:}); end function varargout = setRotationParametrization(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1985, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1999, self, varargin{:}); end function varargout = rotationParametrization(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1986, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2000, self, varargin{:}); end function varargout = setMaxIterations(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1987, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2001, self, varargin{:}); end function varargout = maxIterations(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1988, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2002, self, varargin{:}); end function varargout = setMaxCPUTime(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1989, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2003, self, varargin{:}); end function varargout = maxCPUTime(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1990, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2004, self, varargin{:}); end function varargout = setCostTolerance(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1991, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2005, self, varargin{:}); end function varargout = costTolerance(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1992, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2006, self, varargin{:}); end function varargout = setConstraintsTolerance(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1993, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2007, self, varargin{:}); end function varargout = constraintsTolerance(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1994, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2008, self, varargin{:}); end function varargout = setVerbosity(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1995, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2009, self, varargin{:}); end function varargout = linearSolverName(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1996, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2010, self, varargin{:}); end function varargout = setLinearSolverName(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1997, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2011, self, varargin{:}); end function varargout = addFrameConstraint(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1998, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2012, self, varargin{:}); end function varargout = addFramePositionConstraint(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1999, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2013, self, varargin{:}); end function varargout = addFrameRotationConstraint(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2000, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2014, self, varargin{:}); end function varargout = activateFrameConstraint(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2001, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2015, self, varargin{:}); end function varargout = deactivateFrameConstraint(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2002, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2016, self, varargin{:}); end function varargout = isFrameConstraintActive(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2003, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2017, self, varargin{:}); end function varargout = addCenterOfMassProjectionConstraint(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2004, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2018, self, varargin{:}); end function varargout = getCenterOfMassProjectionMargin(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2005, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2019, self, varargin{:}); end function varargout = getCenterOfMassProjectConstraintConvexHull(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2006, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2020, self, varargin{:}); end function varargout = addTarget(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2007, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2021, self, varargin{:}); end function varargout = addPositionTarget(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2008, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2022, self, varargin{:}); end function varargout = addRotationTarget(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2009, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2023, self, varargin{:}); end function varargout = updateTarget(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2010, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2024, self, varargin{:}); end function varargout = updatePositionTarget(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2011, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2025, self, varargin{:}); end function varargout = updateRotationTarget(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2012, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2026, self, varargin{:}); end function varargout = setDefaultTargetResolutionMode(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2013, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2027, self, varargin{:}); end function varargout = defaultTargetResolutionMode(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2014, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2028, self, varargin{:}); end function varargout = setTargetResolutionMode(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2015, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2029, self, varargin{:}); end function varargout = targetResolutionMode(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2016, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2030, self, varargin{:}); end function varargout = setDesiredFullJointsConfiguration(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2017, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2031, self, varargin{:}); end function varargout = setDesiredReducedJointConfiguration(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2018, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2032, self, varargin{:}); end function varargout = setFullJointsInitialCondition(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2019, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2033, self, varargin{:}); end function varargout = setReducedInitialCondition(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2020, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2034, self, varargin{:}); end function varargout = solve(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2021, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2035, self, varargin{:}); end function varargout = getFullJointsSolution(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2022, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2036, self, varargin{:}); end function varargout = getReducedSolution(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2023, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2037, self, varargin{:}); end function varargout = getPoseForFrame(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2024, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2038, self, varargin{:}); end function varargout = fullModel(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2025, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2039, self, varargin{:}); end function varargout = reducedModel(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2026, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2040, self, varargin{:}); end function varargout = setCOMTarget(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2027, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2041, self, varargin{:}); end function varargout = setCOMAsConstraint(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2028, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2042, self, varargin{:}); end function varargout = setCOMAsConstraintTolerance(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2029, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2043, self, varargin{:}); end function varargout = isCOMAConstraint(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2030, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2044, self, varargin{:}); end function varargout = isCOMTargetActive(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2031, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2045, self, varargin{:}); end function varargout = deactivateCOMTarget(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2032, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2046, self, varargin{:}); end function varargout = setCOMConstraintProjectionDirection(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(2033, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(2047, self, varargin{:}); end end methods(Static) diff --git a/bindings/matlab/autogenerated/+iDynTree/Polygon.m b/bindings/matlab/autogenerated/+iDynTree/Polygon.m index d3b32a72868..384d31c6712 100644 --- a/bindings/matlab/autogenerated/+iDynTree/Polygon.m +++ b/bindings/matlab/autogenerated/+iDynTree/Polygon.m @@ -7,10 +7,10 @@ narginchk(1, 2) if nargin==1 nargoutchk(0, 1) - varargout{1} = iDynTreeMEX(1928, self); + varargout{1} = iDynTreeMEX(1942, self); else nargoutchk(0, 0) - iDynTreeMEX(1929, self, varargin{1}); + iDynTreeMEX(1943, self, varargin{1}); end end function self = Polygon(varargin) @@ -19,36 +19,36 @@ self.swigPtr = varargin{1}.swigPtr; end else - tmp = iDynTreeMEX(1930, varargin{:}); + tmp = iDynTreeMEX(1944, varargin{:}); self.swigPtr = tmp.swigPtr; tmp.SwigClear(); end end function varargout = setNrOfVertices(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1931, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1945, self, varargin{:}); end function varargout = getNrOfVertices(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1932, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1946, self, varargin{:}); end function varargout = isValid(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1933, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1947, self, varargin{:}); end function varargout = applyTransform(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1934, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1948, self, varargin{:}); end function varargout = paren(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1935, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1949, self, varargin{:}); end function delete(self) if self.swigPtr - iDynTreeMEX(1937, self); + iDynTreeMEX(1951, self); self.SwigClear(); end end end methods(Static) function varargout = XYRectangleFromOffsets(varargin) - [varargout{1:nargout}] = iDynTreeMEX(1936, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1950, varargin{:}); end end end diff --git a/bindings/matlab/autogenerated/+iDynTree/Polygon2D.m b/bindings/matlab/autogenerated/+iDynTree/Polygon2D.m index a7bac3f2e12..86644ea7954 100644 --- a/bindings/matlab/autogenerated/+iDynTree/Polygon2D.m +++ b/bindings/matlab/autogenerated/+iDynTree/Polygon2D.m @@ -7,10 +7,10 @@ narginchk(1, 2) if nargin==1 nargoutchk(0, 1) - varargout{1} = iDynTreeMEX(1938, self); + varargout{1} = iDynTreeMEX(1952, self); else nargoutchk(0, 0) - iDynTreeMEX(1939, self, varargin{1}); + iDynTreeMEX(1953, self, varargin{1}); end end function self = Polygon2D(varargin) @@ -19,26 +19,26 @@ self.swigPtr = varargin{1}.swigPtr; end else - tmp = iDynTreeMEX(1940, varargin{:}); + tmp = iDynTreeMEX(1954, varargin{:}); self.swigPtr = tmp.swigPtr; tmp.SwigClear(); end end function varargout = setNrOfVertices(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1941, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1955, self, varargin{:}); end function varargout = getNrOfVertices(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1942, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1956, self, varargin{:}); end function varargout = isValid(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1943, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1957, self, varargin{:}); end function varargout = paren(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1944, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1958, self, varargin{:}); end function delete(self) if self.swigPtr - iDynTreeMEX(1945, self); + iDynTreeMEX(1959, self); self.SwigClear(); end end diff --git a/bindings/matlab/autogenerated/+iDynTree/Visualizer.m b/bindings/matlab/autogenerated/+iDynTree/Visualizer.m index 565870f70ad..2d05a2404b1 100644 --- a/bindings/matlab/autogenerated/+iDynTree/Visualizer.m +++ b/bindings/matlab/autogenerated/+iDynTree/Visualizer.m @@ -9,67 +9,70 @@ self.swigPtr = varargin{1}.swigPtr; end else - tmp = iDynTreeMEX(1909, varargin{:}); + tmp = iDynTreeMEX(1922, varargin{:}); self.swigPtr = tmp.swigPtr; tmp.SwigClear(); end end function delete(self) if self.swigPtr - iDynTreeMEX(1910, self); + iDynTreeMEX(1923, self); self.SwigClear(); end end function varargout = init(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1911, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1924, self, varargin{:}); end function varargout = getNrOfVisualizedModels(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1912, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1925, self, varargin{:}); end function varargout = getModelInstanceName(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1913, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1926, self, varargin{:}); end function varargout = getModelInstanceIndex(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1914, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1927, self, varargin{:}); end function varargout = addModel(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1915, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1928, self, varargin{:}); end function varargout = modelViz(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1916, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1929, self, varargin{:}); end function varargout = camera(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1917, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1930, self, varargin{:}); end function varargout = enviroment(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1918, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1931, self, varargin{:}); end function varargout = vectors(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1919, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1932, self, varargin{:}); end function varargout = frames(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1920, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1933, self, varargin{:}); end function varargout = textures(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1921, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1934, self, varargin{:}); + end + function varargout = getLabel(self,varargin) + [varargout{1:nargout}] = iDynTreeMEX(1935, self, varargin{:}); end function varargout = run(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1922, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1936, self, varargin{:}); end function varargout = draw(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1923, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1937, self, varargin{:}); end function varargout = drawToFile(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1924, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1938, self, varargin{:}); end function varargout = close(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1925, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1939, self, varargin{:}); end function varargout = isWindowActive(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1926, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1940, self, varargin{:}); end function varargout = setColorPalette(self,varargin) - [varargout{1:nargout}] = iDynTreeMEX(1927, self, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1941, self, varargin{:}); end end methods(Static) diff --git a/bindings/matlab/autogenerated/+iDynTree/VisualizerOptions.m b/bindings/matlab/autogenerated/+iDynTree/VisualizerOptions.m index f006bced908..dac886d9154 100644 --- a/bindings/matlab/autogenerated/+iDynTree/VisualizerOptions.m +++ b/bindings/matlab/autogenerated/+iDynTree/VisualizerOptions.m @@ -7,40 +7,40 @@ narginchk(1, 2) if nargin==1 nargoutchk(0, 1) - varargout{1} = iDynTreeMEX(1896, self); + varargout{1} = iDynTreeMEX(1909, self); else nargoutchk(0, 0) - iDynTreeMEX(1897, self, varargin{1}); + iDynTreeMEX(1910, self, varargin{1}); end end function varargout = winWidth(self, varargin) narginchk(1, 2) if nargin==1 nargoutchk(0, 1) - varargout{1} = iDynTreeMEX(1898, self); + varargout{1} = iDynTreeMEX(1911, self); else nargoutchk(0, 0) - iDynTreeMEX(1899, self, varargin{1}); + iDynTreeMEX(1912, self, varargin{1}); end end function varargout = winHeight(self, varargin) narginchk(1, 2) if nargin==1 nargoutchk(0, 1) - varargout{1} = iDynTreeMEX(1900, self); + varargout{1} = iDynTreeMEX(1913, self); else nargoutchk(0, 0) - iDynTreeMEX(1901, self, varargin{1}); + iDynTreeMEX(1914, self, varargin{1}); end end function varargout = rootFrameArrowsDimension(self, varargin) narginchk(1, 2) if nargin==1 nargoutchk(0, 1) - varargout{1} = iDynTreeMEX(1902, self); + varargout{1} = iDynTreeMEX(1915, self); else nargoutchk(0, 0) - iDynTreeMEX(1903, self, varargin{1}); + iDynTreeMEX(1916, self, varargin{1}); end end function self = VisualizerOptions(varargin) @@ -49,14 +49,14 @@ self.swigPtr = varargin{1}.swigPtr; end else - tmp = iDynTreeMEX(1904, varargin{:}); + tmp = iDynTreeMEX(1917, varargin{:}); self.swigPtr = tmp.swigPtr; tmp.SwigClear(); end end function delete(self) if self.swigPtr - iDynTreeMEX(1905, self); + iDynTreeMEX(1918, self); self.SwigClear(); end end diff --git a/bindings/matlab/autogenerated/+iDynTree/sizeOfRotationParametrization.m b/bindings/matlab/autogenerated/+iDynTree/sizeOfRotationParametrization.m index 595c66d467a..25878a54003 100644 --- a/bindings/matlab/autogenerated/+iDynTree/sizeOfRotationParametrization.m +++ b/bindings/matlab/autogenerated/+iDynTree/sizeOfRotationParametrization.m @@ -1,3 +1,3 @@ function varargout = sizeOfRotationParametrization(varargin) - [varargout{1:nargout}] = iDynTreeMEX(1974, varargin{:}); + [varargout{1:nargout}] = iDynTreeMEX(1988, varargin{:}); end diff --git a/bindings/matlab/autogenerated/iDynTreeMATLAB_wrap.cxx b/bindings/matlab/autogenerated/iDynTreeMATLAB_wrap.cxx index a8ab775c785..c134a309b06 100644 --- a/bindings/matlab/autogenerated/iDynTreeMATLAB_wrap.cxx +++ b/bindings/matlab/autogenerated/iDynTreeMATLAB_wrap.cxx @@ -1266,150 +1266,150 @@ namespace swig { #define SWIGTYPE_p_iDynTree__IFrameVisualization swig_types[54] #define SWIGTYPE_p_iDynTree__IJetsVisualization swig_types[55] #define SWIGTYPE_p_iDynTree__IJoint swig_types[56] -#define SWIGTYPE_p_iDynTree__ILight swig_types[57] -#define SWIGTYPE_p_iDynTree__IModelVisualization swig_types[58] -#define SWIGTYPE_p_iDynTree__ITexture swig_types[59] -#define SWIGTYPE_p_iDynTree__ITexturesHandler swig_types[60] -#define SWIGTYPE_p_iDynTree__IVectorsVisualization swig_types[61] -#define SWIGTYPE_p_iDynTree__IndexRange swig_types[62] -#define SWIGTYPE_p_iDynTree__InverseKinematics swig_types[63] -#define SWIGTYPE_p_iDynTree__JointDOFsDoubleArray swig_types[64] -#define SWIGTYPE_p_iDynTree__JointPosDoubleArray swig_types[65] -#define SWIGTYPE_p_iDynTree__JointSensor swig_types[66] -#define SWIGTYPE_p_iDynTree__KinDynComputations swig_types[67] -#define SWIGTYPE_p_iDynTree__Link swig_types[68] -#define SWIGTYPE_p_iDynTree__LinkAccArray swig_types[69] -#define SWIGTYPE_p_iDynTree__LinkArticulatedBodyInertias swig_types[70] -#define SWIGTYPE_p_iDynTree__LinkContactWrenches swig_types[71] -#define SWIGTYPE_p_iDynTree__LinkInertias swig_types[72] -#define SWIGTYPE_p_iDynTree__LinkPositions swig_types[73] -#define SWIGTYPE_p_iDynTree__LinkSensor swig_types[74] -#define SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts swig_types[75] -#define SWIGTYPE_p_iDynTree__LinkVelArray swig_types[76] -#define SWIGTYPE_p_iDynTree__LinkWrenches swig_types[77] -#define SWIGTYPE_p_iDynTree__Material swig_types[78] -#define SWIGTYPE_p_iDynTree__MatrixDynSize swig_types[79] -#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t swig_types[80] -#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t swig_types[81] -#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t swig_types[82] -#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t swig_types[83] -#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_4_t swig_types[84] -#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_3_t swig_types[85] -#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t swig_types[86] -#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t swig_types[87] -#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_1_t swig_types[88] -#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t swig_types[89] -#define SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t swig_types[90] -#define SWIGTYPE_p_iDynTree__MatrixViewT_double_t swig_types[91] -#define SWIGTYPE_p_iDynTree__Model swig_types[92] -#define SWIGTYPE_p_iDynTree__ModelCalibrationHelper swig_types[93] -#define SWIGTYPE_p_iDynTree__ModelExporter swig_types[94] -#define SWIGTYPE_p_iDynTree__ModelExporterOptions swig_types[95] -#define SWIGTYPE_p_iDynTree__ModelLoader swig_types[96] -#define SWIGTYPE_p_iDynTree__ModelParserOptions swig_types[97] -#define SWIGTYPE_p_iDynTree__ModelSolidShapes swig_types[98] -#define SWIGTYPE_p_iDynTree__MomentumFreeFloatingJacobian swig_types[99] -#define SWIGTYPE_p_iDynTree__MovableJointImplT_1_1_t swig_types[100] -#define SWIGTYPE_p_iDynTree__MovableJointImplT_2_2_t swig_types[101] -#define SWIGTYPE_p_iDynTree__MovableJointImplT_3_3_t swig_types[102] -#define SWIGTYPE_p_iDynTree__MovableJointImplT_4_4_t swig_types[103] -#define SWIGTYPE_p_iDynTree__MovableJointImplT_5_5_t swig_types[104] -#define SWIGTYPE_p_iDynTree__MovableJointImplT_6_6_t swig_types[105] -#define SWIGTYPE_p_iDynTree__Neighbor swig_types[106] -#define SWIGTYPE_p_iDynTree__PixelViz swig_types[107] -#define SWIGTYPE_p_iDynTree__Polygon swig_types[108] -#define SWIGTYPE_p_iDynTree__Polygon2D swig_types[109] -#define SWIGTYPE_p_iDynTree__Position swig_types[110] -#define SWIGTYPE_p_iDynTree__PositionRaw swig_types[111] -#define SWIGTYPE_p_iDynTree__PrismaticJoint swig_types[112] -#define SWIGTYPE_p_iDynTree__RevoluteJoint swig_types[113] -#define SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization swig_types[114] -#define SWIGTYPE_p_iDynTree__Rotation swig_types[115] -#define SWIGTYPE_p_iDynTree__RotationRaw swig_types[116] -#define SWIGTYPE_p_iDynTree__RotationalInertiaRaw swig_types[117] -#define SWIGTYPE_p_iDynTree__Sensor swig_types[118] -#define SWIGTYPE_p_iDynTree__SensorsList swig_types[119] -#define SWIGTYPE_p_iDynTree__SensorsMeasurements swig_types[120] -#define SWIGTYPE_p_iDynTree__SimpleLeggedOdometry swig_types[121] -#define SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor swig_types[122] -#define SWIGTYPE_p_iDynTree__SolidShape swig_types[123] -#define SWIGTYPE_p_iDynTree__SpanT_double__1_t swig_types[124] -#define SWIGTYPE_p_iDynTree__SpanT_double_const__1_t swig_types[125] -#define SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t swig_types[126] -#define SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t swig_types[127] -#define SWIGTYPE_p_iDynTree__SpatialAcc swig_types[128] -#define SWIGTYPE_p_iDynTree__SpatialForceVector swig_types[129] -#define SWIGTYPE_p_iDynTree__SpatialInertia swig_types[130] -#define SWIGTYPE_p_iDynTree__SpatialInertiaRaw swig_types[131] -#define SWIGTYPE_p_iDynTree__SpatialMomentum swig_types[132] -#define SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__AngularVector3Type swig_types[133] -#define SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__LinearVector3Type swig_types[134] -#define SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__AngularVector3Type swig_types[135] -#define SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__LinearVector3Type swig_types[136] -#define SWIGTYPE_p_iDynTree__SpatialMotionVector swig_types[137] -#define SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t swig_types[138] -#define SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t swig_types[139] -#define SWIGTYPE_p_iDynTree__Sphere swig_types[140] -#define SWIGTYPE_p_iDynTree__SubModelDecomposition swig_types[141] -#define SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor swig_types[142] -#define SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor swig_types[143] -#define SWIGTYPE_p_iDynTree__Transform swig_types[144] -#define SWIGTYPE_p_iDynTree__TransformDerivative swig_types[145] -#define SWIGTYPE_p_iDynTree__Traversal swig_types[146] -#define SWIGTYPE_p_iDynTree__Triplets swig_types[147] -#define SWIGTYPE_p_iDynTree__Twist swig_types[148] -#define SWIGTYPE_p_iDynTree__UnknownWrenchContact swig_types[149] -#define SWIGTYPE_p_iDynTree__VectorDynSize swig_types[150] -#define SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t swig_types[151] -#define SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t swig_types[152] -#define SWIGTYPE_p_iDynTree__VectorFixSizeT_2_t swig_types[153] -#define SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t swig_types[154] -#define SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t swig_types[155] -#define SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t swig_types[156] -#define SWIGTYPE_p_iDynTree__Visualizer swig_types[157] -#define SWIGTYPE_p_iDynTree__VisualizerOptions swig_types[158] -#define SWIGTYPE_p_iDynTree__Wrench swig_types[159] -#define SWIGTYPE_p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t swig_types[160] -#define SWIGTYPE_p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t swig_types[161] -#define SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers swig_types[162] -#define SWIGTYPE_p_index_type swig_types[163] -#define SWIGTYPE_p_iterator swig_types[164] -#define SWIGTYPE_p_pointer swig_types[165] -#define SWIGTYPE_p_reference swig_types[166] -#define SWIGTYPE_p_reverse_iterator swig_types[167] -#define SWIGTYPE_p_size_type swig_types[168] -#define SWIGTYPE_p_std__allocatorT_iDynTree__BerdyDynamicVariable_t swig_types[169] -#define SWIGTYPE_p_std__allocatorT_iDynTree__BerdySensor_t swig_types[170] -#define SWIGTYPE_p_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t swig_types[171] -#define SWIGTYPE_p_std__allocatorT_iDynTree__SolidShape_p_t swig_types[172] -#define SWIGTYPE_p_std__allocatorT_int_t swig_types[173] -#define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[174] -#define SWIGTYPE_p_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t swig_types[175] -#define SWIGTYPE_p_std__ptrdiff_t swig_types[176] -#define SWIGTYPE_p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t_t swig_types[177] -#define SWIGTYPE_p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t_t swig_types[178] -#define SWIGTYPE_p_std__size_t swig_types[179] -#define SWIGTYPE_p_std__string swig_types[180] -#define SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t swig_types[181] -#define SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t swig_types[182] -#define SWIGTYPE_p_std__vectorT_iDynTree__MatrixDynSize_std__allocatorT_iDynTree__MatrixDynSize_t_t swig_types[183] -#define SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t swig_types[184] -#define SWIGTYPE_p_std__vectorT_iDynTree__PixelViz_std__allocatorT_iDynTree__PixelViz_t_t swig_types[185] -#define SWIGTYPE_p_std__vectorT_iDynTree__Polygon_std__allocatorT_iDynTree__Polygon_t_t swig_types[186] -#define SWIGTYPE_p_std__vectorT_iDynTree__Position_std__allocatorT_iDynTree__Position_t_t swig_types[187] -#define SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t swig_types[188] -#define SWIGTYPE_p_std__vectorT_iDynTree__Transform_std__allocatorT_iDynTree__Transform_t_t swig_types[189] -#define SWIGTYPE_p_std__vectorT_iDynTree__VectorDynSize_std__allocatorT_iDynTree__VectorDynSize_t_t swig_types[190] -#define SWIGTYPE_p_std__vectorT_iDynTree__VectorFixSizeT_2_t_std__allocatorT_iDynTree__VectorFixSizeT_2_t_t_t swig_types[191] -#define SWIGTYPE_p_std__vectorT_iDynTree__VectorFixSizeT_6_t_std__allocatorT_iDynTree__VectorFixSizeT_6_t_t_t swig_types[192] -#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[193] -#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[194] -#define SWIGTYPE_p_std__vectorT_std__ptrdiff_t_std__allocatorT_std__ptrdiff_t_t_t swig_types[195] -#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[196] -#define SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t swig_types[197] -#define SWIGTYPE_p_swig__MatlabSwigIterator swig_types[198] -#define SWIGTYPE_p_typed_iterator swig_types[199] -#define SWIGTYPE_p_unsigned_int swig_types[200] +#define SWIGTYPE_p_iDynTree__ILabel swig_types[57] +#define SWIGTYPE_p_iDynTree__ILight swig_types[58] +#define SWIGTYPE_p_iDynTree__IModelVisualization swig_types[59] +#define SWIGTYPE_p_iDynTree__ITexture swig_types[60] +#define SWIGTYPE_p_iDynTree__ITexturesHandler swig_types[61] +#define SWIGTYPE_p_iDynTree__IVectorsVisualization swig_types[62] +#define SWIGTYPE_p_iDynTree__IndexRange swig_types[63] +#define SWIGTYPE_p_iDynTree__InverseKinematics swig_types[64] +#define SWIGTYPE_p_iDynTree__JointDOFsDoubleArray swig_types[65] +#define SWIGTYPE_p_iDynTree__JointPosDoubleArray swig_types[66] +#define SWIGTYPE_p_iDynTree__JointSensor swig_types[67] +#define SWIGTYPE_p_iDynTree__KinDynComputations swig_types[68] +#define SWIGTYPE_p_iDynTree__Link swig_types[69] +#define SWIGTYPE_p_iDynTree__LinkAccArray swig_types[70] +#define SWIGTYPE_p_iDynTree__LinkArticulatedBodyInertias swig_types[71] +#define SWIGTYPE_p_iDynTree__LinkContactWrenches swig_types[72] +#define SWIGTYPE_p_iDynTree__LinkInertias swig_types[73] +#define SWIGTYPE_p_iDynTree__LinkPositions swig_types[74] +#define SWIGTYPE_p_iDynTree__LinkSensor swig_types[75] +#define SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts swig_types[76] +#define SWIGTYPE_p_iDynTree__LinkVelArray swig_types[77] +#define SWIGTYPE_p_iDynTree__LinkWrenches swig_types[78] +#define SWIGTYPE_p_iDynTree__Material swig_types[79] +#define SWIGTYPE_p_iDynTree__MatrixDynSize swig_types[80] +#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t swig_types[81] +#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t swig_types[82] +#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t swig_types[83] +#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t swig_types[84] +#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_4_t swig_types[85] +#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_3_t swig_types[86] +#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t swig_types[87] +#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t swig_types[88] +#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_1_t swig_types[89] +#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t swig_types[90] +#define SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t swig_types[91] +#define SWIGTYPE_p_iDynTree__MatrixViewT_double_t swig_types[92] +#define SWIGTYPE_p_iDynTree__Model swig_types[93] +#define SWIGTYPE_p_iDynTree__ModelCalibrationHelper swig_types[94] +#define SWIGTYPE_p_iDynTree__ModelExporter swig_types[95] +#define SWIGTYPE_p_iDynTree__ModelExporterOptions swig_types[96] +#define SWIGTYPE_p_iDynTree__ModelLoader swig_types[97] +#define SWIGTYPE_p_iDynTree__ModelParserOptions swig_types[98] +#define SWIGTYPE_p_iDynTree__ModelSolidShapes swig_types[99] +#define SWIGTYPE_p_iDynTree__MomentumFreeFloatingJacobian swig_types[100] +#define SWIGTYPE_p_iDynTree__MovableJointImplT_1_1_t swig_types[101] +#define SWIGTYPE_p_iDynTree__MovableJointImplT_2_2_t swig_types[102] +#define SWIGTYPE_p_iDynTree__MovableJointImplT_3_3_t swig_types[103] +#define SWIGTYPE_p_iDynTree__MovableJointImplT_4_4_t swig_types[104] +#define SWIGTYPE_p_iDynTree__MovableJointImplT_5_5_t swig_types[105] +#define SWIGTYPE_p_iDynTree__MovableJointImplT_6_6_t swig_types[106] +#define SWIGTYPE_p_iDynTree__Neighbor swig_types[107] +#define SWIGTYPE_p_iDynTree__PixelViz swig_types[108] +#define SWIGTYPE_p_iDynTree__Polygon swig_types[109] +#define SWIGTYPE_p_iDynTree__Polygon2D swig_types[110] +#define SWIGTYPE_p_iDynTree__Position swig_types[111] +#define SWIGTYPE_p_iDynTree__PositionRaw swig_types[112] +#define SWIGTYPE_p_iDynTree__PrismaticJoint swig_types[113] +#define SWIGTYPE_p_iDynTree__RevoluteJoint swig_types[114] +#define SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization swig_types[115] +#define SWIGTYPE_p_iDynTree__Rotation swig_types[116] +#define SWIGTYPE_p_iDynTree__RotationRaw swig_types[117] +#define SWIGTYPE_p_iDynTree__RotationalInertiaRaw swig_types[118] +#define SWIGTYPE_p_iDynTree__Sensor swig_types[119] +#define SWIGTYPE_p_iDynTree__SensorsList swig_types[120] +#define SWIGTYPE_p_iDynTree__SensorsMeasurements swig_types[121] +#define SWIGTYPE_p_iDynTree__SimpleLeggedOdometry swig_types[122] +#define SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor swig_types[123] +#define SWIGTYPE_p_iDynTree__SolidShape swig_types[124] +#define SWIGTYPE_p_iDynTree__SpanT_double__1_t swig_types[125] +#define SWIGTYPE_p_iDynTree__SpanT_double_const__1_t swig_types[126] +#define SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t swig_types[127] +#define SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t swig_types[128] +#define SWIGTYPE_p_iDynTree__SpatialAcc swig_types[129] +#define SWIGTYPE_p_iDynTree__SpatialForceVector swig_types[130] +#define SWIGTYPE_p_iDynTree__SpatialInertia swig_types[131] +#define SWIGTYPE_p_iDynTree__SpatialInertiaRaw swig_types[132] +#define SWIGTYPE_p_iDynTree__SpatialMomentum swig_types[133] +#define SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__AngularVector3Type swig_types[134] +#define SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__LinearVector3Type swig_types[135] +#define SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__AngularVector3Type swig_types[136] +#define SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__LinearVector3Type swig_types[137] +#define SWIGTYPE_p_iDynTree__SpatialMotionVector swig_types[138] +#define SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t swig_types[139] +#define SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t swig_types[140] +#define SWIGTYPE_p_iDynTree__Sphere swig_types[141] +#define SWIGTYPE_p_iDynTree__SubModelDecomposition swig_types[142] +#define SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor swig_types[143] +#define SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor swig_types[144] +#define SWIGTYPE_p_iDynTree__Transform swig_types[145] +#define SWIGTYPE_p_iDynTree__TransformDerivative swig_types[146] +#define SWIGTYPE_p_iDynTree__Traversal swig_types[147] +#define SWIGTYPE_p_iDynTree__Triplets swig_types[148] +#define SWIGTYPE_p_iDynTree__Twist swig_types[149] +#define SWIGTYPE_p_iDynTree__UnknownWrenchContact swig_types[150] +#define SWIGTYPE_p_iDynTree__VectorDynSize swig_types[151] +#define SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t swig_types[152] +#define SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t swig_types[153] +#define SWIGTYPE_p_iDynTree__VectorFixSizeT_2_t swig_types[154] +#define SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t swig_types[155] +#define SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t swig_types[156] +#define SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t swig_types[157] +#define SWIGTYPE_p_iDynTree__Visualizer swig_types[158] +#define SWIGTYPE_p_iDynTree__VisualizerOptions swig_types[159] +#define SWIGTYPE_p_iDynTree__Wrench swig_types[160] +#define SWIGTYPE_p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t swig_types[161] +#define SWIGTYPE_p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t swig_types[162] +#define SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers swig_types[163] +#define SWIGTYPE_p_index_type swig_types[164] +#define SWIGTYPE_p_iterator swig_types[165] +#define SWIGTYPE_p_pointer swig_types[166] +#define SWIGTYPE_p_reference swig_types[167] +#define SWIGTYPE_p_reverse_iterator swig_types[168] +#define SWIGTYPE_p_size_type swig_types[169] +#define SWIGTYPE_p_std__allocatorT_iDynTree__BerdyDynamicVariable_t swig_types[170] +#define SWIGTYPE_p_std__allocatorT_iDynTree__BerdySensor_t swig_types[171] +#define SWIGTYPE_p_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t swig_types[172] +#define SWIGTYPE_p_std__allocatorT_iDynTree__SolidShape_p_t swig_types[173] +#define SWIGTYPE_p_std__allocatorT_int_t swig_types[174] +#define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[175] +#define SWIGTYPE_p_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t swig_types[176] +#define SWIGTYPE_p_std__ptrdiff_t swig_types[177] +#define SWIGTYPE_p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t_t swig_types[178] +#define SWIGTYPE_p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t_t swig_types[179] +#define SWIGTYPE_p_std__size_t swig_types[180] +#define SWIGTYPE_p_std__string swig_types[181] +#define SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t swig_types[182] +#define SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t swig_types[183] +#define SWIGTYPE_p_std__vectorT_iDynTree__MatrixDynSize_std__allocatorT_iDynTree__MatrixDynSize_t_t swig_types[184] +#define SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t swig_types[185] +#define SWIGTYPE_p_std__vectorT_iDynTree__PixelViz_std__allocatorT_iDynTree__PixelViz_t_t swig_types[186] +#define SWIGTYPE_p_std__vectorT_iDynTree__Polygon_std__allocatorT_iDynTree__Polygon_t_t swig_types[187] +#define SWIGTYPE_p_std__vectorT_iDynTree__Position_std__allocatorT_iDynTree__Position_t_t swig_types[188] +#define SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t swig_types[189] +#define SWIGTYPE_p_std__vectorT_iDynTree__Transform_std__allocatorT_iDynTree__Transform_t_t swig_types[190] +#define SWIGTYPE_p_std__vectorT_iDynTree__VectorDynSize_std__allocatorT_iDynTree__VectorDynSize_t_t swig_types[191] +#define SWIGTYPE_p_std__vectorT_iDynTree__VectorFixSizeT_2_t_std__allocatorT_iDynTree__VectorFixSizeT_2_t_t_t swig_types[192] +#define SWIGTYPE_p_std__vectorT_iDynTree__VectorFixSizeT_6_t_std__allocatorT_iDynTree__VectorFixSizeT_6_t_t_t swig_types[193] +#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[194] +#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[195] +#define SWIGTYPE_p_std__vectorT_std__ptrdiff_t_std__allocatorT_std__ptrdiff_t_t_t swig_types[196] +#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[197] +#define SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t swig_types[198] +#define SWIGTYPE_p_swig__MatlabSwigIterator swig_types[199] +#define SWIGTYPE_p_typed_iterator swig_types[200] #define SWIGTYPE_p_value_type swig_types[201] static swig_type_info *swig_types[203]; static swig_module_info swig_module = {swig_types, 202, 0, 0, 0, 0}; @@ -63669,67 +63669,6 @@ int _wrap_SensorsList_getSensorIndex__SWIG_0(int resc, mxArray *resv[], int argc int _wrap_SensorsList_getSensorIndex__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) { - iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ; - iDynTree::SensorType *arg2 = 0 ; - std::string *arg3 = 0 ; - ptrdiff_t *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 ; - iDynTree::SensorType temp2 ; - int res3 = SWIG_OLDOBJ ; - void *argp4 = 0 ; - int res4 = 0 ; - mxArray * _out; - bool result; - - if (!SWIG_check_num_args("SensorsList_getSensorIndex",argc,4,4,0)) { - SWIG_fail; - } - res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_getSensorIndex" "', argument " "1"" of type '" "iDynTree::SensorsList const *""'"); - } - arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1); - ecode2 = SWIG_AsVal_int (argv[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsList_getSensorIndex" "', argument " "2"" of type '" "iDynTree::SensorType const &""'"); - } else { - temp2 = static_cast< iDynTree::SensorType >(val2); - arg2 = &temp2; - } - { - std::string *ptr = (std::string *)0; - res3 = SWIG_AsPtr_std_string(argv[2], &ptr); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SensorsList_getSensorIndex" "', argument " "3"" of type '" "std::string const &""'"); - } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsList_getSensorIndex" "', argument " "3"" of type '" "std::string const &""'"); - } - arg3 = ptr; - } - res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_unsigned_int, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SensorsList_getSensorIndex" "', argument " "4"" of type '" "unsigned int &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsList_getSensorIndex" "', argument " "4"" of type '" "unsigned int &""'"); - } - arg4 = reinterpret_cast< ptrdiff_t * >(argp4); - result = (bool)((iDynTree::SensorsList const *)arg1)->getSensorIndex((iDynTree::SensorType const &)*arg2,(std::string const &)*arg3,*arg4); - _out = SWIG_From_bool(static_cast< bool >(result)); - if (_out) --resc, *resv++ = _out; - if (SWIG_IsNewObj(res3)) delete arg3; - return 0; -fail: - if (SWIG_IsNewObj(res3)) delete arg3; - return 1; -} - - -int _wrap_SensorsList_getSensorIndex__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) { iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ; iDynTree::SensorType *arg2 = 0 ; std::string *arg3 = 0 ; @@ -63794,31 +63733,7 @@ int _wrap_SensorsList_getSensorIndex(int resc, mxArray *resv[], int argc, mxArra int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SensorsList_getSensorIndex__SWIG_2(resc,resv,argc,argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SensorsList, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SensorsList_getSensorIndex__SWIG_1(resc,resv,argc,argv); - } + return _wrap_SensorsList_getSensorIndex__SWIG_1(resc,resv,argc,argv); } } } @@ -63851,7 +63766,6 @@ int _wrap_SensorsList_getSensorIndex(int resc, mxArray *resv[], int argc, mxArra SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SensorsList_getSensorIndex'." " Possible C/C++ prototypes are:\n" " iDynTree::SensorsList::getSensorIndex(iDynTree::SensorType const &,std::string const &,std::ptrdiff_t &) const\n" - " iDynTree::SensorsList::getSensorIndex(iDynTree::SensorType const &,std::string const &,unsigned int &) const\n" " iDynTree::SensorsList::getSensorIndex(iDynTree::SensorType const &,std::string const &) const\n"); return 1; } @@ -93685,6 +93599,439 @@ int _wrap_IJetsVisualization_setJetsIntensity(int resc, mxArray *resv[], int arg } +int _wrap_delete_ILabel(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + iDynTree::ILabel *arg1 = (iDynTree::ILabel *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mxArray * _out; + + int is_owned; + if (!SWIG_check_num_args("delete_ILabel",argc,1,1,0)) { + SWIG_fail; + } + is_owned = SWIG_Matlab_isOwned(argv[0]); + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILabel, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ILabel" "', argument " "1"" of type '" "iDynTree::ILabel *""'"); + } + arg1 = reinterpret_cast< iDynTree::ILabel * >(argp1); + if (is_owned) { + delete arg1; + } + _out = (mxArray*)0; + if (_out) --resc, *resv++ = _out; + return 0; +fail: + return 1; +} + + +int _wrap_ILabel_setText(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + iDynTree::ILabel *arg1 = (iDynTree::ILabel *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + mxArray * _out; + + if (!SWIG_check_num_args("ILabel_setText",argc,2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILabel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILabel_setText" "', argument " "1"" of type '" "iDynTree::ILabel *""'"); + } + arg1 = reinterpret_cast< iDynTree::ILabel * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(argv[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ILabel_setText" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ILabel_setText" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->setText((std::string const &)*arg2); + _out = (mxArray*)0; + if (_out) --resc, *resv++ = _out; + if (SWIG_IsNewObj(res2)) delete arg2; + return 0; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return 1; +} + + +int _wrap_ILabel_getText(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + iDynTree::ILabel *arg1 = (iDynTree::ILabel *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mxArray * _out; + std::string result; + + if (!SWIG_check_num_args("ILabel_getText",argc,1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILabel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILabel_getText" "', argument " "1"" of type '" "iDynTree::ILabel const *""'"); + } + arg1 = reinterpret_cast< iDynTree::ILabel * >(argp1); + result = ((iDynTree::ILabel const *)arg1)->getText(); + _out = SWIG_From_std_string(static_cast< std::string >(result)); + if (_out) --resc, *resv++ = _out; + return 0; +fail: + return 1; +} + + +int _wrap_ILabel_setSize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + iDynTree::ILabel *arg1 = (iDynTree::ILabel *) 0 ; + float arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + mxArray * _out; + + if (!SWIG_check_num_args("ILabel_setSize",argc,2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILabel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILabel_setSize" "', argument " "1"" of type '" "iDynTree::ILabel *""'"); + } + arg1 = reinterpret_cast< iDynTree::ILabel * >(argp1); + ecode2 = SWIG_AsVal_float(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ILabel_setSize" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + (arg1)->setSize(arg2); + _out = (mxArray*)0; + if (_out) --resc, *resv++ = _out; + return 0; +fail: + return 1; +} + + +int _wrap_ILabel_setSize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + iDynTree::ILabel *arg1 = (iDynTree::ILabel *) 0 ; + float arg2 ; + float arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + float val3 ; + int ecode3 = 0 ; + mxArray * _out; + + if (!SWIG_check_num_args("ILabel_setSize",argc,3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILabel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILabel_setSize" "', argument " "1"" of type '" "iDynTree::ILabel *""'"); + } + arg1 = reinterpret_cast< iDynTree::ILabel * >(argp1); + ecode2 = SWIG_AsVal_float(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ILabel_setSize" "', argument " "2"" of type '" "float""'"); + } + arg2 = static_cast< float >(val2); + ecode3 = SWIG_AsVal_float(argv[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ILabel_setSize" "', argument " "3"" of type '" "float""'"); + } + arg3 = static_cast< float >(val3); + (arg1)->setSize(arg2,arg3); + _out = (mxArray*)0; + if (_out) --resc, *resv++ = _out; + return 0; +fail: + return 1; +} + + +int _wrap_ILabel_setSize(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ILabel, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ILabel_setSize__SWIG_0(resc,resv,argc,argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ILabel, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_float(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_float(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ILabel_setSize__SWIG_1(resc,resv,argc,argv); + } + } + } + } + + SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ILabel_setSize'." + " Possible C/C++ prototypes are:\n" + " iDynTree::ILabel::setSize(float)\n" + " iDynTree::ILabel::setSize(float,float)\n"); + return 1; +} + + +int _wrap_ILabel_width(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + iDynTree::ILabel *arg1 = (iDynTree::ILabel *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mxArray * _out; + float result; + + if (!SWIG_check_num_args("ILabel_width",argc,1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILabel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILabel_width" "', argument " "1"" of type '" "iDynTree::ILabel const *""'"); + } + arg1 = reinterpret_cast< iDynTree::ILabel * >(argp1); + result = (float)((iDynTree::ILabel const *)arg1)->width(); + _out = SWIG_From_float(static_cast< float >(result)); + if (_out) --resc, *resv++ = _out; + return 0; +fail: + return 1; +} + + +int _wrap_ILabel_height(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + iDynTree::ILabel *arg1 = (iDynTree::ILabel *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mxArray * _out; + float result; + + if (!SWIG_check_num_args("ILabel_height",argc,1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILabel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILabel_height" "', argument " "1"" of type '" "iDynTree::ILabel const *""'"); + } + arg1 = reinterpret_cast< iDynTree::ILabel * >(argp1); + result = (float)((iDynTree::ILabel const *)arg1)->height(); + _out = SWIG_From_float(static_cast< float >(result)); + if (_out) --resc, *resv++ = _out; + return 0; +fail: + return 1; +} + + +int _wrap_ILabel_setPosition(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + iDynTree::ILabel *arg1 = (iDynTree::ILabel *) 0 ; + iDynTree::Position *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + mxArray * _out; + + if (!SWIG_check_num_args("ILabel_setPosition",argc,2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILabel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILabel_setPosition" "', argument " "1"" of type '" "iDynTree::ILabel *""'"); + } + arg1 = reinterpret_cast< iDynTree::ILabel * >(argp1); + res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ILabel_setPosition" "', argument " "2"" of type '" "iDynTree::Position const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ILabel_setPosition" "', argument " "2"" of type '" "iDynTree::Position const &""'"); + } + arg2 = reinterpret_cast< iDynTree::Position * >(argp2); + (arg1)->setPosition((iDynTree::Position const &)*arg2); + _out = (mxArray*)0; + if (_out) --resc, *resv++ = _out; + return 0; +fail: + return 1; +} + + +int _wrap_ILabel_getPosition(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + iDynTree::ILabel *arg1 = (iDynTree::ILabel *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mxArray * _out; + iDynTree::Position result; + + if (!SWIG_check_num_args("ILabel_getPosition",argc,1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILabel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILabel_getPosition" "', argument " "1"" of type '" "iDynTree::ILabel const *""'"); + } + arg1 = reinterpret_cast< iDynTree::ILabel * >(argp1); + result = ((iDynTree::ILabel const *)arg1)->getPosition(); + _out = SWIG_NewPointerObj((new iDynTree::Position(static_cast< const iDynTree::Position& >(result))), SWIGTYPE_p_iDynTree__Position, SWIG_POINTER_OWN | 0 ); + if (_out) --resc, *resv++ = _out; + return 0; +fail: + return 1; +} + + +int _wrap_ILabel_setColor(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + iDynTree::ILabel *arg1 = (iDynTree::ILabel *) 0 ; + iDynTree::ColorViz *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + mxArray * _out; + + if (!SWIG_check_num_args("ILabel_setColor",argc,2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILabel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILabel_setColor" "', argument " "1"" of type '" "iDynTree::ILabel *""'"); + } + arg1 = reinterpret_cast< iDynTree::ILabel * >(argp1); + res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__ColorViz, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ILabel_setColor" "', argument " "2"" of type '" "iDynTree::ColorViz const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ILabel_setColor" "', argument " "2"" of type '" "iDynTree::ColorViz const &""'"); + } + arg2 = reinterpret_cast< iDynTree::ColorViz * >(argp2); + (arg1)->setColor((iDynTree::ColorViz const &)*arg2); + _out = (mxArray*)0; + if (_out) --resc, *resv++ = _out; + return 0; +fail: + return 1; +} + + +int _wrap_ILabel_setVisible__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + iDynTree::ILabel *arg1 = (iDynTree::ILabel *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + mxArray * _out; + + if (!SWIG_check_num_args("ILabel_setVisible",argc,2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILabel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILabel_setVisible" "', argument " "1"" of type '" "iDynTree::ILabel *""'"); + } + arg1 = reinterpret_cast< iDynTree::ILabel * >(argp1); + ecode2 = SWIG_AsVal_bool(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ILabel_setVisible" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + (arg1)->setVisible(arg2); + _out = (mxArray*)0; + if (_out) --resc, *resv++ = _out; + return 0; +fail: + return 1; +} + + +int _wrap_ILabel_setVisible__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + iDynTree::ILabel *arg1 = (iDynTree::ILabel *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mxArray * _out; + + if (!SWIG_check_num_args("ILabel_setVisible",argc,1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILabel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILabel_setVisible" "', argument " "1"" of type '" "iDynTree::ILabel *""'"); + } + arg1 = reinterpret_cast< iDynTree::ILabel * >(argp1); + (arg1)->setVisible(); + _out = (mxArray*)0; + if (_out) --resc, *resv++ = _out; + return 0; +fail: + return 1; +} + + +int _wrap_ILabel_setVisible(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ILabel, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ILabel_setVisible__SWIG_1(resc,resv,argc,argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ILabel, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ILabel_setVisible__SWIG_0(resc,resv,argc,argv); + } + } + } + + SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ILabel_setVisible'." + " Possible C/C++ prototypes are:\n" + " iDynTree::ILabel::setVisible(bool)\n" + " iDynTree::ILabel::setVisible()\n"); + return 1; +} + + int _wrap_delete_IVectorsVisualization(int resc, mxArray *resv[], int argc, mxArray *argv[]) { iDynTree::IVectorsVisualization *arg1 = (iDynTree::IVectorsVisualization *) 0 ; void *argp1 = 0 ; @@ -94415,6 +94762,156 @@ int _wrap_IVectorsVisualization_setVectorsAspect(int resc, mxArray *resv[], int } +int _wrap_IVectorsVisualization_setVisible__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + iDynTree::IVectorsVisualization *arg1 = (iDynTree::IVectorsVisualization *) 0 ; + size_t arg2 ; + bool arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + mxArray * _out; + bool result; + + if (!SWIG_check_num_args("IVectorsVisualization_setVisible",argc,3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IVectorsVisualization, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IVectorsVisualization_setVisible" "', argument " "1"" of type '" "iDynTree::IVectorsVisualization *""'"); + } + arg1 = reinterpret_cast< iDynTree::IVectorsVisualization * >(argp1); + ecode2 = SWIG_AsVal_size_t(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IVectorsVisualization_setVisible" "', argument " "2"" of type '" "size_t""'"); + } + arg2 = static_cast< size_t >(val2); + ecode3 = SWIG_AsVal_bool(argv[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IVectorsVisualization_setVisible" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + result = (bool)(arg1)->setVisible(arg2,arg3); + _out = SWIG_From_bool(static_cast< bool >(result)); + if (_out) --resc, *resv++ = _out; + return 0; +fail: + return 1; +} + + +int _wrap_IVectorsVisualization_setVisible__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + iDynTree::IVectorsVisualization *arg1 = (iDynTree::IVectorsVisualization *) 0 ; + size_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + mxArray * _out; + bool result; + + if (!SWIG_check_num_args("IVectorsVisualization_setVisible",argc,2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IVectorsVisualization, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IVectorsVisualization_setVisible" "', argument " "1"" of type '" "iDynTree::IVectorsVisualization *""'"); + } + arg1 = reinterpret_cast< iDynTree::IVectorsVisualization * >(argp1); + ecode2 = SWIG_AsVal_size_t(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IVectorsVisualization_setVisible" "', argument " "2"" of type '" "size_t""'"); + } + arg2 = static_cast< size_t >(val2); + result = (bool)(arg1)->setVisible(arg2); + _out = SWIG_From_bool(static_cast< bool >(result)); + if (_out) --resc, *resv++ = _out; + return 0; +fail: + return 1; +} + + +int _wrap_IVectorsVisualization_setVisible(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__IVectorsVisualization, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IVectorsVisualization_setVisible__SWIG_1(resc,resv,argc,argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__IVectorsVisualization, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IVectorsVisualization_setVisible__SWIG_0(resc,resv,argc,argv); + } + } + } + } + + SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'IVectorsVisualization_setVisible'." + " Possible C/C++ prototypes are:\n" + " iDynTree::IVectorsVisualization::setVisible(size_t,bool)\n" + " iDynTree::IVectorsVisualization::setVisible(size_t)\n"); + return 1; +} + + +int _wrap_IVectorsVisualization_getVectorLabel(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + iDynTree::IVectorsVisualization *arg1 = (iDynTree::IVectorsVisualization *) 0 ; + size_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + mxArray * _out; + iDynTree::ILabel *result = 0 ; + + if (!SWIG_check_num_args("IVectorsVisualization_getVectorLabel",argc,2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IVectorsVisualization, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IVectorsVisualization_getVectorLabel" "', argument " "1"" of type '" "iDynTree::IVectorsVisualization *""'"); + } + arg1 = reinterpret_cast< iDynTree::IVectorsVisualization * >(argp1); + ecode2 = SWIG_AsVal_size_t(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IVectorsVisualization_getVectorLabel" "', argument " "2"" of type '" "size_t""'"); + } + arg2 = static_cast< size_t >(val2); + result = (iDynTree::ILabel *)(arg1)->getVectorLabel(arg2); + _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ILabel, 0 | 0 ); + if (_out) --resc, *resv++ = _out; + return 0; +fail: + return 1; +} + + int _wrap_delete_IFrameVisualization(int resc, mxArray *resv[], int argc, mxArray *argv[]) { iDynTree::IFrameVisualization *arg1 = (iDynTree::IFrameVisualization *) 0 ; void *argp1 = 0 ; @@ -94714,6 +95211,38 @@ int _wrap_IFrameVisualization_updateFrame(int resc, mxArray *resv[], int argc, m } +int _wrap_IFrameVisualization_getFrameLabel(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + iDynTree::IFrameVisualization *arg1 = (iDynTree::IFrameVisualization *) 0 ; + size_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + mxArray * _out; + iDynTree::ILabel *result = 0 ; + + if (!SWIG_check_num_args("IFrameVisualization_getFrameLabel",argc,2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IFrameVisualization, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFrameVisualization_getFrameLabel" "', argument " "1"" of type '" "iDynTree::IFrameVisualization *""'"); + } + arg1 = reinterpret_cast< iDynTree::IFrameVisualization * >(argp1); + ecode2 = SWIG_AsVal_size_t(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IFrameVisualization_getFrameLabel" "', argument " "2"" of type '" "size_t""'"); + } + arg2 = static_cast< size_t >(val2); + result = (iDynTree::ILabel *)(arg1)->getFrameLabel(arg2); + _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ILabel, 0 | 0 ); + if (_out) --resc, *resv++ = _out; + return 0; +fail: + return 1; +} + + int _wrap_delete_IModelVisualization(int resc, mxArray *resv[], int argc, mxArray *argv[]) { iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ; void *argp1 = 0 ; @@ -95203,11 +95732,6 @@ int _wrap_IModelVisualization_jets(int resc, mxArray *resv[], int argc, mxArray } -int _wrap_IModelVisualization_getWorldModelTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) { - return 1; -} - - int _wrap_IModelVisualization_getWorldLinkTransform__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) { iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ; iDynTree::LinkIndex *arg2 = 0 ; @@ -95430,6 +95954,30 @@ int _wrap_IModelVisualization_getWorldFrameTransform(int resc, mxArray *resv[], } +int _wrap_IModelVisualization_label(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mxArray * _out; + iDynTree::ILabel *result = 0 ; + + if (!SWIG_check_num_args("IModelVisualization_label",argc,1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IModelVisualization_label" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); + } + arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1); + result = (iDynTree::ILabel *) &(arg1)->label(); + _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ILabel, 0 | 0 ); + if (_out) --resc, *resv++ = _out; + return 0; +fail: + return 1; +} + + int _wrap_delete_ITexture(int resc, mxArray *resv[], int argc, mxArray *argv[]) { iDynTree::ITexture *arg1 = (iDynTree::ITexture *) 0 ; void *argp1 = 0 ; @@ -96521,6 +97069,45 @@ int _wrap_Visualizer_textures(int resc, mxArray *resv[], int argc, mxArray *argv } +int _wrap_Visualizer_getLabel(int resc, mxArray *resv[], int argc, mxArray *argv[]) { + iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + mxArray * _out; + iDynTree::ILabel *result = 0 ; + + if (!SWIG_check_num_args("Visualizer_getLabel",argc,2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_getLabel" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); + } + arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(argv[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Visualizer_getLabel" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Visualizer_getLabel" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + result = (iDynTree::ILabel *) &(arg1)->getLabel((std::string const &)*arg2); + _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ILabel, 0 | 0 ); + if (_out) --resc, *resv++ = _out; + if (SWIG_IsNewObj(res2)) delete arg2; + return 0; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return 1; +} + + int _wrap_Visualizer_run(int resc, mxArray *resv[], int argc, mxArray *argv[]) { iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ; void *argp1 = 0 ; @@ -98125,7 +98712,7 @@ int _wrap_ConvexHullProjectionConstraint_computeMargin(int resc, mxArray *resv[] int _wrap_ConvexHullProjectionConstraint_setProjectionAlongDirection(int resc, mxArray *resv[], int argc, mxArray *argv[]) { iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ; - iDynTree::Vector3 arg2 ; + iDynTree::Vector3 *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; @@ -98140,18 +98727,15 @@ int _wrap_ConvexHullProjectionConstraint_setProjectionAlongDirection(int resc, m SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_setProjectionAlongDirection" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); } arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1); - { - res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvexHullProjectionConstraint_setProjectionAlongDirection" "', argument " "2"" of type '" "iDynTree::Vector3""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvexHullProjectionConstraint_setProjectionAlongDirection" "', argument " "2"" of type '" "iDynTree::Vector3""'"); - } else { - arg2 = *(reinterpret_cast< iDynTree::Vector3 * >(argp2)); - } + res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvexHullProjectionConstraint_setProjectionAlongDirection" "', argument " "2"" of type '" "iDynTree::Vector3 const &""'"); } - (arg1)->setProjectionAlongDirection(arg2); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvexHullProjectionConstraint_setProjectionAlongDirection" "', argument " "2"" of type '" "iDynTree::Vector3 const &""'"); + } + arg2 = reinterpret_cast< iDynTree::Vector3 * >(argp2); + (arg1)->setProjectionAlongDirection((iDynTree::Vector3 const &)*arg2); _out = (mxArray*)0; if (_out) --resc, *resv++ = _out; return 0; @@ -98165,7 +98749,7 @@ int _wrap_ConvexHullProjectionConstraint_projectAlongDirection(int resc, mxArray iDynTree::Position *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; + void *argp2 ; int res2 = 0 ; mxArray * _out; SwigValueWrapper< iDynTree::VectorFixSize< 2 > > result; @@ -98180,13 +98764,13 @@ int _wrap_ConvexHullProjectionConstraint_projectAlongDirection(int resc, mxArray arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1); res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvexHullProjectionConstraint_projectAlongDirection" "', argument " "2"" of type '" "iDynTree::Position &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvexHullProjectionConstraint_projectAlongDirection" "', argument " "2"" of type '" "iDynTree::Position const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvexHullProjectionConstraint_projectAlongDirection" "', argument " "2"" of type '" "iDynTree::Position &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvexHullProjectionConstraint_projectAlongDirection" "', argument " "2"" of type '" "iDynTree::Position const &""'"); } arg2 = reinterpret_cast< iDynTree::Position * >(argp2); - result = (arg1)->projectAlongDirection(*arg2); + result = (arg1)->projectAlongDirection((iDynTree::Position const &)*arg2); _out = SWIG_NewPointerObj((new iDynTree::Vector2(static_cast< const iDynTree::Vector2& >(result))), SWIGTYPE_p_iDynTree__VectorFixSizeT_2_t, SWIG_POINTER_OWN | 0 ); if (_out) --resc, *resv++ = _out; return 0; @@ -105279,7 +105863,7 @@ int _wrap_InverseKinematics_setCOMTarget__SWIG_0(int resc, mxArray *resv[], int double arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; + void *argp2 ; int res2 = 0 ; double val3 ; int ecode3 = 0 ; @@ -105295,10 +105879,10 @@ int _wrap_InverseKinematics_setCOMTarget__SWIG_0(int resc, mxArray *resv[], int arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1); res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Position &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Position const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Position &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Position const &""'"); } arg2 = reinterpret_cast< iDynTree::Position * >(argp2); ecode3 = SWIG_AsVal_double(argv[2], &val3); @@ -105306,7 +105890,7 @@ int _wrap_InverseKinematics_setCOMTarget__SWIG_0(int resc, mxArray *resv[], int SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InverseKinematics_setCOMTarget" "', argument " "3"" of type '" "double""'"); } arg3 = static_cast< double >(val3); - (arg1)->setCOMTarget(*arg2,arg3); + (arg1)->setCOMTarget((iDynTree::Position const &)*arg2,arg3); _out = (mxArray*)0; if (_out) --resc, *resv++ = _out; return 0; @@ -105320,7 +105904,7 @@ int _wrap_InverseKinematics_setCOMTarget__SWIG_1(int resc, mxArray *resv[], int iDynTree::Position *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; + void *argp2 ; int res2 = 0 ; mxArray * _out; @@ -105334,13 +105918,13 @@ int _wrap_InverseKinematics_setCOMTarget__SWIG_1(int resc, mxArray *resv[], int arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1); res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Position &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Position const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Position &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Position const &""'"); } arg2 = reinterpret_cast< iDynTree::Position * >(argp2); - (arg1)->setCOMTarget(*arg2); + (arg1)->setCOMTarget((iDynTree::Position const &)*arg2); _out = (mxArray*)0; if (_out) --resc, *resv++ = _out; return 0; @@ -105351,7 +105935,7 @@ int _wrap_InverseKinematics_setCOMTarget__SWIG_1(int resc, mxArray *resv[], int int _wrap_InverseKinematics_setCOMTarget__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) { iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ; - SwigValueWrapper< iDynTree::Span< const double,-1 > > arg2 ; + SwigValueWrapper< iDynTree::Span< double const,-1 > > arg2 ; double arg3 ; void *argp1 = 0 ; int res1 = 0 ; @@ -105371,14 +105955,14 @@ int _wrap_InverseKinematics_setCOMTarget__SWIG_2(int resc, mxArray *resv[], int } arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1); { - res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 ); + res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Span< double const,-1 >""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Span< double const,-1 >""'"); } else { - arg2 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2)); + arg2 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp2)); } } ecode3 = SWIG_AsVal_double(argv[2], &val3); @@ -105397,7 +105981,7 @@ int _wrap_InverseKinematics_setCOMTarget__SWIG_2(int resc, mxArray *resv[], int int _wrap_InverseKinematics_setCOMTarget__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) { iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ; - SwigValueWrapper< iDynTree::Span< const double,-1 > > arg2 ; + SwigValueWrapper< iDynTree::Span< double const,-1 > > arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; @@ -105414,14 +105998,14 @@ int _wrap_InverseKinematics_setCOMTarget__SWIG_3(int resc, mxArray *resv[], int } arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1); { - res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 ); + res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Span< double const,-1 >""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Span< double const,-1 >""'"); } else { - arg2 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2)); + arg2 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp2)); } } result = (bool)(arg1)->setCOMTarget(arg2); @@ -105455,7 +106039,7 @@ int _wrap_InverseKinematics_setCOMTarget(int resc, mxArray *resv[], int argc, mx _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_InverseKinematics_setCOMTarget__SWIG_3(resc,resv,argc,argv); @@ -105469,7 +106053,7 @@ int _wrap_InverseKinematics_setCOMTarget(int resc, mxArray *resv[], int argc, mx _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0); _v = SWIG_CheckState(res); if (_v) { { @@ -105505,10 +106089,10 @@ int _wrap_InverseKinematics_setCOMTarget(int resc, mxArray *resv[], int argc, mx SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_setCOMTarget'." " Possible C/C++ prototypes are:\n" - " iDynTree::InverseKinematics::setCOMTarget(iDynTree::Position &,double)\n" - " iDynTree::InverseKinematics::setCOMTarget(iDynTree::Position &)\n" - " iDynTree::InverseKinematics::setCOMTarget(iDynTree::Span< double,-1 >,double)\n" - " iDynTree::InverseKinematics::setCOMTarget(iDynTree::Span< double,-1 >)\n"); + " iDynTree::InverseKinematics::setCOMTarget(iDynTree::Position const &,double)\n" + " iDynTree::InverseKinematics::setCOMTarget(iDynTree::Position const &)\n" + " iDynTree::InverseKinematics::setCOMTarget(iDynTree::Span< double const,-1 >,double)\n" + " iDynTree::InverseKinematics::setCOMTarget(iDynTree::Span< double const,-1 >)\n"); return 1; } @@ -105762,7 +106346,7 @@ int _wrap_InverseKinematics_deactivateCOMTarget(int resc, mxArray *resv[], int a int _wrap_InverseKinematics_setCOMConstraintProjectionDirection__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) { iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ; - iDynTree::Vector3 arg2 ; + iDynTree::Vector3 *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; @@ -105777,18 +106361,15 @@ int _wrap_InverseKinematics_setCOMConstraintProjectionDirection__SWIG_0(int resc SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setCOMConstraintProjectionDirection" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); } arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1); - { - res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setCOMConstraintProjectionDirection" "', argument " "2"" of type '" "iDynTree::Vector3""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setCOMConstraintProjectionDirection" "', argument " "2"" of type '" "iDynTree::Vector3""'"); - } else { - arg2 = *(reinterpret_cast< iDynTree::Vector3 * >(argp2)); - } + res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setCOMConstraintProjectionDirection" "', argument " "2"" of type '" "iDynTree::Vector3 const &""'"); } - (arg1)->setCOMConstraintProjectionDirection(arg2); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setCOMConstraintProjectionDirection" "', argument " "2"" of type '" "iDynTree::Vector3 const &""'"); + } + arg2 = reinterpret_cast< iDynTree::Vector3 * >(argp2); + (arg1)->setCOMConstraintProjectionDirection((iDynTree::Vector3 const &)*arg2); _out = (mxArray*)0; if (_out) --resc, *resv++ = _out; return 0; @@ -105867,7 +106448,7 @@ int _wrap_InverseKinematics_setCOMConstraintProjectionDirection(int resc, mxArra SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_setCOMConstraintProjectionDirection'." " Possible C/C++ prototypes are:\n" - " iDynTree::InverseKinematics::setCOMConstraintProjectionDirection(iDynTree::Vector3)\n" + " iDynTree::InverseKinematics::setCOMConstraintProjectionDirection(iDynTree::Vector3 const &)\n" " iDynTree::InverseKinematics::setCOMConstraintProjectionDirection(iDynTree::Span< double const,-1 >)\n"); return 1; } @@ -106104,6 +106685,7 @@ static swig_type_info _swigt__p_iDynTree__IEnvironment = {"_p_iDynTree__IEnviron static swig_type_info _swigt__p_iDynTree__IFrameVisualization = {"_p_iDynTree__IFrameVisualization", "iDynTree::IFrameVisualization *", 0, 0, (void*)"iDynTree.IFrameVisualization", 0}; static swig_type_info _swigt__p_iDynTree__IJetsVisualization = {"_p_iDynTree__IJetsVisualization", "iDynTree::IJetsVisualization *", 0, 0, (void*)"iDynTree.IJetsVisualization", 0}; static swig_type_info _swigt__p_iDynTree__IJoint = {"_p_iDynTree__IJoint", "iDynTree::IJointPtr|iDynTree::IJoint *|iDynTree::IJointConstPtr", 0, 0, (void*)"iDynTree.IJoint", 0}; +static swig_type_info _swigt__p_iDynTree__ILabel = {"_p_iDynTree__ILabel", "iDynTree::ILabel *", 0, 0, (void*)"iDynTree.ILabel", 0}; static swig_type_info _swigt__p_iDynTree__ILight = {"_p_iDynTree__ILight", "iDynTree::ILight *", 0, 0, (void*)"iDynTree.ILight", 0}; static swig_type_info _swigt__p_iDynTree__IModelVisualization = {"_p_iDynTree__IModelVisualization", "iDynTree::IModelVisualization *", 0, 0, (void*)"iDynTree.IModelVisualization", 0}; static swig_type_info _swigt__p_iDynTree__ITexture = {"_p_iDynTree__ITexture", "iDynTree::ITexture *", 0, 0, (void*)"iDynTree.ITexture", 0}; @@ -106247,7 +106829,6 @@ static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__st static swig_type_info _swigt__p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t = {"_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t", "std::vector< std::vector< iDynTree::SolidShape * > > *|std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > >,std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > > *|std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > *", 0, 0, (void*)"iDynTree.LinksSolidShapesVector", 0}; static swig_type_info _swigt__p_swig__MatlabSwigIterator = {"_p_swig__MatlabSwigIterator", "swig::MatlabSwigIterator *", 0, 0, (void*)"iDynTree.MatlabSwigIterator", 0}; static swig_type_info _swigt__p_typed_iterator = {"_p_typed_iterator", "typed_iterator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { @@ -106308,6 +106889,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_iDynTree__IFrameVisualization, &_swigt__p_iDynTree__IJetsVisualization, &_swigt__p_iDynTree__IJoint, + &_swigt__p_iDynTree__ILabel, &_swigt__p_iDynTree__ILight, &_swigt__p_iDynTree__IModelVisualization, &_swigt__p_iDynTree__ITexture, @@ -106451,7 +107033,6 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, &_swigt__p_swig__MatlabSwigIterator, &_swigt__p_typed_iterator, - &_swigt__p_unsigned_int, &_swigt__p_value_type, }; @@ -106512,6 +107093,7 @@ static swig_cast_info _swigc__p_iDynTree__IEnvironment[] = { {&_swigt__p_iDynTr static swig_cast_info _swigc__p_iDynTree__IFrameVisualization[] = { {&_swigt__p_iDynTree__IFrameVisualization, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_iDynTree__IJetsVisualization[] = { {&_swigt__p_iDynTree__IJetsVisualization, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_iDynTree__IJoint[] = { {&_swigt__p_iDynTree__MovableJointImplT_3_3_t, _p_iDynTree__MovableJointImplT_3_3_tTo_p_iDynTree__IJoint, 0, 0}, {&_swigt__p_iDynTree__RevoluteJoint, _p_iDynTree__RevoluteJointTo_p_iDynTree__IJoint, 0, 0}, {&_swigt__p_iDynTree__MovableJointImplT_2_2_t, _p_iDynTree__MovableJointImplT_2_2_tTo_p_iDynTree__IJoint, 0, 0}, {&_swigt__p_iDynTree__IJoint, 0, 0, 0}, {&_swigt__p_iDynTree__MovableJointImplT_1_1_t, _p_iDynTree__MovableJointImplT_1_1_tTo_p_iDynTree__IJoint, 0, 0}, {&_swigt__p_iDynTree__PrismaticJoint, _p_iDynTree__PrismaticJointTo_p_iDynTree__IJoint, 0, 0}, {&_swigt__p_iDynTree__MovableJointImplT_6_6_t, _p_iDynTree__MovableJointImplT_6_6_tTo_p_iDynTree__IJoint, 0, 0}, {&_swigt__p_iDynTree__MovableJointImplT_5_5_t, _p_iDynTree__MovableJointImplT_5_5_tTo_p_iDynTree__IJoint, 0, 0}, {&_swigt__p_iDynTree__FixedJoint, _p_iDynTree__FixedJointTo_p_iDynTree__IJoint, 0, 0}, {&_swigt__p_iDynTree__MovableJointImplT_4_4_t, _p_iDynTree__MovableJointImplT_4_4_tTo_p_iDynTree__IJoint, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_iDynTree__ILabel[] = { {&_swigt__p_iDynTree__ILabel, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_iDynTree__ILight[] = { {&_swigt__p_iDynTree__ILight, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_iDynTree__IModelVisualization[] = { {&_swigt__p_iDynTree__IModelVisualization, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_iDynTree__ITexture[] = { {&_swigt__p_iDynTree__ITexture, 0, 0, 0},{0, 0, 0, 0}}; @@ -106655,7 +107237,6 @@ static swig_cast_info _swigc__p_std__vectorT_std__string_std__allocatorT_std__st static swig_cast_info _swigc__p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t[] = { {&_swigt__p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_swig__MatlabSwigIterator[] = { {&_swigt__p_swig__MatlabSwigIterator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_typed_iterator[] = { {&_swigt__p_typed_iterator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { @@ -106716,6 +107297,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_iDynTree__IFrameVisualization, _swigc__p_iDynTree__IJetsVisualization, _swigc__p_iDynTree__IJoint, + _swigc__p_iDynTree__ILabel, _swigc__p_iDynTree__ILight, _swigc__p_iDynTree__IModelVisualization, _swigc__p_iDynTree__ITexture, @@ -106859,7 +107441,6 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, _swigc__p_swig__MatlabSwigIterator, _swigc__p_typed_iterator, - _swigc__p_unsigned_int, _swigc__p_value_type, }; @@ -109097,181 +109678,195 @@ SWIGINTERN const char* SwigFunctionName(int fcn_id) { case 1856: return "IJetsVisualization_setJetColor"; case 1857: return "IJetsVisualization_setJetsDimensions"; case 1858: return "IJetsVisualization_setJetsIntensity"; - case 1859: return "delete_IVectorsVisualization"; - case 1860: return "IVectorsVisualization_addVector"; - case 1861: return "IVectorsVisualization_getNrOfVectors"; - case 1862: return "IVectorsVisualization_getVector"; - case 1863: return "IVectorsVisualization_updateVector"; - case 1864: return "IVectorsVisualization_setVectorColor"; - case 1865: return "IVectorsVisualization_setVectorsDefaultColor"; - case 1866: return "IVectorsVisualization_setVectorsColor"; - case 1867: return "IVectorsVisualization_setVectorsAspect"; - case 1868: return "delete_IFrameVisualization"; - case 1869: return "IFrameVisualization_addFrame"; - case 1870: return "IFrameVisualization_setVisible"; - case 1871: return "IFrameVisualization_getNrOfFrames"; - case 1872: return "IFrameVisualization_getFrameTransform"; - case 1873: return "IFrameVisualization_updateFrame"; - case 1874: return "delete_IModelVisualization"; - case 1875: return "IModelVisualization_setPositions"; - case 1876: return "IModelVisualization_setLinkPositions"; - case 1877: return "IModelVisualization_model"; - case 1878: return "IModelVisualization_getInstanceName"; - case 1879: return "IModelVisualization_setModelVisibility"; - case 1880: return "IModelVisualization_setModelColor"; - case 1881: return "IModelVisualization_resetModelColor"; - case 1882: return "IModelVisualization_setLinkColor"; - case 1883: return "IModelVisualization_resetLinkColor"; - case 1884: return "IModelVisualization_getLinkNames"; - case 1885: return "IModelVisualization_setLinkVisibility"; - case 1886: return "IModelVisualization_getFeatures"; - case 1887: return "IModelVisualization_setFeatureVisibility"; - case 1888: return "IModelVisualization_jets"; - case 1889: return "IModelVisualization_getWorldModelTransform"; - case 1890: return "IModelVisualization_getWorldLinkTransform"; - case 1891: return "IModelVisualization_getWorldFrameTransform"; - case 1892: return "delete_ITexture"; - case 1893: return "ITexture_environment"; - case 1894: return "ITexture_getPixelColor"; - case 1895: return "ITexture_getPixels"; - case 1896: return "VisualizerOptions_verbose_get"; - case 1897: return "VisualizerOptions_verbose_set"; - case 1898: return "VisualizerOptions_winWidth_get"; - case 1899: return "VisualizerOptions_winWidth_set"; - case 1900: return "VisualizerOptions_winHeight_get"; - case 1901: return "VisualizerOptions_winHeight_set"; - case 1902: return "VisualizerOptions_rootFrameArrowsDimension_get"; - case 1903: return "VisualizerOptions_rootFrameArrowsDimension_set"; - case 1904: return "new_VisualizerOptions"; - case 1905: return "delete_VisualizerOptions"; - case 1906: return "delete_ITexturesHandler"; - case 1907: return "ITexturesHandler_add"; - case 1908: return "ITexturesHandler_get"; - case 1909: return "new_Visualizer"; - case 1910: return "delete_Visualizer"; - case 1911: return "Visualizer_init"; - case 1912: return "Visualizer_getNrOfVisualizedModels"; - case 1913: return "Visualizer_getModelInstanceName"; - case 1914: return "Visualizer_getModelInstanceIndex"; - case 1915: return "Visualizer_addModel"; - case 1916: return "Visualizer_modelViz"; - case 1917: return "Visualizer_camera"; - case 1918: return "Visualizer_enviroment"; - case 1919: return "Visualizer_vectors"; - case 1920: return "Visualizer_frames"; - case 1921: return "Visualizer_textures"; - case 1922: return "Visualizer_run"; - case 1923: return "Visualizer_draw"; - case 1924: return "Visualizer_drawToFile"; - case 1925: return "Visualizer_close"; - case 1926: return "Visualizer_isWindowActive"; - case 1927: return "Visualizer_setColorPalette"; - case 1928: return "Polygon_m_vertices_get"; - case 1929: return "Polygon_m_vertices_set"; - case 1930: return "new_Polygon"; - case 1931: return "Polygon_setNrOfVertices"; - case 1932: return "Polygon_getNrOfVertices"; - case 1933: return "Polygon_isValid"; - case 1934: return "Polygon_applyTransform"; - case 1935: return "Polygon_paren"; - case 1936: return "Polygon_XYRectangleFromOffsets"; - case 1937: return "delete_Polygon"; - case 1938: return "Polygon2D_m_vertices_get"; - case 1939: return "Polygon2D_m_vertices_set"; - case 1940: return "new_Polygon2D"; - case 1941: return "Polygon2D_setNrOfVertices"; - case 1942: return "Polygon2D_getNrOfVertices"; - case 1943: return "Polygon2D_isValid"; - case 1944: return "Polygon2D_paren"; - case 1945: return "delete_Polygon2D"; - case 1946: return "ConvexHullProjectionConstraint_setActive"; - case 1947: return "ConvexHullProjectionConstraint_isActive"; - case 1948: return "ConvexHullProjectionConstraint_getNrOfConstraints"; - case 1949: return "ConvexHullProjectionConstraint_projectedConvexHull_get"; - case 1950: return "ConvexHullProjectionConstraint_projectedConvexHull_set"; - case 1951: return "ConvexHullProjectionConstraint_A_get"; - case 1952: return "ConvexHullProjectionConstraint_A_set"; - case 1953: return "ConvexHullProjectionConstraint_b_get"; - case 1954: return "ConvexHullProjectionConstraint_b_set"; - case 1955: return "ConvexHullProjectionConstraint_P_get"; - case 1956: return "ConvexHullProjectionConstraint_P_set"; - case 1957: return "ConvexHullProjectionConstraint_Pdirection_get"; - case 1958: return "ConvexHullProjectionConstraint_Pdirection_set"; - case 1959: return "ConvexHullProjectionConstraint_AtimesP_get"; - case 1960: return "ConvexHullProjectionConstraint_AtimesP_set"; - case 1961: return "ConvexHullProjectionConstraint_o_get"; - case 1962: return "ConvexHullProjectionConstraint_o_set"; - case 1963: return "ConvexHullProjectionConstraint_buildConvexHull"; - case 1964: return "ConvexHullProjectionConstraint_supportFrameIndices_get"; - case 1965: return "ConvexHullProjectionConstraint_supportFrameIndices_set"; - case 1966: return "ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_get"; - case 1967: return "ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_set"; - case 1968: return "ConvexHullProjectionConstraint_project"; - case 1969: return "ConvexHullProjectionConstraint_computeMargin"; - case 1970: return "ConvexHullProjectionConstraint_setProjectionAlongDirection"; - case 1971: return "ConvexHullProjectionConstraint_projectAlongDirection"; - case 1972: return "new_ConvexHullProjectionConstraint"; - case 1973: return "delete_ConvexHullProjectionConstraint"; - case 1974: return "_wrap_sizeOfRotationParametrization"; - case 1975: return "new_InverseKinematics"; - case 1976: return "delete_InverseKinematics"; - case 1977: return "InverseKinematics_loadModelFromFile"; - case 1978: return "InverseKinematics_setModel"; - case 1979: return "InverseKinematics_setJointLimits"; - case 1980: return "InverseKinematics_getJointLimits"; - case 1981: return "InverseKinematics_clearProblem"; - case 1982: return "InverseKinematics_setFloatingBaseOnFrameNamed"; - case 1983: return "InverseKinematics_setCurrentRobotConfiguration"; - case 1984: return "InverseKinematics_setJointConfiguration"; - case 1985: return "InverseKinematics_setRotationParametrization"; - case 1986: return "InverseKinematics_rotationParametrization"; - case 1987: return "InverseKinematics_setMaxIterations"; - case 1988: return "InverseKinematics_maxIterations"; - case 1989: return "InverseKinematics_setMaxCPUTime"; - case 1990: return "InverseKinematics_maxCPUTime"; - case 1991: return "InverseKinematics_setCostTolerance"; - case 1992: return "InverseKinematics_costTolerance"; - case 1993: return "InverseKinematics_setConstraintsTolerance"; - case 1994: return "InverseKinematics_constraintsTolerance"; - case 1995: return "InverseKinematics_setVerbosity"; - case 1996: return "InverseKinematics_linearSolverName"; - case 1997: return "InverseKinematics_setLinearSolverName"; - case 1998: return "InverseKinematics_addFrameConstraint"; - case 1999: return "InverseKinematics_addFramePositionConstraint"; - case 2000: return "InverseKinematics_addFrameRotationConstraint"; - case 2001: return "InverseKinematics_activateFrameConstraint"; - case 2002: return "InverseKinematics_deactivateFrameConstraint"; - case 2003: return "InverseKinematics_isFrameConstraintActive"; - case 2004: return "InverseKinematics_addCenterOfMassProjectionConstraint"; - case 2005: return "InverseKinematics_getCenterOfMassProjectionMargin"; - case 2006: return "InverseKinematics_getCenterOfMassProjectConstraintConvexHull"; - case 2007: return "InverseKinematics_addTarget"; - case 2008: return "InverseKinematics_addPositionTarget"; - case 2009: return "InverseKinematics_addRotationTarget"; - case 2010: return "InverseKinematics_updateTarget"; - case 2011: return "InverseKinematics_updatePositionTarget"; - case 2012: return "InverseKinematics_updateRotationTarget"; - case 2013: return "InverseKinematics_setDefaultTargetResolutionMode"; - case 2014: return "InverseKinematics_defaultTargetResolutionMode"; - case 2015: return "InverseKinematics_setTargetResolutionMode"; - case 2016: return "InverseKinematics_targetResolutionMode"; - case 2017: return "InverseKinematics_setDesiredFullJointsConfiguration"; - case 2018: return "InverseKinematics_setDesiredReducedJointConfiguration"; - case 2019: return "InverseKinematics_setFullJointsInitialCondition"; - case 2020: return "InverseKinematics_setReducedInitialCondition"; - case 2021: return "InverseKinematics_solve"; - case 2022: return "InverseKinematics_getFullJointsSolution"; - case 2023: return "InverseKinematics_getReducedSolution"; - case 2024: return "InverseKinematics_getPoseForFrame"; - case 2025: return "InverseKinematics_fullModel"; - case 2026: return "InverseKinematics_reducedModel"; - case 2027: return "InverseKinematics_setCOMTarget"; - case 2028: return "InverseKinematics_setCOMAsConstraint"; - case 2029: return "InverseKinematics_setCOMAsConstraintTolerance"; - case 2030: return "InverseKinematics_isCOMAConstraint"; - case 2031: return "InverseKinematics_isCOMTargetActive"; - case 2032: return "InverseKinematics_deactivateCOMTarget"; - case 2033: return "InverseKinematics_setCOMConstraintProjectionDirection"; + case 1859: return "delete_ILabel"; + case 1860: return "ILabel_setText"; + case 1861: return "ILabel_getText"; + case 1862: return "ILabel_setSize"; + case 1863: return "ILabel_width"; + case 1864: return "ILabel_height"; + case 1865: return "ILabel_setPosition"; + case 1866: return "ILabel_getPosition"; + case 1867: return "ILabel_setColor"; + case 1868: return "ILabel_setVisible"; + case 1869: return "delete_IVectorsVisualization"; + case 1870: return "IVectorsVisualization_addVector"; + case 1871: return "IVectorsVisualization_getNrOfVectors"; + case 1872: return "IVectorsVisualization_getVector"; + case 1873: return "IVectorsVisualization_updateVector"; + case 1874: return "IVectorsVisualization_setVectorColor"; + case 1875: return "IVectorsVisualization_setVectorsDefaultColor"; + case 1876: return "IVectorsVisualization_setVectorsColor"; + case 1877: return "IVectorsVisualization_setVectorsAspect"; + case 1878: return "IVectorsVisualization_setVisible"; + case 1879: return "IVectorsVisualization_getVectorLabel"; + case 1880: return "delete_IFrameVisualization"; + case 1881: return "IFrameVisualization_addFrame"; + case 1882: return "IFrameVisualization_setVisible"; + case 1883: return "IFrameVisualization_getNrOfFrames"; + case 1884: return "IFrameVisualization_getFrameTransform"; + case 1885: return "IFrameVisualization_updateFrame"; + case 1886: return "IFrameVisualization_getFrameLabel"; + case 1887: return "delete_IModelVisualization"; + case 1888: return "IModelVisualization_setPositions"; + case 1889: return "IModelVisualization_setLinkPositions"; + case 1890: return "IModelVisualization_model"; + case 1891: return "IModelVisualization_getInstanceName"; + case 1892: return "IModelVisualization_setModelVisibility"; + case 1893: return "IModelVisualization_setModelColor"; + case 1894: return "IModelVisualization_resetModelColor"; + case 1895: return "IModelVisualization_setLinkColor"; + case 1896: return "IModelVisualization_resetLinkColor"; + case 1897: return "IModelVisualization_getLinkNames"; + case 1898: return "IModelVisualization_setLinkVisibility"; + case 1899: return "IModelVisualization_getFeatures"; + case 1900: return "IModelVisualization_setFeatureVisibility"; + case 1901: return "IModelVisualization_jets"; + case 1902: return "IModelVisualization_getWorldLinkTransform"; + case 1903: return "IModelVisualization_getWorldFrameTransform"; + case 1904: return "IModelVisualization_label"; + case 1905: return "delete_ITexture"; + case 1906: return "ITexture_environment"; + case 1907: return "ITexture_getPixelColor"; + case 1908: return "ITexture_getPixels"; + case 1909: return "VisualizerOptions_verbose_get"; + case 1910: return "VisualizerOptions_verbose_set"; + case 1911: return "VisualizerOptions_winWidth_get"; + case 1912: return "VisualizerOptions_winWidth_set"; + case 1913: return "VisualizerOptions_winHeight_get"; + case 1914: return "VisualizerOptions_winHeight_set"; + case 1915: return "VisualizerOptions_rootFrameArrowsDimension_get"; + case 1916: return "VisualizerOptions_rootFrameArrowsDimension_set"; + case 1917: return "new_VisualizerOptions"; + case 1918: return "delete_VisualizerOptions"; + case 1919: return "delete_ITexturesHandler"; + case 1920: return "ITexturesHandler_add"; + case 1921: return "ITexturesHandler_get"; + case 1922: return "new_Visualizer"; + case 1923: return "delete_Visualizer"; + case 1924: return "Visualizer_init"; + case 1925: return "Visualizer_getNrOfVisualizedModels"; + case 1926: return "Visualizer_getModelInstanceName"; + case 1927: return "Visualizer_getModelInstanceIndex"; + case 1928: return "Visualizer_addModel"; + case 1929: return "Visualizer_modelViz"; + case 1930: return "Visualizer_camera"; + case 1931: return "Visualizer_enviroment"; + case 1932: return "Visualizer_vectors"; + case 1933: return "Visualizer_frames"; + case 1934: return "Visualizer_textures"; + case 1935: return "Visualizer_getLabel"; + case 1936: return "Visualizer_run"; + case 1937: return "Visualizer_draw"; + case 1938: return "Visualizer_drawToFile"; + case 1939: return "Visualizer_close"; + case 1940: return "Visualizer_isWindowActive"; + case 1941: return "Visualizer_setColorPalette"; + case 1942: return "Polygon_m_vertices_get"; + case 1943: return "Polygon_m_vertices_set"; + case 1944: return "new_Polygon"; + case 1945: return "Polygon_setNrOfVertices"; + case 1946: return "Polygon_getNrOfVertices"; + case 1947: return "Polygon_isValid"; + case 1948: return "Polygon_applyTransform"; + case 1949: return "Polygon_paren"; + case 1950: return "Polygon_XYRectangleFromOffsets"; + case 1951: return "delete_Polygon"; + case 1952: return "Polygon2D_m_vertices_get"; + case 1953: return "Polygon2D_m_vertices_set"; + case 1954: return "new_Polygon2D"; + case 1955: return "Polygon2D_setNrOfVertices"; + case 1956: return "Polygon2D_getNrOfVertices"; + case 1957: return "Polygon2D_isValid"; + case 1958: return "Polygon2D_paren"; + case 1959: return "delete_Polygon2D"; + case 1960: return "ConvexHullProjectionConstraint_setActive"; + case 1961: return "ConvexHullProjectionConstraint_isActive"; + case 1962: return "ConvexHullProjectionConstraint_getNrOfConstraints"; + case 1963: return "ConvexHullProjectionConstraint_projectedConvexHull_get"; + case 1964: return "ConvexHullProjectionConstraint_projectedConvexHull_set"; + case 1965: return "ConvexHullProjectionConstraint_A_get"; + case 1966: return "ConvexHullProjectionConstraint_A_set"; + case 1967: return "ConvexHullProjectionConstraint_b_get"; + case 1968: return "ConvexHullProjectionConstraint_b_set"; + case 1969: return "ConvexHullProjectionConstraint_P_get"; + case 1970: return "ConvexHullProjectionConstraint_P_set"; + case 1971: return "ConvexHullProjectionConstraint_Pdirection_get"; + case 1972: return "ConvexHullProjectionConstraint_Pdirection_set"; + case 1973: return "ConvexHullProjectionConstraint_AtimesP_get"; + case 1974: return "ConvexHullProjectionConstraint_AtimesP_set"; + case 1975: return "ConvexHullProjectionConstraint_o_get"; + case 1976: return "ConvexHullProjectionConstraint_o_set"; + case 1977: return "ConvexHullProjectionConstraint_buildConvexHull"; + case 1978: return "ConvexHullProjectionConstraint_supportFrameIndices_get"; + case 1979: return "ConvexHullProjectionConstraint_supportFrameIndices_set"; + case 1980: return "ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_get"; + case 1981: return "ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_set"; + case 1982: return "ConvexHullProjectionConstraint_project"; + case 1983: return "ConvexHullProjectionConstraint_computeMargin"; + case 1984: return "ConvexHullProjectionConstraint_setProjectionAlongDirection"; + case 1985: return "ConvexHullProjectionConstraint_projectAlongDirection"; + case 1986: return "new_ConvexHullProjectionConstraint"; + case 1987: return "delete_ConvexHullProjectionConstraint"; + case 1988: return "_wrap_sizeOfRotationParametrization"; + case 1989: return "new_InverseKinematics"; + case 1990: return "delete_InverseKinematics"; + case 1991: return "InverseKinematics_loadModelFromFile"; + case 1992: return "InverseKinematics_setModel"; + case 1993: return "InverseKinematics_setJointLimits"; + case 1994: return "InverseKinematics_getJointLimits"; + case 1995: return "InverseKinematics_clearProblem"; + case 1996: return "InverseKinematics_setFloatingBaseOnFrameNamed"; + case 1997: return "InverseKinematics_setCurrentRobotConfiguration"; + case 1998: return "InverseKinematics_setJointConfiguration"; + case 1999: return "InverseKinematics_setRotationParametrization"; + case 2000: return "InverseKinematics_rotationParametrization"; + case 2001: return "InverseKinematics_setMaxIterations"; + case 2002: return "InverseKinematics_maxIterations"; + case 2003: return "InverseKinematics_setMaxCPUTime"; + case 2004: return "InverseKinematics_maxCPUTime"; + case 2005: return "InverseKinematics_setCostTolerance"; + case 2006: return "InverseKinematics_costTolerance"; + case 2007: return "InverseKinematics_setConstraintsTolerance"; + case 2008: return "InverseKinematics_constraintsTolerance"; + case 2009: return "InverseKinematics_setVerbosity"; + case 2010: return "InverseKinematics_linearSolverName"; + case 2011: return "InverseKinematics_setLinearSolverName"; + case 2012: return "InverseKinematics_addFrameConstraint"; + case 2013: return "InverseKinematics_addFramePositionConstraint"; + case 2014: return "InverseKinematics_addFrameRotationConstraint"; + case 2015: return "InverseKinematics_activateFrameConstraint"; + case 2016: return "InverseKinematics_deactivateFrameConstraint"; + case 2017: return "InverseKinematics_isFrameConstraintActive"; + case 2018: return "InverseKinematics_addCenterOfMassProjectionConstraint"; + case 2019: return "InverseKinematics_getCenterOfMassProjectionMargin"; + case 2020: return "InverseKinematics_getCenterOfMassProjectConstraintConvexHull"; + case 2021: return "InverseKinematics_addTarget"; + case 2022: return "InverseKinematics_addPositionTarget"; + case 2023: return "InverseKinematics_addRotationTarget"; + case 2024: return "InverseKinematics_updateTarget"; + case 2025: return "InverseKinematics_updatePositionTarget"; + case 2026: return "InverseKinematics_updateRotationTarget"; + case 2027: return "InverseKinematics_setDefaultTargetResolutionMode"; + case 2028: return "InverseKinematics_defaultTargetResolutionMode"; + case 2029: return "InverseKinematics_setTargetResolutionMode"; + case 2030: return "InverseKinematics_targetResolutionMode"; + case 2031: return "InverseKinematics_setDesiredFullJointsConfiguration"; + case 2032: return "InverseKinematics_setDesiredReducedJointConfiguration"; + case 2033: return "InverseKinematics_setFullJointsInitialCondition"; + case 2034: return "InverseKinematics_setReducedInitialCondition"; + case 2035: return "InverseKinematics_solve"; + case 2036: return "InverseKinematics_getFullJointsSolution"; + case 2037: return "InverseKinematics_getReducedSolution"; + case 2038: return "InverseKinematics_getPoseForFrame"; + case 2039: return "InverseKinematics_fullModel"; + case 2040: return "InverseKinematics_reducedModel"; + case 2041: return "InverseKinematics_setCOMTarget"; + case 2042: return "InverseKinematics_setCOMAsConstraint"; + case 2043: return "InverseKinematics_setCOMAsConstraintTolerance"; + case 2044: return "InverseKinematics_isCOMAConstraint"; + case 2045: return "InverseKinematics_isCOMTargetActive"; + case 2046: return "InverseKinematics_deactivateCOMTarget"; + case 2047: return "InverseKinematics_setCOMConstraintProjectionDirection"; default: return 0; } } @@ -111187,181 +111782,195 @@ void mexFunction(int resc, mxArray *resv[], int argc, const mxArray *argv[]) { case 1856: flag=_wrap_IJetsVisualization_setJetColor(resc,resv,argc,(mxArray**)(argv)); break; case 1857: flag=_wrap_IJetsVisualization_setJetsDimensions(resc,resv,argc,(mxArray**)(argv)); break; case 1858: flag=_wrap_IJetsVisualization_setJetsIntensity(resc,resv,argc,(mxArray**)(argv)); break; - case 1859: flag=_wrap_delete_IVectorsVisualization(resc,resv,argc,(mxArray**)(argv)); break; - case 1860: flag=_wrap_IVectorsVisualization_addVector(resc,resv,argc,(mxArray**)(argv)); break; - case 1861: flag=_wrap_IVectorsVisualization_getNrOfVectors(resc,resv,argc,(mxArray**)(argv)); break; - case 1862: flag=_wrap_IVectorsVisualization_getVector(resc,resv,argc,(mxArray**)(argv)); break; - case 1863: flag=_wrap_IVectorsVisualization_updateVector(resc,resv,argc,(mxArray**)(argv)); break; - case 1864: flag=_wrap_IVectorsVisualization_setVectorColor(resc,resv,argc,(mxArray**)(argv)); break; - case 1865: flag=_wrap_IVectorsVisualization_setVectorsDefaultColor(resc,resv,argc,(mxArray**)(argv)); break; - case 1866: flag=_wrap_IVectorsVisualization_setVectorsColor(resc,resv,argc,(mxArray**)(argv)); break; - case 1867: flag=_wrap_IVectorsVisualization_setVectorsAspect(resc,resv,argc,(mxArray**)(argv)); break; - case 1868: flag=_wrap_delete_IFrameVisualization(resc,resv,argc,(mxArray**)(argv)); break; - case 1869: flag=_wrap_IFrameVisualization_addFrame(resc,resv,argc,(mxArray**)(argv)); break; - case 1870: flag=_wrap_IFrameVisualization_setVisible(resc,resv,argc,(mxArray**)(argv)); break; - case 1871: flag=_wrap_IFrameVisualization_getNrOfFrames(resc,resv,argc,(mxArray**)(argv)); break; - case 1872: flag=_wrap_IFrameVisualization_getFrameTransform(resc,resv,argc,(mxArray**)(argv)); break; - case 1873: flag=_wrap_IFrameVisualization_updateFrame(resc,resv,argc,(mxArray**)(argv)); break; - case 1874: flag=_wrap_delete_IModelVisualization(resc,resv,argc,(mxArray**)(argv)); break; - case 1875: flag=_wrap_IModelVisualization_setPositions(resc,resv,argc,(mxArray**)(argv)); break; - case 1876: flag=_wrap_IModelVisualization_setLinkPositions(resc,resv,argc,(mxArray**)(argv)); break; - case 1877: flag=_wrap_IModelVisualization_model(resc,resv,argc,(mxArray**)(argv)); break; - case 1878: flag=_wrap_IModelVisualization_getInstanceName(resc,resv,argc,(mxArray**)(argv)); break; - case 1879: flag=_wrap_IModelVisualization_setModelVisibility(resc,resv,argc,(mxArray**)(argv)); break; - case 1880: flag=_wrap_IModelVisualization_setModelColor(resc,resv,argc,(mxArray**)(argv)); break; - case 1881: flag=_wrap_IModelVisualization_resetModelColor(resc,resv,argc,(mxArray**)(argv)); break; - case 1882: flag=_wrap_IModelVisualization_setLinkColor(resc,resv,argc,(mxArray**)(argv)); break; - case 1883: flag=_wrap_IModelVisualization_resetLinkColor(resc,resv,argc,(mxArray**)(argv)); break; - case 1884: flag=_wrap_IModelVisualization_getLinkNames(resc,resv,argc,(mxArray**)(argv)); break; - case 1885: flag=_wrap_IModelVisualization_setLinkVisibility(resc,resv,argc,(mxArray**)(argv)); break; - case 1886: flag=_wrap_IModelVisualization_getFeatures(resc,resv,argc,(mxArray**)(argv)); break; - case 1887: flag=_wrap_IModelVisualization_setFeatureVisibility(resc,resv,argc,(mxArray**)(argv)); break; - case 1888: flag=_wrap_IModelVisualization_jets(resc,resv,argc,(mxArray**)(argv)); break; - case 1889: flag=_wrap_IModelVisualization_getWorldModelTransform(resc,resv,argc,(mxArray**)(argv)); break; - case 1890: flag=_wrap_IModelVisualization_getWorldLinkTransform(resc,resv,argc,(mxArray**)(argv)); break; - case 1891: flag=_wrap_IModelVisualization_getWorldFrameTransform(resc,resv,argc,(mxArray**)(argv)); break; - case 1892: flag=_wrap_delete_ITexture(resc,resv,argc,(mxArray**)(argv)); break; - case 1893: flag=_wrap_ITexture_environment(resc,resv,argc,(mxArray**)(argv)); break; - case 1894: flag=_wrap_ITexture_getPixelColor(resc,resv,argc,(mxArray**)(argv)); break; - case 1895: flag=_wrap_ITexture_getPixels(resc,resv,argc,(mxArray**)(argv)); break; - case 1896: flag=_wrap_VisualizerOptions_verbose_get(resc,resv,argc,(mxArray**)(argv)); break; - case 1897: flag=_wrap_VisualizerOptions_verbose_set(resc,resv,argc,(mxArray**)(argv)); break; - case 1898: flag=_wrap_VisualizerOptions_winWidth_get(resc,resv,argc,(mxArray**)(argv)); break; - case 1899: flag=_wrap_VisualizerOptions_winWidth_set(resc,resv,argc,(mxArray**)(argv)); break; - case 1900: flag=_wrap_VisualizerOptions_winHeight_get(resc,resv,argc,(mxArray**)(argv)); break; - case 1901: flag=_wrap_VisualizerOptions_winHeight_set(resc,resv,argc,(mxArray**)(argv)); break; - case 1902: flag=_wrap_VisualizerOptions_rootFrameArrowsDimension_get(resc,resv,argc,(mxArray**)(argv)); break; - case 1903: flag=_wrap_VisualizerOptions_rootFrameArrowsDimension_set(resc,resv,argc,(mxArray**)(argv)); break; - case 1904: flag=_wrap_new_VisualizerOptions(resc,resv,argc,(mxArray**)(argv)); break; - case 1905: flag=_wrap_delete_VisualizerOptions(resc,resv,argc,(mxArray**)(argv)); break; - case 1906: flag=_wrap_delete_ITexturesHandler(resc,resv,argc,(mxArray**)(argv)); break; - case 1907: flag=_wrap_ITexturesHandler_add(resc,resv,argc,(mxArray**)(argv)); break; - case 1908: flag=_wrap_ITexturesHandler_get(resc,resv,argc,(mxArray**)(argv)); break; - case 1909: flag=_wrap_new_Visualizer(resc,resv,argc,(mxArray**)(argv)); break; - case 1910: flag=_wrap_delete_Visualizer(resc,resv,argc,(mxArray**)(argv)); break; - case 1911: flag=_wrap_Visualizer_init(resc,resv,argc,(mxArray**)(argv)); break; - case 1912: flag=_wrap_Visualizer_getNrOfVisualizedModels(resc,resv,argc,(mxArray**)(argv)); break; - case 1913: flag=_wrap_Visualizer_getModelInstanceName(resc,resv,argc,(mxArray**)(argv)); break; - case 1914: flag=_wrap_Visualizer_getModelInstanceIndex(resc,resv,argc,(mxArray**)(argv)); break; - case 1915: flag=_wrap_Visualizer_addModel(resc,resv,argc,(mxArray**)(argv)); break; - case 1916: flag=_wrap_Visualizer_modelViz(resc,resv,argc,(mxArray**)(argv)); break; - case 1917: flag=_wrap_Visualizer_camera(resc,resv,argc,(mxArray**)(argv)); break; - case 1918: flag=_wrap_Visualizer_enviroment(resc,resv,argc,(mxArray**)(argv)); break; - case 1919: flag=_wrap_Visualizer_vectors(resc,resv,argc,(mxArray**)(argv)); break; - case 1920: flag=_wrap_Visualizer_frames(resc,resv,argc,(mxArray**)(argv)); break; - case 1921: flag=_wrap_Visualizer_textures(resc,resv,argc,(mxArray**)(argv)); break; - case 1922: flag=_wrap_Visualizer_run(resc,resv,argc,(mxArray**)(argv)); break; - case 1923: flag=_wrap_Visualizer_draw(resc,resv,argc,(mxArray**)(argv)); break; - case 1924: flag=_wrap_Visualizer_drawToFile(resc,resv,argc,(mxArray**)(argv)); break; - case 1925: flag=_wrap_Visualizer_close(resc,resv,argc,(mxArray**)(argv)); break; - case 1926: flag=_wrap_Visualizer_isWindowActive(resc,resv,argc,(mxArray**)(argv)); break; - case 1927: flag=_wrap_Visualizer_setColorPalette(resc,resv,argc,(mxArray**)(argv)); break; - case 1928: flag=_wrap_Polygon_m_vertices_get(resc,resv,argc,(mxArray**)(argv)); break; - case 1929: flag=_wrap_Polygon_m_vertices_set(resc,resv,argc,(mxArray**)(argv)); break; - case 1930: flag=_wrap_new_Polygon(resc,resv,argc,(mxArray**)(argv)); break; - case 1931: flag=_wrap_Polygon_setNrOfVertices(resc,resv,argc,(mxArray**)(argv)); break; - case 1932: flag=_wrap_Polygon_getNrOfVertices(resc,resv,argc,(mxArray**)(argv)); break; - case 1933: flag=_wrap_Polygon_isValid(resc,resv,argc,(mxArray**)(argv)); break; - case 1934: flag=_wrap_Polygon_applyTransform(resc,resv,argc,(mxArray**)(argv)); break; - case 1935: flag=_wrap_Polygon_paren(resc,resv,argc,(mxArray**)(argv)); break; - case 1936: flag=_wrap_Polygon_XYRectangleFromOffsets(resc,resv,argc,(mxArray**)(argv)); break; - case 1937: flag=_wrap_delete_Polygon(resc,resv,argc,(mxArray**)(argv)); break; - case 1938: flag=_wrap_Polygon2D_m_vertices_get(resc,resv,argc,(mxArray**)(argv)); break; - case 1939: flag=_wrap_Polygon2D_m_vertices_set(resc,resv,argc,(mxArray**)(argv)); break; - case 1940: flag=_wrap_new_Polygon2D(resc,resv,argc,(mxArray**)(argv)); break; - case 1941: flag=_wrap_Polygon2D_setNrOfVertices(resc,resv,argc,(mxArray**)(argv)); break; - case 1942: flag=_wrap_Polygon2D_getNrOfVertices(resc,resv,argc,(mxArray**)(argv)); break; - case 1943: flag=_wrap_Polygon2D_isValid(resc,resv,argc,(mxArray**)(argv)); break; - case 1944: flag=_wrap_Polygon2D_paren(resc,resv,argc,(mxArray**)(argv)); break; - case 1945: flag=_wrap_delete_Polygon2D(resc,resv,argc,(mxArray**)(argv)); break; - case 1946: flag=_wrap_ConvexHullProjectionConstraint_setActive(resc,resv,argc,(mxArray**)(argv)); break; - case 1947: flag=_wrap_ConvexHullProjectionConstraint_isActive(resc,resv,argc,(mxArray**)(argv)); break; - case 1948: flag=_wrap_ConvexHullProjectionConstraint_getNrOfConstraints(resc,resv,argc,(mxArray**)(argv)); break; - case 1949: flag=_wrap_ConvexHullProjectionConstraint_projectedConvexHull_get(resc,resv,argc,(mxArray**)(argv)); break; - case 1950: flag=_wrap_ConvexHullProjectionConstraint_projectedConvexHull_set(resc,resv,argc,(mxArray**)(argv)); break; - case 1951: flag=_wrap_ConvexHullProjectionConstraint_A_get(resc,resv,argc,(mxArray**)(argv)); break; - case 1952: flag=_wrap_ConvexHullProjectionConstraint_A_set(resc,resv,argc,(mxArray**)(argv)); break; - case 1953: flag=_wrap_ConvexHullProjectionConstraint_b_get(resc,resv,argc,(mxArray**)(argv)); break; - case 1954: flag=_wrap_ConvexHullProjectionConstraint_b_set(resc,resv,argc,(mxArray**)(argv)); break; - case 1955: flag=_wrap_ConvexHullProjectionConstraint_P_get(resc,resv,argc,(mxArray**)(argv)); break; - case 1956: flag=_wrap_ConvexHullProjectionConstraint_P_set(resc,resv,argc,(mxArray**)(argv)); break; - case 1957: flag=_wrap_ConvexHullProjectionConstraint_Pdirection_get(resc,resv,argc,(mxArray**)(argv)); break; - case 1958: flag=_wrap_ConvexHullProjectionConstraint_Pdirection_set(resc,resv,argc,(mxArray**)(argv)); break; - case 1959: flag=_wrap_ConvexHullProjectionConstraint_AtimesP_get(resc,resv,argc,(mxArray**)(argv)); break; - case 1960: flag=_wrap_ConvexHullProjectionConstraint_AtimesP_set(resc,resv,argc,(mxArray**)(argv)); break; - case 1961: flag=_wrap_ConvexHullProjectionConstraint_o_get(resc,resv,argc,(mxArray**)(argv)); break; - case 1962: flag=_wrap_ConvexHullProjectionConstraint_o_set(resc,resv,argc,(mxArray**)(argv)); break; - case 1963: flag=_wrap_ConvexHullProjectionConstraint_buildConvexHull(resc,resv,argc,(mxArray**)(argv)); break; - case 1964: flag=_wrap_ConvexHullProjectionConstraint_supportFrameIndices_get(resc,resv,argc,(mxArray**)(argv)); break; - case 1965: flag=_wrap_ConvexHullProjectionConstraint_supportFrameIndices_set(resc,resv,argc,(mxArray**)(argv)); break; - case 1966: flag=_wrap_ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_get(resc,resv,argc,(mxArray**)(argv)); break; - case 1967: flag=_wrap_ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_set(resc,resv,argc,(mxArray**)(argv)); break; - case 1968: flag=_wrap_ConvexHullProjectionConstraint_project(resc,resv,argc,(mxArray**)(argv)); break; - case 1969: flag=_wrap_ConvexHullProjectionConstraint_computeMargin(resc,resv,argc,(mxArray**)(argv)); break; - case 1970: flag=_wrap_ConvexHullProjectionConstraint_setProjectionAlongDirection(resc,resv,argc,(mxArray**)(argv)); break; - case 1971: flag=_wrap_ConvexHullProjectionConstraint_projectAlongDirection(resc,resv,argc,(mxArray**)(argv)); break; - case 1972: flag=_wrap_new_ConvexHullProjectionConstraint(resc,resv,argc,(mxArray**)(argv)); break; - case 1973: flag=_wrap_delete_ConvexHullProjectionConstraint(resc,resv,argc,(mxArray**)(argv)); break; - case 1974: flag=_wrap_sizeOfRotationParametrization(resc,resv,argc,(mxArray**)(argv)); break; - case 1975: flag=_wrap_new_InverseKinematics(resc,resv,argc,(mxArray**)(argv)); break; - case 1976: flag=_wrap_delete_InverseKinematics(resc,resv,argc,(mxArray**)(argv)); break; - case 1977: flag=_wrap_InverseKinematics_loadModelFromFile(resc,resv,argc,(mxArray**)(argv)); break; - case 1978: flag=_wrap_InverseKinematics_setModel(resc,resv,argc,(mxArray**)(argv)); break; - case 1979: flag=_wrap_InverseKinematics_setJointLimits(resc,resv,argc,(mxArray**)(argv)); break; - case 1980: flag=_wrap_InverseKinematics_getJointLimits(resc,resv,argc,(mxArray**)(argv)); break; - case 1981: flag=_wrap_InverseKinematics_clearProblem(resc,resv,argc,(mxArray**)(argv)); break; - case 1982: flag=_wrap_InverseKinematics_setFloatingBaseOnFrameNamed(resc,resv,argc,(mxArray**)(argv)); break; - case 1983: flag=_wrap_InverseKinematics_setCurrentRobotConfiguration(resc,resv,argc,(mxArray**)(argv)); break; - case 1984: flag=_wrap_InverseKinematics_setJointConfiguration(resc,resv,argc,(mxArray**)(argv)); break; - case 1985: flag=_wrap_InverseKinematics_setRotationParametrization(resc,resv,argc,(mxArray**)(argv)); break; - case 1986: flag=_wrap_InverseKinematics_rotationParametrization(resc,resv,argc,(mxArray**)(argv)); break; - case 1987: flag=_wrap_InverseKinematics_setMaxIterations(resc,resv,argc,(mxArray**)(argv)); break; - case 1988: flag=_wrap_InverseKinematics_maxIterations(resc,resv,argc,(mxArray**)(argv)); break; - case 1989: flag=_wrap_InverseKinematics_setMaxCPUTime(resc,resv,argc,(mxArray**)(argv)); break; - case 1990: flag=_wrap_InverseKinematics_maxCPUTime(resc,resv,argc,(mxArray**)(argv)); break; - case 1991: flag=_wrap_InverseKinematics_setCostTolerance(resc,resv,argc,(mxArray**)(argv)); break; - case 1992: flag=_wrap_InverseKinematics_costTolerance(resc,resv,argc,(mxArray**)(argv)); break; - case 1993: flag=_wrap_InverseKinematics_setConstraintsTolerance(resc,resv,argc,(mxArray**)(argv)); break; - case 1994: flag=_wrap_InverseKinematics_constraintsTolerance(resc,resv,argc,(mxArray**)(argv)); break; - case 1995: flag=_wrap_InverseKinematics_setVerbosity(resc,resv,argc,(mxArray**)(argv)); break; - case 1996: flag=_wrap_InverseKinematics_linearSolverName(resc,resv,argc,(mxArray**)(argv)); break; - case 1997: flag=_wrap_InverseKinematics_setLinearSolverName(resc,resv,argc,(mxArray**)(argv)); break; - case 1998: flag=_wrap_InverseKinematics_addFrameConstraint(resc,resv,argc,(mxArray**)(argv)); break; - case 1999: flag=_wrap_InverseKinematics_addFramePositionConstraint(resc,resv,argc,(mxArray**)(argv)); break; - case 2000: flag=_wrap_InverseKinematics_addFrameRotationConstraint(resc,resv,argc,(mxArray**)(argv)); break; - case 2001: flag=_wrap_InverseKinematics_activateFrameConstraint(resc,resv,argc,(mxArray**)(argv)); break; - case 2002: flag=_wrap_InverseKinematics_deactivateFrameConstraint(resc,resv,argc,(mxArray**)(argv)); break; - case 2003: flag=_wrap_InverseKinematics_isFrameConstraintActive(resc,resv,argc,(mxArray**)(argv)); break; - case 2004: flag=_wrap_InverseKinematics_addCenterOfMassProjectionConstraint(resc,resv,argc,(mxArray**)(argv)); break; - case 2005: flag=_wrap_InverseKinematics_getCenterOfMassProjectionMargin(resc,resv,argc,(mxArray**)(argv)); break; - case 2006: flag=_wrap_InverseKinematics_getCenterOfMassProjectConstraintConvexHull(resc,resv,argc,(mxArray**)(argv)); break; - case 2007: flag=_wrap_InverseKinematics_addTarget(resc,resv,argc,(mxArray**)(argv)); break; - case 2008: flag=_wrap_InverseKinematics_addPositionTarget(resc,resv,argc,(mxArray**)(argv)); break; - case 2009: flag=_wrap_InverseKinematics_addRotationTarget(resc,resv,argc,(mxArray**)(argv)); break; - case 2010: flag=_wrap_InverseKinematics_updateTarget(resc,resv,argc,(mxArray**)(argv)); break; - case 2011: flag=_wrap_InverseKinematics_updatePositionTarget(resc,resv,argc,(mxArray**)(argv)); break; - case 2012: flag=_wrap_InverseKinematics_updateRotationTarget(resc,resv,argc,(mxArray**)(argv)); break; - case 2013: flag=_wrap_InverseKinematics_setDefaultTargetResolutionMode(resc,resv,argc,(mxArray**)(argv)); break; - case 2014: flag=_wrap_InverseKinematics_defaultTargetResolutionMode(resc,resv,argc,(mxArray**)(argv)); break; - case 2015: flag=_wrap_InverseKinematics_setTargetResolutionMode(resc,resv,argc,(mxArray**)(argv)); break; - case 2016: flag=_wrap_InverseKinematics_targetResolutionMode(resc,resv,argc,(mxArray**)(argv)); break; - case 2017: flag=_wrap_InverseKinematics_setDesiredFullJointsConfiguration(resc,resv,argc,(mxArray**)(argv)); break; - case 2018: flag=_wrap_InverseKinematics_setDesiredReducedJointConfiguration(resc,resv,argc,(mxArray**)(argv)); break; - case 2019: flag=_wrap_InverseKinematics_setFullJointsInitialCondition(resc,resv,argc,(mxArray**)(argv)); break; - case 2020: flag=_wrap_InverseKinematics_setReducedInitialCondition(resc,resv,argc,(mxArray**)(argv)); break; - case 2021: flag=_wrap_InverseKinematics_solve(resc,resv,argc,(mxArray**)(argv)); break; - case 2022: flag=_wrap_InverseKinematics_getFullJointsSolution(resc,resv,argc,(mxArray**)(argv)); break; - case 2023: flag=_wrap_InverseKinematics_getReducedSolution(resc,resv,argc,(mxArray**)(argv)); break; - case 2024: flag=_wrap_InverseKinematics_getPoseForFrame(resc,resv,argc,(mxArray**)(argv)); break; - case 2025: flag=_wrap_InverseKinematics_fullModel(resc,resv,argc,(mxArray**)(argv)); break; - case 2026: flag=_wrap_InverseKinematics_reducedModel(resc,resv,argc,(mxArray**)(argv)); break; - case 2027: flag=_wrap_InverseKinematics_setCOMTarget(resc,resv,argc,(mxArray**)(argv)); break; - case 2028: flag=_wrap_InverseKinematics_setCOMAsConstraint(resc,resv,argc,(mxArray**)(argv)); break; - case 2029: flag=_wrap_InverseKinematics_setCOMAsConstraintTolerance(resc,resv,argc,(mxArray**)(argv)); break; - case 2030: flag=_wrap_InverseKinematics_isCOMAConstraint(resc,resv,argc,(mxArray**)(argv)); break; - case 2031: flag=_wrap_InverseKinematics_isCOMTargetActive(resc,resv,argc,(mxArray**)(argv)); break; - case 2032: flag=_wrap_InverseKinematics_deactivateCOMTarget(resc,resv,argc,(mxArray**)(argv)); break; - case 2033: flag=_wrap_InverseKinematics_setCOMConstraintProjectionDirection(resc,resv,argc,(mxArray**)(argv)); break; + case 1859: flag=_wrap_delete_ILabel(resc,resv,argc,(mxArray**)(argv)); break; + case 1860: flag=_wrap_ILabel_setText(resc,resv,argc,(mxArray**)(argv)); break; + case 1861: flag=_wrap_ILabel_getText(resc,resv,argc,(mxArray**)(argv)); break; + case 1862: flag=_wrap_ILabel_setSize(resc,resv,argc,(mxArray**)(argv)); break; + case 1863: flag=_wrap_ILabel_width(resc,resv,argc,(mxArray**)(argv)); break; + case 1864: flag=_wrap_ILabel_height(resc,resv,argc,(mxArray**)(argv)); break; + case 1865: flag=_wrap_ILabel_setPosition(resc,resv,argc,(mxArray**)(argv)); break; + case 1866: flag=_wrap_ILabel_getPosition(resc,resv,argc,(mxArray**)(argv)); break; + case 1867: flag=_wrap_ILabel_setColor(resc,resv,argc,(mxArray**)(argv)); break; + case 1868: flag=_wrap_ILabel_setVisible(resc,resv,argc,(mxArray**)(argv)); break; + case 1869: flag=_wrap_delete_IVectorsVisualization(resc,resv,argc,(mxArray**)(argv)); break; + case 1870: flag=_wrap_IVectorsVisualization_addVector(resc,resv,argc,(mxArray**)(argv)); break; + case 1871: flag=_wrap_IVectorsVisualization_getNrOfVectors(resc,resv,argc,(mxArray**)(argv)); break; + case 1872: flag=_wrap_IVectorsVisualization_getVector(resc,resv,argc,(mxArray**)(argv)); break; + case 1873: flag=_wrap_IVectorsVisualization_updateVector(resc,resv,argc,(mxArray**)(argv)); break; + case 1874: flag=_wrap_IVectorsVisualization_setVectorColor(resc,resv,argc,(mxArray**)(argv)); break; + case 1875: flag=_wrap_IVectorsVisualization_setVectorsDefaultColor(resc,resv,argc,(mxArray**)(argv)); break; + case 1876: flag=_wrap_IVectorsVisualization_setVectorsColor(resc,resv,argc,(mxArray**)(argv)); break; + case 1877: flag=_wrap_IVectorsVisualization_setVectorsAspect(resc,resv,argc,(mxArray**)(argv)); break; + case 1878: flag=_wrap_IVectorsVisualization_setVisible(resc,resv,argc,(mxArray**)(argv)); break; + case 1879: flag=_wrap_IVectorsVisualization_getVectorLabel(resc,resv,argc,(mxArray**)(argv)); break; + case 1880: flag=_wrap_delete_IFrameVisualization(resc,resv,argc,(mxArray**)(argv)); break; + case 1881: flag=_wrap_IFrameVisualization_addFrame(resc,resv,argc,(mxArray**)(argv)); break; + case 1882: flag=_wrap_IFrameVisualization_setVisible(resc,resv,argc,(mxArray**)(argv)); break; + case 1883: flag=_wrap_IFrameVisualization_getNrOfFrames(resc,resv,argc,(mxArray**)(argv)); break; + case 1884: flag=_wrap_IFrameVisualization_getFrameTransform(resc,resv,argc,(mxArray**)(argv)); break; + case 1885: flag=_wrap_IFrameVisualization_updateFrame(resc,resv,argc,(mxArray**)(argv)); break; + case 1886: flag=_wrap_IFrameVisualization_getFrameLabel(resc,resv,argc,(mxArray**)(argv)); break; + case 1887: flag=_wrap_delete_IModelVisualization(resc,resv,argc,(mxArray**)(argv)); break; + case 1888: flag=_wrap_IModelVisualization_setPositions(resc,resv,argc,(mxArray**)(argv)); break; + case 1889: flag=_wrap_IModelVisualization_setLinkPositions(resc,resv,argc,(mxArray**)(argv)); break; + case 1890: flag=_wrap_IModelVisualization_model(resc,resv,argc,(mxArray**)(argv)); break; + case 1891: flag=_wrap_IModelVisualization_getInstanceName(resc,resv,argc,(mxArray**)(argv)); break; + case 1892: flag=_wrap_IModelVisualization_setModelVisibility(resc,resv,argc,(mxArray**)(argv)); break; + case 1893: flag=_wrap_IModelVisualization_setModelColor(resc,resv,argc,(mxArray**)(argv)); break; + case 1894: flag=_wrap_IModelVisualization_resetModelColor(resc,resv,argc,(mxArray**)(argv)); break; + case 1895: flag=_wrap_IModelVisualization_setLinkColor(resc,resv,argc,(mxArray**)(argv)); break; + case 1896: flag=_wrap_IModelVisualization_resetLinkColor(resc,resv,argc,(mxArray**)(argv)); break; + case 1897: flag=_wrap_IModelVisualization_getLinkNames(resc,resv,argc,(mxArray**)(argv)); break; + case 1898: flag=_wrap_IModelVisualization_setLinkVisibility(resc,resv,argc,(mxArray**)(argv)); break; + case 1899: flag=_wrap_IModelVisualization_getFeatures(resc,resv,argc,(mxArray**)(argv)); break; + case 1900: flag=_wrap_IModelVisualization_setFeatureVisibility(resc,resv,argc,(mxArray**)(argv)); break; + case 1901: flag=_wrap_IModelVisualization_jets(resc,resv,argc,(mxArray**)(argv)); break; + case 1902: flag=_wrap_IModelVisualization_getWorldLinkTransform(resc,resv,argc,(mxArray**)(argv)); break; + case 1903: flag=_wrap_IModelVisualization_getWorldFrameTransform(resc,resv,argc,(mxArray**)(argv)); break; + case 1904: flag=_wrap_IModelVisualization_label(resc,resv,argc,(mxArray**)(argv)); break; + case 1905: flag=_wrap_delete_ITexture(resc,resv,argc,(mxArray**)(argv)); break; + case 1906: flag=_wrap_ITexture_environment(resc,resv,argc,(mxArray**)(argv)); break; + case 1907: flag=_wrap_ITexture_getPixelColor(resc,resv,argc,(mxArray**)(argv)); break; + case 1908: flag=_wrap_ITexture_getPixels(resc,resv,argc,(mxArray**)(argv)); break; + case 1909: flag=_wrap_VisualizerOptions_verbose_get(resc,resv,argc,(mxArray**)(argv)); break; + case 1910: flag=_wrap_VisualizerOptions_verbose_set(resc,resv,argc,(mxArray**)(argv)); break; + case 1911: flag=_wrap_VisualizerOptions_winWidth_get(resc,resv,argc,(mxArray**)(argv)); break; + case 1912: flag=_wrap_VisualizerOptions_winWidth_set(resc,resv,argc,(mxArray**)(argv)); break; + case 1913: flag=_wrap_VisualizerOptions_winHeight_get(resc,resv,argc,(mxArray**)(argv)); break; + case 1914: flag=_wrap_VisualizerOptions_winHeight_set(resc,resv,argc,(mxArray**)(argv)); break; + case 1915: flag=_wrap_VisualizerOptions_rootFrameArrowsDimension_get(resc,resv,argc,(mxArray**)(argv)); break; + case 1916: flag=_wrap_VisualizerOptions_rootFrameArrowsDimension_set(resc,resv,argc,(mxArray**)(argv)); break; + case 1917: flag=_wrap_new_VisualizerOptions(resc,resv,argc,(mxArray**)(argv)); break; + case 1918: flag=_wrap_delete_VisualizerOptions(resc,resv,argc,(mxArray**)(argv)); break; + case 1919: flag=_wrap_delete_ITexturesHandler(resc,resv,argc,(mxArray**)(argv)); break; + case 1920: flag=_wrap_ITexturesHandler_add(resc,resv,argc,(mxArray**)(argv)); break; + case 1921: flag=_wrap_ITexturesHandler_get(resc,resv,argc,(mxArray**)(argv)); break; + case 1922: flag=_wrap_new_Visualizer(resc,resv,argc,(mxArray**)(argv)); break; + case 1923: flag=_wrap_delete_Visualizer(resc,resv,argc,(mxArray**)(argv)); break; + case 1924: flag=_wrap_Visualizer_init(resc,resv,argc,(mxArray**)(argv)); break; + case 1925: flag=_wrap_Visualizer_getNrOfVisualizedModels(resc,resv,argc,(mxArray**)(argv)); break; + case 1926: flag=_wrap_Visualizer_getModelInstanceName(resc,resv,argc,(mxArray**)(argv)); break; + case 1927: flag=_wrap_Visualizer_getModelInstanceIndex(resc,resv,argc,(mxArray**)(argv)); break; + case 1928: flag=_wrap_Visualizer_addModel(resc,resv,argc,(mxArray**)(argv)); break; + case 1929: flag=_wrap_Visualizer_modelViz(resc,resv,argc,(mxArray**)(argv)); break; + case 1930: flag=_wrap_Visualizer_camera(resc,resv,argc,(mxArray**)(argv)); break; + case 1931: flag=_wrap_Visualizer_enviroment(resc,resv,argc,(mxArray**)(argv)); break; + case 1932: flag=_wrap_Visualizer_vectors(resc,resv,argc,(mxArray**)(argv)); break; + case 1933: flag=_wrap_Visualizer_frames(resc,resv,argc,(mxArray**)(argv)); break; + case 1934: flag=_wrap_Visualizer_textures(resc,resv,argc,(mxArray**)(argv)); break; + case 1935: flag=_wrap_Visualizer_getLabel(resc,resv,argc,(mxArray**)(argv)); break; + case 1936: flag=_wrap_Visualizer_run(resc,resv,argc,(mxArray**)(argv)); break; + case 1937: flag=_wrap_Visualizer_draw(resc,resv,argc,(mxArray**)(argv)); break; + case 1938: flag=_wrap_Visualizer_drawToFile(resc,resv,argc,(mxArray**)(argv)); break; + case 1939: flag=_wrap_Visualizer_close(resc,resv,argc,(mxArray**)(argv)); break; + case 1940: flag=_wrap_Visualizer_isWindowActive(resc,resv,argc,(mxArray**)(argv)); break; + case 1941: flag=_wrap_Visualizer_setColorPalette(resc,resv,argc,(mxArray**)(argv)); break; + case 1942: flag=_wrap_Polygon_m_vertices_get(resc,resv,argc,(mxArray**)(argv)); break; + case 1943: flag=_wrap_Polygon_m_vertices_set(resc,resv,argc,(mxArray**)(argv)); break; + case 1944: flag=_wrap_new_Polygon(resc,resv,argc,(mxArray**)(argv)); break; + case 1945: flag=_wrap_Polygon_setNrOfVertices(resc,resv,argc,(mxArray**)(argv)); break; + case 1946: flag=_wrap_Polygon_getNrOfVertices(resc,resv,argc,(mxArray**)(argv)); break; + case 1947: flag=_wrap_Polygon_isValid(resc,resv,argc,(mxArray**)(argv)); break; + case 1948: flag=_wrap_Polygon_applyTransform(resc,resv,argc,(mxArray**)(argv)); break; + case 1949: flag=_wrap_Polygon_paren(resc,resv,argc,(mxArray**)(argv)); break; + case 1950: flag=_wrap_Polygon_XYRectangleFromOffsets(resc,resv,argc,(mxArray**)(argv)); break; + case 1951: flag=_wrap_delete_Polygon(resc,resv,argc,(mxArray**)(argv)); break; + case 1952: flag=_wrap_Polygon2D_m_vertices_get(resc,resv,argc,(mxArray**)(argv)); break; + case 1953: flag=_wrap_Polygon2D_m_vertices_set(resc,resv,argc,(mxArray**)(argv)); break; + case 1954: flag=_wrap_new_Polygon2D(resc,resv,argc,(mxArray**)(argv)); break; + case 1955: flag=_wrap_Polygon2D_setNrOfVertices(resc,resv,argc,(mxArray**)(argv)); break; + case 1956: flag=_wrap_Polygon2D_getNrOfVertices(resc,resv,argc,(mxArray**)(argv)); break; + case 1957: flag=_wrap_Polygon2D_isValid(resc,resv,argc,(mxArray**)(argv)); break; + case 1958: flag=_wrap_Polygon2D_paren(resc,resv,argc,(mxArray**)(argv)); break; + case 1959: flag=_wrap_delete_Polygon2D(resc,resv,argc,(mxArray**)(argv)); break; + case 1960: flag=_wrap_ConvexHullProjectionConstraint_setActive(resc,resv,argc,(mxArray**)(argv)); break; + case 1961: flag=_wrap_ConvexHullProjectionConstraint_isActive(resc,resv,argc,(mxArray**)(argv)); break; + case 1962: flag=_wrap_ConvexHullProjectionConstraint_getNrOfConstraints(resc,resv,argc,(mxArray**)(argv)); break; + case 1963: flag=_wrap_ConvexHullProjectionConstraint_projectedConvexHull_get(resc,resv,argc,(mxArray**)(argv)); break; + case 1964: flag=_wrap_ConvexHullProjectionConstraint_projectedConvexHull_set(resc,resv,argc,(mxArray**)(argv)); break; + case 1965: flag=_wrap_ConvexHullProjectionConstraint_A_get(resc,resv,argc,(mxArray**)(argv)); break; + case 1966: flag=_wrap_ConvexHullProjectionConstraint_A_set(resc,resv,argc,(mxArray**)(argv)); break; + case 1967: flag=_wrap_ConvexHullProjectionConstraint_b_get(resc,resv,argc,(mxArray**)(argv)); break; + case 1968: flag=_wrap_ConvexHullProjectionConstraint_b_set(resc,resv,argc,(mxArray**)(argv)); break; + case 1969: flag=_wrap_ConvexHullProjectionConstraint_P_get(resc,resv,argc,(mxArray**)(argv)); break; + case 1970: flag=_wrap_ConvexHullProjectionConstraint_P_set(resc,resv,argc,(mxArray**)(argv)); break; + case 1971: flag=_wrap_ConvexHullProjectionConstraint_Pdirection_get(resc,resv,argc,(mxArray**)(argv)); break; + case 1972: flag=_wrap_ConvexHullProjectionConstraint_Pdirection_set(resc,resv,argc,(mxArray**)(argv)); break; + case 1973: flag=_wrap_ConvexHullProjectionConstraint_AtimesP_get(resc,resv,argc,(mxArray**)(argv)); break; + case 1974: flag=_wrap_ConvexHullProjectionConstraint_AtimesP_set(resc,resv,argc,(mxArray**)(argv)); break; + case 1975: flag=_wrap_ConvexHullProjectionConstraint_o_get(resc,resv,argc,(mxArray**)(argv)); break; + case 1976: flag=_wrap_ConvexHullProjectionConstraint_o_set(resc,resv,argc,(mxArray**)(argv)); break; + case 1977: flag=_wrap_ConvexHullProjectionConstraint_buildConvexHull(resc,resv,argc,(mxArray**)(argv)); break; + case 1978: flag=_wrap_ConvexHullProjectionConstraint_supportFrameIndices_get(resc,resv,argc,(mxArray**)(argv)); break; + case 1979: flag=_wrap_ConvexHullProjectionConstraint_supportFrameIndices_set(resc,resv,argc,(mxArray**)(argv)); break; + case 1980: flag=_wrap_ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_get(resc,resv,argc,(mxArray**)(argv)); break; + case 1981: flag=_wrap_ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_set(resc,resv,argc,(mxArray**)(argv)); break; + case 1982: flag=_wrap_ConvexHullProjectionConstraint_project(resc,resv,argc,(mxArray**)(argv)); break; + case 1983: flag=_wrap_ConvexHullProjectionConstraint_computeMargin(resc,resv,argc,(mxArray**)(argv)); break; + case 1984: flag=_wrap_ConvexHullProjectionConstraint_setProjectionAlongDirection(resc,resv,argc,(mxArray**)(argv)); break; + case 1985: flag=_wrap_ConvexHullProjectionConstraint_projectAlongDirection(resc,resv,argc,(mxArray**)(argv)); break; + case 1986: flag=_wrap_new_ConvexHullProjectionConstraint(resc,resv,argc,(mxArray**)(argv)); break; + case 1987: flag=_wrap_delete_ConvexHullProjectionConstraint(resc,resv,argc,(mxArray**)(argv)); break; + case 1988: flag=_wrap_sizeOfRotationParametrization(resc,resv,argc,(mxArray**)(argv)); break; + case 1989: flag=_wrap_new_InverseKinematics(resc,resv,argc,(mxArray**)(argv)); break; + case 1990: flag=_wrap_delete_InverseKinematics(resc,resv,argc,(mxArray**)(argv)); break; + case 1991: flag=_wrap_InverseKinematics_loadModelFromFile(resc,resv,argc,(mxArray**)(argv)); break; + case 1992: flag=_wrap_InverseKinematics_setModel(resc,resv,argc,(mxArray**)(argv)); break; + case 1993: flag=_wrap_InverseKinematics_setJointLimits(resc,resv,argc,(mxArray**)(argv)); break; + case 1994: flag=_wrap_InverseKinematics_getJointLimits(resc,resv,argc,(mxArray**)(argv)); break; + case 1995: flag=_wrap_InverseKinematics_clearProblem(resc,resv,argc,(mxArray**)(argv)); break; + case 1996: flag=_wrap_InverseKinematics_setFloatingBaseOnFrameNamed(resc,resv,argc,(mxArray**)(argv)); break; + case 1997: flag=_wrap_InverseKinematics_setCurrentRobotConfiguration(resc,resv,argc,(mxArray**)(argv)); break; + case 1998: flag=_wrap_InverseKinematics_setJointConfiguration(resc,resv,argc,(mxArray**)(argv)); break; + case 1999: flag=_wrap_InverseKinematics_setRotationParametrization(resc,resv,argc,(mxArray**)(argv)); break; + case 2000: flag=_wrap_InverseKinematics_rotationParametrization(resc,resv,argc,(mxArray**)(argv)); break; + case 2001: flag=_wrap_InverseKinematics_setMaxIterations(resc,resv,argc,(mxArray**)(argv)); break; + case 2002: flag=_wrap_InverseKinematics_maxIterations(resc,resv,argc,(mxArray**)(argv)); break; + case 2003: flag=_wrap_InverseKinematics_setMaxCPUTime(resc,resv,argc,(mxArray**)(argv)); break; + case 2004: flag=_wrap_InverseKinematics_maxCPUTime(resc,resv,argc,(mxArray**)(argv)); break; + case 2005: flag=_wrap_InverseKinematics_setCostTolerance(resc,resv,argc,(mxArray**)(argv)); break; + case 2006: flag=_wrap_InverseKinematics_costTolerance(resc,resv,argc,(mxArray**)(argv)); break; + case 2007: flag=_wrap_InverseKinematics_setConstraintsTolerance(resc,resv,argc,(mxArray**)(argv)); break; + case 2008: flag=_wrap_InverseKinematics_constraintsTolerance(resc,resv,argc,(mxArray**)(argv)); break; + case 2009: flag=_wrap_InverseKinematics_setVerbosity(resc,resv,argc,(mxArray**)(argv)); break; + case 2010: flag=_wrap_InverseKinematics_linearSolverName(resc,resv,argc,(mxArray**)(argv)); break; + case 2011: flag=_wrap_InverseKinematics_setLinearSolverName(resc,resv,argc,(mxArray**)(argv)); break; + case 2012: flag=_wrap_InverseKinematics_addFrameConstraint(resc,resv,argc,(mxArray**)(argv)); break; + case 2013: flag=_wrap_InverseKinematics_addFramePositionConstraint(resc,resv,argc,(mxArray**)(argv)); break; + case 2014: flag=_wrap_InverseKinematics_addFrameRotationConstraint(resc,resv,argc,(mxArray**)(argv)); break; + case 2015: flag=_wrap_InverseKinematics_activateFrameConstraint(resc,resv,argc,(mxArray**)(argv)); break; + case 2016: flag=_wrap_InverseKinematics_deactivateFrameConstraint(resc,resv,argc,(mxArray**)(argv)); break; + case 2017: flag=_wrap_InverseKinematics_isFrameConstraintActive(resc,resv,argc,(mxArray**)(argv)); break; + case 2018: flag=_wrap_InverseKinematics_addCenterOfMassProjectionConstraint(resc,resv,argc,(mxArray**)(argv)); break; + case 2019: flag=_wrap_InverseKinematics_getCenterOfMassProjectionMargin(resc,resv,argc,(mxArray**)(argv)); break; + case 2020: flag=_wrap_InverseKinematics_getCenterOfMassProjectConstraintConvexHull(resc,resv,argc,(mxArray**)(argv)); break; + case 2021: flag=_wrap_InverseKinematics_addTarget(resc,resv,argc,(mxArray**)(argv)); break; + case 2022: flag=_wrap_InverseKinematics_addPositionTarget(resc,resv,argc,(mxArray**)(argv)); break; + case 2023: flag=_wrap_InverseKinematics_addRotationTarget(resc,resv,argc,(mxArray**)(argv)); break; + case 2024: flag=_wrap_InverseKinematics_updateTarget(resc,resv,argc,(mxArray**)(argv)); break; + case 2025: flag=_wrap_InverseKinematics_updatePositionTarget(resc,resv,argc,(mxArray**)(argv)); break; + case 2026: flag=_wrap_InverseKinematics_updateRotationTarget(resc,resv,argc,(mxArray**)(argv)); break; + case 2027: flag=_wrap_InverseKinematics_setDefaultTargetResolutionMode(resc,resv,argc,(mxArray**)(argv)); break; + case 2028: flag=_wrap_InverseKinematics_defaultTargetResolutionMode(resc,resv,argc,(mxArray**)(argv)); break; + case 2029: flag=_wrap_InverseKinematics_setTargetResolutionMode(resc,resv,argc,(mxArray**)(argv)); break; + case 2030: flag=_wrap_InverseKinematics_targetResolutionMode(resc,resv,argc,(mxArray**)(argv)); break; + case 2031: flag=_wrap_InverseKinematics_setDesiredFullJointsConfiguration(resc,resv,argc,(mxArray**)(argv)); break; + case 2032: flag=_wrap_InverseKinematics_setDesiredReducedJointConfiguration(resc,resv,argc,(mxArray**)(argv)); break; + case 2033: flag=_wrap_InverseKinematics_setFullJointsInitialCondition(resc,resv,argc,(mxArray**)(argv)); break; + case 2034: flag=_wrap_InverseKinematics_setReducedInitialCondition(resc,resv,argc,(mxArray**)(argv)); break; + case 2035: flag=_wrap_InverseKinematics_solve(resc,resv,argc,(mxArray**)(argv)); break; + case 2036: flag=_wrap_InverseKinematics_getFullJointsSolution(resc,resv,argc,(mxArray**)(argv)); break; + case 2037: flag=_wrap_InverseKinematics_getReducedSolution(resc,resv,argc,(mxArray**)(argv)); break; + case 2038: flag=_wrap_InverseKinematics_getPoseForFrame(resc,resv,argc,(mxArray**)(argv)); break; + case 2039: flag=_wrap_InverseKinematics_fullModel(resc,resv,argc,(mxArray**)(argv)); break; + case 2040: flag=_wrap_InverseKinematics_reducedModel(resc,resv,argc,(mxArray**)(argv)); break; + case 2041: flag=_wrap_InverseKinematics_setCOMTarget(resc,resv,argc,(mxArray**)(argv)); break; + case 2042: flag=_wrap_InverseKinematics_setCOMAsConstraint(resc,resv,argc,(mxArray**)(argv)); break; + case 2043: flag=_wrap_InverseKinematics_setCOMAsConstraintTolerance(resc,resv,argc,(mxArray**)(argv)); break; + case 2044: flag=_wrap_InverseKinematics_isCOMAConstraint(resc,resv,argc,(mxArray**)(argv)); break; + case 2045: flag=_wrap_InverseKinematics_isCOMTargetActive(resc,resv,argc,(mxArray**)(argv)); break; + case 2046: flag=_wrap_InverseKinematics_deactivateCOMTarget(resc,resv,argc,(mxArray**)(argv)); break; + case 2047: flag=_wrap_InverseKinematics_setCOMConstraintProjectionDirection(resc,resv,argc,(mxArray**)(argv)); break; default: flag=1, SWIG_Error(SWIG_RuntimeError, "No function id %d.", fcn_id); } if (flag) {