Format rviz code

.clang-format

@@ -49,7 +49,7 @@ IncludeCategories:
     Priority:  1
   - Regex:     '^(<|")aikido/' # Aikido headers
     Priority:  3
-  - Regex:     '^(<[a-z]+)'    # dependency headers
+  - Regex:     '^(<[A-z]+)'    # dependency headers
     Priority:  2
   - Regex:     '^".*'          # headers relative to this project
     Priority:  4

CMakeLists.txt

@@ -88,7 +88,9 @@ endfunction()
 
 # TODO: Temporarily split header list per subdirectories.
 file(GLOB_RECURSE headers_util "${CMAKE_SOURCE_DIR}/include/aikido/util/*.hpp")
+file(GLOB_RECURSE headers_rviz "${CMAKE_SOURCE_DIR}/include/aikido/rviz/*.hpp")
 format_add_sources(${headers_util})
+format_add_sources(${headers_rviz})
 
 #==============================================================================
 # Helper functions.

include/aikido/rviz/BodyNodeMarker.hpp

@@ -10,39 +10,40 @@
 namespace aikido {
 namespace rviz {
 
-class BodyNodeMarker {
+class BodyNodeMarker
+{
 public:
   BodyNodeMarker(
-    ResourceServer *resourceServer,
-    interactive_markers::InteractiveMarkerServer *markerServer,
-    dart::dynamics::WeakBodyNodePtr const &bodyNode);
+      ResourceServer* resourceServer,
+      interactive_markers::InteractiveMarkerServer* markerServer,
+      dart::dynamics::WeakBodyNodePtr const& bodyNode);
 
-  BodyNodeMarker(BodyNodeMarker const &) = delete;
-  BodyNodeMarker &operator=(BodyNodeMarker const &) = delete;
+  BodyNodeMarker(BodyNodeMarker const&) = delete;
+  BodyNodeMarker& operator=(BodyNodeMarker const&) = delete;
 
   virtual ~BodyNodeMarker() = default;
 
   bool update();
 
-  void SetColor(Eigen::Vector4d const &color);
+  void SetColor(Eigen::Vector4d const& color);
   void ResetColor();
 
 private:
-  using ShapeFrameMarkerMap = std::map<
-    const dart::dynamics::ShapeNode *, std::unique_ptr<ShapeFrameMarker>>;
+  using ShapeFrameMarkerMap = std::map<const dart::dynamics::ShapeNode*,
+                                       std::unique_ptr<ShapeFrameMarker>>;
 
   dart::dynamics::WeakBodyNodePtr mBodyNode;
   dart::common::Connection mOnStructuralChange;
 
-  ResourceServer *mResourceServer;
-  interactive_markers::InteractiveMarkerServer *mMarkerServer;
+  ResourceServer* mResourceServer;
+  interactive_markers::InteractiveMarkerServer* mMarkerServer;
   visualization_msgs::InteractiveMarker mInteractiveMarker;
-  visualization_msgs::InteractiveMarkerControl *mVisualControl;
+  visualization_msgs::InteractiveMarkerControl* mVisualControl;
 
   std::string mName;
   ShapeFrameMarkerMap mShapeFrameMarkers;
 
-  std::string getName(dart::dynamics::BodyNode const &bodyNode);
+  std::string getName(dart::dynamics::BodyNode const& bodyNode);
 };
 
 } // namespace rviz

include/aikido/rviz/FrameMarker.hpp

@@ -15,23 +15,24 @@ class Frame;
 namespace aikido {
 namespace rviz {
 
-class FrameMarker {
+class FrameMarker
+{
 public:
   FrameMarker(
-    interactive_markers::InteractiveMarkerServer *markerServer,
-    dart::dynamics::Frame *frame,
-    double length = 0.25,
-    double thickness = 0.02,
-    double alpha = 1.0);
+      interactive_markers::InteractiveMarkerServer* markerServer,
+      dart::dynamics::Frame* frame,
+      double length = 0.25,
+      double thickness = 0.02,
+      double alpha = 1.0);
   ~FrameMarker();
 
   void update();
 
 private:
-  interactive_markers::InteractiveMarkerServer *mMarkerServer;
+  interactive_markers::InteractiveMarkerServer* mMarkerServer;
   visualization_msgs::InteractiveMarker mInteractiveMarker;
 
-  dart::dynamics::Frame *mFrame;
+  dart::dynamics::Frame* mFrame;
 };
 
 } // namespace rviz

include/aikido/rviz/InteractiveMarkerViewer.hpp

@@ -5,10 +5,10 @@
 #include <set>
 #include <thread>
 
-#include <ros/ros.h>
 #include <dart/dynamics/Frame.hpp>
 #include <dart/dynamics/SmartPointer.hpp>
 #include <interactive_markers/interactive_marker_server.h>
+#include <ros/ros.h>
 
 #include <aikido/constraint/TSR.hpp>
 #include <aikido/rviz/SmartPointers.hpp>
@@ -25,27 +25,30 @@ class InteractiveMarkerViewer
 
   InteractiveMarkerViewer(const InteractiveMarkerViewer&) = delete;
   InteractiveMarkerViewer(const InteractiveMarkerViewer&&) = delete;
-  InteractiveMarkerViewer &operator=(const InteractiveMarkerViewer&) = delete;
+  InteractiveMarkerViewer& operator=(const InteractiveMarkerViewer&) = delete;
 
   interactive_markers::InteractiveMarkerServer& marker_server();
 
   SkeletonMarkerPtr addSkeleton(const dart::dynamics::SkeletonPtr& skeleton);
 
   FrameMarkerPtr addFrame(
-    dart::dynamics::Frame* frame, double length = 0.25,
-    double thickness = 0.02, double alpha = 1.0);
+      dart::dynamics::Frame* frame,
+      double length = 0.25,
+      double thickness = 0.02,
+      double alpha = 1.0);
 
   SkeletonMarkerPtr CreateSkeletonMarker(
-    const dart::dynamics::SkeletonPtr& skeleton);
+      const dart::dynamics::SkeletonPtr& skeleton);
 
   /// Visualizes a TSR.
   /// \param tsr TSR constraint
   /// \param nSamples Max number of samples to be used in visualization
   /// \param basename Basename for markers
   /// \return TSRMarkerPtr contains sampled frames of TSR.
   TSRMarkerPtr addTSRMarker(
-    const aikido::constraint::TSR& tsr,
-    int nSamples = 10, const std::string& basename = "");
+      const aikido::constraint::TSR& tsr,
+      int nSamples = 10,
+      const std::string& basename = "");
 
   void setAutoUpdate(bool flag);
   void update();

include/aikido/rviz/ResourceServer.hpp

@@ -2,53 +2,56 @@
 #define AIKIDO_RVIZ_RESOURCESERVER_H_
 #include <mutex>
 #include <unordered_map>
-#include <microhttpd.h>
 #include <dart/dynamics/dynamics.hpp>
+#include <microhttpd.h>
 
 namespace aikido {
 namespace rviz {
 
-struct BinaryResource {
-  BinaryResource()
-    : mSize(0)
-    , mData(nullptr)
+struct BinaryResource
+{
+  BinaryResource() : mSize(0), mData(nullptr)
   {
   }
 
   virtual ~BinaryResource()
   {
-    if (mData) {
-      delete[] mData; 
+    if (mData)
+    {
+      delete[] mData;
     }
   }
 
   std::string mPath;
   size_t mSize;
-  char *mData;
+  char* mData;
 };
 
-struct TextureResource : public BinaryResource {
+struct TextureResource : public BinaryResource
+{
   virtual ~TextureResource() = default;
 };
 
 typedef std::shared_ptr<TextureResource> TextureResourcePtr;
 
-struct MeshResource : public BinaryResource {
+struct MeshResource : public BinaryResource
+{
   virtual ~MeshResource() = default;
 
   std::unordered_map<std::string, TextureResourcePtr> mTextures;
 };
 
-struct ResourceRequest {
+struct ResourceRequest
+{
   std::shared_ptr<BinaryResource> resource;
 };
 
-
-class ResourceServer {
+class ResourceServer
+{
 public:
   ResourceServer();
-  ResourceServer(ResourceServer const &other) = delete;
-  ResourceServer &operator=(ResourceServer const &other) = delete;
+  ResourceServer(ResourceServer const& other) = delete;
+  ResourceServer& operator=(ResourceServer const& other) = delete;
 
   virtual ~ResourceServer();
 
@@ -58,37 +61,44 @@ class ResourceServer {
   bool start(unsigned short port = 0);
   bool stop();
 
-  std::string addMesh(aiScene const &scene, std::string const &scenePath);
+  std::string addMesh(aiScene const& scene, std::string const& scenePath);
 
 private:
   typedef std::shared_ptr<MeshResource> MeshResourcePtr;
   typedef std::shared_ptr<BinaryResource> ResourcePtr;
   typedef std::weak_ptr<BinaryResource> WeakResourcePtr;
 
-  struct MHD_Daemon *mDaemon;
+  struct MHD_Daemon* mDaemon;
   std::string mHost;
   unsigned short mPort;
 
   std::mutex mMutex;
-  std::unordered_map<aiScene const *, MeshResourcePtr> mScenes;
+  std::unordered_map<aiScene const*, MeshResourcePtr> mScenes;
   std::unordered_map<std::string, WeakResourcePtr> mResources;
 
   static bool hasBuggyAssimp();
 
-  static int queueHttpError(struct MHD_Connection *connection,
-                            unsigned int code, std::string const &message);
+  static int queueHttpError(
+      struct MHD_Connection* connection,
+      unsigned int code,
+      std::string const& message);
 
-  static ssize_t resourceReaderCallback(void *cls, uint64_t pos, char *buf, 
-                                        size_t max);
+  static ssize_t resourceReaderCallback(
+      void* cls, uint64_t pos, char* buf, size_t max);
 
-  static void resourceReaderFreeCallback(void *cls);
+  static void resourceReaderFreeCallback(void* cls);
 
   static int processConnection(
-    void *cls, struct MHD_Connection *connection, const char *url,
-    const char *method, const char *version, const char *upload_data,
-    long unsigned int *upload_data_size, void **ptr);
-
-  std::string getMeshURI(MeshResourcePtr const &meshResource) const;
+      void* cls,
+      struct MHD_Connection* connection,
+      const char* url,
+      const char* method,
+      const char* version,
+      const char* upload_data,
+      long unsigned int* upload_data_size,
+      void** ptr);
+
+  std::string getMeshURI(MeshResourcePtr const& meshResource) const;
 };
 
 } // namespace rviz

include/aikido/rviz/ShapeFrameMarker.hpp

@@ -14,28 +14,28 @@ class ShapeFrameMarker
 {
 public:
   ShapeFrameMarker(
-    ResourceServer *resourceServer,
-    interactive_markers::InteractiveMarkerServer *markerServer,
-    const std::string &name,
-    const dart::dynamics::ShapeFrame *shapeFrame);
+      ResourceServer* resourceServer,
+      interactive_markers::InteractiveMarkerServer* markerServer,
+      const std::string& name,
+      const dart::dynamics::ShapeFrame* shapeFrame);
 
-  ShapeFrameMarker(ShapeFrameMarker const &) = delete;
-  ShapeFrameMarker &operator=(ShapeFrameMarker const &) = delete;
+  ShapeFrameMarker(ShapeFrameMarker const&) = delete;
+  ShapeFrameMarker& operator=(ShapeFrameMarker const&) = delete;
 
   virtual ~ShapeFrameMarker();
 
   bool update();
 
-  void SetColor(Eigen::Vector4d const &color);
+  void SetColor(Eigen::Vector4d const& color);
   void ResetColor();
 
 private:
-  ResourceServer *mResourceServer;
-  interactive_markers::InteractiveMarkerServer *mMarkerServer;
+  ResourceServer* mResourceServer;
+  interactive_markers::InteractiveMarkerServer* mMarkerServer;
   visualization_msgs::InteractiveMarker mInteractiveMarker;
-  visualization_msgs::InteractiveMarkerControl *mVisualControl;
+  visualization_msgs::InteractiveMarkerControl* mVisualControl;
 
-  const dart::dynamics::ShapeFrame *mShapeFrame;
+  const dart::dynamics::ShapeFrame* mShapeFrame;
 
   bool mExists;
   bool mForceUpdate;

include/aikido/rviz/SkeletonMarker.hpp

@@ -11,30 +11,30 @@
 namespace aikido {
 namespace rviz {
 
-class SkeletonMarker {
+class SkeletonMarker
+{
 public:
   SkeletonMarker(
-    ResourceServer *resourceServer,
-    interactive_markers::InteractiveMarkerServer *markerServer,
-    dart::dynamics::WeakSkeletonPtr const &skeleton);
+      ResourceServer* resourceServer,
+      interactive_markers::InteractiveMarkerServer* markerServer,
+      dart::dynamics::WeakSkeletonPtr const& skeleton);
 
   dart::dynamics::SkeletonPtr getSkeleton() const;
   std::vector<BodyNodeMarkerPtr> bodynode_markers() const;
 
   bool update();
 
-  BodyNodeMarkerPtr GetBodyNodeMarker(
-    dart::dynamics::BodyNode const *bodynode);
+  BodyNodeMarkerPtr GetBodyNodeMarker(dart::dynamics::BodyNode const* bodynode);
 
-  void SetColor(Eigen::Vector4d const &color);
+  void SetColor(Eigen::Vector4d const& color);
   void ResetColor();
 
 private:
   dart::dynamics::WeakSkeletonPtr mSkeleton;
-  ResourceServer *mResourceServer;
-  interactive_markers::InteractiveMarkerServer *mMarkerServer;
-  std::unordered_map<dart::dynamics::BodyNode const *,
-                     BodyNodeMarkerPtr> mBodyNodeMarkers;
+  ResourceServer* mResourceServer;
+  interactive_markers::InteractiveMarkerServer* mMarkerServer;
+  std::unordered_map<dart::dynamics::BodyNode const*, BodyNodeMarkerPtr>
+      mBodyNodeMarkers;
 
   bool mHasColor;
   Eigen::Vector4d mColor;

include/aikido/rviz/SmartPointers.hpp

@@ -7,7 +7,7 @@
 // class X
 #define AIKIDO_DEFINE_SHARED_PTR(X)                                            \
   class X;                                                                     \
-  using X##Ptr      = std::shared_ptr<X>;                                      \
+  using X##Ptr = std::shared_ptr<X>;                                           \
   using X##ConstPtr = std::shared_ptr<const X>;
 
 namespace aikido {

include/aikido/rviz/TSRMarker.hpp

@@ -12,7 +12,7 @@ class TSRMarker
 {
 public:
   explicit TSRMarker(
-    std::vector<std::unique_ptr<dart::dynamics::SimpleFrame>> tsrFrames);
+      std::vector<std::unique_ptr<dart::dynamics::SimpleFrame>> tsrFrames);
   virtual ~TSRMarker() = default;
 
 private: