Changeset 2176


Ignore:
Timestamp:
02/28/07 19:38:47 (17 years ago)
Author:
mattausch
Message:

removed using namespace std from .h

Location:
GTP/trunk/Lib/Vis
Files:
103 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp

    r2171 r2176  
    18381838        if (mNormalExecution) 
    18391839        { 
    1840                 // not in the normal workflow 
     1840                // problems using this function in the normal workflow 
    18411841                return; 
    18421842        } 

  • GTP/trunk/Lib/Vis/Preprocessing/include/Containers.h

    r2168 r2176  
    33 
    44#include <vector> 
    5 //using namespace std; 
     5// 
    66 
    77namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/AxisAlignedBox3.cpp

    r2124 r2176  
    33#include <assert.h> 
    44#include <iostream> 
    5 using namespace std; 
    65#include "AxisAlignedBox3.h" 
    76#include "Ray.h" 
    … …  
    1211#include "VssRay.h" 
    1312 
     13 
     14using namespace std; 
    1415 
    1516namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/AxisAlignedBox3.h

    r2124 r2176  
    255255  // Writes a brief description of the object, indenting by the given 
    256256  // number of spaces first. 
    257   virtual void Describe(ostream& app, int ind) const; 
     257  virtual void Describe(std::ostream& app, int ind) const; 
    258258 
    259259  // For edge .. number <0..11> returns two incident vertices 
    … …  
    434434 
    435435  // input and output operator with stream 
    436   friend ostream& operator<<(ostream &s, const AxisAlignedBox3 &A); 
    437   friend istream& operator>>(istream &s, AxisAlignedBox3 &A); 
     436  friend std::ostream& operator<<(std::ostream &s, const AxisAlignedBox3 &A); 
     437  friend std::istream& operator>>(std::istream &s, AxisAlignedBox3 &A); 
    438438 
    439439protected: 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Beam.cpp

    r863 r2176  
    131131 
    132132 
    133 void BeamSampleStatistics::Print(ostream &app) const 
     133void BeamSampleStatistics::Print(std::ostream &app) const 
    134134{ 
    135135  app << "===== Beam sample statistics ===============\n"; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Beam.h

    r863 r2176  
    66#include "Statistics.h" 
    77 
    8 using namespace std; 
    98 
    109namespace GtpVisibilityPreprocessor { 
    … …  
    4746        } 
    4847 
    49         void Print(ostream &app) const; 
     48        void Print(std::ostream &app) const; 
    5049 
    51         friend ostream &operator<<(ostream &s, const BeamSampleStatistics &stat)  
     50        friend std::ostream &operator<<(std::ostream &s, const BeamSampleStatistics &stat)  
    5251        { 
    5352                stat.Print(s); 

  • GTP/trunk/Lib/Vis/Preprocessing/src/BitVectorPvs.h

    r2117 r2176  
    66#include "PvsBase.h" 
    77 
    8 using namespace std; 
    98 
    109namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/BvHierarchy.h

    r2124 r2176  
    137137        int maxRayContriNodes; 
    138138 
    139         void Print(ostream &app) const; 
    140  
    141         friend ostream &operator<<(ostream &s, const BvhStatistics &stat)  
     139        void Print(std::ostream &app) const; 
     140 
     141        friend std::ostream &operator<<(std::ostream &s, const BvhStatistics &stat)  
    142142        { 
    143143                stat.Print(s); 
    … …  
    241241        } 
    242242 
    243         ostream &Describe(ostream &s) { return s; } 
     243        std::ostream &Describe(std::ostream &s) { return s; } 
    244244 
    245245        /////////////////////////////////// 
    … …  
    283283        void SetupChildLinks(BvhNode *front, BvhNode *back); 
    284284 
    285         friend ostream &operator<<(ostream &s, const BvhInterior &A) 
     285        friend std::ostream &operator<<(std::ostream &s, const BvhInterior &A) 
    286286        { 
    287287                return s << A.mBoundingBox; 
    … …  
    10001000        bool mStoreRays; 
    10011001        // subdivision stats output file 
    1002         ofstream  mSubdivisionStats; 
     1002        std::ofstream  mSubdivisionStats; 
    10031003        /// keeps track of cost during subdivision 
    10041004        float mTotalCost; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Camera.cpp

    r1583 r2176  
    1313#include "SceneGraph.h" 
    1414 
     15using namespace std; 
    1516 
    1617namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Camera.h

    r1583 r2176  
    6767   
    6868  bool 
    69   SnapImage(string filename, 
     69          SnapImage(std::string filename, 
    7070                        KdTree *tree, 
    7171                        SceneGraph *sceneGraph 

  • GTP/trunk/Lib/Vis/Preprocessing/src/CombinedPreprocessor.h

    r1966 r2176  
    11#ifndef _CombinedPreprocessor_H__ 
    22#define _CombinedPreprocessor_H__ 
    3  
    4 #include <fstream> 
    5 using namespace std; 
    63 
    74#include "Preprocessor.h" 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Containers.h

    r2116 r2176  
    66#include <map> 
    77 
    8 using namespace std; 
     8using std::vector; 
    99 
    1010namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Environment.h

    r1004 r2176  
    7171  char *description; 
    7272  void *pointer; 
    73   friend ostream &operator <<(ostream &s, const COption &o) { 
     73  friend std::ostream &operator <<(std::ostream &s, const COption &o) { 
    7474    s<<o.name<<"\t"; 
    7575    if (o.abbrev) 
    … …  
    8989    s<<"\t"; 
    9090    if (o.description) 
    91       s<<endl<<o.description; 
     91      s<<std::endl<<o.description; 
    9292    return s; 
    9393  } 
    … …  
    184184 
    185185    /// This method is used as a help on available command line options. 
    186         virtual void PrintUsage(ostream &s) const; 
     186        virtual void PrintUsage(std::ostream &s) const; 
    187187 
    188188        virtual void SetStaticOptions(); 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Exporter.cpp

    r2124 r2176  
    99#include "TraversalTree.h" 
    1010 
     11 
     12using namespace std; 
    1113 
    1214namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Exporter.h

    r2124 r2176  
    44#include <string> 
    55#include <vector> 
    6 using namespace std; 
    76 
    87 
    … …  
    3938{ 
    4039protected: 
    41   string mFilename; 
     40  std::string mFilename; 
    4241  bool mWireframe; 
    4342  bool mUseForcedMaterial; 
    … …  
    4847public: 
    4948   
    50   Exporter(const string filename):mFilename(filename), 
     49  Exporter(const std::string filename):  
     50                                  mFilename(filename), 
    5151                                  mWireframe(false), 
    5252                                  mUseForcedMaterial(false), 
    … …  
    154154     
    155155  static Exporter * 
    156   GetExporter(const string filename); 
     156  GetExporter(const std::string filename); 
    157157 
    158158  virtual void ExportViewpoint(const Vector3 &point, const Vector3 &direction) = 0; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/FlexibleHeap.h

    r1667 r2176  
    44#include <vector> 
    55 
    6 using namespace std; 
    76 
    87namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/GlRenderer.h

    r2116 r2176  
    22#define __GLRENDERER_H 
    33 
     4#include "ObjectPvs.h" 
    45#include "Vector3.h" 
    56#include "Containers.h" 
    … …  
    78#include "Renderer.h" 
    89#include "Beam.h" 
    9 #include "ObjectPvs.h" 
     10 
    1011 
    1112 
    … …  
    2526class TransformedMeshInstance; 
    2627class TriangleIntersectable; 
    27  class BvhNode; 
    28   class SimpleRayContainer; 
     28class BvhNode; 
     29class SimpleRayContainer; 
    2930 
    3031struct VssRayContainer; 
    … …  
    166167 
    167168  inline const bool GetSnapErrorFrames() { return mSnapErrorFrames; } 
    168   inline const string GetSnapPrefix() { return mSnapPrefix; } 
     169  inline const std::string GetSnapPrefix() { return mSnapPrefix; } 
    169170 
    170171  inline void SetSnapErrorFrames(bool snapframes) { mSnapErrorFrames = snapframes; } 
    171   inline void SetSnapPrefix(const string &pref) { mSnapPrefix = pref; } 
     172  inline void SetSnapPrefix(const std::string &pref) { mSnapPrefix = pref; } 
    172173 
    173174  virtual void ClearErrorBuffer(); 
    … …  
    228229  bool mUseGlLists; 
    229230   
    230   string mSnapPrefix; 
     231  std::string mSnapPrefix; 
    231232 
    232233  GLUquadric *mSphere; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/GvsPreprocessor.h

    r2053 r2176  
    44#include <fstream> 
    55#include <stack> 
    6 using namespace std; 
    76 
    87#include "Preprocessor.h" 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Halton.h

    r2105 r2176  
    33 
    44#include <iostream> 
    5 using namespace std; 
    65 
    76namespace GtpVisibilityPreprocessor { 
    … …  
    198197        } 
    199198        else { 
    200           cerr<<"Error generating Halton sequence."<<endl; 
     199          std::cerr<<"Error generating Halton sequence."<<std::endl; 
    201200          exit(1); 
    202201        } 

  • GTP/trunk/Lib/Vis/Preprocessing/src/HashPvs.h

    r2164 r2176  
    22#define __HASHPVS_H 
    33 
    4  
    5 #include <hash_set> 
     4//#include <hash_set> 
    65#include "common.h" 
    76#include <math.h> 
    … …  
    1110 
    1211 
    13 using namespace std; 
    14  
    1512namespace GtpVisibilityPreprocessor { 
    1613 

  • GTP/trunk/Lib/Vis/Preprocessing/src/HierarchyManager.h

    r2130 r2176  
    102102        } 
    103103 
    104         void Print(ostream &app) const; 
    105  
    106         friend ostream &operator<<(ostream &s, const HierarchyStatistics &stat)  
     104        void Print(std::ostream &app) const; 
     105 
     106        friend std::ostream &operator<<(std::ostream &s, const HierarchyStatistics &stat)  
    107107        { 
    108108                stat.Print(s); 
    … …  
    154154 
    155155 
    156         void Print(ostream &app) const; 
    157  
    158         friend ostream &operator<<(ostream &s, const HierarchySubdivisionStats &stat) 
     156        void Print(std::ostream &app) const; 
     157 
     158        friend std::ostream &operator<<(std::ostream &s, const HierarchySubdivisionStats &stat) 
    159159        { 
    160160                stat.Print(s); 
    … …  
    251251        /** Print out statistics. 
    252252        */ 
    253         void PrintHierarchyStatistics(ostream &stream) const; 
     253        void PrintHierarchyStatistics(std::ostream &stream) const; 
    254254 
    255255        /** Returns the view space partition tree. 
    … …  
    279279        void ExportBoundingBoxes(OUT_STREAM &stream, const ObjectContainer &objects); 
    280280 
    281         friend ostream &operator<<(ostream &s, const HierarchyManager &hm)  
     281        friend std::ostream &operator<<(std::ostream &s, const HierarchyManager &hm)  
    282282        { 
    283283                hm.PrintHierarchyStatistics(s); 
    … …  
    291291        void EvaluateSubdivision(const VssRayContainer &sampleRays,                                                                                       
    292292                                                         const ObjectContainer &objects, 
    293                                                          const string &filename); 
    294  
    295         void EvaluateSubdivision2(ofstream &splitsStats, 
     293                                                         const std::string &filename); 
     294 
     295        void EvaluateSubdivision2(std::ofstream &splitsStats, 
    296296                                                          const int splitsStepSize, 
    297297                                                          const bool useFilter, 
    … …  
    532532        /////////////////////////// 
    533533 
    534         void ExportStats(ofstream &stats,  
     534        void ExportStats(std::ofstream &stats,  
    535535                                         SplitQueue &tQueue,  
    536536                                         const ObjectContainer &objects); 
    … …  
    644644        //int mMinRenderCostDecrease; 
    645645 
    646         ofstream mSubdivisionStats; 
     646        std::ofstream mSubdivisionStats; 
    647647 
    648648        /// if the queue should be repaired after a subdivision steps 

  • GTP/trunk/Lib/Vis/Preprocessing/src/IntelRayCaster.h

    r2105 r2176  
    2929        */ 
    3030        IntelRayCaster(const Preprocessor &preprocessor, 
    31                                    const string externKdTree); 
     31                                   const std::string externKdTree); 
    3232 
    3333        virtual ~IntelRayCaster(); 
    … …  
    7575protected: 
    7676 
    77         bool InitRayCast(const string externKdTree); 
     77        bool InitRayCast(const std::string externKdTree); 
    7878}; 
    7979 

  • GTP/trunk/Lib/Vis/Preprocessing/src/InternalRayCaster.h

    r2003 r2176  
    55#include "Containers.h" 
    66#include <string> 
    7 using namespace std; 
     7// 
    88 
    99 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Intersectable.cpp

    r2066 r2176  
    11#include "Intersectable.h" 
     2 
     3using namespace std; 
    24 
    35 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Intersectable.h

    r2164 r2176  
    118118  // vector3 &normal) = 0; 
    119119 
    120   virtual ostream &Describe(ostream &s) = 0; 
     120  virtual std::ostream &Describe(std::ostream &s) = 0; 
    121121 
    122122  ////////////////////////////////////// 
    … …  
    140140  /** Returns the name of the type of this intersectable 
    141141  */ 
    142   static string GetTypeName(Intersectable *obj); 
     142  static std::string GetTypeName(Intersectable *obj); 
    143143 
    144144   /** Returns normal from the face with the specified index. 

  • GTP/trunk/Lib/Vis/Preprocessing/src/IntersectableWrapper.h

    r2113 r2176  
    5555                                                                         const int maxTries); 
    5656   
    57         ostream &Describe(ostream &s); 
     57        std::ostream &Describe(std::ostream &s); 
    5858         
    5959        int GetRandomEdgePoint(Vector3 &point, Vector3 &normal); 
    … …  
    150150   
    151151template<typename T> 
    152 ostream &IntersectableWrapper<T>::Describe(ostream &s) 
     152std::ostream &IntersectableWrapper<T>::Describe(std::ostream &s) 
    153153{ 
    154154        s << mItem; 
    … …  
    176176 
    177177 
    178 typedef map<KdNode *, KdIntersectable *> KdIntersectableMap; 
     178typedef std::map<KdNode *, KdIntersectable *> KdIntersectableMap; 
    179179 
    180180 
    … …  
    220220public: 
    221221        DummyIntersectable(const int item): 
    222           IntersectableWrapper<int>(item) {} 
     222          IntersectableWrapper<int>(item) { SetId(item); } 
    223223 
    224224        int Type() const 

  • GTP/trunk/Lib/Vis/Preprocessing/src/KdTree.cpp

    r2124 r2176  
    1010#include "IntersectableWrapper.h" 
    1111 
     12 
     13using namespace std; 
    1214 
    1315// $$JB HACK 

  • GTP/trunk/Lib/Vis/Preprocessing/src/KdTree.h

    r2117 r2176  
    33 
    44#include <functional> 
    5 using namespace std; 
     5// 
    66 
    77#include "Containers.h" 
    … …  
    8383 
    8484  void 
    85   Print(ostream &app) const; 
    86  
    87   friend ostream &operator<<(ostream &s, const KdTreeStatistics &stat) { 
     85  Print(std::ostream &app) const; 
     86 
     87  friend std::ostream &operator<<(std::ostream &s, const KdTreeStatistics &stat) { 
    8888    stat.Print(s); 
    8989    return s; 
    … …  
    268268    // comparator for the  
    269269    struct less_priority : public 
    270     binary_function<const TraversalData, const TraversalData, bool> { 
     270    std::binary_function<const TraversalData, const TraversalData, bool> { 
    271271       
    272272      bool operator()(const TraversalData a, const TraversalData b) { 
    … …  
    425425  CollectLeafPvs(); 
    426426 
    427   bool ExportBinTree(const string &filename); 
    428   bool LoadBinTree(const string &filename, ObjectContainer &object); 
     427  bool ExportBinTree(const std::string &filename); 
     428  bool LoadBinTree(const std::string &filename, ObjectContainer &object); 
    429429 
    430430protected: 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Matrix4x4.h

    r1001 r2176  
    33 
    44#include <iostream> 
    5 using namespace std; 
     5// 
    66 
    77namespace GtpVisibilityPreprocessor { 
    … …  
    100100 
    101101  // Overloaded output operator. 
    102   friend ostream& operator<< (ostream &s, const Matrix4x4 &M); 
     102  friend std::ostream& operator<< (std::ostream &s, const Matrix4x4 &M); 
    103103}; 
    104104 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Mesh.cpp

    r1990 r2176  
    44#include "Triangle3.h" 
    55#include "ResourceManager.h" 
     6 
     7using namespace std; 
    68 
    79namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Mesh.h

    r1763 r2176  
    33 
    44#include <vector> 
    5 using namespace std; 
     5// 
    66#include "Intersectable.h" 
    77#include "Plane3.h" 
    … …  
    5656 
    5757/// default vertex container for Mesh 
    58 typedef vector<Vector3> VertexContainer; 
     58typedef std::vector<Vector3> VertexContainer; 
    5959 
    6060/// default patch container for Mesh 
    … …  
    164164  CastRayToSelectedFaces( 
    165165                                                 Ray &ray, 
    166                                                  const vector<int> &faces, 
     166                                                 const std::vector<int> &faces, 
    167167                                                 Intersectable *instance 
    168168                                                 ); 
    … …  
    213213  bool CheckMesh() const; 
    214214 
    215   void Print(ostream &app) const; 
    216  
    217   virtual ostream &Describe(ostream &s) const { 
     215  void Print(std::ostream &app) const; 
     216 
     217  virtual std::ostream &Describe(std::ostream &s) const { 
    218218        return s<<"Mesh #vertices="<<(int)mVertices.size()<<" #faces="<<(int)mFaces.size(); 
    219219  } 
    … …  
    224224  friend Mesh *CreateMeshFromBox(const AxisAlignedBox3 &box); 
    225225 
    226   friend ostream& operator<< (ostream &s, const Vector3 &A); 
     226  friend std::ostream& operator<< (std::ostream &s, const Vector3 &A); 
    227227 
    228228protected: 
    … …  
    234234 
    235235// Overload << operator for C++-style output 
    236 inline ostream& 
    237 operator<< (ostream &s, const Mesh &A) 
     236inline std::ostream& 
     237operator<< (std::ostream &s, const Mesh &A) 
    238238{ 
    239239        A.Print(s); 
    … …  
    280280                CastRay( 
    281281                Ray &ray, 
    282                 const vector<int> &faces 
     282                const std::vector<int> &faces 
    283283                ); 
    284284 
    285285 
    286         virtual ostream &Describe(ostream &s) { 
     286        virtual std::ostream &Describe(std::ostream &s) { 
    287287                s<<"MeshInstance Id="<<GetId(); 
    288288                return mMesh->Describe(s); 
    … …  
    323323  virtual int CastRay(Ray &ray); 
    324324 
    325   virtual int CastRay(Ray &ray, const vector<int> &faces); 
     325  virtual int CastRay(Ray &ray, const std::vector<int> &faces); 
    326326 
    327327  virtual int Type() const { return TRANSFORMED_MESH_INSTANCE; } 

  • GTP/trunk/Lib/Vis/Preprocessing/src/MeshKdTree.cpp

    r1486 r2176  
    55#include "Mesh.h" 
    66#include "MeshKdTree.h" 
     7 
     8using namespace std; 
    79 
    810namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/MeshKdTree.h

    r1486 r2176  
    33 
    44#include <functional> 
    5 using namespace std; 
     5// 
    66 
    77#include "Containers.h" 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Mutation.h

    r2076 r2176  
    33 
    44#include <vector> 
    5 using namespace std; 
     5// 
    66 
    77#include "common.h" 

  • GTP/trunk/Lib/Vis/Preprocessing/src/MutualVisibility.cpp

    r1867 r2176  
    11#include <assert.h> 
    22#include <stack> 
    3 using namespace std; 
    43#include "KdTree.h" 
    54#include "AxisAlignedBox3.h" 
    … …  
    109#include "Triangle3.h" 
    1110#include "SceneGraph.h" 
     11 
     12using namespace std; 
    1213 
    1314namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ObjExporter.cpp

    r1694 r2176  
    44#include "ObjExporter.h" 
    55 
     6 
     7using namespace std; 
    68 
    79namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ObjParser.cpp

    r2123 r2176  
    44#include <map> 
    55#include <math.h> 
    6  
    7 using namespace std; 
    86 
    97#include "Vector3.h" 
    … …  
    1816#include "IntersectableWrapper.h" 
    1917 
     18 
     19using namespace std; 
    2020 
    2121namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ObjectPvs.cpp

    r2123 r2176  
    88#include "BvHierarchy.h" 
    99 
     10using namespace std; 
    1011 
    1112namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ObjectPvs.h

    r2123 r2176  
    55#include "PvsDefinitions.h" 
    66 
    7 using namespace std; 
     7// 
    88 
    99namespace GtpVisibilityPreprocessor { 
    … …  
    2525        float EvalPvsCost() const; 
    2626 
    27         friend ostream &operator<<(ostream &s, const ObjectPvs &p)  
     27        friend std::ostream &operator<<(std::ostream &s, const ObjectPvs &p)  
    2828        { 
    2929                ObjectPvsIterator pit = p.GetIterator(); 
    … …  
    3232                {                
    3333                        Intersectable *obj = pit.Next(); 
    34                         cout << obj << " "; 
     34                        std::cout << obj << " "; 
    3535                } 
    3636                 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ObjectsParser.cpp

    r2130 r2176  
    55#include <stdlib.h> 
    66#include <iostream> 
    7 //#include <ext/algorithm> 
    8  
    9 using namespace std; 
    107#include <xercesc/util/PlatformUtils.hpp> 
    118 
    … …  
    3431#include "BvHierarchy.h" 
    3532 
     33 
     34using namespace std; 
    3635 
    3736namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ObjectsParser.h

    r2119 r2176  
    1818        ObjectsParser(): Parser() {} 
    1919   
    20         bool ParseObjects(const string &filename,  
     20        bool ParseObjects(const std::string &filename,  
    2121                                          ObjectContainer &pvsObjects, 
    2222                                          const ObjectContainer &preprocessorObjects); 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ObjectsParserXerces.h

    r2119 r2176  
    9494 
    9595        void StartBvhLeaf(AttributeList& attributes); 
    96         void StartBvhElement(string element, AttributeList& attributes); 
     96        void StartBvhElement(std::string element, AttributeList& attributes); 
    9797 
    9898        void EndObjectSpaceHierarchy(); 

  • GTP/trunk/Lib/Vis/Preprocessing/src/OspTree.cpp

    r2116 r2176  
    2020#include "VspTree.h" 
    2121 
     22using namespace std; 
     23 
    2224 
    2325namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/OspTree.h

    r1779 r2176  
    129129 
    130130 
    131         void Print(ostream &app) const; 
    132  
    133         friend ostream &operator<<(ostream &s, const OspTreeStatistics &stat)  
     131        void Print(std::ostream &app) const; 
     132 
     133        friend std::ostream &operator<<(std::ostream &s, const OspTreeStatistics &stat)  
    134134        { 
    135135                stat.Print(s); 
    … …  
    830830        float mEpsilon; 
    831831        /// subdivision stats output file 
    832         ofstream  mSubdivisionStats; 
     832        std::ofstream  mSubdivisionStats; 
    833833        /// keeps track of cost during subdivision 
    834834        float mTotalCost; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Plane3.h

    r1932 r2176  
    7070  friend SimpleRay GetPlaneIntersection(const Plane3 &plane1, const Plane3 &plane2); 
    7171 
    72   friend ostream &operator<<(ostream &s, const Plane3 &p) { 
     72  friend std::ostream &operator<<(std::ostream &s, const Plane3 &p) { 
    7373    s<<p.mNormal<<" "<<p.mD; 
    7474    return s; 
    … …  
    8989          { 
    9090          } 
     91 
    9192        Plane3 GetPlane() const 
    9293        { 
    … …  
    104105        bool mOrientation; 
    105106 
    106         friend ostream &operator<<(ostream &s, const AxisAlignedPlane &p)  
     107        friend std::ostream &operator<<(std::ostream &s, const AxisAlignedPlane &p)  
    107108        { 
    108109                s << "a: " << p.mAxis << " p: " << p.mPosition; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/PlyParser.cpp

    r1419 r2176  
    11#include <iostream> 
    2 using namespace std; 
    32#include <ply.h> 
    43#include <stdio.h> 
    … …  
    87#include "SceneGraph.h" 
    98#include "Mesh.h" 
     9 
     10using namespace std; 
    1011 
    1112namespace GtpVisibilityPreprocessor { 
    … …  
    5455 
    5556bool 
    56 PlyParser::ParseSingleFile(const string filename, 
     57PlyParser::ParseSingleFile(const std::string filename, 
    5758                                                   SceneGraphNode *root) 
    5859{ 

  • GTP/trunk/Lib/Vis/Preprocessing/src/PlyParser.h

    r1379 r2176  
    1414  PlyParser():Parser() {} 
    1515   
    16   bool ParseFile(const string filename, 
     16  bool ParseFile(const std::string filename, 
    1717                                 SceneGraphNode *root, 
    1818                                 const bool loadMeshes = true, 
    19                                  vector<FaceParentInfo> *parents = NULL); 
     19                                 std::vector<FaceParentInfo> *parents = NULL); 
    2020 
    21   bool ParseFile(const string filename, ViewCellsManager &viewCells) { return false; } 
     21  bool ParseFile(const std::string filename, ViewCellsManager &viewCells) { return false; } 
    2222 
    2323  bool 
    24   ParseSingleFile(const string filename, 
     24  ParseSingleFile(const std::string filename, 
    2525                                  SceneGraphNode *root); 
    2626         

  • GTP/trunk/Lib/Vis/Preprocessing/src/Polygon3.h

    r2116 r2176  
    170170 
    171171// Overload << operator for C++-style output 
    172 inline ostream& 
    173 operator<< (ostream &s, const Polygon3 &A) 
     172inline std::ostream& 
     173operator<< (std::ostream &s, const Polygon3 &A) 
    174174{ 
    175175        VertexContainer::const_iterator it; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.h

    r2115 r2176  
    33 
    44#include <string> 
    5 using namespace std; 
     5// 
    66#include "Containers.h" 
    77#include "Mesh.h" 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.vcproj

    r2168 r2176  
    221221                                OptimizeForProcessor="3" 
    222222                                OptimizeForWindowsApplication="TRUE" 
    223                                 AdditionalIncludeDirectories="..\src;..\..\..\..\..\..\NonGTP\Devil\include;..\..\..\..\..\..\NonGTP\Zlib\include;..\..\..\..\..\..\NonGTP\Xerces;..\..\..\..\..\..\NonGTP\Boost;..\MultiLevelRayTracing;&quot;$(QTDIR)\include\QtCore&quot;;&quot;$(QTDIR)\include\QtGui&quot;;&quot;$(QTDIR)\include&quot;;&quot;$(QTDIR)\include\QtOpenGl&quot;;&quot;$(CG_INC_PATH)&quot;;Timer;..\src\ootl\src\;..\src\ootl\src\cpp;..\src\ootl\src\include\ootl\sandbox;..\src\ootl\src;..\src\ootl\src\include\ootl;..\src\sparsehash\src\google\sparsehash;..\src\sparsehash\src\windows;..\src\sparsehash\src\google;..\src\sparsehash\src;..\src\ootl\;..\src\ootl\src\cpp\include\;..\src\ootl\src\cpp\include\ootl\mswin" 
     223                                AdditionalIncludeDirectories="..\src;..\..\..\..\..\..\NonGTP\Devil\include;..\..\..\..\..\..\NonGTP\Zlib\include;..\..\..\..\..\..\NonGTP\Xerces;..\..\..\..\..\..\NonGTP\Boost;..\MultiLevelRayTracing;&quot;$(QTDIR)\include\QtCore&quot;;&quot;$(QTDIR)\include\QtGui&quot;;&quot;$(QTDIR)\include&quot;;&quot;$(QTDIR)\include\QtOpenGl&quot;;&quot;$(CG_INC_PATH)&quot;;Timer;..\src\sparsehash\src\google\sparsehash;..\src\sparsehash\src\windows;..\src\sparsehash\src\google;..\src\sparsehash\src;..\src\ootl\;..\src\ootl\src\;..\src\ootl\src\cpp;..\src\ootl\src\cpp\include\;..\src\ootl\src\include\ootl;..\src\ootl\src\include\ootl\sandbox;..\src\ootl\src\cpp\include\ootl\mswin" 
    224224                                PreprocessorDefinitions="WIN32;NDEBUG;_LIB;GTP_INTERNAL;USE_QT;USE_HASH_PVS" 
    225225                                ExceptionHandling="TRUE" 

  • GTP/trunk/Lib/Vis/Preprocessing/src/PreprocessorFactory.h

    r1486 r2176  
    33 
    44#include <string> 
    5 using namespace std; 
     5// 
    66 
    77namespace GtpVisibilityPreprocessor { 
    … …  
    1818                does not exist. 
    1919        */ 
    20         static Preprocessor *CreatePreprocessor(const string &preprocessorName); 
     20        static Preprocessor *CreatePreprocessor(const std::string &preprocessorName); 
    2121 
    2222protected: 

  • GTP/trunk/Lib/Vis/Preprocessing/src/PreprocessorThread.h

    r1926 r2176  
    33 
    44#include <vector> 
    5 using namespace std; 
     5// 
    66namespace GtpVisibilityPreprocessor  
    77{ 
    … …  
    1515{ 
    1616public: 
    17         static vector<PreprocessorThread *> sThreads; 
     17        static std::vector<PreprocessorThread *> sThreads; 
    1818 
    1919        PreprocessorThread(Preprocessor *p); 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Pvs.h

    r2117 r2176  
    88 
    99 
    10 using namespace std; 
     10// 
    1111 
    1212namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/PvsBase.h

    r2168 r2176  
    55#include "Containers.h" 
    66 
    7 //using namespace std; 
     7// 
    88 
    99namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/PvsDefinitions.h

    r2122 r2176  
    1010#ifdef USE_HASH_PVS 
    1111 
     12        //#include "HashPvs2.h" 
    1213        #include "HashPvs.h" 
    1314 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Ray.cpp

    r1883 r2176  
    22#include "Plane3.h" 
    33#include "VssRay.h" 
     4 
     5using namespace std; 
    46 
    57namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Ray.h

    r2105 r2176  
    7272  Intersection sourceObject; 
    7373   
    74   vector<Intersection> intersections; 
    75  // vector<BspIntersection> bspIntersections; 
    76   vector<KdLeaf *> kdLeaves; 
    77   vector<Intersectable *> testedObjects; 
     74  std::vector<Intersection> intersections; 
     75 // std::vector<BspIntersection> bspIntersections; 
     76  std::vector<KdLeaf *> kdLeaves; 
     77  std::vector<Intersectable *> testedObjects; 
    7878 
    7979  // various flags 
    … …  
    244244 
    245245private: 
    246   Vector3 loc, dir;             // Describes ray origin and vector 
     246  Vector3 loc, dir;             // Describes ray origin and std::vector 
    247247   
    248248  // The inverted direction of the ray components. It is computed optionally 
    … …  
    284284  friend int MakeIntersectLine(const Plane3 &p, const Plane3 &q, Ray &ray); 
    285285 
    286         friend ostream &operator<<(ostream &s, const Ray &r) { 
     286        friend std::ostream &operator<<(std::ostream &s, const Ray &r) { 
    287287                return s<<"Ray:loc="<<r.loc<<" dir="<<r.dir; 
    288288        } 
    … …  
    311311  int GetEntryIndex(const Vector3 &direction) const; 
    312312 
    313   friend ostream &operator<<(ostream &s, const PassingRaySet &set); 
     313  friend std::ostream &operator<<(std::ostream &s, const PassingRaySet &set); 
    314314 
    315315}; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/RayCaster.h

    r2164 r2176  
    77#include "VssRay.h" 
    88 
    9 using namespace std; 
     9// 
    1010 
    1111 

  • GTP/trunk/Lib/Vis/Preprocessing/src/RayInfo.cpp

    r1149 r2176  
    33#include "VssRay.h" 
    44#include "Plane3.h" 
     5 
     6using namespace std; 
    57 
    68namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/RayInfo.h

    r1692 r2176  
    33 
    44#include <vector> 
    5 using namespace std; 
     5 
    66 
    77namespace GtpVisibilityPreprocessor { 
    … …  
    1313 
    1414 
    15 typedef vector<RayInfo> RayInfoContainer; 
     15typedef std::vector<RayInfo> RayInfoContainer; 
    1616 
    1717 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Rectangle3.h

    r1772 r2176  
    33 
    44#include <iostream> 
    5 using namespace std; 
     5// 
    66#include "Vector3.h" 
    77 
    … …  
    6060        ) const; 
    6161 
    62   friend ostream& operator<< (ostream &s, const Rectangle3 &r) { 
     62  friend std::ostream& operator<< (std::ostream &s, const Rectangle3 &r) { 
    6363    return s<<"Rectangle3:"<<r.mVertices[0]<<r.mVertices[1]<<r.mVertices[2]<<r.mVertices[3]; 
    6464  } 

  • GTP/trunk/Lib/Vis/Preprocessing/src/RenderSampler.h

    r871 r2176  
    33 
    44#include <fstream> 
    5 using namespace std; 
     5// 
    66 
    77#include "Preprocessor.h" 

  • GTP/trunk/Lib/Vis/Preprocessing/src/RenderSimulator.cpp

    r1020 r2176  
    66#include "ViewCellsManager.h" 
    77 
     8 
     9using namespace std; 
    810 
    911namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/RenderSimulator.h

    r860 r2176  
    4444        } 
    4545 
    46         void Print(ostream &app) const; 
     46        void Print(std::ostream &app) const; 
    4747 
    48         friend ostream &operator<<(ostream &s, const SimulationStatistics &stat)  
     48        friend std::ostream &operator<<(std::ostream &s, const SimulationStatistics &stat)  
    4949        { 
    5050                stat.Print(s); 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ResourceManager.h

    r1197 r2176  
    9191        } 
    9292         
    93         bool ExportEntries(const string &filename) 
     93        bool ExportEntries(const std::string &filename) 
    9494        { 
    9595                ofstream stream(filename.c_str(), ios::binary); 

  • GTP/trunk/Lib/Vis/Preprocessing/src/RssPreprocessor.h

    r2002 r2176  
    33 
    44#include <fstream> 
    5 using namespace std; 
     5// 
    66 
    77#include "Preprocessor.h" 

  • GTP/trunk/Lib/Vis/Preprocessing/src/RssTree.h

    r1900 r2176  
    116116   
    117117  void 
    118   Print(ostream &app) const; 
    119  
    120   friend ostream &operator<<(ostream &s, const RssStatistics &stat) { 
     118  Print(std::ostream &app) const; 
     119 
     120  friend std::ostream &operator<<(std::ostream &s, const RssStatistics &stat) { 
    121121    stat.Print(s); 
    122122    return s; 
    … …  
    330330  bool IsLeaf() const { return axis == -1; } 
    331331   
    332   virtual void Print(ostream &s) const = 0; 
     332  virtual void Print(std::ostream &s) const = 0; 
    333333 
    334334  virtual int GetAccessTime() { 
    … …  
    399399  } 
    400400   
    401   virtual void Print(ostream &s) const { 
     401  virtual void Print(std::ostream &s) const { 
    402402    if (axis == 0) 
    403403      s<<"x "; 
    … …  
    454454  virtual int Type() const  { return ELeaf; } 
    455455 
    456   virtual void Print(ostream &s) const { 
     456  virtual void Print(std::ostream &s) const { 
    457457    s<< 
    458458          "L: rays="<<(int)rays.size()<< 
    459           " pvs="<<mPvsSize<<" importance="<<mImportance<<endl; 
     459          " pvs="<<mPvsSize<<" importance="<<mImportance<<std::endl; 
    460460  }; 
    461461   
    … …  
    515515  // comparator for the  
    516516  struct less_contribution : public 
    517   binary_function<const RssTreeLeaf *, const RssTreeLeaf *, bool> { 
     517  std::binary_function<const RssTreeLeaf *, const RssTreeLeaf *, bool> { 
    518518         
    519519        bool operator()(const RssTreeLeaf * a, const RssTreeLeaf *b) { 
    … …  
    523523   
    524524  struct greater_contribution : public 
    525   binary_function<const RssTreeLeaf *, const RssTreeLeaf *, bool> { 
     525  std::binary_function<const RssTreeLeaf *, const RssTreeLeaf *, bool> { 
    526526         
    527527        bool operator()(const RssTreeLeaf * a, const RssTreeLeaf *b) { 
    … …  
    570570    // comparator for the  
    571571    struct less_priority : public 
    572     binary_function<const TraversalData, const TraversalData, bool> { 
     572    std::binary_function<const TraversalData, const TraversalData, bool> { 
    573573                         
    574574      bool operator()(const TraversalData a, const TraversalData b) { 
    … …  
    956956  TraverseInternalNode( 
    957957                                           RayTraversalData &data, 
    958                                            stack<RayTraversalData> &tstack); 
     958                                           std::stack<RayTraversalData> &tstack); 
    959959 
    960960  void 
    … …  
    10941094 
    10951095  void 
    1096   PushRoots(priority_queue<TraversalData> &stack) const; 
    1097  
    1098   void 
    1099   PushRoots(stack<RssTreeNode *> &st) const; 
    1100  
    1101   void 
    1102   PushRoots(stack<RayTraversalData> &st, RssTreeNode::RayInfo &info) const; 
     1096  PushRoots(std::priority_queue<TraversalData> &stack) const; 
     1097 
     1098  void 
     1099  PushRoots(std::stack<RssTreeNode *> &st) const; 
     1100 
     1101  void 
     1102  PushRoots(std::stack<RayTraversalData> &st, RssTreeNode::RayInfo &info) const; 
    11031103 
    11041104  void 

  • GTP/trunk/Lib/Vis/Preprocessing/src/SamplingPreprocessor.h

    r2168 r2176  
    33 
    44#include <fstream> 
    5 //using namespace std; 
     5// 
    66 
    77#include "Preprocessor.h" 

  • GTP/trunk/Lib/Vis/Preprocessing/src/SamplingStrategy.h

    r2168 r2176  
    33 
    44#include <vector> 
    5 //using namespace std; 
     5// 
    66 
    77#include "common.h" 
    … …  
    280280    
    281281  // container for the distributions 
    282   vector<SamplingStrategy *> mDistributions; 
     282        std::vector<SamplingStrategy *> mDistributions; 
    283283   
    284284  MixtureDistribution(Preprocessor &preprocessor): 

  • GTP/trunk/Lib/Vis/Preprocessing/src/SceneGraph.cpp

    r1958 r2176  
    66#include "Intersectable.h" 
    77 
     8 
     9using namespace std; 
    810 
    911namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/SceneGraph.h

    r2168 r2176  
    33 
    44#include <string> 
    5 //using namespace std; 
     5// 
    66 
    77#include "Containers.h" 
    … …  
    3131        ~SceneGraph(); 
    3232         
    33         bool Export(const string filename); 
     33        bool Export(const std::string filename); 
    3434   
    3535        int CollectObjects(ObjectContainer *instances); 
    … …  
    4343        /** Exports binary version of the scene. 
    4444        */ 
    45         void ExportScene(const string filename); 
     45        void ExportScene(const std::string filename); 
    4646 
    4747        /** Loads binary version of the scene. 
    4848        */ 
    49         void LoadScene(const string filename); 
     49        void LoadScene(const std::string filename); 
    5050 
    5151        SceneGraphNode *GetRoot(); 

  • GTP/trunk/Lib/Vis/Preprocessing/src/SimpleRay.h

    r2116 r2176  
    7474  } 
    7575 
    76   friend ostream &operator<<(ostream &s, const SimpleRay &r) 
     76  friend std::ostream &operator<<(std::ostream &s, const SimpleRay &r) 
    7777  { 
    7878          return s << "origin=" << r.mOrigin << " dir=" << r.mDirection; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/SubdivisionCandidate.h

    r2168 r2176  
    55#include "FlexibleHeap.h" 
    66 
    7 //using namespace std; 
     7// 
    88 
    99namespace GtpVisibilityPreprocessor { 
    … …  
    1111class SubdivisionCandidate; 
    1212 
    13 typedef vector<SubdivisionCandidate *> SubdivisionCandidateContainer; 
     13typedef std::vector<SubdivisionCandidate *> SubdivisionCandidateContainer; 
    1414typedef FlexibleHeap<SubdivisionCandidate *> SplitQueue; 
    1515 

  • GTP/trunk/Lib/Vis/Preprocessing/src/TestPreprocessor.vcproj

    r2162 r2176  
    198198                                OptimizeForProcessor="3" 
    199199                                OptimizeForWindowsApplication="TRUE" 
    200                                 AdditionalIncludeDirectories="..\include;..\..\..\..\..\..\NonGTP\Boost;..\src;..\..\..\..\..\..\NonGTP\Devil\include;..\..\..\..\..\..\NonGTP\Zlib\include;..\..\..\..\..\..\NonGTP\Xerces;&quot;$(QTDIR)\include\QtOpenGl&quot;;&quot;$(QTDIR)\include\Qt&quot;;&quot;$(QTDIR)\include\QtCore&quot;;&quot;$(QTDIR)\include&quot;;QtInterface;..\src\sparsehash\src\;$(NOINHERIT)" 
     200                                AdditionalIncludeDirectories="..\include;..\..\..\..\..\..\NonGTP\Boost;..\src;..\..\..\..\..\..\NonGTP\Devil\include;..\..\..\..\..\..\NonGTP\Zlib\include;..\..\..\..\..\..\NonGTP\Xerces;&quot;$(QTDIR)\include\QtOpenGl&quot;;&quot;$(QTDIR)\include\Qt&quot;;&quot;$(QTDIR)\include\QtCore&quot;;&quot;$(QTDIR)\include&quot;;QtInterface;..\src\sparsehash\src\;..\src\ootl\src\include\ootl;..\src\ootl\src\include\ootl\sandbox;$(NOINHERIT)" 
    201201                                PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;GTP_INTERNAL;USE_QT;USE_CG;USE_HASH_PVS" 
    202202                                ExceptionHandling="TRUE" 

  • GTP/trunk/Lib/Vis/Preprocessing/src/TraversalTree.cpp

    r2149 r2176  
    99#include "Exporter.h" 
    1010 
     11 
     12using namespace std; 
    1113 
    1214// $$JB HACK 

  • GTP/trunk/Lib/Vis/Preprocessing/src/TraversalTree.h

    r2168 r2176  
    33 
    44#include <functional> 
    5 //using namespace std; 
     5// 
    66 
    77#include "Containers.h" 
    … …  
    8787  } 
    8888 
    89   void Print(ostream &app) const; 
    90  
    91   friend ostream &operator<<(ostream &s, const TraversalTreeStatistics &stat)  
     89  void Print(std::ostream &app) const; 
     90 
     91  friend std::ostream &operator<<(std::ostream &s, const TraversalTreeStatistics &stat)  
    9292  { 
    9393          stat.Print(s); 
    … …  
    266266                // comparator for the  
    267267                struct less_priority: public  
    268                                 binary_function<const TraversalData, const TraversalData, bool>  
     268                                std::binary_function<const TraversalData, const TraversalData, bool>  
    269269                { 
    270270                        bool operator()(const TraversalData a, const TraversalData b)  

  • GTP/trunk/Lib/Vis/Preprocessing/src/Triangle3.cpp

    r1933 r2176  
    55#include "Polygon3.h" 
    66 
     7 
     8using namespace std; 
    79 
    810namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Triangle3.h

    r1933 r2176  
    3232        int CastRay(const Ray &ray, float &t, const float nearestT, Vector3 &normal) const; 
    3333 
    34         friend ostream& operator<< (ostream &s, const Triangle3 &A); 
    35         friend istream& operator>> (istream &s, Triangle3 &A); 
     34        friend std::ostream& operator<< (std::ostream &s, const Triangle3 &A); 
     35        friend std::istream& operator>> (std::istream &s, Triangle3 &A); 
    3636 
    3737        /** Checks if this triangle is ill-defined. 
    … …  
    5656 
    5757// Overload << operator for C++-style output 
    58 inline ostream& 
    59 operator<< (ostream &s, const Triangle3 &A) 
     58inline std::ostream& 
     59operator<< (std::ostream &s, const Triangle3 &A) 
    6060{ 
    6161  return s << "(" << A.mVertices[0] << ", " << A.mVertices[1] << ", " << A.mVertices[2] << ")"; 
    … …  
    6363 
    6464// Overload >> operator for C++-style input 
    65 inline istream& 
    66 operator>> (istream &s, Triangle3 &A) 
     65inline std::istream& 
     66operator>> (std::istream &s, Triangle3 &A) 
    6767{ 
    6868  char a; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/UnigraphicsParser.cpp

    r1627 r2176  
    33#include <list> 
    44#include <map> 
    5 using namespace std; 
    65 
    76#include "Vector3.h" 
    … …  
    1716#include "Polygon3.h" 
    1817 
     18using namespace std; 
    1919 
    2020namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Vector3.h

    r2168 r2176  
    33 
    44#include <iostream> 
    5 //using namespace std; 
     5// 
    66#include <math.h> 
    77#include "common.h" 
    88 
     9//using std::ostream; 
     10//using std::istream; 
    911 
    1012namespace GtpVisibilityPreprocessor { 
    … …  
    1416class Vector2; 
    1517 
    16  
    17 // HACK of returning vector components as array fields. 
     18// HACK of returning std::vector components as array fields. 
    1819// NOT guarrantied to work with some strange variable allignment ! 
    1920#define __VECTOR_HACK 
    … …  
    3940  Vector3(const Vector3 &v) { x = v.x; y = v.y; z = v.z; } 
    4041 
    41   // Functions to get at the vector components 
     42  // Functions to get at the std::vector components 
    4243  float& operator[] (int inx) { 
    4344#ifndef __VECTOR_HACK 
    … …  
    8081  void SetValue(const float a) { x = y = z = a; } 
    8182   
    82   // returns the axis, where the vector has the largest value 
     83  // returns the axis, where the std::vector has the largest value 
    8384  int DrivingAxis(void) const; 
    8485 
    85   // returns the axis, where the vector has the smallest value 
     86  // returns the axis, where the std::vector has the smallest value 
    8687  int TinyAxis(void) const; 
    8788 
    … …  
    9596   } 
    9697 
    97   // normalizes the vector of unit size corresponding to given vector 
     98  // normalizes the std::vector of unit size corresponding to given std::vector 
    9899  inline void Normalize(); 
    99100   
    100   /** Returns false if this vector has a nan component. 
     101  /** Returns false if this std::vector has a nan component. 
    101102  */ 
    102103  bool CheckValidity() const; 
    … …  
    109110     In fact it tries v x (0,0,1) an if the result is too small, 
    110111     it definitely does v x (0,1,0). It will always work for 
    111      non-degenareted vector and is much faster than to use 
     112     non-degenareted std::vector and is much faster than to use 
    112113     TangentVectors. 
    113114 
    114      @param v(in) The vector we want to find normal for. 
    115      @return The normal vector to v. 
     115     @param v(in) The std::vector we want to find normal for. 
     116     @return The normal std::vector to v. 
    116117  */ 
    117118  friend inline Vector3 ArbitraryNormal(const Vector3 &v);  
    … …  
    140141  void RightHandedBase(Vector3& U, Vector3& V) const; 
    141142 
    142   /// Transforms a vector to the global coordinate frame. 
     143  /// Transforms a std::vector to the global coordinate frame. 
    143144  /** 
    144145    Given a local coordinate frame (U,V,N) (i.e. U,V,N are  
    145146    the x,y,z axes of the local coordinate system) and 
    146     a vector 'loc' in the local coordiante system, this 
    147     function returns a the coordinates of the same vector 
     147    a std::vector 'loc' in the local coordiante system, this 
     148    function returns a the coordinates of the same std::vector 
    148149    in global frame (i.e. frame (1,0,0), (0,1,0), (0,0,1). 
    149150  */ 
    … …  
    153154          const Vector3& N); 
    154155   
    155   /// Transforms a vector to a local coordinate frame. 
     156  /// Transforms a std::vector to a local coordinate frame. 
    156157  /** 
    157158    Given a local coordinate frame (U,V,N) (i.e. U,V,N are  
    158159    the x,y,z axes of the local coordinate system) and 
    159     a vector 'loc' in the global coordiante system, this 
    160     function returns a the coordinates of the same vector 
     160    a std::vector 'loc' in the global coordiante system, this 
     161    function returns a the coordinates of the same std::vector 
    161162    in the local frame. 
    162163  */ 
    … …  
    166167          const Vector3& N); 
    167168 
    168   /// the magnitude=size of the vector 
     169  /// the magnitude=size of the std::vector 
    169170  friend inline float Magnitude(const Vector3 &v); 
    170   /// the squared magnitude of the vector .. for efficiency in some cases 
     171  /// the squared magnitude of the std::vector .. for efficiency in some cases 
    171172  friend inline float SqrMagnitude(const Vector3 &v); 
    172173  /// Magnitude(v1-v2) 
    … …  
    175176  friend inline float SqrDistance(const Vector3 &v1, const Vector3 &v2); 
    176177 
    177   // creates the vector of unit size corresponding to given vector 
     178  // creates the std::vector of unit size corresponding to given std::vector 
    178179  friend inline Vector3 Normalize(const Vector3 &A); 
    179180 
    180   // Rotate a normal vector. 
     181  // Rotate a normal std::vector. 
    181182  friend Vector3 PlaneRotate(const Matrix4x4 &, const Vector3 &); 
    182183 
    183184  // construct view vectors .. DirAt is the main viewing direction 
    184   // Viewer is the coordinates of viewer location, UpL is the vector. 
     185  // Viewer is the coordinates of viewer location, UpL is the std::vector. 
    185186  friend void ViewVectors(const Vector3 &DirAt, const Vector3 &Viewer, 
    186187                                                  const Vector3 &UpL, Vector3 &ViewV, 
    … …  
    224225  friend inline Vector3 CrossProd (const Vector3 &A, const Vector3 &B); 
    225226 
    226   friend ostream& operator<< (ostream &s, const Vector3 &A); 
    227   friend istream& operator>> (istream &s, Vector3 &A); 
     227  friend std::ostream& operator<< (std::ostream &s, const Vector3 &A); 
     228  friend std::istream& operator>> (std::istream &s, Vector3 &A); 
    228229     
    229230  friend void Minimize(Vector3 &min, const Vector3 &candidate); 
    … …  
    477478 
    478479// Overload << operator for C++-style output 
    479 inline ostream& 
    480 operator<< (ostream &s, const Vector3 &A) 
     480inline std::ostream& 
     481operator<< (std::ostream &s, const Vector3 &A) 
    481482{ 
    482483  return s << "(" << A.x << ", " << A.y << ", " << A.z << ")"; 
    … …  
    484485 
    485486// Overload >> operator for C++-style input 
    486 inline istream& 
    487 operator>> (istream &s, Vector3 &A) 
     487inline std::istream& 
     488operator>> (std::istream &s, Vector3 &A) 
    488489{ 
    489490  char a; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ViewCell.h

    r2124 r2176  
    7474        } 
    7575 
    76         void Print(ostream &app) const; 
    77  
    78         friend ostream &operator<<(ostream &s, const ViewCellsStatistics &stat) 
     76        void Print(std::ostream &app) const; 
     77 
     78        friend std::ostream &operator<<(std::ostream &s, const ViewCellsStatistics &stat) 
    7979        { 
    8080                stat.Print(s); 
    … …  
    132132 
    133133 
    134         void Print(ostream &app) const; 
    135  
    136         friend ostream &operator<<(ostream &s, const ViewCellsTreeStats &stat) 
     134        void Print(std::ostream &app) const; 
     135 
     136        friend std::ostream &operator<<(std::ostream &s, const ViewCellsTreeStats &stat) 
    137137        { 
    138138                stat.Print(s); 
    … …  
    540540        /** Export statistics of this view cell tree. 
    541541        */ 
    542         void ExportStats(const string &mergeStats); 
     542        void ExportStats(const std::string &mergeStats); 
    543543 
    544544        /** Sets root of hierarchy. 
    … …  
    685685        /** Update stats for the log. 
    686686        */ 
    687         void UpdateStats(ofstream &stats, 
     687        void UpdateStats(std::ofstream &stats, 
    688688                                         const ViewCellsTreeStats &vcStats); 
    689689 
    … …  
    723723        float mMergeMaxCostRatio; 
    724724 
    725         typedef priority_queue<MergeCandidate> MergeQueue; 
     725        typedef std::priority_queue<MergeCandidate> MergeQueue; 
    726726 
    727727        MergeQueue mMergeQueue; 
    … …  
    846846        } 
    847847 
    848         void Print(ostream &app) const; 
    849  
    850         friend ostream &operator<<(ostream &s, const MergeStatistics &stat)  
     848        void Print(std::ostream &app) const; 
     849 
     850        friend std::ostream &operator<<(std::ostream &s, const MergeStatistics &stat)  
    851851        { 
    852852                stat.Print(s); 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellBsp.h

    r1923 r2176  
    9393        bool Valid() const; 
    9494         
    95         friend ostream &operator<<(ostream &s, const BspNodeGeometry &a) 
     95        friend std::ostream &operator<<(std::ostream &s, const BspNodeGeometry &a) 
    9696        { 
    9797                PolygonContainer::const_iterator it, it_end = a.mPolys.end(); 
    9898 
    9999                for (it = a.mPolys.begin(); it != it_end; ++ it) 
    100                         s << *(*it) << endl; 
    101                 return s << endl; 
     100                        s << *(*it) << std::endl; 
     101                return s << std::endl; 
    102102        } 
    103103 
    … …  
    259259        } 
    260260 
    261         void Print(ostream &app) const; 
    262  
    263         friend ostream &operator<<(ostream &s, const BspTreeStatistics &stat)  
     261        void Print(std::ostream &app) const; 
     262 
     263        friend std::ostream &operator<<(std::ostream &s, const BspTreeStatistics &stat)  
    264264        { 
    265265                stat.Print(s); 
    … …  
    394394        void SetupChildLinks(BspNode *b, BspNode *f); 
    395395 
    396         friend ostream &operator<<(ostream &s, const BspInterior &A) 
     396        friend std::ostream &operator<<(std::ostream &s, const BspInterior &A) 
    397397        { 
    398398                return s << A.mPlane; 
    … …  
    10841084 
    10851085        //int mSplits; 
    1086         ofstream  mSubdivisionStats; 
     1086        std::ofstream  mSubdivisionStats; 
    10871087 
    10881088        ViewCellsTree *mViewCellsTree; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.cpp

    r2170 r2176  
    2424#include "SamplingStrategy.h" 
    2525#include "SceneGraph.h" 
    26  
    2726#include "PerfTimer.h" 
    2827 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.h

    r2168 r2176  
    77#include "Containers.h" 
    88#include "ViewCell.h" 
    9 //#include "ootl_map.hpp" 
     9 
    1010 
    1111namespace GtpVisibilityPreprocessor { 
    … …  
    183183        /** Prints out statistics of the view cells. 
    184184        */ 
    185         virtual void PrintStatistics(ostream &s) const; 
     185        virtual void PrintStatistics(std::ostream &s) const; 
    186186 
    187187        /** Post processes view cells givemŽa number of rays. 
    … …  
    297297        ViewCell *GetViewCell(const int idx) const {return mViewCells[idx];} 
    298298 
    299         virtual void PrintPvsStatistics(ostream &s); 
     299        virtual void PrintPvsStatistics(std::ostream &s); 
    300300 
    301301        /** Updates pvs of the view cell hierarchy if necessary. 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsParser.cpp

    r2123 r2176  
    55#include <stdlib.h> 
    66#include <iostream> 
    7 //#include <ext/algorithm> 
    8  
    9 using namespace std; 
    107#include <xercesc/util/PlatformUtils.hpp> 
    118 
    … …  
    3835#include "HierarchyManager.h" 
    3936 
     37 
     38using namespace std; 
    4039 
    4140namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsParser.h

    r2123 r2176  
    1818  ViewCellsParser(): Parser() {} 
    1919   
    20   bool ParseViewCellsFile(const string &filename,  
     20  bool ParseViewCellsFile(const std::string &filename,  
    2121                                                  ViewCellsManager **viewCells, 
    2222                                                  ObjectContainer &pvsObjects, 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsParserXerces.h

    r2123 r2176  
    88#include "Mesh.h" 
    99#include "BoundingBoxConverter.h" 
     10#include <hash_map> 
     11 
    1012#include "PerfTimer.h" 
    11 #include <hash_map> 
    1213 
    1314namespace GtpVisibilityPreprocessor { 
    … …  
    183184  void EndBoundingBoxes(); 
    184185 
    185   void StartBspElement(string element, AttributeList& attributes); 
    186   void StartVspElement(string element, AttributeList& attributes); 
     186  void StartBspElement(std::string element, AttributeList& attributes); 
     187  void StartVspElement(std::string element, AttributeList& attributes); 
    187188 
    188189  void StartViewSpaceHierarchy(AttributeList& attributes); 
    … …  
    197198  void StartViewCellHierarchyElement(const std::string &element, AttributeList& attributes); 
    198199 
    199   void StartOspElement(string element, AttributeList& attributes); 
     200  void StartOspElement(std::string element, AttributeList& attributes); 
    200201 
    201202  void StartOspLeaf(AttributeList& attributes); 
    … …  
    206207  void StartBvhLeaf(AttributeList& attributes); 
    207208  void StartBvhInterior(AttributeList& attributes); 
    208   void StartBvhElement(string element, AttributeList& attributes); 
     209  void StartBvhElement(std::string element, AttributeList& attributes); 
    209210 
    210211  void EndViewSpaceHierarchyInterior(); 

  • GTP/trunk/Lib/Vis/Preprocessing/src/VrmlExporter.cpp

    r2017 r2176  
    1717#include "Triangle3.h" 
    1818 
     19 
     20using namespace std; 
    1921 
    2022namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/VspBspTree.h

    r1667 r2176  
    863863 
    864864        /// subdivision stats output file 
    865         ofstream mSubdivisionStats; 
     865        std::ofstream mSubdivisionStats; 
    866866        float mTotalCost; 
    867867        int mTotalPvsSize; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/VspTree.cpp

    r2170 r2176  
    2222#include "OspTree.h" 
    2323 
     24#if USE_SSE 
     25#include <xmmintrin.h> 
     26#endif 
    2427 
    2528 
    … …  
    35003503} 
    35013504 
    3502  
    3503 } 
     3505#if 0 
     3506void VspTree::TraverseRayPacket(RayBundle &rays); 
     3507{ 
     3508        float splitPos [3]; 
     3509        float dist[3]; 
     3510 
     3511        const int allValid = 1xf; 
     3512        int mask = all_valid; 
     3513 
     3514        int comparisonResult = 0; 
     3515 
     3516        while (!node->IsLeaf()) 
     3517        { 
     3518                comparisonResult = 0; 
     3519 
     3520                for (int i = 0; i < 4; ++ i) 
     3521                { 
     3522                        splitPos[i] = node->splitPos; 
     3523                        dist[i] = (splitpos[i] – rp.origin[i][axis]) / (rp.dir[i][axis]); 
     3524 
     3525                        comparisonresult |= ((dist[i] <= tnear[i]) << i); 
     3526                } 
     3527                 
     3528                comparisonresult &= mask; 
     3529 
     3530                if (comparisonresult == allValid) 
     3531                {  
     3532                        node = node->far; 
     3533                        continue 
     3534                } 
     3535 
     3536                comparisonresult = 0; 
     3537 
     3538                for (int i = 0; i < 4; ++ i){ 
     3539             
     3540                        comparisonresult |= (dist[i] >= tfar[i]); 
     3541                } 
     3542         
     3543                comparisonresult &= mask; 
     3544         
     3545                if (comparisonresult == allValid) 
     3546                { 
     3547                        node = node->near; 
     3548                        continue; 
     3549                } 
     3550                 
     3551                if (comparisonresult)    
     3552                { 
     3553                 
     3554                        Push( node->far, dist[0...3], tfar[0...3] ) 
     3555                 
     3556                        node = node->near; 
     3557 
     3558                        mask = 0; 
     3559 
     3560                        for (int i = 0; i < 4; ++ i) 
     3561                        { 
     3562                                bool b = (tnear[i] < tfar[i]); 
     3563                                mask |= b; 
     3564                 
     3565                                if (b) 
     3566                                { 
     3567                                        tfar[i] = dist[i]; 
     3568                                } 
     3569 
     3570                        } 
     3571 
     3572                } 
     3573} 
     3574#endif 
     3575/* 
     3576struct RayPacket 
     3577{ 
     3578        union { float ox[4]; __m128 ox4; }; 
     3579        union { float oy[4]; __m128 oy4; }; 
     3580        union { float oz[4]; __m128 oz4; }; 
     3581        union { float dx[4]; __m128 dx4; }; 
     3582        union { float dy[4]; __m128 dy4; }; 
     3583        union { float dz[4]; __m128 dz4; }; 
     3584}; 
     3585*/ 
     3586void VspTree::TraverseRayPacket()//RayBundle &rays) 
     3587{ 
     3588#if USE_SSE 
     3589        VspNode *node; 
     3590 
     3591        RayPacket rp; 
     3592 
     3593        __m128 mask; 
     3594        __m128 tf4; 
     3595        __m128 tn4; 
     3596        //const int offs[4] = { (RP->dcell[0] >= 0)?1:0,  (RP->dcell[4] >= 0)?1:0,  (RP->dcell[8] >= 0)?1:0, 0 }; 
     3597         
     3598        const int offs[4] = { 0, 0, 0, 0 }; 
     3599 
     3600        while (!node->IsLeaf()) 
     3601        { 
     3602                VspInterior *interior = static_cast<VspInterior *>(node); 
     3603 
     3604                float pos = interior->GetPosition(); 
     3605                const __m128 spos = _mm_load_ps(&pos); 
     3606                 
     3607                const int aidx = interior->GetAxis(); 
     3608                const __m128 d4;// = _mm_mul_ps( _mm_sub_ps( spos, RP->oc4[aidx] ), RP->rdc4[aidx] ); 
     3609                 
     3610                VspNode* ln = interior->GetBack();// + offs[aidx]; 
     3611                 
     3612                if (!_mm_movemask_ps( _mm_and_ps( _mm_cmpgt_ps( d4, tn4 ), mask ) ))  
     3613                {  
     3614                        node = ln;  
     3615                        continue;  
     3616                } 
     3617                 
     3618                node = interior->GetBack();// + (offs[aidx]^1); 
     3619                 
     3620                if (_mm_movemask_ps( _mm_and_ps( _mm_cmplt_ps( d4, tf4 ), mask ) )) 
     3621                { 
     3622                        const __m128 mask2 = _mm_cmpgt_ps( d4, tn4 ); 
     3623                        const __m128 mask3 = _mm_cmplt_ps( d4, tf4 ); 
     3624                         
     3625                        //m_Stack[stackptr].tf4 = tf4; 
     3626 
     3627                        tf4 = _mm_or_ps( _mm_and_ps( mask3, d4 ), _mm_andnot_ps( mask3, tf4 ) ); 
     3628 
     3629                        //m_Stack[stackptr].node = (KdTreeNode*)ln; 
     3630                        //m_Stack[stackptr].mask = mask; 
     3631                        //m_Stack[stackptr++].tn4 = _mm_or_ps( _mm_and_ps( mask2, d4 ), _mm_andnot_ps( mask2, tn4 ) ); 
     3632                        mask = _mm_cmplt_ps( tn4, tf4 ); 
     3633                } 
     3634        } 
     3635#endif 
     3636 
     3637} 
     3638 
     3639} 

  • GTP/trunk/Lib/Vis/Preprocessing/src/VspTree.h

    r2170 r2176  
    132132        } 
    133133 
    134         void Print(ostream &app) const; 
    135  
    136         friend ostream &operator<<(ostream &s, const VspTreeStatistics &stat)  
     134        void Print(std::ostream &app) const; 
     135 
     136        friend std::ostream &operator<<(std::ostream &s, const VspTreeStatistics &stat)  
    137137        { 
    138138                stat.Print(s); 
    … …  
    278278        void SetupChildLinks(VspNode *front, VspNode *back); 
    279279 
    280         friend ostream &operator<<(ostream &s, const VspInterior &A) 
     280        friend std::ostream &operator<<(std::ostream &s, const VspInterior &A) 
    281281        { 
    282282                return s << A.mPlane.mAxis << " " << A.mPlane.mPosition; 
    … …  
    10771077        int CompressObjects(VspLeaf *leaf); 
    10781078 
     1079        void TraverseRayPacket(); 
     1080 
    10791081protected: 
    10801082 
    … …  
    11591161 
    11601162        /// subdivision stats output file 
    1161         ofstream mSubdivisionStats; 
     1163        std::ofstream mSubdivisionStats; 
    11621164        /// keeps track of cost during subdivision 
    11631165        float mTotalCost; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/VssPreprocessor.h

    r2168 r2176  
    33 
    44#include <fstream> 
    5 //using namespace std; 
     5// 
    66 
    77#include "Preprocessor.h" 

  • GTP/trunk/Lib/Vis/Preprocessing/src/VssRay.cpp

    r2173 r2176  
    315315 
    316316void 
    317 VssRayContainer::PrintStatistics(ostream &s) 
     317VssRayContainer::PrintStatistics(std::ostream &s) 
    318318{ 
    319319 
    … …  
    329329   
    330330  s<<"##### VSS RAY STAT ##########\n"; 
    331   s<<"#RAYS\n"<<(int)size()<<endl; 
    332   s<<"#AVG_RAY_PVS_CONTRIBUTION\n"<<sumContributions/(float)size()<<endl; 
     331  s<<"#RAYS\n"<<(int)size()<<std::endl; 
     332  s<<"#AVG_RAY_PVS_CONTRIBUTION\n"<<sumContributions/(float)size()<<std::endl; 
    333333  s<<"#AVG_RAY_RELATIVE_PVS_CONTRIBUTION\n"<<sumRelContributions/ 
    334         (float)size()<<endl; 
     334        (float)size()<<std::endl; 
    335335   
    336336} 

  • GTP/trunk/Lib/Vis/Preprocessing/src/VssRay.h

    r2168 r2176  
    77#include "Containers.h" 
    88 
    9 //using namespace std; 
     9// 
    1010 
    1111 
    … …  
    208208                mRefCount++; 
    209209      else { 
    210                 cerr<<"Trying to unref already deleted ray!"<<endl; 
     210                std::cerr<<"Trying to unref already deleted ray!"<<std::endl; 
    211211                exit(1); 
    212212      } 
    … …  
    249249          KdNode **node) const; 
    250250 
    251   friend ostream& operator<< (ostream &s, const VssRay &vssRay); 
     251  friend std::ostream& operator<< (std::ostream &s, const VssRay &vssRay); 
    252252     
    253253}; 
    … …  
    286286 
    287287// Overload << operator for C++-style output 
    288 inline ostream& 
    289 operator<< (ostream &s, const VssRay &vssRay) 
     288inline std::ostream& 
     289operator<< (std::ostream &s, const VssRay &vssRay) 
    290290{ 
    291291        return s  
    … …  
    320320struct VssRayContainer : public vector<VssRay *> 
    321321{ 
    322   void PrintStatistics(ostream &s); 
     322  void PrintStatistics(std::ostream &s); 
    323323  int SelectRays(const int number, VssRayContainer &selected, const bool copy=false) const; 
    324324  int 

  • GTP/trunk/Lib/Vis/Preprocessing/src/VssTree.h

    r2105 r2176  
    9999   
    100100  void 
    101   Print(ostream &app) const; 
    102  
    103   friend ostream &operator<<(ostream &s, const VssStatistics &stat) { 
     101  Print(std::ostream &app) const; 
     102 
     103  friend std::ostream &operator<<(std::ostream &s, const VssStatistics &stat) { 
    104104    stat.Print(s); 
    105105    return s; 
    … …  
    303303  bool IsLeaf() const { return axis == -1; } 
    304304   
    305   virtual void Print(ostream &s) const = 0; 
     305  virtual void Print(std::ostream &s) const = 0; 
    306306 
    307307  virtual int GetAccessTime() { 
    … …  
    369369  } 
    370370   
    371   virtual void Print(ostream &s) const { 
     371  virtual void Print(std::ostream &s) const { 
    372372    if (axis == 0) 
    373373      s<<"x "; 
    … …  
    422422  virtual int Type() const  { return ELeaf; } 
    423423 
    424   virtual void Print(ostream &s) const { 
    425     s<<endl<<"L: r="<<(int)rays.size()<<endl; 
     424  virtual void Print(std::ostream &s) const { 
     425    s<<std::endl<<"L: r="<<(int)rays.size()<<std::endl; 
    426426  }; 
    427427   
    … …  
    478478  // comparator for the  
    479479  struct less_contribution : public 
    480   binary_function<const VssTreeLeaf *, const VssTreeLeaf *, bool> { 
     480  std::binary_function<const VssTreeLeaf *, const VssTreeLeaf *, bool> { 
    481481         
    482482        bool operator()(const VssTreeLeaf * a, const VssTreeLeaf *b) { 
    … …  
    486486   
    487487  struct greater_contribution : public 
    488   binary_function<const VssTreeLeaf *, const VssTreeLeaf *, bool> { 
     488  std::binary_function<const VssTreeLeaf *, const VssTreeLeaf *, bool> { 
    489489         
    490490        bool operator()(const VssTreeLeaf * a, const VssTreeLeaf *b) { 
    … …  
    532532    // comparator for the  
    533533    struct less_priority : public 
    534     binary_function<const TraversalData, const TraversalData, bool> { 
     534    std::binary_function<const TraversalData, const TraversalData, bool> { 
    535535                         
    536536      bool operator()(const TraversalData a, const TraversalData b) { 
    … …  
    866866  TraverseInternalNode( 
    867867                                           RayTraversalData &data, 
    868                                            stack<RayTraversalData> &tstack); 
     868                                           std::stack<RayTraversalData> &tstack); 
    869869 
    870870  void 

  • GTP/trunk/Lib/Vis/Preprocessing/src/X3dExporter.cpp

    r2124 r2176  
    1515#include "Beam.h" 
    1616 
     17 
     18using namespace std; 
     19 
    1720namespace GtpVisibilityPreprocessor { 
    1821 
    … …  
    101104        result = ExportRays(*ri, color); 
    102105        if (!result) { 
    103           cerr<<"Error while exporting rays!\n"; 
     106          std::cerr<<"Error while exporting rays!\n"; 
    104107          break; 
    105108        } 

  • GTP/trunk/Lib/Vis/Preprocessing/src/X3dParser.cpp

    r2116 r2176  
    55#include <stdlib.h> 
    66#include <iostream> 
    7 using namespace std; 
    87#include <xercesc/util/PlatformUtils.hpp> 
    98 
    … …  
    3332#include <assert.h> 
    3433#include "Polygon3.h" 
     34 
     35 
     36using namespace std; 
    3537 
    3638namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/X3dParser.h

    r1379 r2176  
    1616   
    1717        bool ParseFile( 
    18                                    const string filename,  
     18                                   const std::string filename,  
    1919                                   SceneGraphNode *root,  
    2020                                   const bool loadMeshes = false, 
    2121                                   vector<FaceParentInfo> *parents = NULL); 
    2222 
    23         bool ParseFile(const string filename, ViewCellsManager &viewCells); 
     23        bool ParseFile(const std::string filename, ViewCellsManager &viewCells); 
    2424  
    2525        /// height of a loaded view cell 

  • GTP/trunk/Lib/Vis/Preprocessing/src/X3dParserXerces.h

    r1379 r2176  
    3636        }; 
    3737 
    38         typedef map<string, int, ltstr> ResourceDefinitions; 
     38        typedef std::map<std::string, int, ltstr> ResourceDefinitions; 
    3939 
    4040  // ----------------------------------------------------------------------- 
    … …  
    9090  bool mLoadMeshes; 
    9191 
    92   typedef stack<Matrix4x4> TrafoStack; 
     92  typedef std::stack<Matrix4x4> TrafoStack; 
    9393 
    9494  bool mUsingMeshDefinition; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/common.cpp

    r2123 r2176  
    2222#include <sys/timeb.h> 
    2323#endif 
     24 
     25 
     26using namespace std; 
    2427 
    2528namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/common.h

    r2123 r2176  
    2020#include <fstream> 
    2121#include <limits.h> 
    22  
    23 using namespace std; 
    2422 
    2523 
    … …  
    253251// This routine is located in main.cpp, for lack of a better place. 
    254252// ------------------------------------------------------------------- 
    255 void indent(ostream &app, int ind); 
     253void indent(std::ostream &app, int ind); 
    256254 
    257255// --------------------------------------------------------- 
    … …  
    335333 
    336334// manipulator 
    337 inline ostream &DEBUGINFO( ostream &s ) { 
    338   return s<<"FILE "<<__FILE__<<",LINE "<<__LINE__<<endl; 
     335inline std::ostream &DEBUGINFO( std::ostream &s ) { 
     336  return s<<"FILE "<<__FILE__<<",LINE "<<__LINE__<<std::endl; 
    339337} 
    340338 
    … …  
    492490   
    493491// debug stream 
    494 extern ofstream Debug; 
     492extern std::ofstream Debug; 
    495493 
    496494 

  • GTP/trunk/Lib/Vis/Preprocessing/src/gzstream.h

    r1264 r2176  
    3535#include <iostream> 
    3636#include <fstream> 
    37 using namespace std; 
    3837 
    3938#ifdef GZSTREAM_NAMESPACE 
    … …  
    5049 
    5150 
    52 //  #define STREAMBUF std::streambuf  
    53 //  #define ISTREAM std::istream 
    54 //  #define OSTREAM std::ostream 
     51#define STREAMBUF std::streambuf  
     52#define ISTREAM std::istream 
     53#define OSTREAM std::ostream 
    5554 
    56 #define STREAMBUF streambuf  
    57 #define ISTREAM istream 
    58 #define OSTREAM ostream 
     55//#define STREAMBUF streambuf  
     56//#define ISTREAM istream 
     57//#define OSTREAM ostream 
    5958 
    6059class gzstreambuf : public STREAMBUF { 
    … …  
    8887}; 
    8988 
    90 class gzstreambase : virtual public ios { 
     89class gzstreambase : virtual public std::ios { 
    9190 
    9291protected: 

  • GTP/trunk/Lib/Vis/Preprocessing/src/main.cpp

    r2161 r2176  
    55#endif 
    66 
     7#define NOMINMAX 
    78#include <windows.h> 
    89#include <stdio.h> 
    … …  
    1516#include "Preprocessor.h" 
    1617#include "common.h" 
    17  
    1818#include "PreprocessorThread.h" 
    1919#include "ObjExporter.h" 
    2020#include "SceneGraph.h" 
    2121#include "GlobalLinesRenderer.h" 
    22 //#include "PvsDefinitions.h" 
     22 
    2323 
    2424#include "ViewCellsManager.h" 
    … …  
    218218        } 
    219219 
    220         Debug << "using pvs type " << PVS_TYPE << endl; 
     220        //Debug << "using pvs type " << PVS_TYPE << endl; 
    221221 
    222222        ///////////// 
Note: See TracChangeset for help on using the changeset viewer.