Resolve URIs relative to file path

include/sdf/ParserConfig.hh

@@ -179,6 +179,10 @@ class SDFORMAT_VISIBLE ParserConfig
   /// and merge the child link into the parent.
   public: bool URDFPreserveFixedJoint() const;
 
+  /// \brief Set the storeResolvedURIs flag value.
+  /// \sa SetStoreResolvedURIs
+  public: void SetStoreResovledURIs(bool _resolveURI);
+
   /// \brief Set the storeResolvedURIs flag value.
   /// \param[in] _resolveURI True to make the parser attempt to resolve any
   /// URIs found and store them.  False to preserve original URIs
@@ -188,7 +192,7 @@ class SDFORMAT_VISIBLE ParserConfig
   /// If the FindFileCallback provides a non-empty string, the URI will be
   /// stored in the DOM object, and the original (unresolved) URI will be
   /// stored in the underlying Element.
-  public: void SetStoreResovledURIs(bool _resolveURI);
+  public: void SetStoreResolvedURIs(bool _resolveURI);
 
   /// \brief Get the storeResolvedURIs flag value.
   /// \return True if the parser will attempt to resolve any URIs found and

src/Heightmap.cc

@@ -15,6 +15,7 @@
  *
 */
 
+#include <filesystem>
 #include <vector>
 
 #include "Utils.hh"
@@ -133,9 +134,15 @@ Errors HeightmapTexture::Load(ElementPtr _sdf, const ParserConfig &_config)
 
   if (_sdf->HasElement("diffuse"))
   {
+    std::unordered_set<std::string> paths;
+    if (!this->dataPtr->sdf->FilePath().empty())
+    {
+      paths.insert(std::filesystem::path(
+          this->dataPtr->sdf->FilePath()).parent_path().string());
+    }
     this->dataPtr->diffuse = resolveURI(
         _sdf->Get<std::string>(errors, "diffuse", this->dataPtr->diffuse).first,
-        _config, errors);
+        _config, errors, paths);
   }
   else
   {
@@ -145,9 +152,15 @@ Errors HeightmapTexture::Load(ElementPtr _sdf, const ParserConfig &_config)
 
   if (_sdf->HasElement("normal"))
   {
+    std::unordered_set<std::string> paths;
+    if (!this->dataPtr->sdf->FilePath().empty())
+    {
+      paths.insert(std::filesystem::path(
+          this->dataPtr->sdf->FilePath()).parent_path().string());
+    }
     this->dataPtr->normal = resolveURI(
         _sdf->Get<std::string>(errors, "normal", this->dataPtr->normal).first,
-        _config, errors);
+        _config, errors, paths);
   }
   else
   {
@@ -326,9 +339,15 @@ Errors Heightmap::Load(ElementPtr _sdf, const ParserConfig &_config)
 
   if (_sdf->HasElement("uri"))
   {
+    std::unordered_set<std::string> paths;
+    if (!this->dataPtr->filePath.empty())
+    {
+      paths.insert(std::filesystem::path(
+          this->dataPtr->filePath).parent_path().string());
+    }
     this->dataPtr->uri = resolveURI(
       _sdf->Get<std::string>(errors, "uri", "").first,
-      _config, errors);
+      _config, errors, paths);
   }
   else
   {

src/Material.cc

@@ -14,8 +14,10 @@
  * limitations under the License.
  *
 */
-#include <string>
+
+#include <filesystem>
 #include <optional>
+#include <string>
 #include <vector>
 #include <gz/math/Vector3.hh>
 
@@ -122,7 +124,14 @@ Errors Material::Load(sdf::ElementPtr _sdf, const sdf::ParserConfig &_config)
           "<uri> element is empty."});
     }
 
-    this->dataPtr->scriptUri = resolveURI(uriPair.first, _config, errors);
+    std::unordered_set<std::string> paths;
+    if (!this->dataPtr->filePath.empty())
+    {
+      paths.insert(std::filesystem::path(
+          this->dataPtr->filePath).parent_path().string());
+    }
+    this->dataPtr->scriptUri = resolveURI(uriPair.first, _config, errors,
+        paths);
 
     std::pair<std::string, bool> namePair =
         elem->Get<std::string>(errors, "name", "");

src/Mesh.cc

@@ -14,6 +14,8 @@
  * limitations under the License.
  *
 */
+#include <filesystem>
+
 #include "sdf/parser.hh"
 #include "sdf/Mesh.hh"
 #include "Utils.hh"
@@ -82,9 +84,15 @@ Errors Mesh::Load(ElementPtr _sdf, const ParserConfig &_config)
 
   if (_sdf->HasElement("uri"))
   {
+    std::unordered_set<std::string> paths;
+    if (!this->dataPtr->filePath.empty())
+    {
+      paths.insert(std::filesystem::path(
+          this->dataPtr->filePath).parent_path().string());
+    }
     this->dataPtr->uri = resolveURI(
       _sdf->Get<std::string>(errors, "uri", "").first,
-      _config, errors);
+      _config, errors, paths);
   }
   else
   {

src/ParserConfig.cc

@@ -183,6 +183,12 @@
 
 /////////////////////////////////////////////////
 void ParserConfig::SetStoreResovledURIs(bool _resolveURI)
+{
+  this->SetStoreResolvedURIs(_resolveURI);
+}
+
+/////////////////////////////////////////////////
+void ParserConfig::SetStoreResolvedURIs(bool _resolveURI)
 {
   this->dataPtr->storeResolvedURIs = _resolveURI;
 }
@@ -192,4 +198,3 @@
 {
   return this->dataPtr->storeResolvedURIs;
 }
-

src/Sky.cc

@@ -14,6 +14,8 @@
  * limitations under the License.
  *
 */
+#include <filesystem>
+
 #include "sdf/parser.hh"
 #include "sdf/Sky.hh"
 #include "Utils.hh"
@@ -201,9 +203,15 @@ Errors Sky::Load(ElementPtr _sdf, const ParserConfig &_config)
 
   if (_sdf->HasElement("cubemap_uri"))
   {
+    std::unordered_set<std::string> paths;
+    if (!_sdf->FilePath().empty())
+    {
+      paths.insert(std::filesystem::path(
+          _sdf->FilePath()).parent_path().string());
+    }
     this->dataPtr->cubemapUri = resolveURI(
       _sdf->Get<std::string>(errors, "cubemap_uri", "").first,
-      _config, errors);
+      _config, errors, paths);
   }
 
   if ( _sdf->HasElement("clouds"))

src/Utils.cc

@@ -14,10 +14,12 @@
  * limitations under the License.
  *
 */
+#include <filesystem>
 #include <limits>
 #include <string>
 #include <utility>
 #include "sdf/Assert.hh"
+#include "sdf/Filesystem.hh"
 #include "sdf/SDFImpl.hh"
 #include "Utils.hh"
 
@@ -382,11 +384,28 @@ void copyChildren(ElementPtr _sdf, tinyxml2::XMLElement *_xml,
 
 /////////////////////////////////////////////////
 std::string resolveURI(const std::string &_inputURI,
-    const sdf::ParserConfig &_config, sdf::Errors &_errors)
+    const sdf::ParserConfig &_config, sdf::Errors &_errors,
+    const std::unordered_set<std::string> &_searchPaths)
 {
   std::string resolvedURI = _inputURI;
   if (_config.StoreResolvedURIs())
   {
+    std::string sep("://");
+    if (!_searchPaths.empty() &&
+        _inputURI.find(sep) == std::string::npos &&
+        !std::filesystem::path(_inputURI).is_absolute())
+    {
+      for (const auto &sp : _searchPaths)
+      {
+        // find file by searching local path but do not use callbacks
+        std::string fullPath = sdf::filesystem::append(sp, _inputURI);
+        resolvedURI = sdf::findFile(fullPath, true, false);
+        if (!resolvedURI.empty())
+          return resolvedURI;
+      }
+    }
+
+    // find file by searching local path and use registered callbacks
     resolvedURI = sdf::findFile(_inputURI, true, true, _config);
     if (resolvedURI.empty())
     {

src/Utils.hh

@@ -23,6 +23,7 @@
 #include <utility>
 #include <vector>
 #include <tinyxml2.h>
+#include <unordered_set>
 #include "sdf/Error.hh"
 #include "sdf/Element.hh"
 #include "sdf/InterfaceElements.hh"
@@ -262,10 +263,14 @@ namespace sdf
   /// \param[in] _inputURI URI from parsed SDF file to resolve
   /// \param[in] _config Parser configuration to use to resolve
   /// \param[in, out] _errors Error vector to append to if resolution fails
+  /// \param[in] _searchPaths Optional additional search paths (directory)
+  /// when resolving URI
   /// \return Resolved URI or Original URI, depending on parser configuration
   std::string resolveURI(const std::string &_inputURI,
                          const sdf::ParserConfig &_config,
-                         sdf::Errors &_errors);
+                         sdf::Errors &_errors,
+                         const std::unordered_set<std::string>
+                         &_searchPaths = {});
 }
 }
 #endif