Choreonoid  1.5
SceneGraph.h
Go to the documentation of this file.
1 
6 #ifndef CNOID_UTIL_SCENE_GRAPH_H
7 #define CNOID_UTIL_SCENE_GRAPH_H
8 
9 #include <cnoid/Referenced>
10 #include <cnoid/BoundingBox>
11 #include <cnoid/Signal>
12 #include <string>
13 #include <vector>
14 #include <set>
15 #include "exportdecl.h"
16 
17 namespace cnoid {
18 
19 class SgObject;
21 
22 class SceneVisitor;
23 
25 {
26 public:
27  enum Action {
28  NONE = 0,
29  ADDED = 1 << 0,
30  REMOVED = 1 << 1,
31  BBOX_UPDATED = 1 << 2,
32  MODIFIED = 1 << 3
33  };
34 
35  typedef std::vector<SgObject*> Path;
36 
37  SgUpdate() : action_(MODIFIED) { path_.reserve(16); }
38  SgUpdate(int action) : action_(action) { path_.reserve(16); }
39  virtual ~SgUpdate();
40  int action() const { return action_; }
41  bool isModified() const { return (action_ & MODIFIED); }
42  void setAction(int act) { action_ = act; }
43  const Path& path() const { return path_; }
44  void push(SgObject* node) { path_.push_back(node); }
45  void pop() { path_.pop_back(); }
46  void clear() { path_.clear(); }
47 
48 private:
49  Path path_;
50  int action_;
51 };
52 
53 
54 class SgCloneMapImpl;
55 
57 {
58 public:
59  SgCloneMap();
60  SgCloneMap(const SgCloneMap& org);
61  ~SgCloneMap();
62 
63  void setNonNodeCloning(bool on) { isNonNodeCloningEnabled_ = on; }
64  bool isNonNodeCloningEnabled() const { return isNonNodeCloningEnabled_; }
65 
66  void clear();
67 
68  template<class ObjType> ObjType* getClone(const ObjType* org){
69  return static_cast<ObjType*>(findOrCreateClone(org));
70  }
71 
72 private:
73  SgObject* findOrCreateClone(const SgObject* org);
74  SgCloneMapImpl* cloneMap;
75  bool isNonNodeCloningEnabled_;
76 };
77 
78 
80 {
81 public:
82  typedef std::set<SgObject*> ParentContainer;
83  typedef ParentContainer::iterator parentIter;
84  typedef ParentContainer::const_iterator const_parentIter;
85 
86  virtual SgObject* clone(SgCloneMap& cloneMap) const;
87 
88  const std::string& name() const { return name_; }
89  void setName(const std::string& name) { name_ = name; }
90 
91  virtual int numChildObjects() const;
92  virtual SgObject* childObject(int index);
93 
95  return sigUpdated_;
96  }
97 
98  void notifyUpdate(SgUpdate& update) {
99  update.clear();
100  onUpdated(update);
101  }
102 
103  void notifyUpdate(int action = SgUpdate::MODIFIED) {
104  SgUpdate update(action);
105  onUpdated(update);
106  }
107 
108  void addParent(SgObject* parent, bool doNotify = false);
109  void removeParent(SgObject* parent);
110  int numParents() const { return parents.size(); }
111  bool hasParents() const { return !parents.empty(); }
112 
113 public:
114  const_parentIter parentBegin() const { return parents.begin(); }
115  const_parentIter parentEnd() const { return parents.end(); }
116 
122  return sigGraphConnection_;
123  }
124 
125 protected:
126  SgObject();
127  SgObject(const SgObject& org);
128  virtual void onUpdated(SgUpdate& update);
129 
130 private:
131  std::string name_;
132  ParentContainer parents;
134  Signal<void(bool on)> sigGraphConnection_;
135 };
136 
137 
138 class SgNode;
139 typedef ref_ptr<SgNode> SgNodePtr;
140 typedef std::vector<SgNode*> SgNodePath;
141 
143 {
144 public:
145  SgNode();
146  SgNode(const SgNode& org);
147  ~SgNode();
148  virtual SgObject* clone(SgCloneMap& cloneMap) const;
149  virtual void accept(SceneVisitor& visitor);
150  virtual const BoundingBox& boundingBox() const;
151 
152  SgNode* cloneNode(SgCloneMap& cloneMap) const {
153  return static_cast<SgNode*>(this->clone(cloneMap));
154  }
155 
156  virtual bool isGroup() const;
157 };
158 
159 
161 {
162  typedef std::vector<SgNodePtr> Container;
163 
164 public:
165  typedef Container::iterator iterator;
166  typedef Container::reverse_iterator reverse_iterator;
167  typedef Container::const_iterator const_iterator;
168  typedef Container::const_reverse_iterator const_reverse_iterator;
169 
170  SgGroup();
171 
173  SgGroup(const SgGroup& org);
174 
176  SgGroup(const SgGroup& org, SgCloneMap& cloneMap);
177 
178  ~SgGroup();
179 
180  virtual SgObject* clone(SgCloneMap& cloneMap) const;
181  virtual int numChildObjects() const;
182  virtual SgObject* childObject(int index);
183  virtual void accept(SceneVisitor& visitor);
184  virtual void onUpdated(SgUpdate& update);
185  virtual const BoundingBox& boundingBox() const;
186  virtual bool isGroup() const;
187 
188  void invalidateBoundingBox() { isBboxCacheValid = false; }
189 
190  iterator begin() { return children.begin(); }
191  iterator end() { return children.end(); }
192  reverse_iterator rbegin() { return children.rbegin(); }
193  reverse_iterator rend() { return children.rend(); }
194 
195  const_iterator begin() const { return children.begin(); }
196  const_iterator end() const { return children.end(); }
197  const_reverse_iterator rbegin() const { return children.rbegin(); }
198  const_reverse_iterator rend() const { return children.rend(); }
199 
200  iterator erase(iterator pos) { return children.erase(pos); }
201 
202  bool contains(SgNode* node) const;
203 
204  bool empty() const { return children.empty(); }
205  int numChildren() const { return children.size(); }
206  SgNode* child(int index) { return children[index]; }
207 
209  template<class NodeType> NodeType* getChild(int index) {
210  NodeType* node = dynamic_cast<NodeType*>(children.at(index).get());
211  if(!node) throwTypeMismatchError();
212  return node;
213  }
214 
215  void clearChildren(bool doNotify = false);
216  void addChild(SgNode* node, bool doNotify = false);
217  bool addChildOnce(SgNode* node, bool doNotify = false);
218  void insertChild(SgNode* node, int index = 0, bool doNotify = false);
219  bool removeChild(SgNode* node, bool doNotify = false);
220  void removeChildAt(int index, bool doNotify = false);
221  void copyChildrenTo(SgGroup* group, bool doNotify = false);
222  void moveChildrenTo(SgGroup* group, bool doNotify = false);
223 
224  template<class NodeType> NodeType* findNodeOfType() {
225  for(size_t i=0; i < numChildren(); ++i){
226  if(NodeType* node = dynamic_cast<NodeType*>(child(i))) return node;
227  }
228  for(size_t i=0; i < numChildren(); ++i){
229  if(child(i)->isGroup()){
230  if(NodeType* node = static_cast<SgGroup*>(child(i))->findNodeOfType<NodeType>()) return node;
231  }
232  }
233  return 0;
234  }
235 
236 protected:
238  mutable bool isBboxCacheValid;
239 
240 private:
241  Container children;
242  static void throwTypeMismatchError();
243  iterator removeChild(iterator childIter, bool doNotify);
244 };
245 
247 
248 
250 {
251 public:
254  SgInvariantGroup(const SgInvariantGroup& org, SgCloneMap& cloneMap);
255  virtual SgObject* clone(SgCloneMap& cloneMap) const;
256  virtual void accept(SceneVisitor& visitor);
257 
258 };
260 
261 
263 {
264 public:
265  SgTransform();
266  SgTransform(const SgTransform& org);
267  SgTransform(const SgTransform& org, SgCloneMap& cloneMap);
268 
269  const BoundingBox& untransformedBoundingBox() const;
270 
271  virtual void getTransform(Affine3& out_T) const = 0;
272 
273 protected:
275 };
277 
278 
280 {
281 public:
283 
284  SgPosTransform();
285  SgPosTransform(const Affine3& T);
286  SgPosTransform(const SgPosTransform& org);
287  SgPosTransform(const SgPosTransform& org, SgCloneMap& cloneMap);
288 
289  virtual SgObject* clone(SgCloneMap& cloneMap) const;
290  virtual void accept(SceneVisitor& visitor);
291  virtual const BoundingBox& boundingBox() const;
292  virtual void getTransform(Affine3& out_T) const;
293 
294  Affine3& T() { return T_; }
295  const Affine3& T() const { return T_; }
296 
297  Affine3& position() { return T_; }
298  const Affine3& position() const { return T_; }
299 
300  Affine3::TranslationPart translation() { return T_.translation(); }
301  Affine3::ConstTranslationPart translation() const { return T_.translation(); }
302 
303  Affine3::LinearPart rotation() { return T_.linear(); }
304  Affine3::ConstLinearPart rotation() const { return T_.linear(); }
305 
306  template<class Scalar, int Mode, int Options>
307  void setPosition(const Eigen::Transform<Scalar, 3, Mode, Options>& T) {
308  T_ = T.template cast<Affine3::Scalar>();
309  }
310  template<class Scalar, int Mode, int Options>
311  void setTransform(const Eigen::Transform<Scalar, 3, Mode, Options>& T) {
312  T_ = T.template cast<Affine3::Scalar>();
313  }
314  template<typename Derived>
315  void setRotation(const Eigen::MatrixBase<Derived>& R) {
316  T_.linear() = R.template cast<Affine3::Scalar>();
317  }
318  template<typename T>
319  void setRotation(const Eigen::AngleAxis<T>& a) {
320  T_.linear() = a.template cast<Affine3::Scalar>().toRotationMatrix();
321  }
322  template<typename Derived>
323  void setTranslation(const Eigen::MatrixBase<Derived>& p) {
324  T_.translation() = p.template cast<Affine3::Scalar>();
325  }
326 
327 private:
328  Affine3 T_;
329 };
331 
332 
334 {
335 public:
338  SgScaleTransform(const SgScaleTransform& org, SgCloneMap& cloneMap);
339  virtual SgObject* clone(SgCloneMap& cloneMap) const;
340  virtual void accept(SceneVisitor& visitor);
341  virtual const BoundingBox& boundingBox() const;
342  virtual void getTransform(Affine3& out_T) const;
343 
344  const Vector3& scale() const { return scale_; }
345  Vector3& scale() { return scale_; }
346  template<typename Derived> void setScale(const Eigen::MatrixBase<Derived>& s) {
347  scale_ = s.template cast<Vector3::Scalar>();
348  }
349  void setScale(double s){
350  scale_.setConstant(s);
351  }
352 
353  Eigen::DiagonalWrapper<const Vector3> T() const { return scale_.asDiagonal(); }
354 
355 private:
356  Vector3 scale_;
357 };
359 
360 
362 {
363 public:
364  SgSwitch();
365  SgSwitch(const SgSwitch& org);
366  SgSwitch(const SgSwitch& org, SgCloneMap& cloneMap);
367  virtual SgObject* clone(SgCloneMap& cloneMap) const;
368  virtual void accept(SceneVisitor& visitor);
369 
370  void turnOn() { isTurnedOn_ = true; }
371  void turnOff() { isTurnedOn_ = false; }
372  void setTurnedOn(bool on) { isTurnedOn_ = on; }
373  bool isTurnedOn() const { return isTurnedOn_; }
374 
375  private:
376  bool isTurnedOn_;
377 };
379 
380 
382 {
383 public:
386  SgUnpickableGroup(const SgUnpickableGroup& org, SgCloneMap& cloneMap);
387  virtual SgObject* clone(SgCloneMap& cloneMap) const;
388  virtual void accept(SceneVisitor& visitor);
389 
390 };
392 
393 
395 {
396 protected:
397  SgPreprocessed();
398  SgPreprocessed(const SgPreprocessed& org);
399 
400 public:
401  virtual SgObject* clone(SgCloneMap& cloneMap) const;
402  virtual void accept(SceneVisitor& visitor);
403 };
404 
405 
406 class SgMaterial;
407 class SgImage;
408 class SgTextureTransform;
409 class SgTexture;
410 class SgMesh;
411 class SgPolygonMesh;
412 class SgShape;
413 class SgPlot;
414 class SgPointSet;
415 class SgLineSet;
416 class SgOverlay;
417 class SgLight;
418 class SgDirectionalLight;
419 class SgPointLight;
420 class SgSpotLight;
421 class SgCamera;
422 class SgPerspectiveCamera;
424 class SgFog;
425 class SgOutlineGroup;
426 
427 }
428 
429 #endif
Definition: SceneLights.h:61
Vector3 & scale()
Definition: SceneGraph.h:345
Definition: SceneLights.h:14
ref_ptr< SgInvariantGroup > SgInvariantGroupPtr
Definition: SceneGraph.h:259
const Vector3 & scale() const
Definition: SceneGraph.h:344
Definition: SceneGraph.h:381
void setPosition(const Eigen::Transform< Scalar, 3, Mode, Options > &T)
Definition: SceneGraph.h:307
ref_ptr< SgTransform > SgTransformPtr
Definition: SceneGraph.h:276
SgUpdate()
Definition: SceneGraph.h:37
void notifyUpdate(int action=SgUpdate::MODIFIED)
Definition: SceneGraph.h:103
Definition: SceneDrawables.h:291
Definition: SceneGraph.h:142
void setRotation(const Eigen::MatrixBase< Derived > &R)
Definition: SceneGraph.h:315
Definition: SceneDrawables.h:113
iterator erase(iterator pos)
Definition: SceneGraph.h:200
SgNode * cloneNode(SgCloneMap &cloneMap) const
Definition: SceneGraph.h:152
ParentContainer::const_iterator const_parentIter
Definition: SceneGraph.h:84
Affine3 & position()
Definition: SceneGraph.h:297
EIGEN_MAKE_ALIGNED_OPERATOR_NEW
Definition: SceneGraph.h:282
Definition: SceneGraph.h:394
SignalProxy< void(bool on)> sigGraphConnection()
Definition: SceneGraph.h:121
Definition: SceneDrawables.h:456
bool isModified() const
Definition: SceneGraph.h:41
Definition: SceneDrawables.h:17
Container::iterator iterator
Definition: SceneGraph.h:165
void clear()
Definition: SceneGraph.h:46
Definition: SceneGraph.h:24
Definition: SceneEffects.h:36
Affine3 & T()
Definition: SceneGraph.h:294
int numChildren() const
Definition: SceneGraph.h:205
Definition: SceneCameras.h:14
Definition: SceneDrawables.h:509
void pop()
Definition: SceneGraph.h:45
bool empty() const
Definition: SceneGraph.h:204
int action() const
Definition: SceneGraph.h:40
Affine3::TranslationPart translation()
Definition: SceneGraph.h:300
void setTransform(const Eigen::Transform< Scalar, 3, Mode, Options > &T)
Definition: SceneGraph.h:311
const_parentIter parentEnd() const
Definition: SceneGraph.h:115
Definition: SceneGraph.h:361
iterator begin()
Definition: SceneGraph.h:190
Eigen::Affine3d Affine3
Definition: EigenTypes.h:64
Definition: SceneDrawables.h:51
ref_ptr< SgPosTransform > SgPosTransformPtr
Definition: SceneGraph.h:330
void turnOn()
Definition: SceneGraph.h:370
Definition: Referenced.h:67
const_iterator end() const
Definition: SceneGraph.h:196
bool hasParents() const
Definition: SceneGraph.h:111
const Path & path() const
Definition: SceneGraph.h:43
Affine3::ConstTranslationPart translation() const
Definition: SceneGraph.h:301
Definition: SceneGraph.h:32
Definition: SceneLights.h:86
void setName(const std::string &name)
Definition: SceneGraph.h:89
const Affine3 & position() const
Definition: SceneGraph.h:298
SgNode * child(int index)
Definition: SceneGraph.h:206
Definition: SceneGraph.h:333
ref_ptr< SgObject > SgObjectPtr
Definition: SceneGraph.h:19
Definition: Referenced.h:128
const_reverse_iterator rbegin() const
Definition: SceneGraph.h:197
std::set< SgObject * > ParentContainer
Definition: SceneGraph.h:82
Definition: BoundingBox.h:17
Definition: SceneGraph.h:56
void setNonNodeCloning(bool on)
Definition: SceneGraph.h:63
Definition: SceneDrawables.h:392
const_reverse_iterator rend() const
Definition: SceneGraph.h:198
ref_ptr< SgNode > SgNodePtr
Definition: SceneGraph.h:138
NodeType * findNodeOfType()
Definition: SceneGraph.h:224
Eigen::DiagonalWrapper< const Vector3 > T() const
Definition: SceneGraph.h:353
Definition: SceneEffects.h:14
void turnOff()
Definition: SceneGraph.h:371
void setTurnedOn(bool on)
Definition: SceneGraph.h:372
const_iterator begin() const
Definition: SceneGraph.h:195
SgUpdate(int action)
Definition: SceneGraph.h:38
std::vector< SgNode * > SgNodePath
Definition: SceneGraph.h:140
Definition: SceneGraph.h:262
Definition: SceneLights.h:43
void setTranslation(const Eigen::MatrixBase< Derived > &p)
Definition: SceneGraph.h:323
Definition: SceneGraph.h:279
void invalidateBoundingBox()
Definition: SceneGraph.h:188
const_parentIter parentBegin() const
Definition: SceneGraph.h:114
Definition: SceneCameras.h:58
ref_ptr< SgSwitch > SgSwitchPtr
Definition: SceneGraph.h:378
Affine3::LinearPart rotation()
Definition: SceneGraph.h:303
Action
Definition: SceneGraph.h:27
BoundingBox untransformedBboxCache
Definition: SceneGraph.h:274
Definition: SceneGraph.h:160
ObjType * getClone(const ObjType *org)
Definition: SceneGraph.h:68
NodeType * getChild(int index)
This throws an exeption when the index is invalid or the type is not matched.
Definition: SceneGraph.h:209
reverse_iterator rend()
Definition: SceneGraph.h:193
Defines the minimum processing for performing pasing file for STL.
Definition: AbstractSceneLoader.h:9
Definition: SceneDrawables.h:590
const std::string & name() const
Definition: SceneGraph.h:88
reverse_iterator rbegin()
Definition: SceneGraph.h:192
bool isNonNodeCloningEnabled() const
Definition: SceneGraph.h:64
void setAction(int act)
Definition: SceneGraph.h:42
Container::const_iterator const_iterator
Definition: SceneGraph.h:167
Definition: SceneCameras.h:81
SignalProxy< void(const SgUpdate &update)> sigUpdated()
Definition: SceneGraph.h:94
void notifyUpdate(SgUpdate &update)
Definition: SceneGraph.h:98
ParentContainer::iterator parentIter
Definition: SceneGraph.h:83
Definition: SceneDrawables.h:420
void setRotation(const Eigen::AngleAxis< T > &a)
Definition: SceneGraph.h:319
void setScale(double s)
Definition: SceneGraph.h:349
ref_ptr< SgUnpickableGroup > SgUnpickableGroupPtr
Definition: SceneGraph.h:391
int numParents() const
Definition: SceneGraph.h:110
std::vector< SgObject * > Path
Definition: SceneGraph.h:35
Container::const_reverse_iterator const_reverse_iterator
Definition: SceneGraph.h:168
Eigen::Vector3d Vector3
Definition: EigenTypes.h:58
Definition: SceneDrawables.h:83
Definition: SceneDrawables.h:532
Definition: Signal.h:320
#define CNOID_EXPORT
Definition: Util/exportdecl.h:37
const Affine3 & T() const
Definition: SceneGraph.h:295
bool isBboxCacheValid
Definition: SceneGraph.h:238
Definition: Signal.h:380
ref_ptr< SgScaleTransform > SgScaleTransformPtr
Definition: SceneGraph.h:358
bool isTurnedOn() const
Definition: SceneGraph.h:373
void setScale(const Eigen::MatrixBase< Derived > &s)
Definition: SceneGraph.h:346
BoundingBox bboxCache
Definition: SceneGraph.h:237
Container::reverse_iterator reverse_iterator
Definition: SceneGraph.h:166
Definition: SceneVisitor.h:15
void push(SgObject *node)
Definition: SceneGraph.h:44
Definition: SceneGraph.h:249
Affine3::ConstLinearPart rotation() const
Definition: SceneGraph.h:304
iterator end()
Definition: SceneGraph.h:191
Definition: SceneGraph.h:79
ref_ptr< SgGroup > SgGroupPtr
Definition: SceneGraph.h:246