From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a03129.html | 2774 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2774 insertions(+) create mode 100644 docs/doxygen/nel/a03129.html (limited to 'docs/doxygen/nel/a03129.html') diff --git a/docs/doxygen/nel/a03129.html b/docs/doxygen/nel/a03129.html new file mode 100644 index 00000000..d99301bf --- /dev/null +++ b/docs/doxygen/nel/a03129.html @@ -0,0 +1,2774 @@ + + +NeL: NLLIGO::CPrimZone class Reference + + + +
+Main Page | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Globals | Related Pages | Search for 
+

NLLIGO::CPrimZone Class Reference

#include <primitive.h> +

+

Inheritance diagram for NLLIGO::CPrimZone: +

+ +NLLIGO::IPrimitive +NLMISC::IClassable + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Types

enum  { NotAnArray, +AtTheEnd = 0xffffffff + }

Public Member Functions

bool contains (const NLMISC::CVector &v, float &distance, NLMISC::CVector &nearPos, bool isPath) const
bool contains (const NLMISC::CVector &v) const
void getAABox (NLMISC::CVector &cornerMin, NLMISC::CVector &cornerMax) const
 Returns the smallest axis-aligned box containing the zone.

NLMISC::CVector getBarycentre () const
 Returns the barycenter of the zone (warning, it may be outside of the zone if it is not convex). Returns CVector::Null if there is no vertex.

virtual std::string getClassName ()=0
 NLMISC_DECLARE_CLASS (CPrimZone)
void serial (NLMISC::IStream &f)
Hierarchy
bool getChild (IPrimitive *&result, uint childId)
bool getChild (const IPrimitive *&result, uint childId) const
bool getChildId (uint &childId, const IPrimitive *child) const
uint getNumChildren () const
const IPrimitive * getParent () const
IPrimitive * getParent ()
bool insertChild (IPrimitive *primitive, uint index=AtTheEnd)
bool removeChild (uint childId)
void removeChildren ()
Properties
bool addPropertyByName (const char *property_name, IProperty *result)
uint getNumProperty () const
bool getProperty (uint index, std::string &property_name, IProperty *&result)
bool getProperty (uint index, std::string &property_name, const IProperty *&result) const
bool getPropertyByName (const char *property_name, NLMISC::CRGBA &result) const
bool getPropertyByName (const char *property_name, const std::vector< std::string > *&result) const
bool getPropertyByName (const char *property_name, std::string &result) const
bool getPropertyByName (const char *property_name, std::vector< std::string > *&result) const
bool getPropertyByName (const char *property_name, std::string *&result) const
bool getPropertyByName (const char *property_name, IProperty *&result) const
bool getPropertyByName (const char *property_name, const IProperty *&result) const
void removeProperties ()
bool removeProperty (uint index)
bool removePropertyByName (const char *property_name)
Hierarchy
bool getChild (IPrimitive *&result, uint childId)
bool getChild (const IPrimitive *&result, uint childId) const
bool getChildId (uint &childId, const IPrimitive *child) const
uint getNumChildren () const
const IPrimitive * getParent () const
IPrimitive * getParent ()
bool insertChild (IPrimitive *primitive, uint index=AtTheEnd)
bool removeChild (uint childId)
void removeChildren ()
Properties
bool addPropertyByName (const char *property_name, IProperty *result)
uint getNumProperty () const
bool getProperty (uint index, std::string &property_name, IProperty *&result)
bool getProperty (uint index, std::string &property_name, const IProperty *&result) const
bool getPropertyByName (const char *property_name, NLMISC::CRGBA &result) const
bool getPropertyByName (const char *property_name, const std::vector< std::string > *&result) const
bool getPropertyByName (const char *property_name, std::string &result) const
bool getPropertyByName (const char *property_name, std::vector< std::string > *&result) const
bool getPropertyByName (const char *property_name, std::string *&result) const
bool getPropertyByName (const char *property_name, IProperty *&result) const
bool getPropertyByName (const char *property_name, const IProperty *&result) const
void removeProperties ()
bool removeProperty (uint index)
bool removePropertyByName (const char *property_name)
Hierarchy
bool getChild (IPrimitive *&result, uint childId)
bool getChild (const IPrimitive *&result, uint childId) const
bool getChildId (uint &childId, const IPrimitive *child) const
uint getNumChildren () const
const IPrimitive * getParent () const
IPrimitive * getParent ()
bool insertChild (IPrimitive *primitive, uint index=AtTheEnd)
bool removeChild (uint childId)
void removeChildren ()
Properties
bool addPropertyByName (const char *property_name, IProperty *result)
uint getNumProperty () const
bool getProperty (uint index, std::string &property_name, IProperty *&result)
bool getProperty (uint index, std::string &property_name, const IProperty *&result) const
bool getPropertyByName (const char *property_name, NLMISC::CRGBA &result) const
bool getPropertyByName (const char *property_name, const std::vector< std::string > *&result) const
bool getPropertyByName (const char *property_name, std::string &result) const
bool getPropertyByName (const char *property_name, std::vector< std::string > *&result) const
bool getPropertyByName (const char *property_name, std::string *&result) const
bool getPropertyByName (const char *property_name, IProperty *&result) const
bool getPropertyByName (const char *property_name, const IProperty *&result) const
void removeProperties ()
bool removeProperty (uint index)
bool removePropertyByName (const char *property_name)
Hierarchy
bool getChild (IPrimitive *&result, uint childId)
bool getChild (const IPrimitive *&result, uint childId) const
bool getChildId (uint &childId, const IPrimitive *child) const
uint getNumChildren () const
const IPrimitive * getParent () const
IPrimitive * getParent ()
bool insertChild (IPrimitive *primitive, uint index=AtTheEnd)
bool removeChild (uint childId)
void removeChildren ()

Static Public Member Functions

bool contains (const NLMISC::CVector &v, const std::vector< CPrimVector > &points, float &distance, NLMISC::CVector &nearPos, bool isPath)
bool contains (const NLMISC::CVector &v, const std::vector< CPrimVector > &points)
bool contains (const NLMISC::CVector &v, const std::vector< NLMISC::CVector > &points, float &distance, NLMISC::CVector &nearPos, bool isPath)
bool contains (const NLMISC::CVector &v, const std::vector< NLMISC::CVector > &points)
float getSegmentDist (const NLMISC::CVector v, const NLMISC::CVector &p1, const NLMISC::CVector &p2, NLMISC::CVector &nearPos)

Data Fields

bool Expanded
std::string Layer
std::string Name
std::vector< CPrimVector > VPoints

Private Member Functions

virtual IPrimitive * copy () const
virtual uint getNumVector () const
virtual CPrimVector * getPrimVector ()
virtual const CPrimVector * getPrimVector () const
virtual bool read (xmlNodePtr xmlNode, const char *filename, uint version, CLigoConfig &config)
virtual void write (xmlNodePtr xmlNode, const char *filename) const
+

Member Enumeration Documentation

+

+ + + + +
+ + +
anonymous enum [inherited] +
+
+ + + + + +
+   + + +

+

Enumeration values:
+ + + +
NotAnArray  +
AtTheEnd  +
+
+ +

+Definition at line 165 of file primitive.h. +

+

00166         {
+00167                 NotAnArray,
+00168                 AtTheEnd = 0xffffffff,
+00169         };
+
+

Member Function Documentation

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLLIGO::IPrimitive::addPropertyByName ( const char *  property_name,
IProperty *  result
)  [inherited]
+
+ + + + + +
+   + + +

+Add a property If the property already exist, the method does nothing and returns false. The pointer will be deleted by the primitive using the ::delete operator. +

+Definition at line 1384 of file primitive.cpp. +

+References NLLIGO::IPrimitive::_Properties. +

+Referenced by NLLIGO::CPrimitives::convertAddPrimitive(), NLLIGO::CPrimitives::convertPrimitive(), and NLLIGO::IPrimitive::read(). +

+

01385 {
+01386         bool inserted = _Properties.insert (std::map<std::string, IProperty*>::value_type (property_name, result)).second;
+01387         if (inserted)
+01388         {
+01389                 return true;
+01390         }
+01391         return false;
+01392 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLLIGO::CPrimZone::contains ( const NLMISC::CVector &  v,
const std::vector< CPrimVector > &  points,
float &  distance,
NLMISC::CVector &  nearPos,
bool  isPath
)  [static]
+
+ + + + + +
+   + + +

+ +

+Definition at line 649 of file primitive.cpp. +

+References getSegmentDist(), H_AUTO, min, uint, uint32, and v. +

+

00650 {
+00651         H_AUTO(NLLIGO_Contains1)
+00652         uint32 i;
+00653         CVector vMin, vMax;
+00654         float nearest = FLT_MAX;
+00655         CVector pos;
+00656 
+00657         // Point or line can't contains !
+00658         if (points.size() < 3 || isPath)
+00659         {
+00660                 // only compute the distance.
+00661                 if (points.size() == 1)
+00662                 {
+00663                         distance = (points[0] - v).norm();
+00664                         nearPos = points[0];
+00665                 }
+00666                 else if (points.size() == 2)
+00667                 {
+00668                         distance = getSegmentDist(v, points[0], points[1], nearPos);
+00669                 }
+00670                 else
+00671                 {
+00672                         // compute nearest segment
+00673                         for (i = 0; i < points.size()-1; ++i)
+00674                         {
+00675                                 const CVector &p1 = points[i];
+00676                                 const CVector &p2 = points[i+1];
+00677 
+00678                                 float dist = getSegmentDist(v, p1, p2, pos);
+00679                                 if( dist < nearest)
+00680                                 {
+00681                                         nearest = dist;
+00682                                         nearPos = pos;
+00683                                 }
+00684                         }
+00685                         distance = nearest;
+00686                 }
+00687                 return false;
+00688         }
+00689         
+00690         // Get the bounding rectangle of the zone
+00691         vMax = vMin = points[0];
+00692         for (i = 0; i < points.size(); ++i)
+00693         {
+00694                 vMin.x = min(vMin.x, points[i].x);
+00695                 vMin.y = min(vMin.y, points[i].y);
+00696                 vMax.x = max(vMax.x, points[i].x);
+00697                 vMax.y = max(vMax.y, points[i].y);
+00698         }
+00699 
+00700         if ((v.x < vMin.x) || (v.y < vMin.y) || (v.x > vMax.x) || (v.y > vMax.y))
+00701         {
+00702                 // find the nearest distance of all segment
+00703                 for (uint i=0; i<points.size(); ++i)
+00704                 {
+00705                         float dist = getSegmentDist(v, points[i], points[(i+1) % points.size()], pos);
+00706 
+00707                         if (dist < nearest)
+00708                         {
+00709                                 nearest = dist;
+00710                                 nearPos = pos;
+00711                         }
+00712                 }
+00713                 distance = nearest;
+00714                 return false;
+00715         }
+00716 
+00717         uint32 nNbIntersection = 0;
+00718         for (i = 0; i < points.size(); ++i)
+00719         {
+00720                 const CVector &p1 = points[i];
+00721                 const CVector &p2 = points[(i+1)%points.size()];
+00722 
+00723                 float dist = getSegmentDist(v, p1, p2, pos);
+00724                 if( dist < nearest)
+00725                 {
+00726                         nearest = dist;
+00727                         nearPos = pos;
+00728                 }
+00729 
+00730                 if (((p1.y-v.y) <= 0.0)&&((p2.y-v.y) <= 0.0))
+00731                         continue;
+00732                 if (((p1.y-v.y) > 0.0)&&((p2.y-v.y) > 0.0))
+00733                         continue;
+00734                 float xinter = p1.x + (p2.x-p1.x) * ((v.y-p1.y)/(p2.y-p1.y));
+00735                 if (xinter > v.x)
+00736                         ++nNbIntersection;
+00737         }
+00738 
+00739         distance = nearest;
+00740         if ((nNbIntersection&1) == 1) // odd intersections so the vertex is inside
+00741                 return true;
+00742         else
+00743                 return false;
+00744 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLLIGO::CPrimZone::contains ( const NLMISC::CVector &  v,
const std::vector< CPrimVector > &  points
)  [static]
+
+ + + + + +
+   + + +

+ +

+Definition at line 270 of file primitive.cpp. +

+References uint32, and v. +

+

00271 {
+00272         uint32 i;
+00273         CVector vMin, vMax;
+00274 
+00275         // Point or line can't contains !
+00276         if (points.size() < 3)
+00277                 return false;
+00278         
+00279         // Get the bounding rectangle of the zone
+00280         vMax = vMin = points[0];
+00281         for (i = 0; i < points.size(); ++i)
+00282         {
+00283                 if (vMin.x > points[i].x)
+00284                         vMin.x = points[i].x;
+00285                 if (vMin.y > points[i].y)
+00286                         vMin.y = points[i].y;
+00287 
+00288                 if (vMax.x < points[i].x)
+00289                         vMax.x = points[i].x;
+00290                 if (vMax.y < points[i].y)
+00291                         vMax.y = points[i].y;
+00292         }
+00293 
+00294         if ((v.x < vMin.x) || (v.y < vMin.y) || (v.x > vMax.x) || (v.y > vMax.y))
+00295                 return false;
+00296 
+00297         uint32 nNbIntersection = 0;
+00298         for (i = 0; i < points.size(); ++i)
+00299         {
+00300                 const CVector &p1 = points[i];
+00301                 const CVector &p2 = points[(i+1)%points.size()];
+00302 
+00303                 if (((p1.y-v.y) <= 0.0)&&((p2.y-v.y) <= 0.0))
+00304                         continue;
+00305                 if (((p1.y-v.y) > 0.0)&&((p2.y-v.y) > 0.0))
+00306                         continue;
+00307                 float xinter = p1.x + (p2.x-p1.x) * ((v.y-p1.y)/(p2.y-p1.y));
+00308                 if (xinter > v.x)
+00309                         ++nNbIntersection;
+00310         }
+00311         if ((nNbIntersection&1) == 1) // odd intersections so the vertex is inside
+00312                 return true;
+00313         else
+00314                 return false;
+00315 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLLIGO::CPrimZone::contains ( const NLMISC::CVector &  v,
const std::vector< NLMISC::CVector > &  points,
float &  distance,
NLMISC::CVector &  nearPos,
bool  isPath
)  [static]
+
+ + + + + +
+   + + +

+ +

+Definition at line 748 of file primitive.cpp. +

+References getSegmentDist(), H_AUTO, min, uint, uint32, and v. +

+

00749 {
+00750         H_AUTO(NLLIGO_Contains2)
+00751         uint32 i;
+00752         CVector vMin, vMax;
+00753         float nearest = FLT_MAX;
+00754         CVector pos;
+00755 
+00756         // Point or line can't contains !
+00757         if (points.size() < 3 || isPath)
+00758         {
+00759                 // only compute the distance.
+00760                 if (points.size() == 1)
+00761                 {
+00762                         distance = (points[0] - v).norm();
+00763                         nearPos = points[0];
+00764                 }
+00765                 else if (points.size() == 2)
+00766                 {
+00767                         distance = getSegmentDist(v, points[0], points[1], nearPos);
+00768                 }
+00769                 else
+00770                 {
+00771                         // compute nearest segment
+00772                         for (i = 0; i < points.size()-1; ++i)
+00773                         {
+00774                                 const CVector &p1 = points[i];
+00775                                 const CVector &p2 = points[i+1];
+00776 
+00777                                 float dist = getSegmentDist(v, p1, p2, pos);
+00778                                 if( dist < nearest)
+00779                                 {
+00780                                         nearest = dist;
+00781                                         nearPos = pos;
+00782                                 }
+00783                         }
+00784                         distance = nearest;
+00785                 }
+00786                 return false;
+00787         }
+00788         
+00789         // Get the bounding rectangle of the zone
+00790         vMax = vMin = points[0];
+00791         for (i = 0; i < points.size(); ++i)
+00792         {
+00793                 vMin.x = min(vMin.x, points[i].x);
+00794                 vMin.y = min(vMin.y, points[i].y);
+00795                 vMax.x = max(vMax.x, points[i].x);
+00796                 vMax.y = max(vMax.y, points[i].y);
+00797         }
+00798 
+00799         if ((v.x < vMin.x) || (v.y < vMin.y) || (v.x > vMax.x) || (v.y > vMax.y))
+00800         {
+00801                 // find the nearest distance of all segment
+00802                 for (uint i=0; i<points.size(); ++i)
+00803                 {
+00804                         float dist = getSegmentDist(v, points[i], points[(i+1) % points.size()], pos);
+00805 
+00806                         if (dist < nearest)
+00807                         {
+00808                                 nearest = dist;
+00809                                 nearPos = pos;
+00810                         }
+00811                 }
+00812                 distance = nearest;
+00813                 return false;
+00814         }
+00815 
+00816         uint32 nNbIntersection = 0;
+00817         for (i = 0; i < points.size(); ++i)
+00818         {
+00819                 const CVector &p1 = points[i];
+00820                 const CVector &p2 = points[(i+1)%points.size()];
+00821 
+00822                 float dist = getSegmentDist(v, p1, p2, pos);
+00823                 if( dist < nearest)
+00824                 {
+00825                         nearest = dist;
+00826                         nearPos = pos;
+00827                 }
+00828 
+00829                 if (((p1.y-v.y) <= 0.0)&&((p2.y-v.y) <= 0.0))
+00830                         continue;
+00831                 if (((p1.y-v.y) > 0.0)&&((p2.y-v.y) > 0.0))
+00832                         continue;
+00833                 float xinter = p1.x + (p2.x-p1.x) * ((v.y-p1.y)/(p2.y-p1.y));
+00834                 if (xinter > v.x)
+00835                         ++nNbIntersection;
+00836         }
+00837 
+00838         distance = nearest;
+00839         if ((nNbIntersection&1) == 1) // odd intersections so the vertex is inside
+00840                 return true;
+00841         else
+00842                 return false;
+00843 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLLIGO::CPrimZone::contains ( const NLMISC::CVector &  v,
const std::vector< NLMISC::CVector > &  points
)  [static]
+
+ + + + + +
+   + + +

+ +

+Definition at line 319 of file primitive.cpp. +

+References uint32, and v. +

+

00320 {
+00321         uint32 i;
+00322         CVector vMin, vMax;
+00323 
+00324         // Point or line can't contains !
+00325         if (points.size() < 3)
+00326                 return false;
+00327         
+00328         // Get the bounding rectangle of the zone
+00329         vMax = vMin = points[0];
+00330         for (i = 0; i < points.size(); ++i)
+00331         {
+00332                 if (vMin.x > points[i].x)
+00333                         vMin.x = points[i].x;
+00334                 if (vMin.y > points[i].y)
+00335                         vMin.y = points[i].y;
+00336 
+00337                 if (vMax.x < points[i].x)
+00338                         vMax.x = points[i].x;
+00339                 if (vMax.y < points[i].y)
+00340                         vMax.y = points[i].y;
+00341         }
+00342 
+00343         if ((v.x < vMin.x) || (v.y < vMin.y) || (v.x > vMax.x) || (v.y > vMax.y))
+00344                 return false;
+00345 
+00346         uint32 nNbIntersection = 0;
+00347         for (i = 0; i < points.size(); ++i)
+00348         {
+00349                 const CVector &p1 = points[i];
+00350                 const CVector &p2 = points[(i+1)%points.size()];
+00351 
+00352                 if (((p1.y-v.y) <= 0.0)&&((p2.y-v.y) <= 0.0))
+00353                         continue;
+00354                 if (((p1.y-v.y) > 0.0)&&((p2.y-v.y) > 0.0))
+00355                         continue;
+00356                 float xinter = p1.x + (p2.x-p1.x) * ((v.y-p1.y)/(p2.y-p1.y));
+00357                 if (xinter > v.x)
+00358                         ++nNbIntersection;
+00359         }
+00360         if ((nNbIntersection&1) == 1) // odd intersections so the vertex is inside
+00361                 return true;
+00362         else
+00363                 return false;
+00364 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLLIGO::CPrimZone::contains ( const NLMISC::CVector &  v,
float &  distance,
NLMISC::CVector &  nearPos,
bool  isPath
)  const [inline]
+
+ + + + + +
+   + + +

+ +

+Definition at line 449 of file primitive.h. +

+References v. +

+

00449 { return CPrimZone::contains(v, VPoints, distance, nearPos, isPath); }
+
+

+ + + + +
+ + + + + + + + + + +
bool NLLIGO::CPrimZone::contains ( const NLMISC::CVector &  v  )  const [inline]
+
+ + + + + +
+   + + +

+ +

+Definition at line 448 of file primitive.h. +

+References v. +

+

00448 { return CPrimZone::contains(v, VPoints); }
+
+

+ + + + +
+ + + + + + + + + +
NLLIGO::IPrimitive * NLLIGO::CPrimZone::copy (   )  const [private, virtual]
+
+ + + + + +
+   + + +

+Add a property If the property already exist, the method does nothing and returns false. The pointer will be deleted by the primitive using the ::delete operator. +

+Implements NLLIGO::IPrimitive. +

+Definition at line 598 of file primitive.cpp. +

+

00599 {
+00600         return new CPrimZone (*this);
+00601 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLLIGO::CPrimZone::getAABox ( NLMISC::CVector &  cornerMin,
NLMISC::CVector &  cornerMax
)  const
+
+ + + + + +
+   + + +

+Returns the smallest axis-aligned box containing the zone. +

+ +

+Definition at line 889 of file primitive.cpp. +

+References uint, NLMISC::CVector::x, and NLMISC::CVector::y. +

+

00890 {
+00891         cornerMin.x = FLT_MAX;
+00892         cornerMin.y = FLT_MAX;
+00893         cornerMax.x = -FLT_MAX;
+00894         cornerMax.y = -FLT_MAX;
+00895         for ( uint i=0; i!=VPoints.size(); ++i )
+00896         {
+00897                 const CVector& p = VPoints[i];
+00898                 if ( p.x < cornerMin.x )
+00899                         cornerMin.x = p.x;
+00900                 if ( p.x > cornerMax.x )
+00901                         cornerMax.x = p.x;
+00902                 if ( p.y < cornerMin.y )
+00903                         cornerMin.y = p.y;
+00904                 if ( p.y > cornerMax.y )
+00905                         cornerMax.y = p.y;
+00906         }
+00907 }
+
+

+ + + + +
+ + + + + + + + + +
NLMISC::CVector NLLIGO::CPrimZone::getBarycentre (   )  const
+
+ + + + + +
+   + + +

+Returns the barycenter of the zone (warning, it may be outside of the zone if it is not convex). Returns CVector::Null if there is no vertex. +

+ +

+Definition at line 874 of file primitive.cpp. +

+References uint. +

+

00875 {
+00876         CVector sum( CVector::Null );
+00877         uint n = VPoints.size();
+00878         if ( n != 0 )
+00879         {
+00880                 for ( uint i=0; i!=n; ++i )
+00881                         sum += VPoints[i];
+00882                 return sum / (float)n;
+00883         }
+00884         else
+00885                 return sum;
+00886 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLLIGO::IPrimitive::getChild ( IPrimitive *&  result,
uint  childId
)  [inherited]
+
+ + + + + +
+   + + +

+Get a child primitive +

+Definition at line 1303 of file primitive.cpp. +

+References nlwarning, and uint. +

+

01304 {
+01305         if (childId < _Children.size ())
+01306         {
+01307                 result = _Children[childId];
+01308                 return true;
+01309         }
+01310         else
+01311         {
+01312                 nlwarning ("NLLIGO::IPrimitive::getChild : invalid index (index : %d, size %d).", childId, _Children.size ());
+01313         }
+01314         return false;
+01315 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLLIGO::IPrimitive::getChild ( const IPrimitive *&  result,
uint  childId
)  const [inherited]
+
+ + + + + +
+   + + +

+Get a child primitive +

+Definition at line 1287 of file primitive.cpp. +

+References nlwarning, and uint. +

+Referenced by NLLIGO::CPrimitives::convertPrimitive(), NLSOUND::CBackgroundSoundManager::loadAudioFromPrimitives(), NLSOUND::CBackgroundSoundManager::loadEffectsFromPrimitives(), NLSOUND::CBackgroundSoundManager::loadSamplesFromPrimitives(), and NLSOUND::CBackgroundSoundManager::loadSoundsFromPrimitives(). +

+

01288 {
+01289         if (childId < _Children.size ())
+01290         {
+01291                 result = _Children[childId];
+01292                 return true;
+01293         }
+01294         else
+01295         {
+01296                 nlwarning ("NLLIGO::IPrimitive::getChild : invalid index (index : %d, size %d).", childId, _Children.size ());
+01297         }
+01298         return false;
+01299 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLLIGO::IPrimitive::getChildId ( uint &  childId,
const IPrimitive *  child
)  const [inherited]
+
+ + + + + +
+   + + +

+Get the id of the child, return 0xffffffff if not found +

+Definition at line 1713 of file primitive.cpp. +

+References NLLIGO::IPrimitive::_ChildId, and uint. +

+

01714 {
+01715         childId = child->_ChildId;
+01716         return true;
+01717 }
+
+

+ + + + +
+ + + + + + + + + +
virtual std::string NLMISC::IClassable::getClassName (   )  [pure virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implemented in NLAIAGENT::CNumericIndex, NLAIC::IPointerGestion, NLAIC::CIdentType, and CAutomataDesc. +

+Referenced by NLMISC::CClassRegistry::checkObject(), and NL3D::GetTextureSize().

+

+ + + + +
+ + + + + + + + + +
uint NLLIGO::IPrimitive::getNumChildren (   )  const [inline, inherited]
+
+ + + + + +
+   + + +

+Get the children primitive count +

+Definition at line 183 of file primitive.h. +

+References uint. +

+Referenced by NLLIGO::CPrimitives::convertPrimitive(), NLSOUND::CBackgroundSoundManager::loadAudioFromPrimitives(), NLSOUND::CBackgroundSoundManager::loadEffectsFromPrimitives(), NLSOUND::CBackgroundSoundManager::loadSamplesFromPrimitives(), and NLSOUND::CBackgroundSoundManager::loadSoundsFromPrimitives(). +

+

00184         {
+00185                 return _Children.size ();
+00186         }
+
+

+ + + + +
+ + + + + + + + + +
uint NLLIGO::IPrimitive::getNumProperty (   )  const [inherited]
+
+ + + + + +
+   + + +

+Get a num properties +

+Definition at line 1721 of file primitive.cpp. +

+References NLLIGO::IPrimitive::_Properties, and uint. +

+

01722 {
+01723         return _Properties.size ();
+01724 }
+
+

+ + + + +
+ + + + + + + + + +
uint NLLIGO::CPrimZone::getNumVector (   )  const [private, virtual]
+
+ + + + + +
+   + + +

+Add a property If the property already exist, the method does nothing and returns false. The pointer will be deleted by the primitive using the ::delete operator. +

+Implements NLLIGO::IPrimitive. +

+Definition at line 584 of file primitive.cpp. +

+References uint. +

+

00585 {
+00586         return VPoints.size ();
+00587 }
+
+

+ + + + +
+ + + + + + + + + +
const IPrimitive* NLLIGO::IPrimitive::getParent (   )  const [inline, inherited]
+
+ + + + + +
+   + + +

+Get a child primitive +

+Definition at line 199 of file primitive.h. +

+

00200         {
+00201                 return _Parent;
+00202         }
+
+

+ + + + +
+ + + + + + + + + +
IPrimitive* NLLIGO::IPrimitive::getParent (   )  [inline, inherited]
+
+ + + + + +
+   + + +

+Get the parent primtive +

+Definition at line 195 of file primitive.h. +

+Referenced by NLLIGO::CLigoConfig::canBeChild(), and NLLIGO::CLigoConfig::getPrimitiveClass(). +

+

00196         {
+00197                 return _Parent;
+00198         }
+
+

+ + + + +
+ + + + + + + + + +
CPrimVector * NLLIGO::CPrimZone::getPrimVector (   )  [private, virtual]
+
+ + + + + +
+   + + +

+Add a property If the property already exist, the method does nothing and returns false. The pointer will be deleted by the primitive using the ::delete operator. +

+Implements NLLIGO::IPrimitive. +

+Definition at line 605 of file primitive.cpp. +

+

00606 {
+00607         return &(VPoints[0]);
+00608 }
+
+

+ + + + +
+ + + + + + + + + +
const CPrimVector * NLLIGO::CPrimZone::getPrimVector (   )  const [private, virtual]
+
+ + + + + +
+   + + +

+Add a property If the property already exist, the method does nothing and returns false. The pointer will be deleted by the primitive using the ::delete operator. +

+Implements NLLIGO::IPrimitive. +

+Definition at line 591 of file primitive.cpp. +

+

00592 {
+00593         return &(VPoints[0]);
+00594 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLLIGO::IPrimitive::getProperty ( uint  index,
std::string &  property_name,
IProperty *&  result
)  [inherited]
+
+ + + + + +
+   + + +

+Get a properties by its index This is method (iterate a list) is slower than getPropertyByName (look up in a map). +

+Definition at line 1081 of file primitive.cpp. +

+References NLLIGO::IPrimitive::_Properties, index, nlwarning, and uint. +

+

01082 {
+01083         // Look for the property
+01084         std::map<std::string, IProperty*>::iterator ite = _Properties.begin ();
+01085         while (ite != _Properties.end ())
+01086         {
+01087                 if (index == 0)
+01088                 {
+01089                         property_name = ite->first;
+01090                         result = ite->second;
+01091                         return true;
+01092                 }
+01093                 index--;
+01094                 ite ++;
+01095         }
+01096         nlwarning ("NLLIGO::IPrimitive::getProperty : invalid index (index : %d, size : %d).", index, _Properties.size ());
+01097         return false;
+01098 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLLIGO::IPrimitive::getProperty ( uint  index,
std::string &  property_name,
const IProperty *&  result
)  const [inherited]
+
+ + + + + +
+   + + +

+Get a properties by its index This is method (iterate a list) is slower than getPropertyByName (look up in a map). +

+Definition at line 1060 of file primitive.cpp. +

+References NLLIGO::IPrimitive::_Properties, index, nlwarning, and uint. +

+

01061 {
+01062         // Look for the property
+01063         std::map<std::string, IProperty*>::const_iterator ite = _Properties.begin ();
+01064         while (ite != _Properties.end ())
+01065         {
+01066                 if (index == 0)
+01067                 {
+01068                         property_name = ite->first;
+01069                         result = ite->second;
+01070                         return true;
+01071                 }
+01072                 index--;
+01073                 ite ++;
+01074         }
+01075         nlwarning ("NLLIGO::IPrimitive::getProperty : invalid index (index : %d, size : %d).", index, _Properties.size ());
+01076         return false;
+01077 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLLIGO::IPrimitive::getPropertyByName ( const char *  property_name,
NLMISC::CRGBA &  result
)  const [inherited]
+
+ + + + + +
+   + + +

+Get a color property with its name. Return false if the property is not found or is not a string array property. +

+Definition at line 1218 of file primitive.cpp. +

+References NLLIGO::CPropertyColor::Color, NLLIGO::IPrimitive::getPropertyByName(), and nlwarning. +

+

01219 {
+01220         // Get the property
+01221         IProperty *prop;
+01222         if (getPropertyByName (property_name, prop))
+01223         {
+01224                 const CPropertyColor *colorProp = dynamic_cast<const CPropertyColor *> (prop);
+01225                 if (colorProp)
+01226                 {
+01227                         result = colorProp->Color;
+01228                         return true;
+01229                 }
+01230                 else
+01231                 {
+01232                         nlwarning ("NLLIGO::IPrimitive::getPropertyByName : property (%s) in not a color.", property_name);
+01233                 }
+01234         }
+01235         return false;
+01236 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLLIGO::IPrimitive::getPropertyByName ( const char *  property_name,
const std::vector< std::string > *&  result
)  const [inherited]
+
+ + + + + +
+   + + +

+Get a string array property with its name. Return false if the property is not found or is not a string array property. +

+Definition at line 1196 of file primitive.cpp. +

+References NLLIGO::IPrimitive::getPropertyByName(), nlwarning, and NLLIGO::CPropertyStringArray::StringArray. +

+

01197 {
+01198         // Get the property
+01199         IProperty *prop;
+01200         if (getPropertyByName (property_name, prop))
+01201         {
+01202                 const CPropertyStringArray *strProp = dynamic_cast<const CPropertyStringArray *> (prop);
+01203                 if (strProp)
+01204                 {
+01205                         result = &(strProp->StringArray);
+01206                         return true;
+01207                 }
+01208                 else
+01209                 {
+01210                         nlwarning ("NLLIGO::IPrimitive::getPropertyByName : property (%s) in not a string.", property_name);
+01211                 }
+01212         }
+01213         return false;
+01214 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLLIGO::IPrimitive::getPropertyByName ( const char *  property_name,
std::string &  result
)  const [inherited]
+
+ + + + + +
+   + + +

+Get a string property with its name. Return false if the property is not found or is not a string property. +

+Definition at line 1152 of file primitive.cpp. +

+References NLLIGO::IPrimitive::getPropertyByName(), nlwarning, and NLLIGO::CPropertyString::String. +

+

01153 {
+01154         // Get the property
+01155         const IProperty *prop;
+01156         if (getPropertyByName (property_name, prop))
+01157         {
+01158                 const CPropertyString *strProp = dynamic_cast<const CPropertyString *> (prop);
+01159                 if (strProp)
+01160                 {
+01161                         result = strProp->String;
+01162                         return true;
+01163                 }
+01164                 else
+01165                 {
+01166                         nlwarning ("NLLIGO::IPrimitive::getPropertyByName : property (%s) in not a string.", property_name);
+01167                 }
+01168         }
+01169         return false;
+01170 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLLIGO::IPrimitive::getPropertyByName ( const char *  property_name,
std::vector< std::string > *&  result
)  const [inherited]
+
+ + + + + +
+   + + +

+Get a string array property with its name. Return false if the property is not found or is not a string array property. +

+Definition at line 1174 of file primitive.cpp. +

+References NLLIGO::IPrimitive::getPropertyByName(), nlwarning, and NLLIGO::CPropertyStringArray::StringArray. +

+

01175 {
+01176         // Get the property
+01177         IProperty *prop;
+01178         if (getPropertyByName (property_name, prop))
+01179         {
+01180                 CPropertyStringArray *strProp = dynamic_cast<CPropertyStringArray *> (prop);
+01181                 if (strProp)
+01182                 {
+01183                         result = &(strProp->StringArray);
+01184                         return true;
+01185                 }
+01186                 else
+01187                 {
+01188                         nlwarning ("NLLIGO::IPrimitive::getPropertyByName : property (%s) in not a string.", property_name);
+01189                 }
+01190         }
+01191         return false;
+01192 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLLIGO::IPrimitive::getPropertyByName ( const char *  property_name,
std::string *&  result
)  const [inherited]
+
+ + + + + +
+   + + +

+Get a string property with its name. Return false if the property is not found or is not a string property. +

+Definition at line 1130 of file primitive.cpp. +

+References NLLIGO::IPrimitive::getPropertyByName(), nlwarning, and NLLIGO::CPropertyString::String. +

+

01131 {
+01132         // Get the property
+01133         IProperty *prop;
+01134         if (getPropertyByName (property_name, prop))
+01135         {
+01136                 CPropertyString *strProp = dynamic_cast<CPropertyString *> (prop);
+01137                 if (strProp)
+01138                 {
+01139                         result = &(strProp->String);
+01140                         return true;
+01141                 }
+01142                 else
+01143                 {
+01144                         nlwarning ("NLLIGO::IPrimitive::getPropertyByName : property (%s) in not a string.", property_name);
+01145                 }
+01146         }
+01147         return false;
+01148 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLLIGO::IPrimitive::getPropertyByName ( const char *  property_name,
IProperty *&  result
)  const [inherited]
+
+ + + + + +
+   + + +

+Get a property with its name +

+Definition at line 1116 of file primitive.cpp. +

+References NLLIGO::IPrimitive::_Properties. +

+

01117 {
+01118         // Look for the property
+01119         std::map<std::string, IProperty*>::const_iterator ite = _Properties.find (property_name);
+01120         if (ite != _Properties.end ())
+01121         {
+01122                 result = ite->second;
+01123                 return true;
+01124         }
+01125         return false;
+01126 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLLIGO::IPrimitive::getPropertyByName ( const char *  property_name,
const IProperty *&  result
)  const [inherited]
+
+ + + + + +
+   + + +

+Get a property with its name +

+Definition at line 1102 of file primitive.cpp. +

+References NLLIGO::IPrimitive::_Properties. +

+Referenced by NLLIGO::CPrimitiveConfigurations::belong(), NLLIGO::CLigoConfig::canBeChild(), NLLIGO::CLigoConfig::canBeRoot(), NLLIGO::CPrimitives::convertPrimitive(), NLLIGO::CLigoConfig::getPrimitiveClass(), NLLIGO::CLigoConfig::getPrimitiveColor(), NLLIGO::IPrimitive::getPropertyByName(), NLLIGO::CLigoConfig::isPrimitiveDeletable(), NLLIGO::CLigoConfig::isPrimitiveLinked(), NLSOUND::CBackgroundSoundManager::loadAudioFromPrimitives(), NLSOUND::CBackgroundSoundManager::loadEffectsFromPrimitives(), NLSOUND::CBackgroundSoundManager::loadSamplesFromPrimitives(), NLSOUND::CBackgroundSoundManager::loadSoundsFromPrimitives(), NLLIGO::IPrimitive::read(), and NLLIGO::CPrimitiveClass::CParameter::translateAutoname(). +

+

01103 {
+01104         // Look for the property
+01105         std::map<std::string, IProperty*>::const_iterator ite = _Properties.find (property_name);
+01106         if (ite != _Properties.end ())
+01107         {
+01108                 result = ite->second;
+01109                 return true;
+01110         }
+01111         return false;
+01112 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
float NLLIGO::CPrimZone::getSegmentDist ( const NLMISC::CVector  v,
const NLMISC::CVector &  p1,
const NLMISC::CVector &  p2,
NLMISC::CVector &  nearPos
)  [static]
+
+ + + + + +
+   + + +

+ +

+Definition at line 847 of file primitive.cpp. +

+References NLMISC::CVector::norm(), t, and v. +

+Referenced by contains(). +

+

00848 {
+00849         // too point, compute distance to the segment.
+00850         CVector V = (p2-p1).normed();
+00851         float t = ((v-p1)*V)/(p2-p1).norm();
+00852         float distance;
+00853         if (t < 0.0f)
+00854         {
+00855                 nearPos = p1;
+00856                 distance = (p1-v).norm();
+00857         }
+00858         else if (t > 1.0f)
+00859         {
+00860                 nearPos = p2;
+00861                 distance = (p2-v).norm();
+00862         }
+00863         else
+00864         {
+00865                 nearPos = p1 + t*(p2-p1);
+00866                 distance = (v-nearPos).norm();
+00867         }
+00868 
+00869         return distance;
+00870 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLLIGO::IPrimitive::insertChild ( IPrimitive *  primitive,
uint  index = AtTheEnd
)  [inherited]
+
+ + + + + +
+   + + +

+Insert a child primitive before the index. The pointer will be deleted by the parent primitive using the ::delete operator. return false if the index is invalid +

+Definition at line 1349 of file primitive.cpp. +

+References NLLIGO::IPrimitive::_Parent, NLLIGO::IPrimitive::AtTheEnd, index, uint, and NLLIGO::IPrimitive::updateChildId(). +

+Referenced by NLLIGO::CPrimitives::convertAddPrimitive(), NLLIGO::CPrimitives::convertPrimitive(), and NLLIGO::IPrimitive::read(). +

+

01350 {
+01351         // At the end ?
+01352         if (index == AtTheEnd)
+01353                 index = _Children.size ();
+01354 
+01355         // Index valid ?
+01356         if (index>_Children.size ())
+01357                 return false;
+01358 
+01359         // Insert
+01360         _Children.insert (_Children.begin () + index, primitive);
+01361 
+01362         // Update child id
+01363         updateChildId (index);
+01364 
+01365         // Link to the parent
+01366         primitive->_Parent = this;
+01367 
+01368         return true;
+01369 }
+
+

+ + + + +
+ + + + + + + + + + +
NLLIGO::CPrimZone::NLMISC_DECLARE_CLASS ( CPrimZone   ) 
+
+ + + + + +
+   + + +

+

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLLIGO::CPrimZone::read ( xmlNodePtr  xmlNode,
const char *  filename,
uint  version,
CLigoConfig &  config
)  [private, virtual]
+
+ + + + + +
+   + + +

+Add a property If the property already exist, the method does nothing and returns false. The pointer will be deleted by the primitive using the ::delete operator. +

+Reimplemented from NLLIGO::IPrimitive. +

+Definition at line 612 of file primitive.cpp. +

+References NLLIGO::ReadVector(), and uint. +

+

00613 {
+00614         // Read points
+00615         VPoints.clear ();
+00616         VPoints.reserve (CIXml::countChildren (xmlNode, "PT"));
+00617         xmlNodePtr ptNode = CIXml::getFirstChildNode (xmlNode, "PT");
+00618         if (ptNode)
+00619         {
+00620                 do
+00621                 {
+00622                         // Read a vector
+00623                         VPoints.push_back (CPrimVector ());
+00624                         if (!ReadVector (VPoints.back (), filename, ptNode))
+00625                                 return false;
+00626                 }
+00627                 while ((ptNode = CIXml::getNextChildNode (ptNode, "PT")));
+00628         }
+00629 
+00630         return IPrimitive::read (xmlNode, filename, version, config);
+00631 }
+
+

+ + + + +
+ + + + + + + + + + +
bool NLLIGO::IPrimitive::removeChild ( uint  childId  )  [inherited]
+
+ + + + + +
+   + + +

+Remove a child primitive +

+Definition at line 1319 of file primitive.cpp. +

+References nlwarning, uint, and NLLIGO::IPrimitive::updateChildId(). +

+

01320 {
+01321         if (childId < _Children.size ())
+01322         {
+01323                 delete _Children[childId];
+01324                 _Children.erase (_Children.begin()+childId);
+01325                 updateChildId (childId);
+01326                 return true;
+01327         }
+01328         else
+01329         {
+01330                 nlwarning ("NLLIGO::IPrimitive::removeChild : invalid index (index : %d, size %d).", childId, _Children.size ());
+01331         }
+01332         return false;
+01333 }
+
+

+ + + + +
+ + + + + + + + + +
void NLLIGO::IPrimitive::removeChildren (   )  [inherited]
+
+ + + + + +
+   + + +

+Remove all children primitives +

+Definition at line 1337 of file primitive.cpp. +

+References uint. +

+Referenced by NLLIGO::CPrimitives::convert(), NLLIGO::IPrimitive::operator=(), NLLIGO::CPrimitives::read(), and NLLIGO::IPrimitive::~IPrimitive(). +

+

01338 {
+01339         // Erase children
+01340         for (uint i=0; i<_Children.size (); i++)
+01341         {
+01342                 delete _Children[i];
+01343         }
+01344         _Children.clear ();
+01345 }
+
+

+ + + + +
+ + + + + + + + + +
void NLLIGO::IPrimitive::removeProperties (   )  [inherited]
+
+ + + + + +
+   + + +

+Remove all the properties +

+Definition at line 1274 of file primitive.cpp. +

+References NLLIGO::IPrimitive::_Properties. +

+Referenced by NLLIGO::CPrimitives::convert(), NLLIGO::IPrimitive::operator=(), NLLIGO::CPrimitives::read(), and NLLIGO::IPrimitive::~IPrimitive(). +

+

01275 {
+01276         std::map<std::string, IProperty*>::iterator ite = _Properties.begin ();
+01277         while (ite != _Properties.end ())
+01278         {
+01279                 delete ite->second;
+01280                 ite++;
+01281         }
+01282         _Properties.clear ();
+01283 }
+
+

+ + + + +
+ + + + + + + + + + +
bool NLLIGO::IPrimitive::removeProperty ( uint  index  )  [inherited]
+
+ + + + + +
+   + + +

+Remove a property This is method (iterate a list) is slower than removePropertyByName (look up in a map). +

+Definition at line 1240 of file primitive.cpp. +

+References NLLIGO::IPrimitive::_Properties, index, nlwarning, and uint. +

+

01241 {
+01242         // Look for the property
+01243         std::map<std::string, IProperty*>::iterator ite = _Properties.begin ();
+01244         while (ite != _Properties.end ())
+01245         {
+01246                 if (index == 0)
+01247                 {
+01248                         _Properties.erase (ite);
+01249                         return true;
+01250                 }
+01251                 index--;
+01252                 ite ++;
+01253         }
+01254         nlwarning ("NLLIGO::IPrimitive::removeProperty : invalid index (index : %d, size : %d).", index, _Properties.size ());
+01255         return false;
+01256 }
+
+

+ + + + +
+ + + + + + + + + + +
bool NLLIGO::IPrimitive::removePropertyByName ( const char *  property_name  )  [inherited]
+
+ + + + + +
+   + + +

+Remove a property by its name +

+Definition at line 1260 of file primitive.cpp. +

+References NLLIGO::IPrimitive::_Properties. +

+

01261 {
+01262         // Look for the property
+01263         std::map<std::string, IProperty*>::iterator ite = _Properties.find (property_name);
+01264         if (ite != _Properties.end ())
+01265         {
+01266                 _Properties.erase (ite);
+01267                 return true;
+01268         }
+01269         return false;
+01270 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLLIGO::CPrimZone::serial ( NLMISC::IStream &  f  ) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 912 of file primitive.cpp. +

+

00913 {
+00914         f.xmlPushBegin ("ZONE");
+00915         
+00916         f.xmlSetAttrib ("NAME");
+00917         f.serial (Name);
+00918         f.xmlSetAttrib ("LAYER");
+00919         f.serial (Layer);
+00920         f.xmlPushEnd ();
+00921 
+00922         f.serialCont (VPoints);
+00923 
+00924         f.xmlPop ();
+00925 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLLIGO::CPrimZone::write ( xmlNodePtr  xmlNode,
const char *  filename
)  const [private, virtual]
+
+ + + + + +
+   + + +

+Add a property If the property already exist, the method does nothing and returns false. The pointer will be deleted by the primitive using the ::delete operator. +

+Reimplemented from NLLIGO::IPrimitive. +

+Definition at line 635 of file primitive.cpp. +

+References uint, and NLLIGO::WriteVector(). +

+

00636 {
+00637         // Save the points
+00638         for (uint i=0; i<VPoints.size (); i++)
+00639         {
+00640                 xmlNodePtr ptNode = xmlNewChild ( xmlNode, NULL, (const xmlChar*)"PT", NULL);
+00641                 WriteVector (VPoints[i], ptNode);
+00642         }
+00643 
+00644         IPrimitive::write (xmlNode, filename);
+00645 }
+
+

Field Documentation

+

+ + + + +
+ + +
bool NLLIGO::IPrimitive::Expanded [inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 163 of file primitive.h. +

+Referenced by NLLIGO::IPrimitive::operator=(), NLLIGO::IPrimitive::read(), and NLLIGO::IPrimitive::write().

+

+ + + + +
+ + +
std::string NLLIGO::IPrimitive::Layer [inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 159 of file primitive.h. +

+Referenced by NLLIGO::CPrimitives::convertPrimitive(), and NLLIGO::IPrimitive::operator=().

+

+ + + + +
+ + +
std::string NLLIGO::IPrimitive::Name [inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 160 of file primitive.h. +

+Referenced by NLLIGO::CPrimitives::convertAddPrimitive(), and NLLIGO::IPrimitive::operator=().

+

+ + + + +
+ + +
std::vector<CPrimVector> NLLIGO::CPrimZone::VPoints +
+
+ + + + + +
+   + + +

+ +

+Definition at line 442 of file primitive.h.

+

The documentation for this class was generated from the following files: +
Generated on Tue Mar 16 12:50:47 2004 for NeL by + +doxygen +1.3.6
+ + -- cgit v1.2.1