Klamp't  0.9.0
Resources.h
Go to the documentation of this file.
1 #ifndef ROBOT_RESOURCES_H
2 #define ROBOT_RESOURCES_H
3 
4 #include <KrisLibrary/utils/ResourceLibrary.h>
5 #include <KrisLibrary/math3d/geometry3d.h>
6 #include <KrisLibrary/meshing/PointCloud.h>
7 #include "World.h"
8 #include "MultiPath.h"
9 #include "Contact/Stance.h"
10 #include "Contact/Grasp.h"
11 
12 class AnyCollection;
13 
18 typedef BasicResource<Config> ConfigResource;
19 typedef BasicResource<Math3D::Vector3> Vector3Resource;
20 typedef BasicResource<Math3D::Matrix3> Matrix3Resource;
21 typedef BasicResource<Math::Matrix> MatrixResource;
22 typedef BasicResource<Math3D::RigidTransform> RigidTransformResource;
23 typedef BasicResource<Geometry::GeometricPrimitive3D> GeometricPrimitive3DResource;
24 typedef BasicResource<Camera::Viewport> ViewportResource;
25 //forward declarations needed before BasicResource<T> instantiation
26 template <> const char* BasicResourceTypeName<Config>();
27 template <> const char* BasicResourceTypeName<Math3D::Vector3>();
28 template <> const char* BasicResourceTypeName<Math3D::Matrix3>();
29 template <> const char* BasicResourceTypeName<Math::Matrix>();
30 template <> const char* BasicResourceTypeName<Math3D::RigidTransform>();
31 template <> const char* BasicResourceTypeName<Meshing::TriMesh>();
32 template <> const char* BasicResourceTypeName<Geometry::GeometricPrimitive3D>();
33 template <> const char* BasicResourceTypeName<Camera::Viewport>();
34 
35 namespace Klampt {
36  using namespace std;
37 
41 class ConfigsResource : public CompoundResourceBase
42 {
43  public:
44  using ResourceBase::Load;
45  using ResourceBase::Save;
46  virtual bool Load(istream& in) override;
47  virtual bool Save(ostream& out) override;
48  virtual bool Save(AnyCollection& c) override;
49  virtual bool Load(AnyCollection& c) override;
50  virtual const char* Type() const override { return "Configs"; }
51  virtual ResourceBase* Make() override { return new ConfigsResource; }
52  virtual ResourceBase* Copy() override;
53  virtual vector<string> CastTypes() const override;
54  virtual vector<string> SubTypes() const override;
55  virtual ResourcePtr Cast(const char* subtype) override;
56  virtual bool Extract(const char* subtype,vector<ResourcePtr>&) override;
57  virtual bool Pack(vector<ResourcePtr>& subobjects,string* errorMessage=NULL) override;
58  virtual bool Unpack(vector<ResourcePtr>& subobjects,bool* incomplete=NULL) override;
59 
60  vector<Vector> configs;
61 };
62 
67 class TriMeshResource : public BasicResource<Meshing::TriMesh>
68 {
69 public:
70  virtual bool Load(const std::string& fn) override;
71  virtual bool Save(const std::string& fn) override;
72  virtual const char* Type() const override { return "TriMesh"; }
73  virtual ResourceBase* Make() override { return new TriMeshResource; }
74  virtual ResourceBase* Copy() override;
75 };
76 
80 class PointCloudResource : public ResourceBase
81 {
82  public:
83  using ResourceBase::Load;
84  using ResourceBase::Save;
85  virtual bool Load(istream& in) override;
86  virtual bool Save(ostream& out) override;
87  virtual const char* Type() const override { return "PointCloud"; }
88  virtual ResourceBase* Make() override { return new PointCloudResource; }
89  virtual ResourceBase* Copy() override;
90 
91  Meshing::PointCloud3D pointCloud;
92 };
93 
97 class RobotResource : public ResourceBase
98 {
99  public:
100  using ResourceBase::Load;
101  using ResourceBase::Save;
102  virtual bool Load(const string& fn) override;
103  virtual bool Save(const string& fn) override;
104  virtual const char* Type() const override { return "Robot"; }
105  virtual ResourceBase* Make() override { return new RobotResource; }
106  virtual ResourceBase* Copy() override;
107 
108  RobotModel robot;
109 };
110 
114 class RigidObjectResource : public ResourceBase
115 {
116  public:
117  using ResourceBase::Load;
118  using ResourceBase::Save;
119  virtual bool Load(const string& fn) override;
120  virtual bool Save(const string& fn) override;
121  virtual const char* Type() const override { return "RigidObject"; }
122  virtual ResourceBase* Make() override { return new RigidObjectResource; }
123  virtual ResourceBase* Copy() override;
124 
125  RigidObjectModel object;
126 };
127 
134 class WorldResource : public CompoundResourceBase
135 {
136  public:
137  using ResourceBase::Load;
138  using ResourceBase::Save;
139  virtual bool Load(const string& fn) override;
140  virtual bool Save(const string& fn) override;
141  virtual const char* Type() const override { return "World"; }
142  virtual ResourceBase* Make() override { return new WorldResource; }
143  virtual ResourceBase* Copy() override;
144  virtual vector<string> SubTypes() const override;
145  virtual bool Extract(const char* subtype,vector<ResourcePtr>&) override;
146  virtual bool Pack(vector<ResourcePtr>& subobjects,string* errorMessage=NULL) override;
147  virtual bool Unpack(vector<ResourcePtr>& subobjects,bool* incomplete=NULL) override;
148 
149  WorldModel world;
150 };
151 
155 class LinearPathResource : public CompoundResourceBase
156 {
157  public:
158  using ResourceBase::Load;
159  using ResourceBase::Save;
160  virtual bool Load(istream& in) override;
161  virtual bool Save(ostream& out) override;
162  virtual bool Save(AnyCollection& c) override;
163  virtual bool Load(AnyCollection& c) override;
164  virtual const char* Type() const override { return "LinearPath"; }
165  virtual ResourceBase* Make() override { return new LinearPathResource; }
166  virtual ResourceBase* Copy() override;
167  virtual vector<string> CastTypes() const override;
168  virtual vector<string> SubTypes() const override;
169  virtual vector<string> ExtractTypes() const override;
170  virtual ResourcePtr Cast(const char* subtype) override;
171  virtual bool Extract(const char* subtype,vector<ResourcePtr>&) override;
172  virtual bool Pack(vector<ResourcePtr>& subobjects,string* errorMessage=NULL) override;
173  virtual bool Unpack(vector<ResourcePtr>& subobjects,bool* incomplete=NULL) override;
174 
175  vector<Real> times;
176  vector<Vector> milestones;
177 };
178 
185 class MultiPathResource : public CompoundResourceBase
186 {
187  public:
188  using ResourceBase::Load;
189  using ResourceBase::Save;
190  virtual bool Load(const string& fn) override;
191  virtual bool Save(const string& fn) override;
192  virtual bool Load(TiXmlElement* in) override;
193  virtual bool Save(TiXmlElement* out) override;
194  virtual const char* Type() const override { return "MultiPath"; }
195  virtual ResourceBase* Make() override { return new MultiPathResource; }
196  virtual ResourceBase* Copy() override;
197  virtual vector<string> CastTypes() const override;
198  virtual vector<string> SubTypes() const override;
199  virtual vector<string> ExtractTypes() const override;
200  virtual ResourcePtr Cast(const char* subtype) override;
201  virtual bool Extract(const char* subtype,vector<ResourcePtr>&) override;
202  virtual bool Pack(vector<ResourcePtr>& subobjects,string* errorMessage=NULL) override;
203  virtual bool Unpack(vector<ResourcePtr>& subobjects,bool* incomplete=NULL) override;
204 
205  MultiPath path;
206 };
207 
213 class IKGoalResource : public CompoundResourceBase
214 {
215  public:
216  IKGoalResource() {}
217  IKGoalResource(const IKGoal& val) : goal(val) {}
218  IKGoalResource(const IKGoal& val,const string& name) : CompoundResourceBase(name),goal(val) {}
219  using ResourceBase::Load;
220  using ResourceBase::Save;
221  virtual bool Load(AnyCollection& c) override;
222  virtual bool Save(AnyCollection& c) override;
223  virtual bool Load(std::istream& in) override {
224  in>>goal;
225  if(in.bad()) return false;
226  return true;
227  }
228  virtual bool Save(std::ostream& out) override {
229  out<<goal<<std::endl;
230  return true;
231  }
232  virtual const char* Type() const override { return "IKGoal"; }
233  virtual ResourceBase* Make() override { return new IKGoalResource; }
234  virtual ResourceBase* Copy() override { return new IKGoalResource(goal,name); }
235  virtual vector<string> CastTypes() const override;
236  virtual ResourcePtr Cast(const char* subtype) override;
237 
238  IKGoal goal;
239 };
240 
244 class HoldResource : public CompoundResourceBase
245 {
246  public:
247  HoldResource() {}
248  HoldResource(const Hold& val) : hold(val) {}
249  HoldResource(const Hold& val,const string& name) : CompoundResourceBase(name),hold(val) {}
250  using ResourceBase::Load;
251  using ResourceBase::Save;
252  virtual bool Load(AnyCollection& c) override;
253  virtual bool Save(AnyCollection& c) override;
254  virtual bool Load(std::istream& in) override {
255  in>>hold;
256  if(in.bad()) return false;
257  return true;
258  }
259  virtual bool Save(std::ostream& out) override {
260  out<<hold<<std::endl;
261  return true;
262  }
263  virtual const char* Type() const override { return "Hold"; }
264  virtual ResourceBase* Make() override { return new HoldResource; }
265  virtual ResourceBase* Copy() override { return new HoldResource(hold,name); }
266  virtual vector<string> CastTypes() const override;
267  virtual vector<string> SubTypes() const override;
268  virtual ResourcePtr Cast(const char* subtype) override;
269  virtual bool Pack(vector<ResourcePtr>& subobjects,string* errorMessage=NULL) override;
270  virtual bool Unpack(vector<ResourcePtr>& subobjects,bool* incomplete=NULL) override;
271 
272  Hold hold;
273 };
274 
278 class StanceResource : public CompoundResourceBase
279 {
280  public:
281  StanceResource() {}
282  StanceResource(const Stance& val);
283  using ResourceBase::Load;
284  using ResourceBase::Save;
285  virtual bool Load(istream& in) override;
286  virtual bool Save(ostream& out) override;
287  virtual bool Load(TiXmlElement* in) override;
288  virtual bool Save(TiXmlElement* out) override;
289  virtual bool Load(AnyCollection& c) override;
290  virtual bool Save(AnyCollection& c) override;
291  virtual const char* Type() const override { return "Stance"; }
292  virtual ResourceBase* Make() override { return new StanceResource; }
293  virtual ResourceBase* Copy() override;
294  virtual vector<string> CastTypes() const override;
295  virtual vector<string> SubTypes() const override;
296  virtual vector<string> ExtractTypes() const override;
297  virtual ResourcePtr Cast(const char* subtype) override;
298  virtual bool Extract(const char* subtype,vector<ResourcePtr>&) override;
299  virtual bool Pack(vector<ResourcePtr>& subobjects,string* errorMessage=NULL) override;
300  virtual bool Unpack(vector<ResourcePtr>& subobjects,bool* incomplete=NULL) override;
301 
302  Stance stance;
303 };
304 
311 class GraspResource : public CompoundResourceBase
312 {
313  public:
314  GraspResource() {}
315  GraspResource(const Grasp& val);
316  using ResourceBase::Load;
317  using ResourceBase::Save;
318  virtual bool Load(TiXmlElement* in) override;
319  virtual bool Save(TiXmlElement* out) override;
320  virtual bool Load(AnyCollection& c) override;
321  virtual bool Save(AnyCollection& c) override;
322  virtual const char* Type() const override { return "Grasp"; }
323  virtual ResourceBase* Make() override { return new GraspResource; }
324  virtual ResourceBase* Copy() override;
325  virtual vector<string> CastTypes() const override;
326  virtual vector<string> SubTypes() const override;
327  virtual vector<string> ExtractTypes() const override;
328  virtual ResourcePtr Cast(const char* subtype) override;
329  virtual bool Extract(const char* subtype,vector<ResourcePtr>&) override;
330  virtual bool Pack(vector<ResourcePtr>& subobjects,string* errorMessage=NULL) override;
331  virtual bool Unpack(vector<ResourcePtr>& subobjects,bool* incomplete=NULL) override;
332 
333  Grasp grasp;
334 };
335 
338 
342 void MakeRobotResourceLibrary(ResourceLibrary& library);
343 
344 ResourcePtr MakeResource(const string& name,const vector<int>& vals);
345 ResourcePtr MakeResource(const string& name,const vector<double>& vals);
346 ResourcePtr MakeResource(const string& name,const Config& q);
347 ResourcePtr MakeResource(const string& name,const vector<Config>& qs);
348 ResourcePtr MakeResource(const string& name,const vector<Real>& ts,const vector<Config>& qs);
349 ResourcePtr MakeResource(const string& name,const MultiPath& path);
350 ResourcePtr MakeResource(const string& name,const Vector3& pt);
351 ResourcePtr MakeResource(const string& name,const Matrix3& R);
352 ResourcePtr MakeResource(const string& name,const RigidTransform& T);
353 ResourcePtr MakeResource(const string& name,const GeometricPrimitive3D& geom);
354 ResourcePtr MakeResource(const string& name,const Meshing::TriMesh& mesh);
355 ResourcePtr MakeResource(const string& name,const Geometry::AnyGeometry3D& geom);
356 ResourcePtr MakeResource(const string& name,const IKGoal& goal);
357 ResourcePtr MakeResource(const string& name,const Hold& hold);
358 ResourcePtr MakeResource(const string& name,const Stance& stance);
359 ResourcePtr MakeResource(const string& name,const Grasp& grasp);
360 
362 bool CanCastResource(const ResourcePtr& item,const char* type);
364 vector<string> CastResourceTypes(const ResourcePtr& item);
366 ResourcePtr CastResource(ResourcePtr& item,const char* type);
367 
369 vector<string> ExtractResourceTypes(const ResourcePtr& item);
371 vector<ResourcePtr> ExtractResources(ResourcePtr& item,const char* type);
372 
375 ResourcePtr PackResources(vector<ResourcePtr>& resources,ResourcePtr rtemplate,string* errorMessage=NULL);
377 ResourcePtr PackResources(ResourceLibrary& resources,const string& type,string* errorMessage=NULL);
378 
384 vector<ResourcePtr> UnpackResource(ResourcePtr r,bool* successful=NULL,bool* incomplete=NULL);
385 
388 } //namespace Klampt
389 
390 #endif
Klampt::TriMeshResource
Resource for a TriMesh. Needs to be overloaded to load from alternate mesh formats (meshing/IO...
Definition: Resources.h:67
Klampt::IKGoalResource
Resource for an IKGoal.
Definition: Resources.h:213
Klampt::RigidObjectResource
Resource for a RigidObject.
Definition: Resources.h:114
Klampt::HoldResource
Resource for a Hold.
Definition: Resources.h:244
Klampt::MultiPath
A very general multi-section path container.
Definition: MultiPath.h:31
Klampt::PointCloudResource
Resource for a PointCloud3D.
Definition: Resources.h:80
Klampt::Stance
A collection of holds.
Definition: Stance.h:20
Klampt::CastResource
ResourcePtr CastResource(ResourcePtr &item, const char *type)
Convert a resource to a given type.
Klampt::GraspResource
Resource for a Grasp.
Definition: Resources.h:311
Klampt::MakeRobotResourceLibrary
void MakeRobotResourceLibrary(ResourceLibrary &library)
Initializes a ResourceLibrary so that it accepts standard RobotSim file types.
Klampt::RigidObjectModel
A (static) rigid object that may be manipulated.
Definition: RigidObject.h:15
Klampt::StanceResource
Resource for a Stance.
Definition: Resources.h:278
World.h
Defines the WorldModel class.
Klampt::ExtractResourceTypes
vector< string > ExtractResourceTypes(const ResourcePtr &item)
Returns the list of types that can be extracted from the item.
Klampt::PackResources
ResourcePtr PackResources(ResourceLibrary &resources, const string &type, string *errorMessage=NULL)
Creates an object of the given type out of the given resources.
Klampt::MultiPathResource
Resource for a MultiPath.
Definition: Resources.h:185
Klampt::CastResourceTypes
vector< string > CastResourceTypes(const ResourcePtr &item)
Returns the list of types which the item is castable to.
Klampt::ConfigsResource
Resource for multiple Config&#39;s.
Definition: Resources.h:41
Klampt::CanCastResource
bool CanCastResource(const ResourcePtr &item, const char *type)
Returns true if CastResource can cast to the given type.
Klampt::RobotModel
The main robot type used in RobotSim.
Definition: Robot.h:83
Klampt::WorldResource
Resource for a WorldModel.
Definition: Resources.h:134
Klampt::Hold
A single contact between the robot and the environment.
Definition: Hold.h:28
Klampt::RobotResource
Resource for a Robot.
Definition: Resources.h:97
Klampt::UnpackResource
vector< ResourcePtr > UnpackResource(ResourcePtr r, bool *successful=NULL, bool *incomplete=NULL)
Klampt::ExtractResources
vector< ResourcePtr > ExtractResources(ResourcePtr &item, const char *type)
Extract all sub-resources of a given type.
Klampt::Grasp
Slightly more sophisticated than a Stance, a Grasp allows some of the robot&#39;s degrees of freedom to b...
Definition: Grasp.h:17
Klampt
Definition: ContactDistance.h:6
Klampt::LinearPathResource
Resource for a LinearPath.
Definition: Resources.h:155
Klampt::WorldModel
The main world class containing multiple robots, objects, and static geometries (terrains). Lights and other viewport information may also be stored here.
Definition: World.h:24
Generated by   doxygen 1.8.11