robotic 0.2.9.dev1__cp311-cp311-manylinux2014_x86_64.whl → 0.3.4.dev5__cp311-cp311-manylinux2014_x86_64.whl

robotic/include/rai/Core/util.h

@@ -19,17 +19,18 @@
 #include <climits>
 #include <mutex>
 #include <functional>
+#include <random>
 
 using std::cout;
-using std::cerr;
 using std::endl;
 
+namespace rai {
+
 //===========================================================================
 //
 // standard little methods (this needs cleanup)
 //
 
-namespace rai {
 extern int argc;
 extern char** argv;
 extern std::string startDir;
@@ -121,7 +122,6 @@ const char* niceTypeidName(const std::type_info& type);
 //----- get verbose level
 bool getInteractivity();
 bool getDisableGui();
-}
 
 //===========================================================================
 //
@@ -132,7 +132,6 @@ bool getDisableGui();
 #define STRINGF(format,...) (rai::String().printf(format, __VA_ARGS__))
 #define STREAM(x) (((rai::String&)(rai::String().stream() <<x)).stream())
 
-namespace rai {
 /** @brief String implements the functionalities of an ostream and an
 istream, but also can be send to an ostream or read from an
 istream. It is based on a simple streambuf derived from the
@@ -184,6 +183,7 @@ struct String : public std::iostream {
   String& printf(const char* format, ...);
   void resize(uint n, bool copy); //low-level resizing the string buffer - with additinal final 0
   void append(char x);
+  String& append(const char* s);
   void prepend(const String& s);
   void replace(uint i, uint n, const char* xp, uint xN);
   void removePrefix(const char* prefix);
@@ -212,18 +212,17 @@ struct String : public std::iostream {
   bool endsWith(const String& substring) const;
   bool endsWith(const char* substring) const;
 
+  void substituteEnvironmentVariables();
+
   /// @name I/O
   void write(std::ostream& os) const;
-  uint read(std::istream& is, const char* skipSymbols=nullptr, const char* stopSymbols=nullptr, int eatStopSymbol=-1);
+  uint read(std::istream& is, const char* skipSymbols=0, const char* stopSymbols=0, int eatStopSymbol=-1);
 };
 stdPipes(String)
 
 inline String operator+(const String& a, const char* b) { String s=a; s <<b; return s; }
   //template<class T> String operator+(const String& a, const T& b) { String s=a; s <<b; return s; }
 
-} //namespace
-
-typedef rai::String str;
 
 void setLogLevels(int fileLogLevel=3, int consoleLogLevel=2);
 
@@ -236,26 +235,25 @@ void setLogLevels(int fileLogLevel=3, int consoleLogLevel=2);
 // give names to Enum (for pipe << >> )
 //
 
-namespace rai {
 template<class enum_T>
 struct Enum {
   enum_T x;
   static const char* names [];
   Enum():x((enum_T)-1) {}
   Enum(enum_T y):x(y) {}
-  explicit Enum(const rai::String& str):Enum() { operator=(str); }
+  explicit Enum(const String& str):Enum() { operator=(str); }
   const enum_T& operator=(enum_T y) { x=y; return x; }
   bool operator==(const enum_T& y) const { return x==y; }
   bool operator!=(const enum_T& y) const { return x!=y; }
   operator enum_T() const { return x; }
   void read(std::istream& is) {
-    rai::String str(is);
+    String str(is);
     operator=(str);
   }
   void operator=(const char* str) {
     operator=(STRING(str));
   }
-  void operator=(const rai::String& str) {
+  void operator=(const String& str) {
     bool good=false;
     for(int i=0; names[i]; i++) {
       const char* n = names[i];
@@ -263,14 +261,14 @@ struct Enum {
         if(str==n) { x=(enum_T)(i); good=true; break; }
     }
     if(!good) {
-      rai::String all;
+      String all;
       for(int i=0; names[i]; i++) all <<names[i] <<' ';
       HALT("Enum::read could not find the keyword '" <<str <<"'. Possible Enum keywords: " <<all);
     } else {
       CHECK(str.p && !strcmp(names[x], str.p), "");
     }
   }
-  static bool contains(const rai::String& str) {
+  static bool contains(const String& str) {
     for(int i=0; names[i]; i++) {
       if(str==names[i]) return true;
     }
@@ -287,14 +285,12 @@ struct Enum {
 };
 template<class T> std::istream& operator>>(std::istream& is, Enum<T>& x) { x.read(is); return is; }
 template<class T> std::ostream& operator<<(std::ostream& os, const Enum<T>& x) { x.write(os); return os; }
-}
 
 //===========================================================================
 //
 // parameters
 //
 
-namespace rai {
 //----- parameter grabbing from command line, config file, or default value
 template<class T> T getParameter(const char* tag);
 template<class T> T getParameter(const char* tag, const T& Default);
@@ -331,8 +327,6 @@ template<class T> struct ParameterInitEnum {
   auto& set_##name(type _##name){ name=_##name; return *this; } \
   rai::ParameterInitEnum<type> __init_##name = {name, scope #name, Default};
 
-}
-
 //===========================================================================
 //
 // Testing
@@ -359,36 +353,34 @@ template<class T> struct ParameterInitEnum {
 // FileToken
 //
 
-namespace rai {
-
 /** @brief A ostream/istream wrapper that allows easier initialization of objects, like:
 arr X = FILE("inname");
 X >>FILE("outfile");
 etc
 */
 struct FileToken {
-  rai::String path, name, baseDir;
+  String path, name, baseDir;
   std::shared_ptr<std::ofstream> os;
   std::shared_ptr<std::ifstream> is;
 
   FileToken();
-  FileToken(const char* _filename, bool change_dir=false);
+  FileToken(const char* _filename);
   FileToken(const FileToken& ft);
   ~FileToken();
   FileToken& operator()() { return *this; }
 
   void decomposeFilename();
-  void cd_start();
+  void cd_base();
   void cd_file();
   bool exists();
-  std::ostream& getOs(bool change_dir=false);
-  std::istream& getIs(bool change_dir=false);
+  std::ostream& getOs();
+  std::istream& getIs();
   operator std::istream& () { return getIs(); }
   operator std::ostream& () { return getOs(); }
 
-  rai::String autoPath() const;
-  rai::String relPath() const;
-  rai::String fullPath() const;
+  String autoPath() const;
+  String relPath() const;
+  String fullPath() const;
 };
 template<class T> FileToken& operator>>(FileToken& fil, T& x) { fil.getIs() >>x;  return fil; }
 template<class T> std::ostream& operator<<(FileToken& fil, const T& x) { fil.getOs() <<x;  return fil.getOs(); }
@@ -396,23 +388,25 @@ inline std::ostream& operator<<(std::ostream& os, const FileToken& fil) { return
 template<class T> FileToken& operator<<(T& x, FileToken& fil) { fil.getIs() >>x; return fil; }
 template<class T> void operator>>(const T& x, FileToken& fil) { fil.getOs() <<x; }
 inline bool operator==(const FileToken&, const FileToken&) { return false; }
-}
-#define FILE(filename) (rai::FileToken(filename, false)()) //it needs to return a REFERENCE to a local scope object
+
+#define FILE(filename) (rai::FileToken(filename)()) //it needs to return a REFERENCE to a local scope object
 
 //===========================================================================
 //
 // random number generator
 //
 
-namespace rai {
 /** @brief A random number generator. An global instantiation \c
-  rai::rnd of a \c Rnd object is created. Use this one object to get
+  rnd of a \c Rnd object is created. Use this one object to get
   random numbers.*/
 class Rnd {
  private:
   bool ready;
   int32_t rpoint;     /* Feldindex    */
   int32_t rfield[256];   /* Schieberegisterfeld  */
+public:
+  std::minstd_rand e1;
+  std::random_device r;
 
  public:
   /// ...
@@ -420,52 +414,23 @@ class Rnd {
 
  public:/// @name initialization
   /// initialize with a specific seed
-  uint32_t seed(uint32_t n);
+   void seed(int s){ e1.seed(s); ready=true; }
 
   /// use Parameter<uint>("seed") as seed
-  uint32_t seed();
+  void seed(){ e1.seed(getParameter<uint32_t>("seed", 0)); ready=true; }
 
   /// uses the internal clock to generate a seed
-  uint32_t clockSeed();
+  void seed_random(){ e1.seed(r()); ready=true; }
 
  public:/// @name access
-  /// a initeger random number uniformly distributed in [0, ?]
-  uint32_t num() { if(!ready) seed(); return (uint32_t)rnd250() >>5; }
-  /// same as \c num()
-  uint32_t operator()() { return num(); }
-  /// a initeger random number uniformly distributed in [0, \c i-1]
-  uint32_t num(uint32_t limit) {
-    CHECK(limit, "zero limit in rnd.num()"); return num() % limit;
-  }
-  uint32_t num(int32_t lo, int32_t hi) { return lo+num(hi-lo+1); }
-  /// same as \c num(i)
-  uint32_t operator()(uint32_t i) { return num(i); }
-  uint32_t operator()(int32_t lo, int32_t hi) { return num(lo, hi); }
-  /// a random variable uniformly distributed in [0, 1]
-  double uni() { return ((double)num(1 <<22))/(1 <<22); }
-  /// a random variable uniformly distributed in [\c low, \c high]
-  double uni(double low, double high) { return low+uni()*(high-low); }
-  /// a gaussian random variable with mean zero
-  double gauss();
-  /** @brief a positive integer drawn from a poisson distribution with given
-    \c mean; is case \c mean>100, a (positive) gauss number
-    \c floor(mean+gauss(sqrt(mean))+.5) is returned */
-  uint32_t poisson(double mean);
+  int uni_int(int lo, int up) { if(!ready) seed(); std::uniform_int_distribution<int> dist(lo, up); return dist(e1); }
+  double uni(double lo=0., double up=1.) { if(!ready) seed(); std::uniform_real_distribution<double> dist(lo, up); return dist(e1); }
+  double gauss(double mean=0., double std=1.){ if(!ready) seed(); std::normal_distribution<double> dist(mean, std); return dist(e1); }
 
- private:
-  int32_t rnd250() {
-    rpoint = (rpoint+1) & 255;          // Index erhoehen
-    return rfield[rpoint] =  rfield[(rpoint-250) & 255]
-                             ^ rfield[(rpoint-103) & 255];
-  }
+  uint operator()(uint up) { return uint(uni_int(0, up-1)); }
 
-  void seed250(int32_t seed);
 };
 
-}
-/// The global Rnd object
-extern rai::Rnd rnd;
-
 //===========================================================================
 //
 /// a little inotify wrapper
@@ -475,7 +440,7 @@ struct Inotify {
   int fd, wd;
   char* buffer;
   uint buffer_size;
-  rai::FileToken* fil;
+  FileToken* fil;
   Inotify(const char* filename);
   ~Inotify();
   bool poll(bool block=false, bool verbose=false);
@@ -541,7 +506,6 @@ struct Singleton {
 // just a hook to make things gl drawable
 //
 
-struct OpenGL;
 struct OpenGLDrawOptions {
   bool drawWires=false;
   bool drawColors=true;
@@ -569,22 +533,20 @@ struct CoutToken {
   ~CoutToken() { coutMutex.unlock(); }
   std::ostream& getOs() { return cout; }
 };
-#define COUT (CoutToken().getOs())
+#define COUT (rai::CoutToken().getOs())
 
 //===========================================================================
 //
 // to register a type
 //
 
-namespace rai {
 struct Node;
 struct Graph;
-}
 
 struct Type {
   virtual ~Type() {}
   virtual const std::type_info& typeId() const {NIY}
-  virtual struct rai::Node* readIntoNewNode(struct rai::Graph& container, std::istream&) const {NIY}
+  virtual struct Node* readIntoNewNode(struct Graph& container, std::istream&) const {NIY}
   virtual void* newInstance() const {NIY}
   void write(std::ostream& os) const {  os <<"Type '" <<typeId().name() <<"' ";  }
   void read(std::istream& is) const {NIY}
@@ -606,10 +568,11 @@ inline bool operator==(Type& t1, Type& t2) { return t1.typeId() == t2.typeId();
 //
 
  template<class T> T fromFile(const char* filename) {
-   rai::FileToken file(filename, true);
+   FileToken file(filename);
    T x;
+   file.cd_file();
    x.read(file.getIs());
-   file.cd_start();
+   file.cd_base();
    return x;
  }
 
@@ -620,13 +583,21 @@ inline bool operator==(Type& t1, Type& t2) { return t1.typeId() == t2.typeId();
 //   return x;
 // }
 
+} //namespace
+
+//===========================================================================
+
+typedef rai::String str;
+extern rai::Rnd rnd;
+std::istream& operator>>(std::istream& is, char* str);
+
 //===========================================================================
 //
-/// running code on init (in cpp files)
+// shared ptrs
 //
 
-#define RUN_ON_INIT_BEGIN(key) struct key##_RUN_ON_INIT{ key##_RUN_ON_INIT(){
-#define RUN_ON_INIT_END(key)   } } key##_RUN_ON_INIT_dummy;
+template<class T> void _delete(T* ptr){}
+template<class T> std::shared_ptr<T> _shared(T& x){ return std::shared_ptr<T>(&x, &_delete<T>); }
 
 //===========================================================================
 //
@@ -636,3 +607,11 @@ inline bool operator==(Type& t1, Type& t2) { return t1.typeId() == t2.typeId();
 void gnuplot(const char* command, bool pause=false, bool persist=false, const char* PDFfile=nullptr);
 void gnuplotClose();
 
+//===========================================================================
+//
+/// running code on init (in cpp files)
+//
+
+#define RUN_ON_INIT_BEGIN(key) struct key##_RUN_ON_INIT{ key##_RUN_ON_INIT(){
+#define RUN_ON_INIT_END(key)   } } key##_RUN_ON_INIT_dummy;
+

robotic/include/rai/DataGen/rndStableConfigs.h

@@ -11,6 +11,7 @@ struct RndStableConfigs {
   RndStableConfigs_Options opt;
   uint totalEvals=0, totalSucc=0;
   bool savePngs=false;
+  str supp;
 
   bool getSample(rai::Configuration& C, const StringA& supports);
   void report();

robotic/include/rai/DataGen/shapenetGrasps.h

@@ -2,7 +2,7 @@
 
 #include <Core/util.h>
 #include <Kin/kin.h>
-#include <Kin/kin_physx.h>
+#include <Kin/i_Physx.h>
 
 struct ShapenetGrasps_Options {
   RAI_PARAM("ShapenetGrasps/", int, verbose, 1)
@@ -32,17 +32,19 @@ struct ShapenetGrasps{
   bool loadObject(uint shape, bool rndOrientation=true);
   void resetObjectPose(int idx=0, bool rndOrientation=true);
   arr getPointCloud();
+  arr getPointNormals();
   arr sampleGraspPose();
-  void setGraspPose(const arr& pose, const char* objPts="objPts0");
+  void setGraspPose(const arr& pose, const char* objPts="obj0_pts");
   arr evaluateGrasp();
 
 
   rai::Configuration C;
   StringA files;
+  arr evalGripperPoses;
 
 private:
   void clearScene();
-  bool addSceneObject(const char* file, int idx, bool rndOri=true, bool visual=false);
+  bool addSceneObject(const char* file, int idx, bool rndOri=true);
 };
 
 arr sampleGraspCandidate(rai::Configuration& C, const char *ptsFrame, const char* refFrame, double pregraspNormalSdv=.2, int verbose=1);

robotic/include/rai/Geo/depth2PointCloud.h

@@ -38,3 +38,5 @@ void depthData2point(arr& pt, const arr& fxycxy);
 void depthData2pointCloud(arr& pts, const floatA& depth, float fx, float fy, float cx, float cy);
 void depthData2pointCloud(arr& pts, const floatA& depth, const arr& fxycxy);
 void point2depthData(double* pt, double* fxycxy);
+
+void depth2depthImage(byteA& img, const floatA& depth, float maxDepth=2.f);

robotic/include/rai/Geo/geo.h

@@ -74,7 +74,7 @@ struct Matrix {
 
   Matrix() {}
   Matrix(int zero) { CHECK_EQ(zero, 0, "this is only for initialization with zero"); setZero(); }
-  Matrix(const arr& m) { CHECK_EQ(m.N, 9, "");  set(m.p); }
+  Matrix(const arr& m) { set(m); }
   Matrix(const Matrix& m) : m00(m.m00), m01(m.m01), m02(m.m02), m10(m.m10), m11(m.m11), m12(m.m12), m20(m.m20), m21(m.m21), m22(m.m22) {}
   double* p() { return &m00; }
   arr getArr() const { return arr(&m00, 9, true).reshape(3, 3); }
@@ -84,6 +84,7 @@ struct Matrix {
   void setZero();
   void setRandom(double range=1.);
   void setId();
+  void set(const arr& X);
   void setDiag(const arr& diag);
   void setSymmetric(const arr& entries6);
   void setSkew(const Vector&);
@@ -132,16 +133,17 @@ struct Quaternion {
   Quaternion& setDiff(const Vector& from, const Vector& to);
   Quaternion& setInterpolateEmbedded(double t, const Quaternion& from, const Quaternion to);
   Quaternion& setInterpolateProper(double t, const Quaternion& from, const Quaternion to);
-  void invert();
-  void flipSign();
+  void integrateDiffEq(arr& qdot, double tau);
+  Quaternion& invert();
+  Quaternion& flipSign();
   void uniqueSign();
-  void normalize();
+  Quaternion& normalize();
   void multiply(double f);
 
   void appendX(double radians);
   void appendY(double radians);
   void appendZ(double radians);
-  void append(const Quaternion& q);
+  Quaternion& append(const Quaternion& q);
 
   double diffZero() const;
   void checkZero() const;
@@ -150,6 +152,7 @@ struct Quaternion {
   bool isNormalized() const;
   Vector getLog() const;
   Vector getVector() const { return getLog(); }
+  Vector getThreeEntries() const { CHECK_ZERO(w, 1e-6, ""); return Vector(x, y, z); }
   double getRad() const;
   double getDeg() const{ return 180./RAI_PI*getRad(); }
   void getRad(double& angle, Vector& axis) const;
@@ -218,6 +221,8 @@ struct Transformation {
   void appendTransformation(const Transformation& f);     // this = this * f
   void appendInvTransformation(const Transformation& f);     // this = this * f^{-1}
 
+  Transformation inv() const{ Transformation X; X.setInverse(*this); return X; }
+
   double* getMatrix(double* m) const;         // 4x4 matrix with 3x3=rotation and right-column=translation
   arr getMatrix() const;                      // 4x4 matrix with 3x3=rotation and right-column=translation
   double* getInverseMatrix(double* m) const;  // 4x4 matrix with 3x3=R^{-1}   and bottom-row=R^{-1}*translation
@@ -241,8 +246,8 @@ struct Camera {
 
   float heightAbs;
   float focalLength;
-  float whRatio;
   float zNear, zFar;
+  float width=640., height=480.;
 
   Camera();
 
@@ -250,16 +255,17 @@ struct Camera {
   void setHeightAngle(float a);
   void setHeightAbs(float h);
   void setZRange(float znear, float zfar);
-  void setWHRatio(float ratio);
   void setFocalLength(float f);
-  void setPosition(float x, float y, float z);
-  void setOffset(float x, float y, float z);
+  void setWidthHeight(float w, float h);
+  void setPosition(const Vector& x);
   void setKinect();
   void setDefault();
 
-  void focus(float x, float y, float z, bool makeUpright=false);
+  void focus(const Vector& x, bool makeUpright=false);
+  void focusAtDist(const Vector& x, double dist);
   void watchDirection(const Vector& d);
   void upright(const Vector& up=Vector(0, 0, 1));
+  bool checkFocus();
 
   //-- projection matrix stuff
   arr getT_IC() const;
@@ -270,12 +276,12 @@ struct Camera {
   arr getInverseProjectionMatrix() const;
   double glConvertToTrueDepth(double d) const;
   double glConvertToLinearDepth(double d) const;
-  void project2PixelsAndTrueDepth(arr& x, double width, double height) const;
-  void unproject_fromPixelsAndTrueDepth(arr& x, double width, double height) const;
-  void unproject_fromPixelsAndGLDepth(arr& x, uint width, uint height) const;
+  void project2PixelsAndTrueDepth(arr& x) const;
+  void unproject_fromPixelsAndTrueDepth(arr& x) const;
+  void unproject_fromPixelsAndGLDepth(arr& x) const;
 
-  arr getFxycxy(double width, double height);
-  arr getIntrinsicMatrix(double width, double height) const;
+  arr getFxycxy();
+  arr getIntrinsicMatrix() const;
 
   //retired
   void setCameraProjectionMatrix(const arr& P); //P is in standard convention -> computes fixedProjectionMatrix in OpenGL convention from this
@@ -348,8 +354,10 @@ bool           operator!=(const Transformation&, const Transformation&);
 
 // MIXED
 Vector operator*(const Quaternion& b, const Vector& c);
+arr    operator*(const Quaternion& b, const arr& c);
 Vector operator/(const Vector& c, const Quaternion& b);
 Vector operator*(const Transformation& b, const Vector& c);
+arr    operator*(const Transformation& b, const arr& c);
 Vector operator/(const Vector& c, const Transformation& b);
 
 std::istream& operator>>(std::istream&, Vector&);

robotic/include/rai/Geo/{fclInterface.h → i_fcl.h}

@@ -16,7 +16,7 @@ struct FclInterface {
   struct FclInterface_self* self=0;
   enum QueryMode { _broadPhaseOnly, _binaryCollisionSingle, _binaryCollisionAll, _distanceCutoff, _fine } mode;
 
-  double cutoff=-1.;
+  double cutoff=.01;
   uintAA excludes;
   uintA collisions; //return values!
   arr X_lastQuery;  //memory to check whether an object has moved in consecutive queries
@@ -24,6 +24,8 @@ struct FclInterface {
   FclInterface(const Array<Shape*>& geometries, const uintAA& _excludes, QueryMode _mode);
   ~FclInterface();
 
+  void setActiveColliders(uintA geom_ids);
+
   void step(const arr& X);
 
  protected:

robotic/include/rai/Geo/mesh.h

@@ -21,7 +21,7 @@ struct SharedTextureImage{ byteA img; charA file; uint glBufferID=UINT32_MAX; };
 
 namespace rai {
 
-enum ShapeType { ST_none=-1, ST_box=0, ST_sphere, ST_capsule, ST_mesh, ST_cylinder, ST_marker, ST_pointCloud, ST_ssCvx, ST_ssBox, ST_ssCylinder, ST_ssBoxElip, ST_quad, ST_camera, ST_sdf, ST_tensor, ST_lines };
+enum ShapeType : int { ST_none=-1, ST_box=0, ST_sphere, ST_capsule, ST_mesh, ST_cylinder, ST_marker, ST_pointCloud, ST_ssCvx, ST_ssBox, ST_ssCylinder, ST_ssBoxElip, ST_quad, ST_camera, ST_sdf, ST_tensor, ST_lines };
 
 //===========================================================================
 /// a mesh (arrays of vertices, triangles, colors & normals)
@@ -44,8 +44,6 @@ struct Mesh {
 
   rai::Transformation glX; ///< transform (only used for drawing! Otherwise use applyOnPoints)  (optional)
 
-  int version = 0;
-
   uint _support_vertex=0;
   bool isArrayFormatted=false;
 
@@ -54,7 +52,7 @@ struct Mesh {
 
   /// @name set or create
   void clear();
-  void setBox(bool edgesOnly=false);
+  Mesh& setBox(bool edgesOnly=false);
   void setBox(const arr& lo, const arr& up, bool edgesOnly=false);
   Mesh& setDot(); ///< an awkward mesh: just a single dot, not tris (e.g. cvx core of a sphere...)
   void setLine(double l); ///< an awkward mesh: just a single line, not tris (e.g. cvx core of a sphere...)
@@ -70,20 +68,20 @@ struct Mesh {
   void setCapsule(double r, double l, uint fineness=2);
   void setSSBox(double x_width, double y_width, double z_height, double r, uint fineness=2);
   void setSSCvx(const arr& core, double r, uint fineness=2);
-  void setImplicitSurface(const ScalarFunction& f, double lo=-10., double hi=+10., uint res=100);
-  void setImplicitSurface(const ScalarFunction& f, double xLo, double xHi, double yLo, double yHi, double zLo, double zHi, uint res);
-  void setImplicitSurface(const arr& gridValues, const arr& lo, const arr& hi);
-  void setImplicitSurface(const floatA& gridValues, const arr& lo, const arr& hi);
-  void setImplicitSurfaceBySphereProjection(const ScalarFunction& f, double rad, uint fineness=3);
+  void setImplicitSurface(ScalarFunction f, double lo=-10., double up=+10., uint res=100);
+  void setImplicitSurface(std::function<double(const arr& x)> f, const arr& bounds, uint res);
+  void setImplicitSurface(const arr& gridValues, const arr& size);
+  void setImplicitSurface(const floatA& gridValues, const arr& size);
+  void setImplicitSurfaceBySphereProjection(ScalarFunction f, double rad, uint fineness=3);
   Mesh& setRandom(uint vertices=10);
   void setGrid(uint X, uint Y);
 
   /// @name transform and modify
   void subDivide();
   void subDivide(uint tri);
-  void scale(double s);
-  void scale(double sx, double sy, double sz);
-  void scale(const arr& s);
+  Mesh& scale(double s);
+  Mesh& scale(double sx, double sy, double sz);
+  Mesh& scale(const arr& s);
   void translate(double dx, double dy, double dz);
   void translate(const arr& d);
   void transform(const Transformation& t);
@@ -95,6 +93,8 @@ struct Mesh {
   void makeTriangleFan();
   void makeLines();
   void makeArrayFormatted(double avgNormalsThreshold=.9);
+  void makeLinesArrayFormatted();
+
 
   /// @name convex decomposition
   rai::Mesh decompose();
@@ -102,7 +102,6 @@ struct Mesh {
 
   /// @name support function
   uint support(const double* dir);
-  void supportMargin(uintA& verts, const arr& dir, double margin, int initialization=-1);
 
   /// @name internal computations & cleanup
   void computeTriNormals();
@@ -125,6 +124,7 @@ struct Mesh {
   double getCircum(uint tri) const;
   double getVolume() const;
   uintA getVertexDegrees() const;
+  void samplePoints(arr& pts, arr& normals, uint n);
 
   ANN& ensure_ann();
 
@@ -148,6 +148,7 @@ struct Mesh {
   void writeJson(std::ostream&);
   void readJson(std::istream&);
   void writeArr(std::ostream&);
+  void writeAssimp(const char* filename, const char* format);
   void writeH5(const char* filename, const String& group);
   void readH5(const char* filename, const String& group);
   void readArr(std::istream&);
@@ -156,8 +157,11 @@ struct Mesh {
 
 stdOutPipe(Mesh)
 
+void clearAssetMeshesTextures();
+
 } //namespace
 
+
 //===========================================================================
 
 //
@@ -166,6 +170,7 @@ stdOutPipe(Mesh)
 
 uintA getSubMeshPositions(const char* filename);
 arr MinkowskiSum(const arr& A, const arr& B);
+void supportMargin(const arr& V, uintA& verts, const arr& dir, double margin, int initialization=-1);
 
 //===========================================================================
 //