Merge remote-tracking branch 'origin/master' into githubaction

Author: Taiju Yamada

CHANELOG.md

@@ -1,5 +1,89 @@
 # Changelog
 
+## 0.82.2 (2025-10-08)
+
+- Add support for std::optional
+
+## 0.82.1 (2025-07-23)
+
+- Fix template resolution for nested container types in mujinjson
+
+## 0.82.0 (2025-06-27)
+
+- Add targetTemplateSceneData in RegisterMinViableRegionInfo.
+
+## 0.81.1 (2025-04-14)
+
+- Use only ZMQ for BinPickingTask when compiled with ZMQ.
+
+## 0.81.0 (2025-03-31)
+
+- Rename octagonalCaseClassificationInfo to registrationVisionInfo to hold general vision related info.
+
+## 0.80.0 (2025-03-28)
+
+- Add support for GraphQL subscriptions.
+
+## 0.79.0 (2025-02-04)
+
+- Support octagonalCaseClassificationInfo in RegisterMinViableRegionInfo.
+
+## 0.78.1 (2025-01-16)
+
+add pointCloudWaitForTrigger into ExecutionVerificationMode enum.
+
+## 0.78.0 (2024-12-03)
+
+add option to resolve IP from host if unique in GetURL().
+
+## 0.77.0 (2024-11-14)
+
+fix mujinjson.h SaveJsonValue specializing stacked array values to bool
+
+## 0.76.1 (2024-11-08)
+
+fix mujinjson.h SaveJsonValue const char* variation.
+
+## 0.76.0 (2024-11-03)
+
+- fix mujinjson.h SaveJsonValue char[] variation.
+
+## 0.75.0 (2024-11-02)
+
+- mujinjson uses rapidjson::GenericValue with templates to allow for other allocators.
+
+## 0.74.2 (2024-10-28)
+
+- Move important code out of the ASSERT blocks in mujinjson
+
+## 0.74.1 (2024-10-25)
+
+- Handle serialization of NaN/Inf values in JSON
+
+## 0.74.0 (2024-09-27)
+
+- Enable non-virtual-dtor error detection and implement missing virtual destructors
+
+## 0.73.4 (2024-08-07)
+
+- Fix the logging error with 'No error', ensured that the curl function is executed only once in the CHECKCURLCODE macro.
+
+## 0.73.3 (2024-07-30)
+
+- Fix missing buffer reset in post helper function.
+
+## 0.73.2 (2024-06-26)
+
+- Fix invalid JSON string construction.
+
+## 0.73.1 (2024-06-12)
+
+- Add post helper function for formdata.
+
+## 0.73.0 (2024-06-08)
+
+- Remove `rotationmat` from `ResultOBB`. Use fixed size array on `ResultOBB`.
+
 ## 0.72.0 (2024-04-27)
 
 - change `CreateLogEntries` to use `vector<LogEntry>` for memory optimization

CMakeLists.txt

@@ -18,8 +18,8 @@ set( CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS TRUE )
 # Define here the needed parameters
 # make sure to change the version in docs/Makefile
 set (MUJINCLIENT_VERSION_MAJOR 0)
-set (MUJINCLIENT_VERSION_MINOR 72)
-set (MUJINCLIENT_VERSION_PATCH 0)
+set (MUJINCLIENT_VERSION_MINOR 82)
+set (MUJINCLIENT_VERSION_PATCH 2)
 set (MUJINCLIENT_VERSION ${MUJINCLIENT_VERSION_MAJOR}.${MUJINCLIENT_VERSION_MINOR}.${MUJINCLIENT_VERSION_PATCH})
 set (MUJINCLIENT_SOVERSION ${MUJINCLIENT_VERSION_MAJOR}.${MUJINCLIENT_VERSION_MINOR})
 set (CLIENT_SOVERSION ${MUJINCLIENT_VERSION_MAJOR}.${MUJINCLIENT_VERSION_MINOR})
@@ -55,6 +55,11 @@ set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}")
 # which point to directories outside the build tree to the install RPATH
 set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
 
+set(COMPILER_IS_CLANG FALSE)
+if( CMAKE_CXX_COMPILER_ID MATCHES "Clang" )
+  set(COMPILER_IS_CLANG TRUE)
+endif()
+
 include(CheckIncludeFile)
 include(CheckIncludeFileCXX)
 include(CheckLibraryExists)
@@ -73,7 +78,7 @@ include_directories(${MUJINCLIENT_INCLUDE_LOCAL_DIRS})
 if( MSVC )
   add_definitions(-D_CRT_SECURE_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE)
   add_definitions(-D_SCL_SECURE_NO_WARNINGS -D_SCL_SECURE_NO_DEPRECATE)
-  
+
   #gives linking problems
   #string(REGEX REPLACE "/MDd" "/MD" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
   #string(REGEX REPLACE "/MDd" "/MD" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
@@ -105,7 +110,7 @@ if( MSVC )
     #install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/msvc_include/stdint.h DESTINATION include/mujinclient-${MUJINCLIENT_VERSION_MAJOR}.${MUJINCLIENT_VERSION_MINOR} COMPONENT ${COMPONENT_PREFIX}dev)
     #include_directories(${CMAKE_CURRENT_SOURCE_DIR}/msvc_include)
   endif()
-  
+
   # have to install dlls manually
   if( MSVC70 OR MSVC71 )
     set(MSVC_PREFIX "vc70")
@@ -121,7 +126,7 @@ if( MSVC )
     set(MSVC_PREFIX2 "v100")
   endif()
   set(MUJINCLIENT_LIBRARY_SUFFIX "${MUJINCLIENT_SOVERSION}-${MSVC_PREFIX}-mt" CACHE STRING "Suffix to append to library names")
-  
+
   # install all DLLs
   install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/msvc_binaries/${MUJINCLIENT_TARGET_PROCESSOR}/${MSVC_PREFIX}/bin/" DESTINATION bin FILES_MATCHING PATTERN "*.dll")
 
@@ -253,7 +258,7 @@ endif()
 
 
 if( CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX )
-  add_definitions("-fno-strict-aliasing -Wall -Werror=shadow")
+  add_definitions("-fno-strict-aliasing -Wall -Werror=shadow -Werror=non-virtual-dtor")
 endif( CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX )
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/include/mujincontrollerclient/config.h IMMEDIATE @ONLY)

include/mujincontrollerclient/binpickingtask.h

@@ -28,8 +28,8 @@ namespace mujinclient {
 /// Margins of the container to be cropped (or enlarged if negative), in order to define 3D container region under (calibration & shape) uncertainty - for pointcloud processing.
 struct CropContainerMarginsXYZXYZ
 {
-    double minMargins[3]; ///< XYZ of how much to crop from min margins (value > 0 means crop inside)
-    double maxMargins[3]; ///< XYZ of how much to crop from min margins (value > 0 means crop inside)
+    double minMargins[3] = {0, 0, 0}; ///< XYZ of how much to crop from min margins (value > 0 means crop inside)
+    double maxMargins[3] = {0, 0, 0}; ///< XYZ of how much to crop from min margins (value > 0 means crop inside)
 };
 
 typedef boost::shared_ptr<CropContainerMarginsXYZXYZ> CropContainerMarginsXYZXYZPtr;
@@ -56,28 +56,29 @@ class MUJINCLIENT_API BinPickingTaskResource : public TaskResource
         std::string object_uri;       // "object_uri": "mujin:/box0.mujin.dae"
         Transform transform; ///< pose of the object in the world coordinate system
         std::string confidence;
-        unsigned long long timestamp; ///< sensor timestamp in ms (from Linux epoch)
+        unsigned long long timestamp = 0; ///< sensor timestamp in ms (from Linux epoch)
         std::string extra;            // (OPTIONAL) "extra": {"type":"randombox", "length":100, "width":100, "height":100}
-        bool isPickable; ///< whether the object is pickable
+        bool isPickable = false; ///< whether the object is pickable
     };
 
     struct MUJINCLIENT_API PointCloudObstacle
     {
         std::string name;
         std::vector<float> points; ///< consecutive x,y,z values in meter
-        Real pointsize; ///< size of each point in meter
+        Real pointsize = 0; ///< size of each point in meter
     };
 
     struct MUJINCLIENT_API SensorOcclusionCheck
     {
         std::string bodyname; ///< name of body whose visibility is to be checked
         std::string cameraname; ///< name of camera
-        unsigned long long starttime; ///< milisecond
-        unsigned long long endtime; ///< milisecond
+        unsigned long long starttime = 0; ///< milisecond
+        unsigned long long endtime = 0; ///< milisecond
     };
 
     struct MUJINCLIENT_API ResultBase
     {
+        virtual ~ResultBase() {}
         virtual void Parse(const rapidjson::Value& pt) = 0;
     };
     typedef boost::shared_ptr<ResultBase> ResultBasePtr;
@@ -86,8 +87,8 @@ class MUJINCLIENT_API BinPickingTaskResource : public TaskResource
     {
         AddPointOffsetInfo() : zOffsetAtBottom(0), zOffsetAtTop(0) {
         }
-        double zOffsetAtBottom;
-        double zOffsetAtTop;
+        double zOffsetAtBottom = 0;
+        double zOffsetAtTop = 0;
     };
     typedef boost::shared_ptr<AddPointOffsetInfo> AddPointOffsetInfoPtr;
 
@@ -106,7 +107,7 @@ class MUJINCLIENT_API BinPickingTaskResource : public TaskResource
         virtual ~ResultMoveJoints();
         void Parse(const rapidjson::Value& pt);
         std::string robottype;
-        int numpoints;
+        int numpoints = 0;
         std::vector<Real>   timedjointvalues;
         //Real elapsedtime;
     };
@@ -122,14 +123,14 @@ class MUJINCLIENT_API BinPickingTaskResource : public TaskResource
     {
         void Parse(const rapidjson::Value& pt);
         std::vector<Real> translation;
-        std::vector<Real> quaternion;
+        std::vector<Real> quaternion = {1, 0, 0, 0};
         std::vector<Real> direction;
-        Real angleXZ;
-        Real angleYX;
-        Real angleZY;
-        Real angleX;
-        Real angleY;
-        Real angleZ;
+        Real angleXZ = 0;
+        Real angleYX = 0;
+        Real angleZY = 0;
+        Real angleX = 0;
+        Real angleY = 0;
+        Real angleZ = 0;
     };
 
     struct MUJINCLIENT_API ResultComputeIKFromParameters : public ResultBase
@@ -158,7 +159,7 @@ class MUJINCLIENT_API BinPickingTaskResource : public TaskResource
         {
             mujin::SensorSelectionInfo sensorSelectionInfo;
             std::string bodyname;
-            int isocclusion;
+            int isocclusion = 0;
         };
 
         ResultGetBinpickingState();
@@ -167,24 +168,24 @@ class MUJINCLIENT_API BinPickingTaskResource : public TaskResource
         std::string statusPickPlace;
         std::string statusDescPickPlace;
         std::string statusPhysics;
-        bool isDynamicEnvironmentStateEmpty;
+        bool isDynamicEnvironmentStateEmpty = true;
 
-        int pickAttemptFromSourceId;
-        unsigned long long timestamp;  ///< ms
-        unsigned long long lastGrabbedTargetTimeStamp;   ///< ms
+        int pickAttemptFromSourceId = 0;
+        unsigned long long timestamp = 0;  ///< ms
+        unsigned long long lastGrabbedTargetTimeStamp = 0;   ///< ms
         //bool isRobotOccludingSourceContainer; ///?
         std::vector<OcclusionResult> vOcclusionResults;
         std::vector<mujin::LocationTrackingInfo> activeLocationTrackingInfos;
         std::vector<mujin::LocationExecutionInfo> locationExecutionInfos;
 
-        bool isGrabbingTarget;
-        bool isGrabbingLastTarget;
+        bool isGrabbingTarget = false;
+        bool isGrabbingLastTarget = false;
 
         bool hasRobotExecutionStarted=false;
-        int orderNumber; ///< -1 if not initiaized
-        int numLeftInOrder; ///< -1 if not initiaized
-        int numLeftInSupply; ///< -1 if not initiaized
-        int placedInDest; ///< -1 if not initiaized
+        int orderNumber = -1; ///< -1 if not initiaized
+        int numLeftInOrder = -1; ///< -1 if not initiaized
+        int numLeftInSupply = -1; ///< -1 if not initiaized
+        int placedInDest = -1; ///< -1 if not initiaized
         std::string cycleIndex; ///< index of the published cycle that pickworker is currently executing
 
         /**
@@ -206,32 +207,34 @@ class MUJINCLIENT_API BinPickingTaskResource : public TaskResource
             struct MinViableRegionInfo
             {
                 MinViableRegionInfo();
-                std::array<double, 2> size2D; ///< width and length on the MVR
-                std::array<double, 3> maxPossibleSize; ///< the max possible size of actual item
-                std::array<double, 3> maxPossibleSizeOriginal; ///< the maxPossibleSize that has originally been given from vision
-                uint8_t cornerMaskOriginal; ///< the cornerMask that has originally been given from vision
-                uint8_t cornerMask; ///< Represents the corner(s) used for corner based detection. 4 bit. -x-y = 1, +x-y = 2, -x+y = 4, +x+y = 8
+                std::array<double, 2> size2D = {0, 0}; ///< width and length on the MVR
+                std::array<double, 3> maxPossibleSize = {0, 0, 0}; ///< the max possible size of actual item
+                std::array<double, 3> maxPossibleSizeOriginal = {0, 0, 0}; ///< the maxPossibleSize that has originally been given from vision
+                uint8_t cornerMaskOriginal = 0; ///< the cornerMask that has originally been given from vision
+                uint8_t cornerMask = 0; ///< Represents the corner(s) used for corner based detection. 4 bit. -x-y = 1, +x-y = 2, -x+y = 4, +x+y = 8
             } minViableRegion;
 
             std::string locationName; ///< The name of the location where the minViableRegion was triggered for
-            std::array<double, 3> translation; ///< Translation of the 2D MVR plane (height = 0)
-            std::array<double, 4> quaternion; ///< Rotation of the 2D MVR plane (height = 0)
-            double objectWeight; ///< If non-zero, use this weight fo registration. unit is kg. zero means unknown.
+            std::array<double, 3> translation = {0, 0, 0}; ///< Translation of the 2D MVR plane (height = 0)
+            std::array<double, 4> quaternion = {1, 0, 0, 0}; ///< Rotation of the 2D MVR plane (height = 0)
+            double objectWeight = 0; ///< If non-zero, use this weight fo registration. unit is kg. zero means unknown.
             std::string objectType; ///< The type of the object
-            uint64_t sensorTimeStampMS; ///< Same as DetectedObject's timestamp sent to planning
-            double robotDepartStopTimestamp; ///< Force capture after robot stops
-            std::array<double, 3> liftedWorldOffset; ///< [dx, dy, dz], mm in world frame
-            std::array<double, 3> maxCandidateSize; ///< the max candidate size expecting
-            std::array<double, 3> minCandidateSize; ///< the min candidate size expecting
-            double transferSpeedPostMult; ///< transfer speed multiplication factor
+            uint64_t sensorTimeStampMS = 0; ///< Same as DetectedObject's timestamp sent to planning
+            double robotDepartStopTimestamp = 0; ///< Force capture after robot stops
+            std::array<double, 3> liftedWorldOffset = {0, 0, 0}; ///< [dx, dy, dz], mm in world frame
+            std::array<double, 3> maxCandidateSize = {0, 0, 0}; ///< the max candidate size expecting
+            std::array<double, 3> minCandidateSize = {0, 0, 0}; ///< the min candidate size expecting
+            double transferSpeedPostMult = 0; ///< transfer speed multiplication factor
+            rapidjson::Document targetTemplateSceneData; ///< targetTemplateSceneData (a openrave scene that is used as a template for the target object)
             rapidjson::Document graspModelInfo; ///< Parameters used for grasping model generation for the object
-            double minCornerVisibleDist; ///< how much distance along with uncertain edge from uncertain corner robot exposes to camera
-            double minCornerVisibleInsideDist; ///< how much distance inside MVR robot exposes to camera
-            double maxCornerAngleDeviation; ///< how much angle deviation around uncertain corner is considered to expose to camera
-            uint8_t occlusionFreeCornerMask; ///< mask of corners that robot exposes to camera. 4 bit. -x-y = 1, +x-y = 2, -x+y = 4, +x+y = 8
+            rapidjson::Document registrationVisionInfo; ///< Parameters used for registration vision for the object
+            double minCornerVisibleDist = 0; ///< how much distance along with uncertain edge from uncertain corner robot exposes to camera
+            double minCornerVisibleInsideDist = 0; ///< how much distance inside MVR robot exposes to camera
+            double maxCornerAngleDeviation = 0; ///< how much angle deviation around uncertain corner is considered to expose to camera
+            uint8_t occlusionFreeCornerMask = 0; ///< mask of corners that robot exposes to camera. 4 bit. -x-y = 1, +x-y = 2, -x+y = 4, +x+y = 8
             mujin::MinViableRegionRegistrationMode registrationMode; ///< lift, drag or perpendicular drag
-            bool skipAppendingToObjectSet; ///<  if true, skip appending newly created registration data into an active object set
-            double maxPossibleSizePadding; ///< how much to additionally expose max possible size region to vision
+            bool skipAppendingToObjectSet = true; ///<  if true, skip appending newly created registration data into an active object set
+            double maxPossibleSizePadding = 0; ///< how much to additionally expose max possible size region to vision
             std::vector<double> fullDofValues; ///< robot configuration state on capturing
             std::vector<int8_t> connectedBodyActiveStates; ///< robot configuration state on capturing
             bool IsEmpty() const {
@@ -251,7 +254,7 @@ class MUJINCLIENT_API BinPickingTaskResource : public TaskResource
 
         struct TriggerDetectionCaptureInfo {
             TriggerDetectionCaptureInfo();
-            double timestamp; ///< timestamp this request was sent. If non-zero, then valid.
+            double timestamp = 0; ///< timestamp this request was sent. If non-zero, then valid.
             std::string triggerType; ///< The type of trigger this is. For now can be: "phase1Detection", "phase2Detection"
             std::string locationName; ///< The name of the location for this detection trigger.
             std::string targetUpdateNamePrefix; ///< if not empty, use this new targetUpdateNamePrefix for the triggering, otherwise do not change the original targetUpdateNamePrefix
@@ -278,26 +281,24 @@ class MUJINCLIENT_API BinPickingTaskResource : public TaskResource
     struct MUJINCLIENT_API ResultAABB : public ResultBase
     {
         void Parse(const rapidjson::Value& pt);
-        std::vector<Real> pos;
-        std::vector<Real> extents;
+        std::array<double, 3> pos;
+        std::array<double, 3> extents;
     };
 
     struct MUJINCLIENT_API ResultOBB : public ResultBase
     {
         void Parse(const rapidjson::Value& pt);
         bool operator!=(const ResultOBB& other) const {
             return !mujin::FuzzyEquals(translation, other.translation) ||
-                   !mujin::FuzzyEquals(extents, other.extents) ||
-                   !mujin::FuzzyEquals(rotationmat, other.rotationmat) ||
-                   !mujin::FuzzyEquals(quaternion, other.quaternion);
+                !mujin::FuzzyEquals(quaternion, other.quaternion) ||
+                !mujin::FuzzyEquals(extents, other.extents);
         }
         bool operator==(const ResultOBB& other) const {
             return !operator!=(other);
         }
-        std::vector<Real> translation;
-        std::vector<Real> extents;
-        std::vector<Real> rotationmat;  // row major
-        std::vector<Real> quaternion; // the quaternion
+        std::array<double, 3> translation;
+        std::array<double, 4> quaternion = {1, 0, 0, 0};
+        std::array<double, 3> extents;
     };
 
     struct MUJINCLIENT_API ResultInstObjectInfo : public ResultBase
@@ -331,7 +332,7 @@ class MUJINCLIENT_API BinPickingTaskResource : public TaskResource
         void Parse(const rapidjson::Value& pt);
         std::string status;
         ResultGetBinpickingState taskstate;
-        Real timestamp;
+        Real timestamp = 0;
         std::string msg;
         std::string _slaverequestid;
     };