Model.hh

Go to the documentation of this file.

/*
 * Copyright 2018 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
#ifndef SDF_MODEL_HH_
#define SDF_MODEL_HH_
 
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
#include <gz/math/Pose3.hh>
#include <gz/utils/ImplPtr.hh>
#include "sdf/Element.hh"
#include "sdf/OutputConfig.hh"
#include "sdf/ParserConfig.hh"
#include "sdf/Plugin.hh"
#include "sdf/SemanticPose.hh"
#include "sdf/Types.hh"
#include "sdf/config.hh"
#include "sdf/system_util.hh"
 
namespace sdf
{
  // Inline bracket to help doxygen filtering.
  inline namespace SDF_VERSION_NAMESPACE {
  //
 
  // Forward declarations.
  class Frame;
  class InterfaceModel;
  class Joint;
  class Link;
  class ParserConfig;
  class NestedInclude;
  struct PoseRelativeToGraph;
  struct FrameAttachedToGraph;
  template <typename T> class ScopedGraph;
  using InterfaceModelConstPtr = std::shared_ptr<const InterfaceModel>;
 
  class SDFORMAT_VISIBLE Model
  {
    public: Model();
 
    public: Errors Load(ElementPtr _sdf);
 
    public: Errors Load(sdf::ElementPtr _sdf, const ParserConfig &_config);
 
    public: Errors ValidateGraphs() const;
 
    public: std::string Name() const;
 
    public: void SetName(const std::string &_name);
 
    public: std::optional<std::string> Namespace() const;
 
    public: std::optional<std::string> RawNamespace() const;
 
    public: void SetRawNamespace(const std::string &_ns);
 
    public: bool Static() const;
 
    public: void SetStatic(bool _static);
 
    public: bool SelfCollide() const;
 
    public: void SetSelfCollide(bool _selfCollide);
 
    public: bool AllowAutoDisable() const;
 
    public: void SetAllowAutoDisable(bool _allowAutoDisable);
 
    public: bool EnableWind() const;
 
    public: void SetEnableWind(bool _enableWind);
 
    public: uint64_t LinkCount() const;
 
    public: const Link *LinkByIndex(const uint64_t _index) const;
 
    public: Link *LinkByIndex(uint64_t _index);
 
    public: const Link *LinkByName(const std::string &_name) const;
 
    public: Link *LinkByName(const std::string &_name);
 
    public: bool LinkNameExists(const std::string &_name) const;
 
    public: uint64_t JointCount() const;
 
    public: const Joint *JointByIndex(const uint64_t _index) const;
 
    public: Joint *JointByIndex(uint64_t _index);
 
    public: bool JointNameExists(const std::string &_name) const;
 
    public: const Joint *JointByName(const std::string &_name) const;
 
    public: Joint *JointByName(const std::string &_name);
 
    public: uint64_t FrameCount() const;
 
    public: const Frame *FrameByIndex(const uint64_t _index) const;
 
    public: Frame *FrameByIndex(uint64_t _index);
 
    public: const Frame *FrameByName(const std::string &_name) const;
 
    public: Frame *FrameByName(const std::string &_name);
 
    public: bool FrameNameExists(const std::string &_name) const;
 
    public: uint64_t ModelCount() const;
 
    public: const Model *ModelByIndex(const uint64_t _index) const;
 
    // based on an index.
    public: Model *ModelByIndex(uint64_t _index);
 
    public: bool ModelNameExists(const std::string &_name) const;
 
    public: const Model *ModelByName(const std::string &_name) const;
 
    public: Model *ModelByName(const std::string &_name);
 
    public: const gz::math::Pose3d &RawPose() const;
 
    public: void SetRawPose(const gz::math::Pose3d &_pose);
 
    public: const Link *CanonicalLink() const;
 
    public: const std::string &CanonicalLinkName() const;
 
    public: void SetCanonicalLinkName(const std::string &_canonicalLink);
 
    public: const std::string &PoseRelativeTo() const;
 
    public: void SetPoseRelativeTo(const std::string &_frame);
 
    public: sdf::ElementPtr Element() const;
 
    public: sdf::SemanticPose SemanticPose() const;
 
    public: const std::string &PlacementFrameName() const;
 
    public: void SetPlacementFrameName(const std::string &_name);
 
    // TODO(addisu): If the canonical link is inside an interface model, this
    // function returns {nullptr, name}. This can be problematic for downstream
    // applications.
    public: std::pair<const Link *, std::string> CanonicalLinkAndRelativeName()
        const;
 
    public: uint64_t InterfaceModelCount() const;
 
    public: std::shared_ptr<const InterfaceModel> InterfaceModelByIndex(
                const uint64_t _index) const;
 
    public: const NestedInclude *InterfaceModelNestedIncludeByIndex(
                const uint64_t _index) const;
 
    public: sdf::ElementPtr ToElement(
        const OutputConfig &_config = OutputConfig::GlobalConfig()) const;
 
    public: bool NameExistsInFrameAttachedToGraph(
                const std::string &_name) const;
 
    public: bool AddLink(const Link &_link);
 
    public: bool AddJoint(const Joint &_joint);
 
    public: bool AddModel(const Model &_model);
 
    public: bool AddFrame(const Frame &_frame);
 
    public: void ClearLinks();
 
    public: void ClearJoints();
 
    public: void ClearModels();
 
    public: void ClearFrames();
 
    public: std::string Uri() const;
 
    public: void SetUri(const std::string &_uri);
 
    public: const sdf::Plugins &Plugins() const;
 
    public: sdf::Plugins &Plugins();
 
    public: void ClearPlugins();
 
    public: void AddPlugin(const Plugin &_plugin);
 
    public: void ResolveAutoInertials(sdf::Errors &_errors,
                                    const ParserConfig &_config);
 
    private: void SetPoseRelativeToGraph(
        sdf::ScopedGraph<PoseRelativeToGraph> _graph);
 
    private: void SetFrameAttachedToGraph(
        sdf::ScopedGraph<FrameAttachedToGraph> _graph);
 
    private: const std::vector<std::pair<std::optional<sdf::NestedInclude>,
             sdf::InterfaceModelConstPtr>> &MergedInterfaceModels() const;
 
    private: bool IsMerged() const;
 
    private: sdf::Frame PrepareForMerge(sdf::Errors &_errors,
                                        const std::string &_parentOfProxyFrame);
 
    private: std::optional<std::string> ResolveNamespace (
        const std::optional<std::string> &_rawNs,
        const std::string &_modelName);
 
    friend class Root;
    friend class World;
 
    // Allow ModelWrapper from FrameSemantics.cc to call MergedInterfaceModels
    friend struct ModelWrapper;
 
    GZ_UTILS_IMPL_PTR(dataPtr)
  };
  }
}
#endif