robotic 0.2.9.dev2__cp310-cp310-manylinux2014_x86_64.whl → 0.3.0__cp310-cp310-manylinux2014_x86_64.whl

robotic/__init__.py

@@ -9,7 +9,7 @@ from .version import __version__
 
 from .manipulation import KOMO_ManipulationHelper
 
-from .src.config_mujoco import MujocoLoader
+from .src.mujoco_io import MujocoLoader
 from .src.config_urdf import URDFLoader
 from .src.mesh_helper import MeshHelper
 

robotic/_robotic.pyi

@@ -291,6 +291,10 @@ class Config:
         """
         clear all frames and additional data; becomes the empty configuration, with no frames
         """
+    def coll_totalViolation(self) -> float:
+        """
+        returns the sum of all penetrations (using FCL for broadphase; and low-level GJK/MRP for fine pair-wise distance/penetration computation)
+        """
     def computeCollisions(self) -> None:
         """
         [should be obsolete; getCollision* methods auto ensure proxies] call the broadphase collision engine (SWIFT++ or FCL) to generate the list of collisions (or near proximities) between all frame shapes that have the collision tag set non-zero
@@ -311,18 +315,10 @@ class Config:
         """
         returns the list of collisable pairs -- this should help debugging the 'contact' flag settings in a configuration
         """
-    def getCollisionFree(self) -> bool:
-        """
-        returns if the configuration is collision free (binary collision check, using FCL only; collidable objects need to have contact flag)
-        """
     def getCollisions(self, belowMargin: float = 1.0) -> list:
         """
         return the results of collision computations: a list of 3 tuples with (frame1, frame2, distance). Optionally report only on distances below a margin To get really precise distances and penetrations use the FS.distance feature with the two frame names
         """
-    def getCollisionsTotalPenetration(self) -> float:
-        """
-        returns the sum of all penetrations (using FCL for broadphase; and low-level GJK/MRP for fine pair-wise distance/penetration computation)
-        """
     def getFrame(self, frameName: str, warnIfNotExist: bool = True) -> Frame:
         """
         get access to a frame by name; use the Frame methods to set/get frame properties
@@ -411,6 +407,10 @@ class Config:
         """
         return the focal length of the view camera (only intrinsic parameter)
         """
+    def view_focus(self, frameName: str, absHeight: float = 2.0) -> None:
+        """
+        focus on a particular frame, given via name; second argument distances camara so that view window has roughly given absHeight around object
+        """
     def view_fxycxy(self) -> arr:
         """
         return (fx, fy, cx, cy): the focal length and image center in PIXEL UNITS
@@ -453,7 +453,7 @@ class Config:
         """
         write the full configuration in a ply mesh file
         """
-    def writeMeshes(self, pathPrefix: ..., copyTextures: bool = True, enumerateTextures: bool = False) -> None:
+    def writeMeshes(self, pathPrefix: ..., copyTextures: bool = True, enumerateAssets: bool = False) -> None:
         """
         write all object meshes in a directory
         """

robotic/include/rai/Algo/rungeKutta.h

@@ -19,7 +19,7 @@ void rk4(arr& x, const arr& x0, const fct& f, double dt);
 //void rk4dd(arr& x1, arr& v1, const arr& x0, const arr& v0,
 //           void (*ddf)(arr& xdd, const arr& x, const arr& v),
 //           double dt);
-void rk4_2ndOrder(arr& x, const arr& x0, const fct& f, double dt);
+arr rk4_2ndOrder(const arr& x0, const std::function<arr (const arr&, const arr&)>& f, double dt);
 
 /** RK with discrete event localization (zero-crossing detection): the
     function sf computes some double-valued indicators. If one of

robotic/include/rai/Control/TimingMPC.h

@@ -44,8 +44,8 @@ struct TimingMPC {
 
   uint nPhases() const { return waypoints.d0; }
   bool done() const { return phase>=nPhases(); }
-  arr getWaypoints() const { if(done()) return waypoints[-1].copy().reshape(1, -1); return waypoints({phase, -1}).copy(); }
-  arr getTimes() const { if(done()) return {.1}; return integral(tau({phase, -1})); }
+  arr getWaypoints() const { if(done()) return waypoints[-1].copy().reshape(1, -1); return waypoints({phase, -1+1}).copy(); }
+  arr getTimes() const { if(done()) return {.1}; return integral(tau({phase, -1+1})); }
   arr getVels() const;
 
   bool set_progressedTime(double gap, double tauCutoff=0.);

robotic/include/rai/Core/array.h

@@ -14,6 +14,8 @@
 #include <initializer_list>
 #include <tuple>
 #include <iostream>
+#include <memory>
+#include <vector>
 
 using std::endl;
 
@@ -26,6 +28,8 @@ namespace rai {
 extern const char* arrayElemsep;
 extern const char* arrayLinesep;
 extern const char* arrayBrackets;
+extern int64_t globalMemoryTotal, globalMemoryBound;
+extern bool globalMemoryStrict;
 
 // default sorting methods
 template<class T> bool lower(const T& a, const T& b) { return a<b; }
@@ -42,9 +46,13 @@ template<class T> bool greaterEqual(const T& a, const T& b) { return a>=b; }
 
 namespace rai {
 
+//fwd declarations
 template<class T> struct ArrayModRaw;
 template<class T> struct ArrayModList;
 struct SpecialArray;
+struct SparseVector;
+struct SparseMatrix;
+struct RowShifted;
 
 /** Simple array container to store arbitrary-dimensional arrays (tensors).
   Can buffer more memory than necessary for faster
@@ -78,6 +86,7 @@ template<class T> struct Array {
   explicit Array(uint D0, uint D1, uint D2);
   Array(std::initializer_list<T> values);
   Array(std::initializer_list<uint> dim, std::initializer_list<T> values);
+  explicit Array(const T* p, uint size, bool byReference);
   virtual ~Array();
 
   /// @name assignments
@@ -132,7 +141,6 @@ template<class T> struct Array {
   Array<T>& resizeAs(const Array<T>& a);
   Array<T>& reshapeAs(const Array<T>& a);
   Array<T>& resizeCopyAs(const Array<T>& a);
-  Array<T>& reshapeFlat();
   Array<T>& dereference();
 
   /// @name dimensionality access
@@ -142,7 +150,7 @@ template<class T> struct Array {
   /// @name initializing/assigning entries
   Array<T>& clear();
   Array<T>& setZero(byte zero=0);
-  void setUni(const T& scalar, int d=-1);
+  void setConst(const T& scalar, int d=-1);
   void setId(int d=-1);
   void setDiag(const T& scalar, int d=-1);
   void setDiag(const Array<T>& vector);
@@ -159,14 +167,13 @@ template<class T> struct Array {
   Array<T>& setCarray(const T** buffer, uint D0, uint D1);
   Array<T>& referTo(const T* buffer, uint n);
   void referTo(const Array<T>& a);
-  void referToRange(const Array<T>& a, int i_lo, int i_up);
-  void referToRange(const Array<T>& a, int i, int j_lo, int j_up);
-  void referToRange(const Array<T>& a, int i, int j, int k_lo, int k_up);
+  void referToRange(const Array<T>& a, std::pair<int, int> I);
+  void referToRange(const Array<T>& a, int i,  std::pair<int, int> J);
+  void referToRange(const Array<T>& a, int i, int j,  std::pair<int, int> K);
   void referToDim(const Array<T>& a, int i);
   void referToDim(const Array<T>& a, uint i, uint j);
   void referToDim(const Array<T>& a, uint i, uint j, uint k);
   void takeOver(Array<T>& a);  //a is cleared (earlier: becomes a reference to its previously owned memory)
-  Array<T>& setGrid(uint dim, T lo, T hi, uint steps);
 
   /// @name access by reference (direct memory access)
   Array<T> ref() const; //a reference on this
@@ -191,11 +198,11 @@ template<class T> struct Array {
 
   /// @name access by copy
   Array<T> copy() const;
-  Array<T> sub(int i, int I) const;
-  Array<T> sub(int i, int I, int j, int J) const;
-  Array<T> sub(int i, int I, int j, int J, int k, int K) const;
-  Array<T> sub(int i, int I, Array<uint> cols) const;
-  Array<T> sub(Array<uint> elems) const;
+  Array<T> sub(std::pair<int, int> I) const;
+  Array<T> sub(std::pair<int, int> I, std::pair<int, int> J) const;
+  Array<T> sub(std::pair<int, int> I, std::pair<int, int> J, std::pair<int, int> K) const;
+  Array<T> pick(std::pair<int, int> I, Array<uint> cols) const;
+  Array<T> pick(Array<uint> elems) const;
   Array<T> row(uint row_index) const;
   Array<T> rows(uint start_row, uint end_row) const;
   Array<T> col(uint col_index) const;
@@ -225,7 +232,7 @@ template<class T> struct Array {
   void delRows(int i, uint k=1);
   void delColumns(int i, uint k=1);
   void insRows(int i, uint k=1);
-  void insColumns(int i, uint k=1);
+  Array<T>& insColumns(int i, uint k=1);
   void resizeDim(uint k, uint dk);
   void setAppend(const T& x); //? same as if(findValue(x)==-1) append(x)
   void setAppend(const Array<T>& x);
@@ -256,6 +263,22 @@ template<class T> struct Array {
   void permuteRandomly();
   void shift(int offset, bool wrapAround=true);
 
+  /// @name special matrices -- only for double
+  double sparsity();
+  SparseMatrix& sparse();
+  const SparseMatrix& sparse() const;
+  SparseVector& sparseVec();
+  const SparseVector& sparseVec() const;
+  RowShifted& rowShifted();
+  const RowShifted& rowShifted() const;
+
+  /// @name attached Jacobian -- only for double
+  std::unique_ptr<Array<double>> jac=0; ///< optional pointer to Jacobian, to enable autodiff
+  void J_setId();
+  Array<double>& J();
+  Array<double> noJ() const;
+  Array<double> J_reset();
+
   /// @name I/O
   void write(std::ostream& os=std::cout, const char* ELEMSEP=nullptr, const char* LINESEP=nullptr, const char* BRACKETS=nullptr, bool dimTag=false, bool binary=false) const;
   Array<T>& read(std::istream& is);
@@ -299,33 +322,14 @@ template<class T> bool operator==(const Array<T>& v, const Array<T>& w); //equal
 template<class T> Array<byte> operator==(const Array<T>& v, const T& w); //element-wise equal
 template<class T> bool operator!=(const Array<T>& v, const Array<T>& w);
 template<class T> std::istream& operator>>(std::istream& is, Array<T>& x);
-template<class T> Array<T>& operator>>(Array<T>& x, std::istream& is);
 template<class T> std::ostream& operator<<(std::ostream& os, const Array<T>& x);
 
-template<class T> void operator+=(Array<T>& x, const Array<T>& y) {
-  CHECK_EQ(x.N, y.N, "update operator on different array dimensions (" <<x.N <<", " <<y.N <<")");
-  T* xp=x.p, *xstop=xp+x.N;
-  const T* yp=y.p;
-  for(; xp!=xstop; xp++, yp++) *xp += *yp;
-}
-template<class T> void operator+=(Array<T>& x, const T& y) {
-  T* xp=x.p, *xstop=xp+x.N;
-  for(; xp!=xstop; xp++) *xp += y;
-}
-template<class T> void operator-=(Array<T>& x, const Array<T>& y) {
-  CHECK_EQ(x.N, y.N, "update operator on different array dimensions (" <<x.N <<", " <<y.N <<")");
-  T* xp=x.p, *xstop=xp+x.N;
-  const T* yp=y.p;
-  for(; xp!=xstop; xp++, yp++) *xp -= *yp;
-}
-template<class T> void operator-=(Array<T>& x, const T& y) {
-  T* xp=x.p, *xstop=xp+x.N;
-  for(; xp!=xstop; xp++) *xp -= y;
-}
-template<class T> void operator*=(Array<T>& x, const T& y) {
-  T* xp=x.p, *xstop=xp+x.N;
-  for(; xp!=xstop; xp++) *xp *= y;
-}
+template<class T> void operator+=(Array<T>& x, const Array<T>& y);
+template<class T> void operator+=(Array<T>& x, const T& y);
+template<class T> void operator-=(Array<T>& x, const Array<T>& y);
+template<class T> void operator-=(Array<T>& x, const T& y);
+template<class T> void operator*=(Array<T>& x, const T& y);
+
 template<class T> Array<T> operator+(const Array<T>& y, const Array<T>& z) { Array<T> x(y); x+=z; return x; }
 template<class T> Array<T> operator+(const Array<T>& y, T z) {                Array<T> x(y); x+=z; return x; }
 template<class T> Array<T> operator-(const Array<T>& y, const Array<T>& z) { Array<T> x(y); x-=z; return x; }
@@ -360,6 +364,7 @@ template <class T> std::ostream& operator<<(std::ostream& os, const ArrayModList
 /// @name standard types
 /// @{
 
+typedef rai::Array<double> arr;
 typedef rai::Array<uint>   uintA;
 typedef rai::Array<int>    intA;
 typedef rai::Array<char>   charA;
@@ -373,6 +378,8 @@ typedef rai::Array<intA>   intAA;
 typedef rai::Array<uintA>  uintAA;
 
 namespace rai { struct String; }
+typedef rai::Array<rai::String> strA;
+typedef rai::Array<rai::String> strAA;
 typedef rai::Array<rai::String> StringA;
 typedef rai::Array<StringA> StringAA;
 typedef rai::Array<rai::String*> StringL;
@@ -385,7 +392,7 @@ typedef rai::Array<rai::String*> StringL;
 namespace rai {
 
 /// return array of c's
-template<class T> Array<T> consts(const T& c, const uintA& d)  {  Array<T> z;  z.resize(d);  z.setUni(c);  return z; }
+template<class T> Array<T> consts(const T& c, const uintA& d)  {  Array<T> z;  z.resize(d);  z.setConst(c);  return z; }
 /// return VECTOR of c's
 template<class T> Array<T> consts(const T& c, uint n) { return consts(c, uintA{n}); }
 /// return matrix of c's
@@ -410,6 +417,11 @@ template<class T> Array<Array<T>> getArrayArray(const Array<T>& data) {
   return xx;
 }
 
+/** @brief return a `dim'-dimensional grid with `steps' intervals
+  filling the range [lo, hi] in each dimension. Note: returned array is
+  `flat', rather than grid-shaped. */
+template<class T> Array<T> grid(uint dim, T lo, T hi, uint steps);
+
 }
 
 //===========================================================================
@@ -526,8 +538,7 @@ template<class T> Array<T> setSectionSorted(const Array<T>& x, const Array<T>& y
   return R;
 }
 
-template<class T>
-void setMinusSorted(Array<T>& x, const Array<T>& y, bool (*comp)(const T& a, const T& b)) {
+template<class T> void setMinusSorted(Array<T>& x, const Array<T>& y, bool (*comp)(const T& a, const T& b)) {
 #if 1
   int i=x.N-1, j=y.N-1;
   if(j<0) return;
@@ -687,6 +698,19 @@ void b64_encode(char* code, int code_len, const char* data, int data_len);
 void b64_decode(char* data, int data_len, const char* code, int code_len);
 }
 
+//===========================================================================
+//
+// conversions
+//
+
+template<class T> rai::Array<T> as_arr(const std::vector<T>& a, bool byReference) {
+  return rai::Array<T>(&a.front(), a.size(), byReference);
+}
+
+template<class T> std::vector<T> as_vector(const rai::Array<T>& a) {
+  return std::vector<T>(a.p, a.p+a.N);
+}
+
 //===========================================================================
 //
 // implementations